Start testing env.

Author: milesj

crates/core/src/args.rs

@@ -57,12 +57,12 @@ impl FromMeta for SerdeRenameArg {
 }
 
 impl SerdeRenameArg {
-    // pub fn get_name(&self, dir: SerdeIoDirection) -> Option<&str> {
-    //     match dir {
-    //         SerdeIoDirection::From => self.deserialize.as_deref(),
-    //         SerdeIoDirection::To => self.serialize.as_deref(),
-    //     }
-    // }
+    pub fn get_name(&self, dir: SerdeIoDirection) -> Option<&str> {
+        match dir {
+            SerdeIoDirection::From => self.deserialize.as_deref(),
+            SerdeIoDirection::To => self.serialize.as_deref(),
+        }
+    }
 
     pub fn get_meta(&self, key: &str) -> TokenStream {
         match (self.deserialize.as_deref(), self.serialize.as_deref()) {

crates/core/src/container.rs

@@ -178,13 +178,15 @@ impl Container {
         };
 
         let default_values_method = self.impl_partial_default_values();
+        let env_values_method = self.impl_partial_env_values();
 
         quote! {
             #[automatically_derived]
             impl schematic::PartialConfig for #partial_name {
                 type Context = #context;
 
                 #default_values_method
+                #env_values_method
             }
 
             #[automatically_derived]
@@ -214,11 +216,11 @@ impl Container {
                     let res = field.impl_partial_default_value();
 
                     if !res.no_value {
-                        let name = field.ident.as_ref().unwrap();
+                        let key = field.get_key();
                         let value = res.value;
 
                         rows.push(quote! {
-                            #name: #value,
+                            #key: #value,
                         });
                     }
 
@@ -227,6 +229,7 @@ impl Container {
                     }
                 }
 
+                // Do not implement method
                 if rows.is_empty() {
                     return quote! {};
                 }
@@ -263,6 +266,7 @@ impl Container {
                     }
                 }
 
+                // Do not implement method
                 if all_none {
                     return quote! {};
                 }
@@ -319,6 +323,58 @@ impl Container {
             }
         }
     }
+
+    pub fn impl_partial_env_values(&self) -> TokenStream {
+        let inner = match &self.inner {
+            ContainerInner::NamedStruct { fields } | ContainerInner::UnnamedStruct { fields } => {
+                let mut rows = vec![];
+
+                for field in fields {
+                    let res = field.impl_partial_env_value();
+
+                    if !res.no_value {
+                        let key = field.get_key();
+                        let value = res.value;
+
+                        rows.push(quote! {
+                            partial.#key = #value;
+                        });
+                    }
+                }
+
+                // Do not implement method
+                if rows.is_empty() {
+                    return quote! {};
+                }
+
+                quote! {
+                    #(#rows)*
+                }
+            }
+
+            // Enums don't support env vars
+            _ => return quote! {},
+        };
+
+        let internal = ImplResult::impl_use_internal(true);
+
+        quote! {
+            fn env_values() -> std::result::Result<Option<Self>, schematic::ConfigError> {
+                #internal
+
+                let mut env = EnvManager::default();
+                let mut partial = Self::default();
+
+                #inner
+
+                Ok(if env.is_empty() {
+                    None
+                } else {
+                    Some(partial)
+                })
+            }
+        }
+    }
 }
 
 impl ToTokens for Container {

crates/core/src/field.rs

@@ -1,9 +1,12 @@
-use crate::args::{PartialArg, SerdeContainerArgs, SerdeFieldArgs, SerdeRenameArg};
+use crate::args::{
+    PartialArg, SerdeContainerArgs, SerdeFieldArgs, SerdeIoDirection, SerdeRenameArg,
+};
 use crate::container::ContainerArgs;
 use crate::field_value::FieldValue;
 use crate::utils::{ImplResult, preserve_str_literal, to_type_string};
 use darling::{FromAttributes, FromMeta};
-use quote::ToTokens;
+use proc_macro2::{Literal, TokenStream};
+use quote::{ToTokens, TokenStreamExt, quote};
 use std::ops::Deref;
 use std::rc::Rc;
 use syn::{Attribute, Expr, ExprPath, Field as NativeField, FieldMutability, Ident, Visibility};
@@ -154,37 +157,13 @@ impl Field {
     fn validate_args(&self) {
         #[cfg(feature = "env")]
         {
-            // env
-            if self.args.env.as_ref().is_some_and(|key| key.is_empty()) {
-                panic!("Attribute `env` cannot be empty.");
-            }
-
-            if self.args.env.is_some() && self.args.env_prefix.is_some() {
-                panic!("Cannot use `env` and `env_prefix` together.");
-            }
-
             // env_prefix
-            if self
-                .args
-                .env_prefix
-                .as_ref()
-                .is_some_and(|key| key.is_empty())
-            {
-                panic!("Attribute `env_prefix` cannot be empty.");
-            }
-
             if self.args.env_prefix.is_some() && self.args.nested.is_none() {
                 panic!("Cannot use `env_prefix` without `nested`.");
             }
         }
 
         // nested
-        if self.args.nested.is_some() {
-            #[cfg(feature = "env")]
-            if self.args.env.is_some() {
-                panic!("Cannot use `env` with `nested`, use `env_prefix` instead?");
-            }
-        }
 
         #[cfg(feature = "env")]
         {
@@ -194,6 +173,83 @@ impl Field {
             }
         }
     }
+
+    #[cfg(not(feature = "env"))]
+    pub fn get_env_var(&self) -> Option<String> {
+        None
+    }
+
+    #[cfg(feature = "env")]
+    pub fn get_env_var(&self) -> Option<String> {
+        if self.args.env.is_some() && self.args.env_prefix.is_some() {
+            panic!("Cannot use `env` and `env_prefix` together.");
+        }
+
+        if let Some(env_key) = &self.args.env {
+            if env_key.is_empty() {
+                panic!("Attribute `env` cannot be empty.");
+            }
+
+            if self.is_nested() {
+                panic!("Cannot use `env` with `nested`, use `env_prefix` instead?");
+            }
+
+            return Some(env_key.to_owned());
+        }
+
+        if let Some(env_prefix) = &self.container_args.env_prefix {
+            if env_prefix.is_empty() {
+                panic!("Attribute `env_prefix` cannot be empty.");
+            }
+
+            return Some(format!("{env_prefix}{}", self.get_name()).to_uppercase());
+        }
+
+        None
+    }
+
+    pub fn get_key(&self) -> TokenStream {
+        self.ident
+            .as_ref()
+            .map(|name| quote! { #name })
+            .unwrap_or_else(|| {
+                let index = Index(self.index);
+
+                quote! { #index }
+            })
+    }
+
+    pub fn get_name(&self) -> String {
+        let dir = SerdeIoDirection::From;
+
+        if let Some(name) = self.args.rename.as_ref().and_then(|rn| rn.get_name(dir)) {
+            return name.into();
+        }
+
+        if let Some(name) = self
+            .serde_args
+            .rename
+            .as_ref()
+            .and_then(|rn| rn.get_name(dir))
+        {
+            return name.into();
+        }
+
+        self.ident
+            .as_ref()
+            .expect("Name only usable on named fields!")
+            .to_string()
+    }
+
+    pub fn is_nested(&self) -> bool {
+        self.args
+            .nested
+            .as_ref()
+            .is_some_and(|nested| match nested {
+                FieldNestedArg::Detect(inner) => *inner,
+                FieldNestedArg::Ident(_) => true,
+            })
+    }
 }
 
 // impl ToTokens for Field {
@@ -223,4 +279,34 @@ impl Field {
     pub fn impl_partial_default_value(&self) -> ImplResult {
         self.value.impl_partial_default_value(&self.args)
     }
+
+    #[cfg(not(feature = "env"))]
+    pub fn impl_partial_env_value(&self) -> ImplResult {
+        ImplResult::skipped()
+    }
+
+    #[cfg(feature = "env")]
+    pub fn impl_partial_env_value(&self) -> ImplResult {
+        if self.is_nested() {
+            return self.value.impl_partial_env_value(&self.args, "");
+        }
+
+        let Some(env_key) = self.get_env_var() else {
+            if self.args.parse_env.is_some() {
+                panic!("Cannot use `parse_env` without `env` or a parent `env_prefix`.");
+            }
+
+            return ImplResult::skipped();
+        };
+
+        self.value.impl_partial_env_value(&self.args, &env_key)
+    }
+}
+
+struct Index(usize);
+
+impl ToTokens for Index {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.append(Literal::usize_unsuffixed(self.0));
+    }
 }

crates/core/src/field_value.rs

@@ -84,10 +84,19 @@ impl FieldValue {
         self.inner_ty.as_ref().unwrap_or(&self.ty)
     }
 
+    pub fn is_collection(&self) -> bool {
+        self.layers.iter().any(|layer| {
+            matches!(
+                layer,
+                Layer::Map(_) | Layer::Set(_) | Layer::Vec(_) | Layer::Unknown(_)
+            )
+        })
+    }
+
     pub fn is_outer_option_wrapped(&self) -> bool {
         self.layers
             .first()
-            .is_some_and(|wrapper| *wrapper == Layer::Option)
+            .is_some_and(|layer| *layer == Layer::Option)
     }
 
     pub fn impl_partial_default_value(&self, field_args: &FieldArgs) -> ImplResult {
@@ -104,8 +113,14 @@ impl FieldValue {
                 panic!("Cannot use `default` with `nested`.");
             }
 
+            let ident = format_ident!("Partial{}", nested_ident);
+
+            // quote! {
+            //     <#nested_ident as schematic::PartialConfig>::default_values(context)?
+            // }
+
             quote! {
-                <#nested_ident as schematic::PartialConfig>::default_values(content)?
+                #ident::default_values(context)?
             }
         } else if let Some(expr) = &field_args.default {
             let ty = self.get_inner_type();
@@ -178,6 +193,34 @@ impl FieldValue {
         res.value = value;
         res
     }
+
+    pub fn impl_partial_env_value(&self, field_args: &FieldArgs, env_key: &str) -> ImplResult {
+        let mut res = ImplResult::default();
+
+        if self.is_collection() {
+            panic!("Collection types cannot be used with `env`.");
+        } else if !self.layers.is_empty() {
+            panic!("Wrapper types cannot be used with `env`.");
+        }
+
+        res.value = if let Some(nested_ident) = &self.nested_ident {
+            let ident = format_ident!("Partial{}", nested_ident);
+
+            quote! {
+                env.nested(#ident::env_values()?)?
+            }
+        } else if let Some(parse_env) = &field_args.parse_env {
+            quote! {
+                env.get_and_parse(#env_key, #parse_env)?
+            }
+        } else {
+            quote! {
+                env.get(#env_key)?
+            }
+        };
+
+        res
+    }
 }
 
 fn extract_type_information(

crates/core/tests/field_default_test.rs

@@ -96,6 +96,21 @@ mod field_default {
             assert_debug_snapshot!(defaults);
         }
 
+        #[test]
+        fn supports_nested() {
+            let container = Container::from(parse_quote! {
+                #[derive(Config)]
+                struct Example {
+                    #[setting(nested)]
+                    a: NestedConfig,
+                    #[setting(nested = CustomConfig)]
+                    b: CustomConfig,
+                }
+            });
+
+            assert_snapshot!(pretty(container.impl_partial_default_values()));
+        }
+
         #[test]
         fn renders_nothing_if_all_option_wrapped() {
             let container = Container::from(parse_quote! {