confgr_derive 0.2.1

Procedural derive macro implementation for the confgr crate
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::{get_ident_from_type, ConfigAttributes, SUFFIX};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Ident, Type};

const DEFAULT_PREFIX: &str = "";
const DEFAULT_SEPARATOR: &str = "_";

pub fn generate_from_env(
    name: &Ident,
    struct_attributes: &ConfigAttributes,
    field_data: &[(&Ident, &Type, ConfigAttributes)],
) -> TokenStream {
    let layer_name = format_ident!("{}{}", name, SUFFIX);

    let env_items = field_data.iter().map(|(field_name, ty, attr)| {
        let mut env_var_name = field_name.to_string().to_uppercase();

        if let Some(ref key) = attr.key {
            env_var_name = key.clone().to_uppercase();
        } else if attr.prefix.is_some() || struct_attributes.prefix.is_some() {
            let separator = attr
                .separator
                .as_ref()
                .unwrap_or(
                    struct_attributes
                        .separator
                        .as_ref()
                        .unwrap_or(&String::from(DEFAULT_SEPARATOR)),
                )
                .clone();

            let prefix = attr
                .prefix
                .as_ref()
                .unwrap_or(
                    struct_attributes
                        .prefix
                        .as_ref()
                        .unwrap_or(&String::from(DEFAULT_PREFIX)),
                )
                .to_uppercase();

            env_var_name = format!(
                "{}{}{}",
                prefix,
                separator,
                field_name.to_string().to_uppercase()
            );
        }

        if attr.skip || struct_attributes.skip {
            quote! { #field_name: None }
        } else if attr.nest {
            let ty_ident = get_ident_from_type(ty);
            let nested_builder = format_ident!("{}{}", ty_ident, SUFFIX);
            quote! { #field_name: #nested_builder::from_env() }
        } else {
            quote! {
                #field_name: match ::std::env::var(#env_var_name) {
                    Ok(val) => val.parse::<#ty>().ok(),
                    Err(_) => None
                }
            }
        }
    });

    let env_keys = field_data.iter().map(|(field_name, _, attr)| {
        let mut env_var_name = field_name.to_string().to_uppercase();

        if let Some(ref key) = attr.key {
            env_var_name = key.clone().to_uppercase();
        } else if attr.prefix.is_some() || struct_attributes.prefix.is_some() {
            let separator = attr
                .separator
                .as_ref()
                .unwrap_or(
                    struct_attributes
                        .separator
                        .as_ref()
                        .unwrap_or(&String::from(DEFAULT_SEPARATOR)),
                )
                .clone();

            let prefix = attr
                .prefix
                .as_ref()
                .unwrap_or(
                    struct_attributes
                        .prefix
                        .as_ref()
                        .unwrap_or(&String::from(DEFAULT_PREFIX)),
                )
                .to_uppercase();

            env_var_name = format!(
                "{}{}{}",
                prefix,
                separator,
                field_name.to_string().to_uppercase()
            );
        }
        quote! { stringify!(#field_name).to_string(), #env_var_name.to_string() }
    });

    quote! {
        #[automatically_derived]
        impl ::confgr::core::FromEnv for #layer_name {
            fn from_env() -> Self {
                Self {
                    #( #env_items ),*
                }
            }

             fn get_env_keys() -> ::std::collections::HashMap<String, String> {
                 let mut map = ::std::collections::HashMap::new();
                 #(
                     map.insert(#env_keys);
                 )*
                 map
             }
        }
    }
}