declarative-env 0.1.1

This crate parses and populates a struct with the environmental variables defined in a file, for having the documentation and the code always synchronized.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use proc_macro::TokenStream;
use proc_macro2::{Span as Span2, TokenStream as TokenStream2};
use quote::{format_ident, quote, ToTokens};
use syn::token::Struct as SynStruct;
use syn::Ident as SynIdent;

use crate::{EmptyStruct, EnvVariableDeclarations};

pub struct DeclarativeEnvGenerator {
    empty_struct: EmptyStruct,
    variable_declarations: EnvVariableDeclarations,
}

impl DeclarativeEnvGenerator {
    pub fn new(
        empty_struct: EmptyStruct,
        variable_declarations: EnvVariableDeclarations,
    ) -> DeclarativeEnvGenerator {
        DeclarativeEnvGenerator {
            empty_struct,
            variable_declarations,
        }
    }

    pub fn generate(&self) -> TokenStream {
        let mut result = TokenStream2::new();
        result.extend(self.create_struct_def());
        result.extend(self.create_struct_impl());
        result.extend(self.requiredenvnotfounderror_code());
        result.into()
    }

    fn create_struct_def(&self) -> TokenStream2 {
        let mut token_stream: TokenStream2 = TokenStream2::new();
        token_stream.extend(quote! { #[derive(Debug, Clone)] });
        token_stream.extend(self.empty_struct.visibility().to_token_stream());
        token_stream.extend(SynStruct::default().to_token_stream());
        token_stream.extend(
            SynIdent::new(self.empty_struct.struct_name(), Span2::call_site()).to_token_stream(),
        );

        let mut fields = TokenStream2::new();
        for it in self.variable_declarations.as_ref() {
            let variable_name = SynIdent::new(it.name(), Span2::call_site());
            let variable_type = it.rust_type();
            fields.extend(quote! { #variable_name: #variable_type, });
        }
        token_stream.extend(quote! { { #fields } });
        token_stream
    }

    fn create_struct_impl(&self) -> TokenStream2 {
        let mut token_stream: TokenStream2 = TokenStream2::new();
        let struct_name = SynIdent::new(self.empty_struct.struct_name(), Span2::call_site());
        let requiredenvnotfounderror_struct_ident = self.requiredenvnotfounderror_struct_ident();
        let mut functions: TokenStream2 = TokenStream2::new();
        let mut variable_reads = TokenStream2::new();
        for it in self.variable_declarations.as_ref() {
            let var_name = SynIdent::new(it.name(), Span2::call_site());
            let var_name_str = it.name();
            let var_type = it.rust_type();
            let default_behaviour = match &it.default_value() {
                Some(v) => {
                    quote! {
                        #v.parse::<#var_type>()?
                    }
                }
                None => quote! {
                    return Err(#requiredenvnotfounderror_struct_ident::new(#var_name_str).into())
                },
            };
            variable_reads.extend(quote! {
                let #var_name = match std::env::var(#var_name_str) {
                    Ok(v) => v.parse::<#var_type>()?,
                    Err(std::env::VarError::NotPresent) => #default_behaviour,
                    Err(e) => return Err(e.into()),
                };
            });
        }
        let all_vars = self
            .variable_declarations
            .iter()
            .map(|it| SynIdent::new(it.name(), Span2::call_site()));
        functions.extend(quote! {
            pub fn from_env() -> Result<Self, Box<dyn std::error::Error>> {
                #variable_reads
                Ok(#struct_name { #(#all_vars),* })
            }
        });
        for it in self.variable_declarations.as_ref() {
            let fn_name = SynIdent::new(it.name(), Span2::call_site());
            let fn_return_type = it.rust_type().to_struct_return_type();
            let self_ref = it.rust_type().to_struct_self_caller();
            functions.extend(quote! {
                pub fn #fn_name(&self) -> #fn_return_type {
                    #self_ref.#fn_name
                }
            });
        }
        token_stream.extend(quote! {
            impl #struct_name {
                #functions
            }
        });
        token_stream
    }

    fn requiredenvnotfounderror_struct_ident(&self) -> SynIdent {
        format_ident!(
            "{}RequiredEnvNotFoundError",
            self.empty_struct.struct_name()
        )
    }

    fn requiredenvnotfounderror_code(&self) -> TokenStream2 {
        let error_struct_name = self.requiredenvnotfounderror_struct_ident();
        quote! {
            #[derive(Debug)]
            pub struct #error_struct_name {
                key: String,
            }

            impl #error_struct_name {
                fn new(key: &str) -> Self {
                    Self { key: key.to_string() }
                }
            }

            impl std::fmt::Display for #error_struct_name {
                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                    write!(
                    f,
                    "failed to load configuration from env: variable {} not found and no default value specified",
                    self.key,
                    )
                }
            }

            impl std::error::Error for #error_struct_name {}
        }
    }
}