meta-enum-derive 0.1.0

Proc Macro for meta-enum crate
Documentation
use proc_macro::TokenStream;
use quote::quote;
use syn::DeriveInput;

#[proc_macro_derive(MetaEnum)]
pub fn derive_meta_enum(input: TokenStream) -> TokenStream {
    let ast: DeriveInput = syn::parse(input).unwrap();
    let ident = ast.ident;
    let len = match &ast.data {
        syn::Data::Enum(data_enum) => Some(data_enum.variants.len()),
        _ => None,
    };
    let variants: Vec<_> = match &ast.data {
        syn::Data::Enum(data_enum) => data_enum.variants.iter().map(|v| &v.ident).collect(),
        _ => Vec::new(),
    };
    let keys: Vec<_> = match &ast.data {
        syn::Data::Enum(data_enum) => data_enum
            .variants
            .iter()
            .map(|v| v.ident.to_string())
            .collect(),
        _ => Vec::new(),
    };
    let mut last_value = -1;
    let values: Vec<i32> = match &ast.data {
        syn::Data::Enum(data_enum) => data_enum
            .variants
            .iter()
            .map(|v| match &v.discriminant {
                Some(discriminant) => match &discriminant.1 {
                    syn::Expr::Lit(literal) => match &literal.lit {
                        syn::Lit::Int(value) => {
                            last_value = value.base10_parse().ok().unwrap();
                            last_value
                        }
                        _ => -1,
                    },
                    _ => -1,
                },
                None => match v.fields {
                    syn::Fields::Unit => {
                        last_value += 1;
                        last_value
                    }
                    _ => -1,
                },
            })
            .collect(),
        _ => Vec::new(),
    };
    if let Some(len) = len {
        quote! {
            impl MetaEnum for #ident {
                fn count() -> usize {
                    #len
                }
                fn keys() -> Vec<String> {
                    vec![#(#keys),*].into_iter().map(|key|key.to_string()).collect()
                }
                fn values() -> Vec<i32> {
                    vec![#(#values),*]
                }
            }
            impl core::str::FromStr for #ident {
                type Err = ParseMetaEnumError<#ident>;
                fn from_str(s: &str) -> Result<Self, Self::Err> {
                    for (key, variant) in vec![#(#keys),*].into_iter().zip(vec![#(#ident::#variants),*]) {
                        if key.to_ascii_lowercase() == s.to_ascii_lowercase() {
                            return Ok(variant);
                        }
                    }
                    Err(ParseMetaEnumError::new())
                }
            }
            impl From<i32> for #ident {
                fn from(value: i32) -> #ident {
                    match value {
                        #(x if x == #ident::#variants as i32 => #ident::#variants),*,
                        _ => unreachable!(),
                    }
                }
            }

            impl From<u8> for #ident {
                fn from(value: u8) -> #ident {
                    match value {
                        #(x if x == #ident::#variants as u8 => #ident::#variants),*,
                        _ => unreachable!(),
                    }
                }
            }
            impl Into<i32> for #ident {
                fn into(self) -> i32 {
                    self as i32
                }
            }
            impl Into<u8> for #ident {
                fn into(self) -> u8 {
                    self as u8
                }
            }
        }
        .into()
    } else {
        quote! {
            impl MetaEnum for #ident {
                fn count() -> usize {
                    compile_error!("MetaEnum Macro Only works on Enums");
                }
                fn keys() -> Vec<String> {
                    compile_error!("MetaEnum Macro Only works on Enums");
                }
                fn values() -> Vec<i32> {
                    compile_error!("MetaEnum Macro Only works on Enums");
                }
            }
        }
        .into()
    }
}