derive_macro.rs

use derive_simple::DeriveSimple;
use proc_macro::TokenStream as TokenStream1;
use quote::quote;
use syn::DeriveInput;

#[proc_macro_derive(Simple)]
pub fn derive_simple(input: TokenStream1) -> TokenStream1 {
    let derive_simple = DeriveSimple {
        input: syn::parse_macro_input!(input as DeriveInput),
    };
    let code_derive_simple = derive_simple.to_code();

    TokenStream1::from(quote! {
      #code_derive_simple
    })
}


mod derive_simple {
    use proc_macro2::TokenStream as TokenStream2;
    use quote::quote;
    use syn::DeriveInput;

    pub struct DeriveSimple {
        pub input: DeriveInput,
    }
    impl DeriveSimple {
        pub fn from_input(input: &DeriveInput) -> DeriveSimple {
            DeriveSimple {
                input: input.clone(),
            }
        }
        pub fn to_code(&self) -> TokenStream2 {
            let name = &self.input.ident;
            let gen = quote! {
                impl #name {
                    fn say_my_name() -> String {
                        format!("Hello, Macro! My name is {}", stringify!(#name))
                    }
                }
            };
            gen.into()
        }
    }
}

#[cfg(test)]
mod tests {
    use proc_macro2::TokenStream as TokenStream2;
    use quote::quote;
    use syn::DeriveInput;

    use crate::derive_simple::DeriveSimple;

    fn derive_input(input: TokenStream2) -> DeriveInput {
        syn::parse2::<DeriveInput>(input).unwrap()
    }

    #[test]
    fn test_my_macro() {
        let input_enum: DeriveInput = derive_input(quote! {
            enum TestErrors {
                #[error("some_error")]
                NotFound,
                #[error("some_error")]
                ServerError,
            }
        });

        let output = DeriveSimple::from_input(&input_enum).to_code();
        dbg!(&output);

        assert_eq!(output.to_string(), "");

    }
}