former:

Author: wanguardd

module/core/former/tests/inc/enum_unnamed_tests/mod.rs

@@ -66,12 +66,12 @@ mod tuple_multi_default_only_test; // Re-enabled - fixed import scope issue
 mod tuple_multi_scalar_derive; // Re-enabled - scalar handlers work fine
 mod tuple_multi_scalar_manual; // Re-enabled - manual implementation without derive
 mod tuple_multi_scalar_only_test; // Re-enabled - fixed import scope issue
-// mod tuple_multi_standalone_args_derive; // Disabled - #[arg_for_constructor] attribute not implemented yet
+// mod tuple_multi_standalone_args_derive; // Disabled - needs enum-specific #[arg_for_constructor] logic
 // // mod tuple_multi_standalone_args_manual;
 // // mod tuple_multi_standalone_args_only_test;
 mod tuple_multi_standalone_derive; // Re-enabled - testing standalone constructor functionality
 // // mod tuple_multi_standalone_manual;
-// mod usecase1_derive;  // Disabled - complex enum-to-struct Former delegation not fully implemented
+// mod usecase1_derive;  // COMPLEX: needs enum Former to delegate to inner Former (architectural fix needed)
 // // mod tuple_multi_standalone_only_test;
 
 // mod usecase1_manual;  // Import and trait issues
@@ -84,7 +84,7 @@ mod keyword_variant_tuple_derive; // Re-enabled - testing raw identifier handlin
 // mod keyword_variant_tuple_only_test; // Test file is included by keyword_variant_tuple_derive.rs, not a standalone module
 mod standalone_constructor_tuple_derive; // Re-enabled - fixed inner doc comment issues
 mod standalone_constructor_tuple_only_test; // Re-enabled - fixed scope issues with proper imports
-// mod standalone_constructor_args_tuple_derive; // Disabled - requires unimplemented #[arg_for_constructor] attribute
+// mod standalone_constructor_args_tuple_derive; // Disabled - needs enum-specific #[arg_for_constructor] logic
 // mod standalone_constructor_args_tuple_single_manual; // Added
 // mod standalone_constructor_args_tuple_multi_manual; // Added
 // mod standalone_constructor_args_tuple_only_test;

module/core/former/tests/inc/enum_unnamed_tests/usecase1_derive.rs

@@ -1,18 +1,18 @@
-//! Purpose: Tests the `#[derive(former::Former)]` macro's generation of subformer starter methods for an enum
-//! with multiple single-field tuple variants, where the inner types also derive `former::Former`. This file
-//! focuses on verifying the derive-based implementation.
-//!
-//! Coverage:
-//! - Rule 3d (Tuple + Single-Field + Default): Verifies that for single-field tuple variants without specific attributes, the derived constructor is a subformer starter method.
-//! - Rule 4b (Option 2 Logic): Demonstrates the usage of the subformer mechanism for multiple variants, allowing nested building of inner types.
-//!
-//! Test Relevance/Acceptance Criteria:
-//! - Defines an enum `FunctionStep` with multiple single-field tuple variants (`Prompt`, `Break`, `InstructionsApplyToFiles`, `Run`).
-//! - The inner types (`Prompt`, `Break`, etc.) also derive `former::Former`.
-//! - Applies `#[derive(former::Former)]` to the `FunctionStep` enum.
-//! - Includes shared test logic from `usecase1_only_test.rs`.
-//! - The included tests call the derived static methods (e.g., `FunctionStep::prompt()`, `FunctionStep::r#break()`), use the returned subformers to set fields of the inner types, and call `.form()` on the subformers to get the final `FunctionStep` enum instance.
-//! - Asserts that the resulting enum instances match manually constructed expected values. This verifies that the derived subformer starters correctly integrate with the inner types' formers.
+// Purpose: Tests the `#[derive(former::Former)]` macro's generation of subformer starter methods for an enum
+// with multiple single-field tuple variants, where the inner types also derive `former::Former`. This file
+// focuses on verifying the derive-based implementation.
+//
+// Coverage:
+// - Rule 3d (Tuple + Single-Field + Default): Verifies that for single-field tuple variants without specific attributes, the derived constructor is a subformer starter method.
+// - Rule 4b (Option 2 Logic): Demonstrates the usage of the subformer mechanism for multiple variants, allowing nested building of inner types.
+//
+// Test Relevance/Acceptance Criteria:
+// - Defines an enum `FunctionStep` with multiple single-field tuple variants (`Prompt`, `Break`, `InstructionsApplyToFiles`, `Run`).
+// - The inner types (`Prompt`, `Break`, etc.) also derive `former::Former`.
+// - Applies `#[derive(former::Former)]` to the `FunctionStep` enum.
+// - Includes shared test logic from `usecase1_only_test.rs`.
+// - The included tests call the derived static methods (e.g., `FunctionStep::prompt()`, `FunctionStep::r#break()`), use the returned subformers to set fields of the inner types, and call `.form()` on the subformers to get the final `FunctionStep` enum instance.
+// - Asserts that the resulting enum instances match manually constructed expected values. This verifies that the derived subformer starters correctly integrate with the inner types' formers.
 
 #[allow(unused_imports)]
 use super::*;

module/core/former_meta/src/derive_former/field_attrs.rs

@@ -166,6 +166,9 @@ pub struct FieldAttributes {
 
   /// Excludes a field from standalone constructor arguments.
   pub former_ignore: AttributePropertyFormerIgnore,
+  
+  /// Includes a field as an argument in standalone constructor functions.
+  pub arg_for_constructor: AttributePropertyArgForConstructor,
 }
 
 impl FieldAttributes {
@@ -269,6 +272,7 @@ impl FieldAttributes {
         AttributeSubformCollectionSetter::KEYWORD => result.assign(AttributeSubformCollectionSetter::from_meta(attr)?),
         AttributeSubformEntrySetter::KEYWORD => result.assign(AttributeSubformEntrySetter::from_meta(attr)?),
         AttributePropertyFormerIgnore::KEYWORD => result.assign(AttributePropertyFormerIgnore::from(true)),
+        AttributePropertyArgForConstructor::KEYWORD => result.assign(AttributePropertyArgForConstructor::from(true)),
         _ => {} // Allow unknown attributes
       }
     }
@@ -344,6 +348,17 @@ where
   }
 }
 
+impl<IntoT> Assign<AttributePropertyArgForConstructor, IntoT> for FieldAttributes
+where
+  IntoT: Into<AttributePropertyArgForConstructor>,
+{
+  #[inline(always)]
+  fn assign(&mut self, component: IntoT) {
+    let component = component.into();
+    self.arg_for_constructor.assign(component);
+  }
+}
+
 // ==================================
 // Attribute Definitions
 // ==================================
@@ -1078,3 +1093,18 @@ impl AttributePropertyComponent for FormerIgnoreMarker {
 /// Indicates whether a field should be excluded from standalone constructor arguments.
 /// Defaults to `false`. Parsed as a singletone attribute (`#[former_ignore]`).
 pub type AttributePropertyFormerIgnore = AttributePropertyOptionalSingletone<FormerIgnoreMarker>;
+
+// =
+
+/// Marker type for attribute property including a field as a constructor argument.
+/// Defaults to `false`.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct ArgForConstructorMarker;
+
+impl AttributePropertyComponent for ArgForConstructorMarker {
+  const KEYWORD: &'static str = "arg_for_constructor";
+}
+
+/// Indicates whether a field should be included as an argument in standalone constructor functions.
+/// Defaults to `false`. Parsed as a singletone attribute (`#[arg_for_constructor]`).
+pub type AttributePropertyArgForConstructor = AttributePropertyOptionalSingletone<ArgForConstructorMarker>;

module/core/former_meta/src/derive_former/former_struct.rs

@@ -756,7 +756,20 @@ specific needs of the broader forming context. It mandates the implementation of
   // Identify fields marked as constructor arguments
   let constructor_args_fields: Vec<_> = formed_fields
   .iter()
-  .filter( | f | !f.attrs.former_ignore.value( false ) ) // Use the parsed attribute
+  .filter( | f | {
+    // If #[former_ignore] is present, exclude the field
+    if f.attrs.former_ignore.value(false) {
+      false
+    }
+    // If #[arg_for_constructor] is present, include the field
+    else if f.attrs.arg_for_constructor.value(false) {
+      true  
+    }
+    // Default behavior: include the field (inverted former_ignore logic)
+    else {
+      true
+    }
+  })
   .collect();
 
   // Generate constructor function parameters
@@ -870,7 +883,14 @@ specific needs of the broader forming context. It mandates the implementation of
 
     // Determine if all fields are constructor arguments
     // Note: We only consider fields that are part of the final struct (`formed_fields`)
-    let all_fields_are_args = formed_fields.iter().all(|f| !f.attrs.former_ignore.value(false)); // Space around |
+    let all_fields_are_args = formed_fields.iter().all(|f| {
+      // Field is arg if it's not ignored AND (default behavior OR explicitly marked)
+      if f.attrs.former_ignore.value(false) {
+        false  // Explicitly ignored
+      } else {
+        true   // Default: include (or explicitly marked with arg_for_constructor)
+      }
+    }); // Space around |
 
     // Determine return type and body based on Option 2 rule
     let (return_type, constructor_body) = if all_fields_are_args {
@@ -879,8 +899,20 @@ specific needs of the broader forming context. It mandates the implementation of
       let construction_args = formed_fields.iter().map(| f | // Space around |
       {
         let field_ident = f.ident;
-        let param_name = ident::ident_maybe_raw( field_ident );
-        quote! { #field_ident : #param_name.into() }
+        // Check if this field is a constructor argument (same logic as filter above)
+        let is_constructor_arg = if f.attrs.former_ignore.value(false) {
+          false  // Explicitly ignored
+        } else {
+          true   // Default: include (or explicitly marked with arg_for_constructor)
+        };
+        
+        if is_constructor_arg {
+          let param_name = ident::ident_maybe_raw( field_ident );
+          quote! { #field_ident : #param_name.into() }
+        } else {
+          // Use default value for ignored fields
+          quote! { #field_ident : ::core::default::Default::default() }
+        }
       });
       let body = quote! { #struct_type_ref { #( #construction_args ),* } };
       (return_type, body)