init4_from_env_derive/
lib.rs

1use proc_macro::TokenStream as Ts;
2use proc_macro2::TokenStream;
3use quote::quote;
4use syn::{parse_macro_input, DeriveInput};
5
6mod field;
7use field::Field;
8
9/// This macro generates an implementation of the `FromEnv` trait for a struct.
10/// See the documenetation in init4_bin_base for more details.
11#[proc_macro_derive(FromEnv, attributes(from_env))]
12pub fn derive(input: Ts) -> Ts {
13    let input = parse_macro_input!(input as DeriveInput);
14
15    if !matches!(input.data, syn::Data::Struct(_)) {
16        syn::Error::new(
17            input.ident.span(),
18            "FromEnv can only be derived for structs",
19        )
20        .to_compile_error();
21    };
22
23    let syn::Data::Struct(data) = &input.data else {
24        unreachable!()
25    };
26
27    let crate_name = input
28        .attrs
29        .iter()
30        .find(|attr| attr.path().is_ident("from_env"))
31        .and_then(|attr| attr.parse_args::<syn::Path>().ok())
32        .unwrap_or_else(|| syn::parse_str::<syn::Path>("::init4_bin_base").unwrap());
33
34    let tuple_like = matches!(data.fields, syn::Fields::Unnamed(_));
35
36    if matches!(data.fields, syn::Fields::Unit) {
37        syn::Error::new(
38            input.ident.span(),
39            "FromEnv can only be derived for structs with fields",
40        )
41        .to_compile_error();
42    }
43
44    let fields = match &data.fields {
45        syn::Fields::Named(fields) => fields.named.iter().map(Field::try_from),
46        syn::Fields::Unnamed(fields) => fields.unnamed.iter().map(Field::try_from),
47        syn::Fields::Unit => unreachable!(),
48    };
49
50    let fields = match fields.collect::<Result<Vec<_>, _>>() {
51        Ok(fields) => fields,
52        Err(err) => {
53            return err.to_compile_error().into();
54        }
55    };
56
57    let input = Input {
58        ident: input.ident.clone(),
59        fields,
60        crate_name,
61        tuple_like,
62    };
63
64    input.expand_mod().into()
65}
66
67struct Input {
68    ident: syn::Ident,
69
70    fields: Vec<Field>,
71
72    crate_name: syn::Path,
73
74    tuple_like: bool,
75}
76
77impl Input {
78    fn field_names(&self) -> Vec<syn::Ident> {
79        self.fields
80            .iter()
81            .enumerate()
82            .map(|(idx, field)| field.field_name(idx))
83            .collect()
84    }
85
86    fn instantiate_struct(&self) -> TokenStream {
87        let struct_name = &self.ident;
88        let field_names = self.field_names();
89
90        if self.tuple_like {
91            return quote! {
92                #struct_name(
93                    #(#field_names),*
94                )
95            };
96        }
97
98        quote! {
99            #struct_name {
100                #(#field_names),*
101            }
102        }
103    }
104
105    fn item_from_envs(&self) -> Vec<TokenStream> {
106        self.fields
107            .iter()
108            .enumerate()
109            .map(|(idx, field)| field.expand_item_from_env(idx))
110            .collect()
111    }
112
113    fn env_item_info(&self) -> Vec<TokenStream> {
114        self.fields
115            .iter()
116            .map(|field| field.expand_env_item_info())
117            .collect()
118    }
119
120    fn expand_impl(&self) -> TokenStream {
121        let env_item_info = self.env_item_info();
122        let struct_name = &self.ident;
123
124        let item_from_envs = self.item_from_envs();
125        let struct_instantiation = self.instantiate_struct();
126
127        quote! {
128            #[automatically_derived]
129            impl FromEnv for #struct_name {
130                fn inventory() -> ::std::vec::Vec<&'static EnvItemInfo> {
131                    let mut items = ::std::vec::Vec::new();
132                    #(
133                        #env_item_info
134                    )*
135                    items
136                }
137
138                fn from_env() -> ::std::result::Result<Self, FromEnvErr> {
139                    #(
140                        #item_from_envs
141                    )*
142
143                    ::std::result::Result::Ok(#struct_instantiation)
144                }
145            }
146        }
147    }
148
149    fn expand_mod(&self) -> TokenStream {
150        let expanded_impl = self.expand_impl();
151        let crate_name = &self.crate_name;
152
153        let mod_ident =
154            syn::parse_str::<syn::Ident>(&format!("__from_env_impls_{}", self.ident)).unwrap();
155
156        quote! {
157            mod #mod_ident {
158                use super::*;
159                use #crate_name::utils::from_env::{FromEnv, FromEnvErr, FromEnvVar, EnvItemInfo};
160
161                #expanded_impl
162            }
163        }
164    }
165}
init4_from_env_derive/lib.rs

init4_from_env_derive/
lib.rs
