WIP

Author: sfackler

postgres-derive-internals/src/enums.rs

@@ -8,13 +8,13 @@ pub struct Variant {
 }
 
 impl Variant {
-    pub fn parse(raw: &mut syn::Variant) -> Result<Variant, String> {
+    pub fn parse(raw: &syn::Variant) -> Result<Variant, String> {
         match raw.data {
             VariantData::Unit => {}
             _ => return Err("non-C-like enums are not supported".to_owned()),
         }
 
-        let overrides = try!(Overrides::extract(&mut raw.attrs));
+        let overrides = try!(Overrides::extract(&raw.attrs));
         Ok(Variant {
             ident: raw.ident.clone(),
             name: overrides.name.unwrap_or_else(|| raw.ident.to_string()),

postgres-derive-internals/src/fromsql.rs

@@ -1,4 +1,82 @@
+use std::fmt::Write;
+use syn::{self, Body, VariantData, Ident};
+use quote::{Tokens, ToTokens};
 
-pub fn expand_derive_fromsql(_: &str) -> Result<String, String> {
-    unimplemented!();
+use accepts;
+use enums::Variant;
+use overrides::Overrides;
+
+pub fn expand_derive_fromsql(source: &str) -> Result<String, String> {
+    let mut input = try!(syn::parse_macro_input(source));
+    let overrides = try!(Overrides::extract(&mut input.attrs));
+
+    let name = overrides.name.unwrap_or_else(|| input.ident.to_string());
+
+    let (accepts_body, to_sql_body) = match input.body {
+        Body::Enum(ref mut variants) => {
+            let variants: Vec<Variant> = try!(variants.iter_mut().map(Variant::parse).collect());
+            (accepts::enum_body(&variants), enum_body(&input.ident, &variants))
+        }
+        _ => {
+            return Err("#[derive(ToSql)] may only be applied to structs, single field tuple \
+                        structs, and enums".to_owned())
+        }
+    };
+
+    let mut tokens = Tokens::new();
+    input.to_tokens(&mut tokens);
+
+    let out = format!("
+{}
+
+impl ::postgres::types::ToSql for {} {{
+    fn to_sql(&self,
+              _: &::postgres::types::Type,
+              buf: &mut ::std::vec::Vec<u8>,
+              _: &::postgres::types::SessionInfo)
+              -> ::postgres::Result<::postgres::types::IsNull> {{{}
+    }}
+
+    fn accepts(type_: &::postgres::types::Type) -> bool {{
+        if type_.name() != \"{}\" {{
+            return false;
+        }}
+{}
+    }}
+
+    to_sql_checked!();
+}}", tokens, input.ident, to_sql_body, name, accepts_body);
+
+    Ok(out)
+}
+
+fn enum_body(ident: &Ident, variants: &[Variant]) -> String {
+    let mut out = "
+        let s = match *self {".to_owned();
+
+    for variant in variants {
+        write!(out, "
+            {}::{} => \"{}\",", ident, variant.ident, variant.name).unwrap();
+    }
+
+    out.push_str("
+        };
+
+        buf.extend_from_slice(s.as_bytes());
+        Ok(::postgres::types::IsNull::No)");
+
+    out
+}
+
+#[test]
+fn foo() {
+    let code = "
+#[postgres(name = \"foo\")]
+enum Foo {
+    #[postgres(name = \"bar\")]
+    Bar,
+    Baz
+}
+";
+    panic!(expand_derive_tosql(code).unwrap());
 }

postgres-derive-internals/src/lib.rs

@@ -1,6 +1,8 @@
 extern crate syn;
 extern crate quote;
 
+use syn::{MacroInput, MetaItem};
+
 pub use fromsql::expand_derive_fromsql;
 pub use tosql::expand_derive_tosql;
 
@@ -9,3 +11,64 @@ mod enums;
 mod fromsql;
 mod overrides;
 mod tosql;
+
+pub fn expand_derive(source: &str) -> Result<String, String> {
+    let mut input = try!(syn::parse_macro_input(source));
+    let (tosql, fromsql) = strip_derives(&mut input);
+
+    let tosql = if tosql {
+        try!(expand_derive_tosql(&input))
+    } else {
+        "".to_owned()
+    };
+    let fromsql = if fromsql {
+        try!(expand_derive_fromsql(&input))
+    } else {
+        "".to_owned()
+    };
+}
+
+fn strip_derives(input: &mut MacroInput) -> (bool, bool) {
+    let mut tosql = false;
+    let mut fromsql = false;
+
+    let mut other_attrs = vec![];
+    for mut attr in input.attrs.drain(..) {
+        {
+            let mut items = match attr.value {
+                MetaItem::List(ref name, ref mut items) if name == "derive" => items,
+                _ => {
+                    other_attrs.push(attr);
+                    continue;
+                }
+            };
+
+            items.retain(|i| {
+                match *i {
+                    MetaItem::Word(ref name) if name == "ToSql" => {
+                        tosql = true;
+                        false
+                    }
+                    MetaItem::Word(ref name) if name == "FromSql" => {
+                        fromsql = true;
+                        false
+                    }
+                    _ => true,
+                }
+            });
+
+            if items.is_empty() {
+                continue;
+            }
+        }
+
+        other_attrs.push(attr);
+    }
+
+    input.attrs = other_attrs;
+    (tosql, fromsql)
+}
+
+fn strip_overrides(input: &mut MacroInput) {
+
+}

postgres-derive-internals/src/overrides.rs

@@ -5,15 +5,13 @@ pub struct Overrides {
 }
 
 impl Overrides {
-    pub fn extract(attrs: &mut Vec<Attribute>) -> Result<Overrides, String> {
+    pub fn extract(attrs: &[Attribute]) -> Result<Overrides, String> {
         let mut overrides = Overrides {
             name: None,
         };
-        let mut other_attrs = vec![];
 
         for attr in attrs.drain(..) {
             if attr.value.name() != "postgres" {
-                other_attrs.push(attr);
                 continue;
             }
 
@@ -41,8 +39,10 @@ impl Overrides {
             }
         }
 
-        *attrs = other_attrs;
         Ok(overrides)
     }
-}
 
+    pub fn strip(attrs: &mut Vec<Attribute>) {
+        attrs.retain(|a| a.name() != "postgres");
+    }
+}

postgres-derive-internals/src/tosql.rs

@@ -67,16 +67,3 @@ fn enum_body(ident: &Ident, variants: &[Variant]) -> String {
 
     out
 }
-
-#[test]
-fn foo() {
-    let code = "
-#[postgres(name = \"foo\")]
-enum Foo {
-    #[postgres(name = \"bar\")]
-    Bar,
-    Baz
-}
-";
-    panic!(expand_derive_tosql(code).unwrap());
-}

postgres-derive/src/lib.rs

@@ -7,7 +7,17 @@ use rustc_macro::TokenStream;
 
 #[rustc_macro_derive(ToSql)]
 pub fn derive_tosql(input: TokenStream) -> TokenStream {
-    match postgres_derive_internals::expand_derive_tosql(&input.to_string()) {
+    derive("ToSql", input)
+}
+
+#[rustc_macro_derive(FromSql)]
+pub fn derive_fromsql(input: TokenStream) -> TokenStream {
+    derive("FromSql", input)
+}
+
+fn derive(trait_: &str, input: TokenStream) -> TokenStream {
+    let input = format!("#[derive({})] {}", trait_, input);
+    match postgres_derive_internals::expand_derive(&input) {
         Ok(expanded) => expanded.parse().unwrap(),
         Err(err) => panic!(err),
     }