envload_derive 0.1.1

Derive macro for envload
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

use convert_case::Casing;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Field, Fields, Ident};

#[proc_macro_derive(Envload)]
pub fn derive_envload(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let name = input.ident;

    let fields: Vec<syn::Field> = match input.data {
        Data::Struct(ref data) => match data.fields {
            Fields::Named(ref fields) => fields.named.iter().map(|f| f.clone()).collect(),
            Fields::Unnamed(_) => unimplemented!(),
            Fields::Unit => unimplemented!(),
        },
        Data::Enum(_) => unimplemented!(),
        Data::Union(_) => unimplemented!(),
    };
    let decls = gen_decls(&fields);
    // let result_decls = gen_result_decls(&fields);
    let return_struct = gen_return_struct(&name, &fields);

    let expanded = quote! {
        use envload::{maybe_option::__private::{MaybeOption, GenerateFallback}, errors::EnvloadError};

        impl envload::LoadEnv for #name {
            fn load_env() -> #name {
                #decls

                #return_struct
            }

            // fn try_load_env() -> Result<#name, EnvloadError> {
            //     #result_decls

            //     #return_struct
            // }
        }
    };

    proc_macro::TokenStream::from(expanded)
}

/// Generate the field declarations:
/// ```rust
///     let secret_key: String = /* ... */;
///     let optional_data: Option<T> = /* ... */;
/// ```
fn gen_decls(fields: &[Field]) -> TokenStream {
    let decls = fields.iter().map(|f| {
        let name = f.ident.clone();
        let key = f
            .ident
            .clone()
            .expect("No field name")
            .clone()
            .to_string()
            .to_case(convert_case::Case::ScreamingSnake);
        let ty = f.ty.clone();

        quote_spanned! {f.span()=>
            let #name: #ty = <MaybeOption<#ty>>::new().generate(#key);
        }
    });

    quote! {
        #(#decls)*
    }
}

/// Generate the return struct based on input fields:
/// ```rust
/// return Env {
///     secret_key,
///     optional_data,
/// };
/// ```
fn gen_return_struct(name: &Ident, fields: &[Field]) -> TokenStream {
    let field_names = fields.iter().map(|f| {
        let name = f.ident.clone();
        quote_spanned! {f.span()=>
            #name,
        }
    });

    quote! {
        return #name {
            #(#field_names)*
        };
    }
}

// /// Generate the field declarations as `Result`s for error handling:
// /// ```rust
// ///     let secret_key: Result<String> = /* ... */;
// ///     let optional_data: Result<Option<T>> = /* ... */;
// /// ```
// fn gen_result_decls(fields: &[Field]) -> TokenStream {
//     let decls = fields.iter().map(|f| {
//         let name = f.ident.clone();
//         let key = f
//             .ident
//             .clone()
//             .expect("No field name")
//             .clone()
//             .to_string()
//             .to_case(convert_case::Case::ScreamingSnake);
//         let ty = f.ty.clone();

//         quote_spanned! {f.span()=>
//             let #name: #ty = <MaybeOption<Result<#ty, EnvloadError>>>::new().generate(#key)?;
//         }
//     });

//     quote! {
//         #(#decls)*
//     }
// }