wip

Author: prestwich

.gitignore

@@ -1,2 +1,3 @@
 /target
+from-env-macro/target
 Cargo.lock

Cargo.toml

@@ -44,6 +44,7 @@ axum = "0.8.1"
 serial_test = "3.2.0"
 signal-hook = "0.3.17"
 tokio = { version = "1.43.0", features = ["macros"] }
+from-env-macro = { path = "./from-env-macro" }
 
 [features]
 default = ["alloy"]

from-env-macro/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "from-env-macro"
+description = "The `FromEnv` derive macro"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+heck = "0.5.0"
+proc-macro2 = "1.0.95"
+quote = "1.0.40"
+syn = { version = "2.0.100", features = ["full", "parsing"] }
+
+[lib]
+proc-macro = true
+
+[dev-dependencies]
+init4-bin-base = { path = ".." }

from-env-macro/src/field.rs

@@ -0,0 +1,69 @@
+use heck::ToPascalCase;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, LitStr, spanned::Spanned};
+
+/// A parsed Field of a struct
+pub(crate) struct Field {
+    env_var: Option<LitStr>,
+    field_name: Option<Ident>,
+    field_type: syn::Type,
+
+    span: proc_macro2::Span,
+}
+
+impl From<&syn::Field> for Field {
+    fn from(field: &syn::Field) -> Self {
+        let env_var = field
+            .attrs
+            .iter()
+            .filter_map(|attr| attr.meta.require_list().ok())
+            .find(|attr| attr.path.is_ident("from_env_var"))
+            .and_then(|attr| attr.parse_args::<LitStr>().ok());
+
+        let field_type = field.ty.clone();
+        let field_name = field.ident.clone();
+        let span = field.span();
+
+        Field {
+            env_var,
+            field_name,
+            field_type,
+            span,
+        }
+    }
+}
+
+impl Field {
+    pub(crate) fn enum_variant_name(&self, idx: usize) -> TokenStream {
+        eprintln!("Field name: {:?}", self.field_name);
+        let n = if let Some(field_name) = self.field_name.as_ref() {
+            field_name.to_string()
+        } else {
+            format!("Field{}", idx)
+        }
+        .to_pascal_case();
+
+        syn::parse_str::<Ident>(&n)
+            .map_err(|_| syn::Error::new(self.span, "Failed to create field name"))
+            .unwrap();
+
+        eprintln!("Field name: {}", n);
+
+        return quote! { #n };
+    }
+
+    pub(crate) fn expand_enum_variant(&self, idx: usize) -> TokenStream {
+        let field_name = self.enum_variant_name(idx);
+        let field_type = &self.field_type;
+        let field_trait = if self.env_var.is_some() {
+            quote! { FromEnv }
+        } else {
+            quote! { FromEnvErr }
+        };
+        quote! {
+            #[doc = "Error for" #field_name]
+            #field_name(<#field_type as #field_trait>::Error)
+        }
+    }
+}

from-env-macro/src/lib.rs

@@ -0,0 +1,125 @@
+use heck::ToPascalCase;
+use proc_macro::TokenStream as Ts;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DeriveInput, parse_macro_input, spanned::Spanned};
+
+mod field;
+use field::Field;
+
+#[proc_macro_derive(FromEnv, attributes(from_env_var))]
+pub fn derive(input: Ts) -> Ts {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    if !matches!(input.data, syn::Data::Struct(_)) {
+        syn::Error::new(
+            input.ident.span(),
+            "FromEnv can only be derived for structs",
+        )
+        .to_compile_error();
+    };
+
+    let syn::Data::Struct(data) = &input.data else {
+        unreachable!()
+    };
+
+    if matches!(data.fields, syn::Fields::Unit) {
+        syn::Error::new(
+            input.ident.span(),
+            "FromEnv can only be derived for structs with fields",
+        )
+        .to_compile_error();
+    }
+
+    expand_mod(&input).into()
+}
+
+fn expand_mod(input: &syn::DeriveInput) -> TokenStream {
+    let expanded_impl = expand_struct(input);
+    let expanded_error = expand_error(input);
+
+    quote! {
+        #[automatically_derived]
+        const _: () = {
+            use ::init4_bin_base::utils::from_env::{FromEnv, FromEnvErr, FromEnvVar};
+
+            #expanded_impl
+
+            #expanded_error
+        };
+    }
+}
+
+fn expand_struct(input: &syn::DeriveInput) -> TokenStream {
+    let struct_name = &input.ident;
+
+    quote! {
+
+        // #[automatically_derived]
+        // impl FromEnv for #struct_name {
+
+        // }
+    }
+}
+
+fn error_ident(input: &syn::DeriveInput) -> syn::Ident {
+    let error_name = format!("{}Error", input.ident);
+    syn::parse_str::<syn::Ident>(&error_name)
+        .map_err(|_| {
+            syn::Error::new(input.ident.span(), "Failed to parse error ident").to_compile_error()
+        })
+        .unwrap()
+}
+
+fn expand_error(input: &syn::DeriveInput) -> TokenStream {
+    let error_ident = error_ident(input);
+
+    let syn::Data::Struct(data) = &input.data else {
+        unreachable!()
+    };
+    let fields = match &data.fields {
+        syn::Fields::Named(fields) => fields.named.iter().map(Field::from).collect::<Vec<_>>(),
+        syn::Fields::Unnamed(fields) => fields.unnamed.iter().map(Field::from).collect::<Vec<_>>(),
+        syn::Fields::Unit => unreachable!(),
+    };
+
+    let error_variants = fields
+        .iter()
+        .enumerate()
+        .map(|(idx, field)| field.expand_enum_variant(idx))
+        .collect::<Vec<_>>();
+
+    let variant_names = fields
+        .iter()
+        .enumerate()
+        .map(|(idx, field)| field.enum_variant_name(idx))
+        .collect::<Vec<_>>();
+
+    let s = quote! {
+        #[doc("Generated error type for `FromEnv`")]
+        #[derive(Debug, PartialEq, Eq)]
+        pub enum #error_ident {
+            #(#error_variants),*
+        }
+
+        impl ::core::error::Error for #error_ident {
+            fn source(&self) -> Option<&(dyn ::core::any::Any + ::core::marker::Send + 'static)> {
+                match self {
+                    #(
+                        Self::#variant_names(err) => Some(err),
+                    )*
+                }
+            }
+
+            fn description(&self) -> &str {
+                match self {
+                    #(
+                        Self::#variant_names(err) => err.description(),
+                    )*
+                }
+            }
+        }
+    };
+    eprintln!("{s}");
+    s
+}

tests/macro.rs

@@ -0,0 +1,9 @@
+use from_env_macro::FromEnv;
+
+#[derive(FromEnv, Debug)]
+pub struct FromEnvTest {
+    pub tony: String,
+
+    #[from_env_var("FIELD2")]
+    pub charles: u64,
+}