cfg_derive/
lib.rs

1//! Auto derive FromConfig.
2#![cfg_attr(docsrs, feature(doc_cfg))]
3#![warn(
4    anonymous_parameters,
5    missing_copy_implementations,
6    missing_debug_implementations,
7    missing_docs,
8    nonstandard_style,
9    rust_2018_idioms,
10    single_use_lifetimes,
11    trivial_casts,
12    trivial_numeric_casts,
13    unreachable_pub,
14    unused_extern_crates,
15    unused_qualifications,
16    variant_size_differences
17)]
18use quote::{__private::TokenStream, quote};
19use syn::*;
20
21#[allow(missing_docs)]
22#[proc_macro_derive(FromConfig, attributes(config))]
23pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
24    let input: DeriveInput = parse_macro_input!(input as DeriveInput);
25    let name = input.ident;
26    let body = match input.data {
27        Data::Struct(data) => derive_config_struct(&name, input.attrs, data),
28        _ => panic!("Only support struct"),
29    };
30    proc_macro::TokenStream::from(quote! {#body})
31}
32
33fn derive_config_struct(name: &Ident, attrs: Vec<Attribute>, data: DataStruct) -> TokenStream {
34    let fields = derive_config_fields(data);
35    let fs: Vec<Ident> = fields.iter().map(|f| f.name.clone()).collect();
36    let rs: Vec<&str> = fields.iter().map(|f| f.ren.as_str()).collect();
37    let ds: Vec<TokenStream> = fields
38        .iter()
39        .map(|f| match &f.def {
40            Some(d) => quote! {,Some(#d.into())},
41            _ => quote! {,None},
42        })
43        .collect();
44    let body = quote! {
45        Self {
46                #(#fs: context.parse_config(#rs#ds)?,)*
47        }
48    };
49
50    let prefix = match derive_config_attr(attrs) {
51        Some(p) => quote! {
52            impl FromConfigWithPrefix for #name {
53                fn prefix() -> &'static str {
54                    #p
55                }
56            }
57        },
58        _ => quote! {},
59    };
60
61    quote! {
62        impl FromConfig for #name {
63            fn from_config(
64                context: &mut ConfigContext<'_>,
65                value: Option<ConfigValue<'_>>,
66            ) -> Result<Self, ConfigError> {
67                Ok(#body)
68            }
69        }
70
71        #prefix
72    }
73}
74
75fn derive_config_attr(attrs: Vec<Attribute>) -> Option<String> {
76    let mut prefix = None;
77    for attr in attrs {
78        if attr.path().is_ident("config") {
79            attr.parse_nested_meta(|meta| {
80                if meta.path.is_ident("prefix") {
81                    let value = meta.value()?;
82                    let s: LitStr = value.parse()?;
83                    prefix = Some(s.value());
84                    Ok(())
85                } else {
86                    Err(meta.error("Only support prefix"))
87                }
88            })
89            .unwrap();
90        }
91        if prefix.is_some() {
92            break;
93        }
94    }
95    prefix
96}
97
98struct FieldInfo {
99    name: Ident,
100    def: Option<String>,
101    ren: String,
102    desc: Option<String>,
103}
104
105fn derive_config_fields(data: DataStruct) -> Vec<FieldInfo> {
106    if let Fields::Named(fields) = data.fields {
107        let mut fs = vec![];
108        for field in fields.named {
109            fs.push(derive_config_field(field));
110        }
111        return fs;
112    }
113    panic!("Only support named body");
114}
115
116fn derive_config_field(field: Field) -> FieldInfo {
117    let name = field.ident.expect("Not possible");
118    let mut f = FieldInfo {
119        ren: name.to_string(),
120        name,
121        def: None,
122        desc: None,
123    };
124    derive_config_field_attr(&mut f, field.attrs);
125    f
126}
127
128fn derive_config_field_attr(f: &mut FieldInfo, attrs: Vec<Attribute>) {
129    for attr in attrs {
130        if attr.path().is_ident("config") {
131            attr.parse_nested_meta(|meta| {
132                if meta.path.is_ident("default") {
133                    f.def = Some(parse_lit(meta.value()?.parse::<Lit>()?));
134                } else if meta.path.is_ident("name") {
135                    f.ren = parse_lit(meta.value()?.parse::<Lit>()?);
136                } else if meta.path.is_ident("desc") {
137                    f.desc = Some(parse_lit(meta.value()?.parse::<Lit>()?));
138                } else {
139                    return Err(meta.error("Only support default/name/desc"));
140                }
141                Ok(())
142            })
143            .unwrap();
144        }
145    }
146}
147
148fn parse_lit(lit: Lit) -> String {
149    match lit {
150        Lit::Str(s) => s.value(),
151        Lit::ByteStr(s) => match String::from_utf8(s.value()) {
152            Ok(v) => v,
153            Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
154        },
155        Lit::Byte(b) => (b.value() as char).to_string(),
156        Lit::Int(i) => i.base10_digits().to_owned(),
157        Lit::Float(f) => f.base10_digits().to_owned(),
158        Lit::Bool(b) => b.value.to_string(),
159        Lit::Char(c) => c.value().to_string(),
160        Lit::Verbatim(_) => panic!("cfg-rs not support Verbatim"),
161        _ => panic!("cfg-rs not support new types"),
162    }
163}
cfg_derive/lib.rs

cfg_derive/
lib.rs
