Merge pull request diesel-rs#2732 from lukas-code/table_name_path

allow paths in #[table_name]

Author: weiznich

CHANGELOG.md

@@ -162,6 +162,9 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
   be compatible with the rewrite, but code calling into `diesel_migrations` requires an update.
   See the [migration guide](#2-0-0-upgrade-migrations) for details.
 
+* The `#[table_name]` attribute for derive macros can now refer to any path and is no
+  longer limited to identifiers from the current scope.
+
 ### Fixed
 
 * Many types were incorrectly considered non-aggregate when they should not

diesel/src/insertable.rs

@@ -15,7 +15,7 @@ use crate::sqlite::Sqlite;
 /// database. This is automatically implemented for `&[T]` and `&Vec<T>` for
 /// inserting more than one record.
 ///
-/// This trait can be [derived](Insertable)
+/// This trait can be [derived](derive@Insertable)
 pub trait Insertable<T> {
     /// The `VALUES` clause to insert these records
     ///

diesel_compile_tests/tests/fail/as_changeset_missing_table_import.stderr

@@ -11,5 +11,3 @@ error[E0433]: failed to resolve: use of undeclared crate or module `users`
    |
 11 | #[table_name = "users"]
    |                ^^^^^^^ use of undeclared crate or module `users`
-   |
-   = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)

diesel_compile_tests/tests/fail/insertable_bad_table_name.rs

@@ -0,0 +1,52 @@
+#[macro_use]
+extern crate diesel;
+
+table! {
+    users {
+        id -> Integer,
+    }
+}
+
+#[derive(Insertable)]
+#[table_name = "self::users"]
+struct UserOk {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name(self::users)]
+struct UserWarn {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name]
+struct UserError1 {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name = true]
+struct UserError2 {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name = ""]
+struct UserError3 {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name = "not a path"]
+struct UserError4 {
+    id: i32,
+}
+
+#[derive(Insertable)]
+#[table_name = "does::not::exist"]
+struct UserError5 {
+    id: i32,
+}
+
+fn main() {}

diesel_compile_tests/tests/fail/insertable_bad_table_name.stderr

@@ -0,0 +1,35 @@
+warning: The form `table_name(value)` is deprecated. Use `table_name = "value"` instead
+  --> $DIR/insertable_bad_table_name.rs:17:3
+   |
+17 | #[table_name(self::users)]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `table_name` must be in the form `table_name = "value"`
+  --> $DIR/insertable_bad_table_name.rs:23:3
+   |
+23 | #[table_name]
+   |   ^^^^^^^^^^
+
+error: `table_name` must be in the form `table_name = "value"`
+  --> $DIR/insertable_bad_table_name.rs:29:3
+   |
+29 | #[table_name = true]
+   |   ^^^^^^^^^^^^^^^^^
+
+error: `` is not a valid path
+  --> $DIR/insertable_bad_table_name.rs:35:16
+   |
+35 | #[table_name = ""]
+   |                ^^
+
+error: `not a path` is not a valid path
+  --> $DIR/insertable_bad_table_name.rs:41:16
+   |
+41 | #[table_name = "not a path"]
+   |                ^^^^^^^^^^^^
+
+error[E0433]: failed to resolve: use of undeclared crate or module `does`
+  --> $DIR/insertable_bad_table_name.rs:47:16
+   |
+47 | #[table_name = "does::not::exist"]
+   |                ^^^^^^^^^^^^^^^^^^ use of undeclared crate or module `does`

diesel_compile_tests/tests/fail/insertable_missing_table_or_column.stderr

@@ -11,8 +11,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `posts`
    |
 16 | #[table_name = "posts"]
    |                ^^^^^^^ use of undeclared crate or module `posts`
-   |
-   = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0412]: cannot find type `name` in module `users`
   --> $DIR/insertable_missing_table_or_column.rs:24:5

diesel_derives/src/as_changeset.rs

@@ -88,7 +88,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
 
 fn field_changeset_ty(
     field: &Field,
-    table_name: &syn::Ident,
+    table_name: &syn::Path,
     treat_none_as_null: bool,
     lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Type {
@@ -104,7 +104,7 @@ fn field_changeset_ty(
 
 fn field_changeset_expr(
     field: &Field,
-    table_name: &syn::Ident,
+    table_name: &syn::Path,
     treat_none_as_null: bool,
     lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Expr {

diesel_derives/src/insertable.rs

@@ -3,6 +3,7 @@ use proc_macro2::Span;
 use syn;
 
 use field::*;
+use meta::path_to_string;
 use model::*;
 use util::*;
 
@@ -14,7 +15,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
             .error("Cannot derive Insertable for unit structs")
             .help(format!(
                 "Use `insert_into({}::table).default_values()` if you want `DEFAULT VALUES`",
-                model.table_name()
+                path_to_string(&model.table_name())
             )));
     }
 
@@ -123,7 +124,7 @@ fn field_expr_embed(field: &Field, lifetime: Option<proc_macro2::TokenStream>) -
     parse_quote!(#lifetime self#field_access)
 }
 
-fn field_ty_serialize_as(field: &Field, table_name: &syn::Ident, ty: &syn::Type) -> syn::Type {
+fn field_ty_serialize_as(field: &Field, table_name: &syn::Path, ty: &syn::Type) -> syn::Type {
     let inner_ty = inner_of_option_ty(&ty);
     let column_name = field.column_name();
 
@@ -135,7 +136,7 @@ fn field_ty_serialize_as(field: &Field, table_name: &syn::Ident, ty: &syn::Type)
     )
 }
 
-fn field_expr_serialize_as(field: &Field, table_name: &syn::Ident, ty: &syn::Type) -> syn::Expr {
+fn field_expr_serialize_as(field: &Field, table_name: &syn::Path, ty: &syn::Type) -> syn::Expr {
     let field_access = field.name.access();
     let column_name = field.column_name();
     let column: syn::Expr = parse_quote!(#table_name::#column_name);
@@ -149,7 +150,7 @@ fn field_expr_serialize_as(field: &Field, table_name: &syn::Ident, ty: &syn::Typ
 
 fn field_ty(
     field: &Field,
-    table_name: &syn::Ident,
+    table_name: &syn::Path,
     lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Type {
     let inner_ty = inner_of_option_ty(&field.ty);
@@ -165,7 +166,7 @@ fn field_ty(
 
 fn field_expr(
     field: &Field,
-    table_name: &syn::Ident,
+    table_name: &syn::Path,
     lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Expr {
     let field_access = field.name.access();

diesel_derives/src/lib.rs

@@ -54,11 +54,9 @@ use diagnostic_shim::*;
 /// Implements `AsChangeset`
 ///
 /// To implement `AsChangeset` this derive needs to know the corresponding table
-/// type. By default it uses the `snake_case` type name with an added `s`.
+/// type. By default it uses the `snake_case` type name with an added `s` from
+/// the current scope.
 /// It is possible to change this default by using `#[table_name = "something"]`.
-/// In both cases the module for that table must be in scope.
-/// For example, to derive this for a struct called `User`, you will
-/// likely need a line such as `use schema::users;`
 ///
 /// If a field name of your struct differs
 /// from the name of the corresponding column, you can annotate the field with
@@ -77,10 +75,10 @@ use diagnostic_shim::*;
 /// the derive should threat `None` values as `NULL`. By default
 /// `Option::<T>::None` is just skipped. To insert a `NULL` using default
 /// behavior use `Option::<Option<T>>::Some(None)`
-/// * `#[table_name = "some_table"]`, specifies the table for which the
-/// current type is a changeset. Requires that `some_table` is in scope.
+/// * `#[table_name = "path::to::table"]`, specifies a path to the table for which the
+/// current type is a changeset. The path is relative to the current module.
 /// If this attribute is not used, the type name converted to
-/// `snake_case` with an added `s` is used as table name
+/// `snake_case` with an added `s` is used as table name.
 ///
 /// ## Optional field attributes
 ///
@@ -148,15 +146,15 @@ pub fn derive_as_expression(input: TokenStream) -> TokenStream {
 ///
 /// # Optional container attributes
 ///
-/// * `#[table_name = "some_table_name"]` specifies the table this
-///    type belongs to. Requires that `some_table_name` is in scope.
+/// * `#[table_name = "path::to::table"]` specifies a path to the table this
+///    type belongs to. The path is relative to the current module.
 ///    If this attribute is not used, the type name converted to
-///    `snake_case` with an added `s` is used as table name
+///    `snake_case` with an added `s` is used as table name.
 ///
 /// # Optional field attributes
 ///
-/// * `#[column_name = "some_table_name"]`, overrides the column the current
-/// field maps to to `some_table_name`. By default the field name is used
+/// * `#[column_name = "some_column_name"]`, overrides the column the current
+/// field maps to to `some_column_name`. By default the field name is used
 /// as column name. Only useful for the foreign key field.
 ///
 #[proc_macro_derive(Associations, attributes(belongs_to, column_name, table_name))]
@@ -187,25 +185,21 @@ pub fn derive_from_sql_row(input: TokenStream) -> TokenStream {
 /// If it's not, you can put `#[primary_key(your_id)]` on your struct.
 /// If you have a composite primary key, the syntax is `#[primary_key(id1, id2)]`.
 ///
-/// By default, `#[derive(Identifiable)]` will assume that your table
-/// name is the plural form of your struct name.
+/// By default, `#[derive(Identifiable)]` will assume that your table is
+/// in scope and its name is the plural form of your struct name.
 /// Diesel uses very simple pluralization rules.
 /// It only adds an `s` to the end, and converts `CamelCase` to `snake_case`.
-/// If your table name does not follow this convention
-/// or the plural form isn't just an `s`,
-/// you can specify the table name with `#[table_name = "some_table_name"]`.
-/// In both cases the module for that table must be in scope.
-/// For example, to derive this for a struct called `User`, you will
-/// likely need a line such as `use schema::users;`
+/// If your table name does not follow this convention or is not in scope,
+/// you can specify a path to the table with `#[table_name = "path::to::table"]`.
 /// Our rules for inferring table names is considered public API.
 /// It will never change without a major version bump.
 ///
 /// # Attributes
 ///
 /// ## Optional container attributes
 ///
-/// * `#[table_name = "some_table_name"]` specifies the table this
-///    type belongs to. Requires that `some_table_name` is in scope.
+/// * `#[table_name = "path::to::table"]` specifies a path to the table this
+///    type belongs to. The path is relative to the current module.
 ///    If this attribute is not used, the type name converted to
 ///    `snake_case` with an added `s` is used as table name
 /// * `#[primary_key(id1, id2)]` to specify the struct field that
@@ -219,11 +213,9 @@ pub fn derive_identifiable(input: TokenStream) -> TokenStream {
 /// Implements `Insertable`
 ///
 /// To implement `Insertable` this derive needs to know the corresponding table
-/// type. By default it uses the `snake_case` type name with an added `s`.
+/// type. By default it uses the `snake_case` type name with an added `s`
+/// from the current scope.
 /// It is possible to change this default by using `#[table_name = "something"]`.
-/// In both cases the module for that table must be in scope.
-/// For example, to derive this for a struct called `User`, you will
-/// likely need a line such as `use schema::users;`
 ///
 /// If a field name of your
 /// struct differs from the name of the corresponding column,
@@ -250,15 +242,15 @@ pub fn derive_identifiable(input: TokenStream) -> TokenStream {
 ///
 /// ## Optional container attributes
 ///
-/// * `#[table_name = "some_table_name"]`, specifies the table this type
-/// is insertable into. Requires that `some_table_name` is in scope.
+/// * `#[table_name = "path::to::table"]`, specifies a path to the table this type
+/// is insertable into. The path is relative to the current module.
 /// If this attribute is not used, the type name converted to
 /// `snake_case` with an added `s` is used as table name
 ///
 /// ## Optional field attributes
 ///
-/// * `#[column_name = "some_table_name"]`, overrides the column the current
-/// field maps to `some_table_name`. By default the field name is used
+/// * `#[column_name = "some_column_name"]`, overrides the column the current
+/// field maps to `some_column_name`. By default the field name is used
 /// as column name
 /// * `#[diesel(embed)]`, specifies that the current field maps not only
 /// to single database field, but is a struct that implements `Insertable`
@@ -560,10 +552,6 @@ pub fn derive_queryable(input: TokenStream) -> TokenStream {
 /// `diesel::dsl::SqlTypeOf<table_name::column_name>`), or by annotating each
 /// field with `#[sql_type = "SomeType"]`.
 ///
-/// If you are using `#[table_name]`, the module for that table must be in
-/// scope. For example, to derive this for a struct called `User`, you will
-/// likely need a line such as `use schema::users;`
-///
 /// If the name of a field on your struct is different than the column in your
 /// `table!` declaration, or if you are deriving this trait on a tuple struct,
 /// you can annotate the field with `#[column_name = "some_column"]`. For tuple
@@ -585,9 +573,10 @@ pub fn derive_queryable(input: TokenStream) -> TokenStream {
 ///
 /// ## Type attributes
 ///
-/// * `#[table_name = "some_table"]`, to specify that this type contains
-///   columns for the specified table. If no field attributes are specified
-///   the derive will use the sql type of the corresponding column.
+/// * `#[table_name = "path::to::table"]`, to specify that this type contains
+///   columns for the specified table. The path is relative to the current module.
+///   If no field attributes are specified the derive will use the sql type of
+///   the corresponding column.
 ///
 /// ## Field attributes
 ///

diesel_derives/src/meta.rs

@@ -101,6 +101,31 @@ impl MetaItem {
         }
     }
 
+    pub fn path_value(&self) -> Result<syn::Path, Diagnostic> {
+        let maybe_attr = self.nested().ok().and_then(|mut n| n.next());
+        let maybe_path = maybe_attr.as_ref().and_then(|m| m.path().ok());
+        match maybe_path {
+            Some(path) => {
+                self.span()
+                    .warning(format!(
+                        "The form `{0}(value)` is deprecated. Use `{0} = \"value\"` instead",
+                        path_to_string(&self.name()),
+                    ))
+                    .emit();
+                Ok(path)
+            }
+            None => {
+                let lit = self.lit_str_value()?;
+                match lit.parse() {
+                    Ok(path) => Ok(path),
+                    _ => Err(lit
+                        .span()
+                        .error(format!("`{}` is not a valid path", lit.value()))),
+                }
+            }
+        }
+    }
+
     pub fn expect_path(&self) -> syn::Path {
         self.path().unwrap_or_else(|e| {
             e.emit();