Port #[derive(Associations)] to entirely use a custom derive

* Deprecated the `BelongsTo` macro
* Add a small check if all options passed to the custom derive are valid

Author: weiznich

diesel/src/macros/associations/belongs_to.rs

@@ -1,5 +1,7 @@
 #[macro_export]
 #[doc(hidden)]
+#[cfg(feature = "with-deprecated")]
+#[deprecated(since = "1.1.0", note = "Use `#[derive(Associations)]` instead")]
 macro_rules! BelongsTo {
     // Format arguments
     (

diesel_derives/src/associations.rs

@@ -2,55 +2,84 @@ use syn;
 use quote;
 
 use model::{infer_association_name, Model};
-use util::str_value_of_meta_item;
+use util::{str_value_of_meta_item, wrap_item_in_const};
 
 pub fn derive_associations(input: syn::DeriveInput) -> quote::Tokens {
-    let mut derived_associations = Vec::new();
     let model = t!(Model::from_item(&input, "Associations"));
 
-    for attr in input.attrs.as_slice() {
+    let derived_associations = input.attrs.as_slice().iter().filter_map(|attr| {
         if attr.name() == "belongs_to" {
-            let options = t!(build_association_options(attr, "belongs_to"));
-            derived_associations.push(expand_belongs_to(&model, options))
+            Some(
+                build_association_options(attr)
+                    .map(|options| expand_belongs_to(&model, options))
+                    .unwrap_or_else(|e| e),
+            )
+        } else {
+            None
         }
-    }
+    });
 
-    quote!(#(#derived_associations)*)
+    wrap_item_in_const(
+        model.dummy_const_name("ASSOCIATIONS"),
+        quote!(#(#derived_associations)*),
+    )
 }
 
 fn expand_belongs_to(model: &Model, options: AssociationOptions) -> quote::Tokens {
     let parent_struct = options.name;
     let struct_name = &model.name;
+    let fields = model.attrs.as_slice();
 
     let foreign_key_name = options
         .foreign_key_name
         .unwrap_or_else(|| to_foreign_key(parent_struct.as_ref()));
+    let foreign_key_name = &foreign_key_name;
     let child_table_name = model.table_name();
-    let fields = model.attrs.as_slice();
+    let child_table_name = &child_table_name;
+    let foreign_key_attr = fields
+        .iter()
+        .find(|attr| attr.column_name().as_ref() == foreign_key_name.as_ref())
+        .unwrap();
+    let foreign_key_ty = &foreign_key_attr.ty;
+
+    // we need to special case foreign keys on with an Option type
+    // to allow self referencing joins
+    let (foreign_key, foreign_key_ty) = match *foreign_key_ty {
+        syn::Ty::Path(None, ref p) if p.segments[0].ident == "Option" => {
+            let segment = &p.segments[0];
+            let t = match segment.parameters {
+                syn::PathParameters::AngleBracketed(ref p) => p.types[0].clone(),
+                syn::PathParameters::Parenthesized(_) => unreachable!(),
+            };
+            (quote!(self.#foreign_key_name.as_ref()), t)
+        }
+        ref t => (quote!(Some(&self.#foreign_key_name)), t.clone()),
+    };
 
-    quote!(BelongsTo! {
-        (
-            struct_name = #struct_name,
-            parent_struct = #parent_struct,
-            foreign_key_name = #foreign_key_name,
-            child_table_name = #child_table_name,
-        ),
-        fields = [#(#fields)*],
-    })
+    quote!(
+        impl diesel::associations::BelongsTo<#parent_struct> for #struct_name {
+            type ForeignKey = #foreign_key_ty;
+            type ForeignKeyColumn = #child_table_name::#foreign_key_name;
+
+            fn foreign_key(&self) -> Option<&Self::ForeignKey> {
+                #foreign_key
+            }
+
+            fn foreign_key_column() -> Self::ForeignKeyColumn {
+                #child_table_name::#foreign_key_name
+            }
+        }
+    )
 }
 
 struct AssociationOptions {
     name: syn::Ident,
     foreign_key_name: Option<syn::Ident>,
 }
 
-fn build_association_options(
-    attr: &syn::Attribute,
-    association_kind: &str,
-) -> Result<AssociationOptions, String> {
-    let usage_error = Err(format!(
-        "`#[{}]` must be in the form `#[{}(table_name, option=value)]`",
-        association_kind, association_kind
+fn build_association_options(attr: &syn::Attribute) -> Result<AssociationOptions, quote::Tokens> {
+    let usage_error = Err(quote!(
+        compile_error!("`#[belongs_to]` must be in the form `#[belongs_to(table_name, foreign_key=\"column_name\")]`")
     ));
     match attr.value {
         syn::MetaItem::List(_, ref options) if options.len() >= 1 => {
@@ -67,11 +96,14 @@ fn build_association_options(
                 .find(|a| a.name() == "foreign_key")
                 .map(|a| str_value_of_meta_item(a, "foreign_key"))
                 .map(syn::Ident::new);
-
-            Ok(AssociationOptions {
-                name: association_name,
-                foreign_key_name: foreign_key_name,
-            })
+            if options.len() == 1 || (options.len() == 2 && foreign_key_name.is_some()) {
+                Ok(AssociationOptions {
+                    name: association_name,
+                    foreign_key_name: foreign_key_name,
+                })
+            } else {
+                usage_error
+            }
         }
         _ => usage_error,
     }