feat: skip for derive

Author: prestwich

from-env-derive/Cargo.toml

@@ -20,4 +20,4 @@ syn = { version = "2.0.100", features = ["full", "parsing"] }
 proc-macro = true
 
 [dev-dependencies]
-init4-bin-base = "0.2"
+init4-bin-base = "0.3"

from-env-derive/src/field.rs

@@ -1,7 +1,7 @@
 use heck::ToPascalCase;
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{Ident, LitStr, spanned::Spanned};
+use syn::{spanned::Spanned, Ident, LitStr};
 
 /// A parsed Field of a struct
 pub(crate) struct Field {
@@ -11,6 +11,7 @@ pub(crate) struct Field {
 
     optional: bool,
     infallible: bool,
+    skip: bool,
     desc: Option<String>,
 
     _attrs: Vec<syn::Attribute>,
@@ -26,13 +27,18 @@ impl TryFrom<&syn::Field> for Field {
         let mut env_var = None;
         let mut infallible = false;
         let mut desc = None;
+        let mut skip = false;
 
         field
             .attrs
             .iter()
             .filter(|attr| attr.path().is_ident("from_env"))
             .for_each(|attr| {
                 let _ = attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("skip") {
+                        skip = true;
+                        return Ok(());
+                    }
                     if meta.path.is_ident("optional") {
                         optional = true;
                         return Ok(());
@@ -68,6 +74,7 @@ impl TryFrom<&syn::Field> for Field {
             field_name,
             field_type,
             optional,
+            skip,
             infallible,
             desc,
             _attrs: field
@@ -115,7 +122,7 @@ impl Field {
 
     /// Produces the name of the enum variant for the field
     pub(crate) fn enum_variant_name(&self, idx: usize) -> Option<TokenStream> {
-        if self.infallible {
+        if self.skip || self.infallible {
             return None;
         }
 
@@ -143,10 +150,16 @@ impl Field {
 
     /// Produces the a line for the `inventory` function
     /// of the form
-    /// items.push(...);
+    /// items.push(...); // (if this is a FromEnvVar)
+    /// or
+    /// items.extend(...); // (if this is a FromEnv)
     /// or
-    /// items.extend(...);
+    /// // nothing if this is a skip
     pub(crate) fn expand_env_item_info(&self) -> TokenStream {
+        if self.skip {
+            return quote! {};
+        }
+
         let description = self.desc.clone().unwrap_or_default();
         let optional = self.optional;
 
@@ -197,10 +210,20 @@ impl Field {
 
         // // OR
         // let field_name =  FromEnv::from_env().map_err()?;
+
+        // // OR
+        // let field_name = Default::default();
+
         //```
         let variant = self.enum_variant_name(idx);
         let field_name = self.field_name(idx);
 
+        if self.skip {
+            return quote! {
+                let #field_name = Default::default();
+            };
+        }
+
         let fn_invoc = if let Some(ref env_var) = self.env_var {
             quote! { FromEnvVar::from_env_var(#env_var) }
         } else {

from-env-derive/src/lib.rs

@@ -1,7 +1,7 @@
 use proc_macro::TokenStream as Ts;
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{DeriveInput, parse_macro_input};
+use syn::{parse_macro_input, DeriveInput};
 
 mod field;
 use field::Field;
@@ -61,6 +61,8 @@ pub fn derive(input: Ts) -> Ts {
         tuple_like,
     };
 
+    eprintln!("{}", input.expand_mod());
+
     input.expand_mod().into()
 }
 

from-env-derive/tests/macro.rs

@@ -25,6 +25,9 @@ pub struct FromEnvTest {
         desc = "Oliver is an Option<String>"
     )]
     pub oliver: Option<String>,
+
+    #[from_env(skip)]
+    memo: std::sync::OnceLock<String>,
 }
 
 #[derive(Debug, FromEnv)]
@@ -36,6 +39,13 @@ pub struct Nested {
     pub from_env_test: FromEnvTest,
 }
 
+impl FromEnvTest {
+    /// Get the memoized value
+    pub fn get_memo(&self) -> &str {
+        self.memo.get_or_init(|| "hello world".to_string())
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

src/utils/from_env.rs

@@ -12,6 +12,21 @@ use std::{convert::Infallible, env::VarError, num::ParseIntError, str::FromStr};
 /// occur when trying to create an instance of the struct from environment
 /// variables. This error type is used in the `FromEnv` trait implementation.
 ///
+/// ## Attributes
+///
+/// The macro supports the following attributes:
+/// - `var = ""`: The name of the environment variable. This is required if the
+///   prop implements [`FromEnvVar`].
+/// - `desc`: A description of the environment variable. This is required if
+///   the prop implements [`FromEnvVar`].
+/// - `optional`: Marks the prop as optional. This is currently only used in the
+///   `fn inventory` function, and is informational.
+/// - `infallible`: Marks the prop as infallible. This means that the prop
+///   cannot fail to be parsed after the environment variable is loaded.
+/// - `skip`: Marks the prop as skipped. This means that the prop will not be
+///   loaded from the environment, and will be generated via
+///   `Default::default()` instead.
+///
 /// ## Conditions of use
 ///
 /// There are a few usage requirements: