WIP Macros 1.1 port

CHANGELOG.md

@@ -41,6 +41,8 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
   `#[derive(AsChangeset)] #[table_name="foo"]`. If you were specifying
   `treat_none_as_null = "true"`, you should additionally have
   `#[changeset_options(treat_none_as_null = "true")]`.
+* `#[insertable_into(foo)]` should now be written as
+  `#[derive(Insertable)] #[table_name="foo"]`.
 
 ## [0.7.2] - 2016-08-20
 

diesel/src/macros/as_changeset.rs

@@ -196,7 +196,7 @@ macro_rules! AsChangeset {
     ) => {
         AsChangeset! {
             $($headers)*
-            self_to_columns = $struct_name { $($field_name: ref $column_name,)+ ..},
+            self_to_columns = $struct_name { $($field_name: ref $column_name,)+ .. },
             columns = ($($column_name, $field_kind),+),
             field_names = [$($field_name)+],
             changeset_ty = $changeset_ty,

diesel/src/macros/queryable.rs

@@ -104,11 +104,12 @@ macro_rules! Queryable {
     (
         struct_ty = $struct_ty:ty,
         generics = ($($generics:ident),*),
+        lifetimes = ($($lifetimes:tt),*),
         row_ty = $row_ty:ty,
         row_pat = $row_pat:pat,
         build_expr = $build_expr:expr,
     ) => {
-        impl<$($generics,)* __DB, __ST> $crate::Queryable<__ST, __DB> for $struct_ty where
+        impl<$($lifetimes,)* $($generics,)* __DB, __ST> $crate::Queryable<__ST, __DB> for $struct_ty where
             __DB: $crate::backend::Backend + $crate::types::HasSqlType<__ST>,
             $row_ty: $crate::types::FromSqlRow<__ST, __DB>,
         {
@@ -131,6 +132,7 @@ macro_rules! Queryable {
                 struct_name = $struct_name,
                 struct_ty = $struct_name<$($generics),*>,
                 generics = ($($generics),*),
+                lifetimes = (),
             ),
             callback = Queryable,
             body = $body,
@@ -147,6 +149,7 @@ macro_rules! Queryable {
                 struct_name = $struct_name,
                 struct_ty = $struct_name,
                 generics = (),
+                lifetimes = (),
             ),
             callback = Queryable,
             body = $body,

diesel/src/persistable.rs

@@ -6,11 +6,10 @@ use result::QueryResult;
 use query_builder::{QueryBuilder, BuildQueryResult};
 use query_source::{Table, Column};
 
-/// Represents that a structure can be used to to insert a new row into the database.
-/// Implementations can be automatically generated by
-/// [`#[insertable_into]`](https://github.com/sgrif/diesel/tree/master/diesel_codegen#insertable_intotable_name).
-/// This is automatically implemented for `&[T]` and `&Vec<T>` for inserting more than
-/// one record.
+/// Represents that a structure can be used to to insert a new row into the
+/// database.  Implementations can be automatically generated by
+/// `#[derive(Insertable)]` This is automatically implemented for `&[T]` and
+/// `&Vec<T>` for inserting more than one record.
 pub trait Insertable<T: Table, DB: Backend> {
     type Values: InsertValues<DB>;
 

diesel_codegen/README.md

@@ -93,17 +93,20 @@ Adds an implementation of the [`Queryable`][queryable] trait to the annotated
 item. At this time it only supports structs with named fields. Enums and tuple
 structs are not supported.
 
-### `#[insertable_into(table_name)]`
+### `#[derive(Insertable)]`
 
 Adds an implementation of the [`Insertable`][insertable] trait to the annotated
 item, targeting the given table. Can only annotate structs and tuple structs.
 Enums are not supported. See [field annotations][#field-annotations] for
 additional configurations.
 
+Structs which derive `Insertable` must have a table name annotation like so:
+`#[table_name = "something"]`
+
 ### `#[derive(AsChangeset)]`
 
 Adds an implementation of the [`AsChangeset`][as_changeset] trait to the
-annotated item, targeting the given table. At this time, it only supports
+annotated item, targeting the given table. at this time, it only supports
 structs with named fields. Tuple structs and enums are not supported. See [field
 annotations][#field-annotations] for additional configurations.
 

diesel_codegen/src/lib.rs

@@ -14,22 +14,6 @@ pub fn register(reg: &mut rustc_plugin::Registry) {
         intern("derive_Associations"),
         MultiDecorator(Box::new(associations::expand_derive_associations)),
     );
-    reg.register_syntax_extension(
-        intern("derive_AsChangeset"),
-        MultiDecorator(Box::new(update::expand_derive_as_changeset)),
-    );
-    reg.register_syntax_extension(
-        intern("derive_Identifiable"),
-        MultiDecorator(Box::new(identifiable::expand_derive_identifiable))
-    );
-    reg.register_syntax_extension(
-        intern("derive_Queryable"),
-        MultiDecorator(Box::new(queryable::expand_derive_queryable))
-    );
-    reg.register_syntax_extension(
-        intern("insertable_into"),
-        MultiDecorator(Box::new(insertable::expand_insert))
-    );
     reg.register_macro("embed_migrations", migrations::expand_embed_migrations);
     reg.register_macro("infer_table_from_schema", schema_inference::expand_load_table);
     reg.register_macro("infer_schema", schema_inference::expand_infer_schema);

diesel_codegen_new/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "diesel_codegen_new"
+version = "0.8.0"
+authors = ["Sean Griffin <sean@seantheprogrammer.com>"]
+
+[dependencies]
+syn = "0.4.0"
+quote = "0.1.1"
+
+[lib]
+rustc-macro = true

diesel_codegen_new/src/as_changeset.rs

@@ -0,0 +1,62 @@
+use syn;
+use quote;
+
+use model::Model;
+use util::attr_with_name;
+
+pub fn derive_as_changeset(item: syn::Item) -> quote::Tokens {
+    let treat_none_as_null = format!("{}", treat_none_as_null(&item.attrs));
+    let model = t!(Model::from_item(&item, "AsChangeset"));
+
+    let struct_name = &model.name;
+    let table_name = model.table_name();
+    let struct_ty = &model.ty;
+    let mut lifetimes = item.generics.lifetimes;
+    let attrs = model.attrs.into_iter()
+        .filter(|a| a.column_name != Some(syn::Ident::new("id")))
+        .collect::<Vec<_>>();
+
+    if lifetimes.is_empty() {
+        lifetimes.push(syn::LifetimeDef {
+            lifetime: syn::Lifetime {
+                ident: syn::Ident::new("'a"),
+            },
+            bounds: Vec::new(),
+        });
+    }
+
+    quote!(AsChangeset! {
+        (
+            struct_name = #struct_name,
+            table_name = #table_name,
+            treat_none_as_null = #treat_none_as_null,
+            struct_ty = #struct_ty,
+            lifetimes = (#(lifetimes),*),
+        ),
+        fields = [#(attrs)*],
+    })
+}
+
+fn treat_none_as_null(attrs: &[syn::Attribute]) -> bool {
+    let options_attr = match attr_with_name(attrs, "changeset_options") {
+        Some(attr) => attr,
+        None => return false,
+    };
+
+    let usage_err = || panic!(r#"`#[changeset_options]` must be in the form \
+        `#[changeset_options(treat_none_as_null = "true")]`"#);
+
+    match options_attr.value {
+        syn::MetaItem::List(_, ref values) => {
+            if values.len() != 1 {
+                usage_err();
+            }
+            match values[0] {
+                syn::MetaItem::NameValue(ref name, ref value)
+                    if name.as_ref() == "treat_none_as_null" => value == "true",
+                _ => usage_err(),
+            }
+        }
+        _ => usage_err(),
+    }
+}

diesel_codegen_new/src/ast_builder.rs

@@ -0,0 +1,16 @@
+use syn::{Ident, Ty, Path, PathSegment};
+
+pub fn ty_ident(ident: Ident) -> Ty {
+    ty_path(path_ident(ident))
+}
+
+pub fn ty_path(path: Path) -> Ty {
+    Ty::Path(None, path)
+}
+
+pub fn path_ident(ident: Ident) -> Path {
+    Path {
+        global: false,
+        segments: vec![PathSegment::ident(ident)],
+    }
+}

diesel_codegen_new/src/attr.rs

@@ -0,0 +1,59 @@
+use quote;
+use syn;
+
+use util::{ident_value_of_attr_with_name, is_option_ty};
+
+pub struct Attr {
+    pub column_name: Option<syn::Ident>,
+    pub field_name: Option<syn::Ident>,
+    pub ty: syn::Ty,
+}
+
+impl Attr {
+    pub fn from_struct_field(field: &syn::Field) -> Self {
+        let field_name = field.ident.clone();
+        let column_name = ident_value_of_attr_with_name(&field.attrs, "column_name")
+            .map(Clone::clone)
+            .or_else(|| field_name.clone());
+        let ty = field.ty.clone();
+
+        Attr {
+            column_name: column_name,
+            field_name: field_name,
+            ty: ty,
+        }
+    }
+
+    fn field_kind(&self) -> &str {
+        if is_option_ty(&self.ty) {
+            "option"
+        } else if self.column_name.is_none() && self.field_name.is_none() {
+            "bare"
+        } else {
+            "regular"
+        }
+    }
+}
+
+impl quote::ToTokens for Attr {
+    fn to_tokens(&self, tokens: &mut quote::Tokens) {
+        tokens.append("{");
+        if let Some(ref name) = self.field_name {
+            tokens.append("field_name: ");
+            name.to_tokens(tokens);
+            tokens.append(", ");
+        }
+        if let Some(ref name) = self.column_name {
+            tokens.append("column_name: ");
+            name.to_tokens(tokens);
+            tokens.append(", ");
+        }
+        tokens.append("field_ty: ");
+        self.ty.to_tokens(tokens);
+        tokens.append(", ");
+        tokens.append("field_kind: ");
+        tokens.append(self.field_kind());
+        tokens.append(", ");
+        tokens.append("}");
+    }
+}

diesel_codegen_new/src/identifiable.rs

@@ -0,0 +1,22 @@
+use quote::Tokens;
+use syn;
+
+use model::Model;
+
+pub fn derive_identifiable(item: syn::Item) -> Tokens {
+    let model = t!(Model::from_item(&item, "Queryable"));
+    let table_name = model.table_name();
+    let struct_ty = &model.ty;
+    let fields = model.attrs;
+    if !fields.iter().any(|f| f.field_name == Some(syn::Ident::new("id"))) {
+        panic!("Could not find a field named `id` on `{}`", &model.name);
+    }
+
+    quote!(Identifiable! {
+        (
+            table_name = #table_name,
+            struct_ty = #struct_ty,
+        ),
+        fields = [#(fields)*],
+    })
+}

diesel_codegen_new/src/insertable.rs

@@ -0,0 +1,33 @@
+use syn;
+use quote;
+
+use model::Model;
+
+pub fn derive_insertable(item: syn::Item) -> quote::Tokens {
+    let model = t!(Model::from_item(&item, "Insertable"));
+
+    if !model.has_table_name_annotation() {
+        panic!(r#"`#[derive(Insertable)]` requires the struct to be annotated \
+            with `#[table_name="something"]`"#);
+    }
+
+    if !model.generics.ty_params.is_empty() {
+        panic!("`#[derive(Insertable)]` does not support generic types");
+    }
+
+    let struct_name = &model.name;
+    let struct_ty = &model.ty;
+    let table_name = &model.table_name();
+    let lifetimes = model.generics.lifetimes;
+    let fields = model.attrs;
+
+    quote!(Insertable! {
+        (
+            struct_name = #struct_name,
+            table_name = #table_name,
+            struct_ty = #struct_ty,
+            lifetimes = (#(lifetimes),*),
+        ),
+        fields = [#(fields)*],
+    })
+}