litenum 1.1.1

minimal convertion utilities between literal and enum
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use syn::{parse::Parse, punctuated::Punctuated, token, Result};
use proc_macro2::{Ident, TokenStream};
use quote::quote;


pub(crate) struct SimpleEnum {
    pub(crate) ident:    Ident,
    pub(crate) variants: Punctuated<Ident, token::Comma>,
}

impl Parse for SimpleEnum {
    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
        while input.peek(token::Pound) {
            input.parse::<token::Pound>()?;
            let attr; syn::bracketed!(attr in input);
            attr.parse::<TokenStream>()?;
        }
        if input.peek(token::Pub) {
            input.parse::<token::Pub>()?;
            if input.peek(token::Paren) {
                let scope; syn::parenthesized!(scope in input);
                scope.parse::<TokenStream>()?;
            }
        }
        input.parse::<token::Enum>()?;
        let ident = input.parse::<Ident>()?;
        let variants_buf; syn::braced!(variants_buf in input);
        let variants = variants_buf.parse_terminated::<_, token::Comma>(Ident::parse)?;

        Ok(Self { ident, variants })
    }
}

impl SimpleEnum {
    pub(crate) fn to_lit_impl(&self) -> TokenStream {
        let Self { ident, variants } = self;

        let proc = {
            let arms = variants.iter().map(|ident| {
                quote! { Self::#ident => stringify!(#ident), }
            });

            quote! {
                match *self {
                    #( #arms )*
                }
            }
        };

        let doc = format!("*implemented by litenum*");

        quote! {
            impl #ident {
                #[doc = #doc]
                #[inline]
                pub(crate) const fn lit(&self) -> &'static str {
                    #proc
                }
            }
        }
    }

    pub(crate) fn from_lit_impl(&self) -> TokenStream {
        let Self { ident, variants } = self;

        let proc = {
            let arms = variants.iter().map(|ident| {
                quote! { stringify!(#ident) => Some(Self::#ident), }
            });

            quote! {
                match lit {
                    #( #arms )*
                    _ => None
                }
            }
        };

        let doc = format!("*implemented by litenum*");

        quote! {
            impl #ident {
                #[doc = #doc]
                #[inline]
                pub(crate) fn from_lit(lit: &str) -> Option<Self> {
                    #proc
                }
            }
        }
    }
}