Merge pull request #5 from chuck-flowers/v0.2.0

Pulls the changes for v0.2.0 into master

Author: chuck-flowers

attribution-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "attribution-macros"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Timothy Flowers <[email protected]>"]
 description = "The macros used by the attribution crate"
 categories = ["development-tools::procedural-macro-helpers"]

attribution-macros/src/extraction.rs

@@ -8,10 +8,7 @@ pub fn build_extractor(field: &FieldSpec) -> TokenStream {
     let field_key = syn::LitStr::new(&field.ident().to_string(), Span::call_site());
 
     quote! {
-        let #var_ident = attr_args.remove(#field_key)
-            .unwrap()
-            .try_into()
-            .unwrap();
+        let #var_ident = attribution::FromParameters::from_parameters(&mut attr_args, #field_key).unwrap();
     }
 }
 
@@ -39,7 +36,7 @@ mod tests {
 
         let extractor = build_extractor(&field);
         let expected = quote! {
-            let foo = attr_args.remove("foo").unwrap().try_into().unwrap();
+            let foo = attribution::FromParameters::from_parameters(&mut attr_args, "foo").unwrap();
         };
 
         assert_eq!(extractor.to_string(), expected.to_string());

attribution-macros/src/lib.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::all, clippy::cargo)]
-
+#![allow(clippy::multiple_crate_versions)]
 extern crate proc_macro;
 
 mod extraction;
@@ -65,8 +65,8 @@ fn impl_parse(struct_name: &Ident, fields: &[FieldSpec]) -> TokenStream {
     };
 
     quote! {
-        impl parse::Parse for #struct_name {
-            fn parse(buffer: &parse::ParseBuffer) -> parse::Result<Self> {
+        impl syn::parse::Parse for #struct_name {
+            fn parse(buffer: &syn::parse::ParseBuffer) -> syn::parse::Result<Self> {
                 use std::convert::TryInto;
                 let mut attr_args = attribution::Parameters::parse(buffer)?;
                 #extraction

attribution/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "attribution"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Timothy Flowers <[email protected]>"]
 description = "A declarative custom attribute parsing framework"
 categories = ["development-tools::procedural-macro-helpers"]
@@ -11,6 +11,18 @@ repository = "https://github.com/chuck-flowers/attribution"
 license = "MIT"
 
 [dependencies]
-attribution-macros = { version = "0.1.0", path = "../attribution-macros" }
+attribution-macros = { version = "0.2.0", path = "../attribution-macros" }
 proc-macro2 = "0.4.30"
-syn = "0.15.41"
+shrinkwraprs = "0.2.1"
+syn = "0.15.41"
+
+[dev-dependencies]
+quote = "0.6.13"
+
+[[example]]
+name = "ez_trace"
+crate-type = ["proc-macro"]
+
+[[example]]
+name = "gs"
+crate-type = ["proc-macro"]

attribution/examples/ez_trace.rs

@@ -0,0 +1,110 @@
+extern crate proc_macro;
+
+use attribution::attr_args;
+use proc_macro::TokenStream;
+use quote::quote;
+use quote::ToTokens;
+
+#[attr_args]
+struct EzTraceArgs {
+    start: Option<String>,
+    end: Option<String>,
+}
+
+#[proc_macro_attribute]
+pub fn ez_trace(attr: TokenStream, tagged: TokenStream) -> TokenStream {
+    ez_trace_impl(attr.into(), tagged.into()).into()
+}
+
+fn ez_trace_impl(
+    attr: proc_macro2::TokenStream,
+    tagged: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+    let args = syn::parse2(attr).unwrap();
+    if let syn::Item::Fn(tagged_fn) = syn::parse2(tagged).unwrap() {
+        impl_trace(args, tagged_fn)
+    } else {
+        panic!("The ez_trace attribute can only be applied to functions");
+    }
+}
+
+fn impl_trace(attr: EzTraceArgs, mut tagged_fn: syn::ItemFn) -> proc_macro2::TokenStream {
+    let start_statement = if let Some(start_text) = attr.start {
+        let start_lit = syn::LitStr::new(&start_text, proc_macro2::Span::call_site());
+        quote! {
+            println!("{}", #start_lit);
+        }
+    } else {
+        quote! {}
+    };
+
+    let end_statement = if let Some(end_text) = attr.end {
+        let end_lit = syn::LitStr::new(&end_text, proc_macro2::Span::call_site());
+        quote! {
+            println!("{}", #end_lit);
+        }
+    } else {
+        quote! {}
+    };
+
+    let old_block = tagged_fn.block;
+    let new_block: syn::Block = syn::parse_quote! {
+        {
+            #start_statement
+            let ret = #old_block;
+            #end_statement
+            ret
+         }
+    };
+
+    tagged_fn.block = Box::new(new_block);
+
+    tagged_fn.into_token_stream().into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proc_macro2::TokenTree;
+    use std::iter::IntoIterator;
+    use syn::parse_quote;
+    use syn::Attribute;
+    use syn::ItemFn;
+
+    fn build_expected() -> ItemFn {
+        parse_quote! {
+            fn start() {
+                println!("{}", "Starting...");
+                let ret = { println!("start"); };
+                ret
+            }
+        }
+    }
+
+    fn build_input_attr() -> Attribute {
+        parse_quote! { #[ez_trace(start = "Starting...")] }
+    }
+
+    fn build_input_fn() -> ItemFn {
+        parse_quote! {
+            fn start() {
+                println!("start");
+            }
+        }
+    }
+
+    #[test]
+    fn example_trace_test() {
+        let expected = build_expected();
+        let expected_str = expected.into_token_stream().to_string();
+        let raw_attr_start = build_input_attr();
+        let raw_fn: ItemFn = build_input_fn();
+        let attr_start_tts = raw_attr_start.tts;
+        if let TokenTree::Group(group) = attr_start_tts.into_iter().next().unwrap() {
+            let output = ez_trace_impl(group.stream(), raw_fn.into_token_stream());
+            let output_str = output.into_token_stream().to_string();
+
+            assert_eq!(output_str, expected_str);
+        }
+    }
+}

attribution/examples/gs.rs

@@ -0,0 +1,153 @@
+extern crate proc_macro;
+
+use attribution::attr_args;
+use attribution::DynamicParameters;
+use attribution::ParamVal;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::Field;
+use syn::Fields;
+use syn::Ident;
+use syn::Item;
+use syn::ItemStruct;
+
+#[attr_args]
+struct GetterSetterArgs {
+    field_names: DynamicParameters,
+}
+
+#[proc_macro_attribute]
+pub fn gs(attr: TokenStream, tagged: TokenStream) -> TokenStream {
+    impl_gs(attr, tagged).into()
+}
+
+fn impl_gs(
+    into_attr: impl Into<TokenStream2>,
+    into_tagged: impl Into<TokenStream2>,
+) -> TokenStream2 {
+    let attr = into_attr.into();
+    let tagged = into_tagged.into();
+    let args: GetterSetterArgs = syn::parse2(attr).expect("Unabled to parse attribute");
+
+    if let Ok(Item::Struct(tagged_struct)) = syn::parse2(tagged) {
+        add_methods(tagged_struct, args.field_names)
+    } else {
+        panic!("The attribute can only be applied to structs")
+    }
+}
+
+fn add_methods(tagged_struct: ItemStruct, parameters: DynamicParameters) -> TokenStream2 {
+    if let Fields::Named(fields) = &tagged_struct.fields {
+        // Gets all the methods for the identifiers that were marked as true
+        let methods = fields
+            .named
+            .iter()
+            .filter(|field| {
+                let ident_text: String = field.ident.as_ref().unwrap().to_string();
+
+                *parameters
+                    .get(&ident_text)
+                    .map(|param_val| {
+                        if let ParamVal::Bool(b) = param_val {
+                            b
+                        } else {
+                            &false
+                        }
+                    })
+                    .unwrap_or(&false)
+            })
+            .map(make_method);
+
+        let impl_block_name = tagged_struct.ident.clone();
+        quote! {
+            #tagged_struct
+
+            impl #impl_block_name {
+                #(#methods)*
+            }
+        }
+    } else {
+        panic!("The tagged struct must have named fields")
+    }
+}
+
+fn make_method(field: &Field) -> TokenStream2 {
+    let field_ident = field.ident.as_ref().unwrap();
+    let field_type = &field.ty;
+    let setter_field = field_ident.clone();
+    let setter_type = field_type.clone();
+    let setter_name = Ident::new(
+        &format!("set_{}", field_ident.to_string()),
+        Span::call_site(),
+    );
+
+    let getter_field = field_ident.clone();
+    let getter_type = syn::TypeReference {
+        and_token: <syn::Token![&]>::default(),
+        lifetime: None,
+        mutability: None,
+        elem: Box::new(field_type.clone()),
+    };
+    let getter_name = Ident::new(
+        &format!("get_{}", field_ident.to_string()),
+        Span::call_site(),
+    );
+
+    quote! {
+        fn #getter_name(&self) -> #getter_type {
+            self.#getter_field
+        }
+
+        fn #setter_name(&mut self, new_val: #setter_type) {
+            self.#setter_field = new_val;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use quote::ToTokens;
+
+    #[test]
+    fn usage_test() {
+        let raw_attr: syn::Attribute = syn::parse_quote! {
+            #[gs(foo = true)]
+        };
+
+        let raw_struct: Item = syn::parse_quote! {
+            struct MyStruct {
+                foo: u32,
+                bar: bool,
+                baz: String
+            }
+        };
+
+        let expected = quote! {
+            struct MyStruct {
+                foo: u32,
+                bar: bool,
+                baz: String
+            }
+
+            impl MyStruct {
+                fn get_foo(&self) -> &u32 {
+                    self.foo
+                }
+
+                fn set_foo(&mut self, new_val: u32) {
+                    self.foo = new_val;
+                }
+            }
+        };
+
+        if let proc_macro2::TokenTree::Group(group) = raw_attr.tts.into_iter().next().unwrap() {
+            let actual = impl_gs(group.stream(), raw_struct.into_token_stream());
+            assert_eq!(actual.to_string(), expected.to_string());
+        } else {
+            panic!()
+        }
+    }
+}