former 2.43.0

A flexible implementation of the Builder pattern supporting nested builders and collection-specific subformers. Simplify the construction of complex objects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135


//! Comprehensive demonstration of the `#[ debug ]` attribute for Former derive macro.
//!
//! The `#[ debug ]` attribute provides detailed debug information about:
//! - Input analysis (generics, lifetimes, fields)
//! - Code generation process
//! - Generated code structure  
//! - Any transformations or validations performed
//!
//! To see the debug output, run with the diagnostic feature:
//! ```bash
//! cargo run --example former_debug --features former_diagnostics_print_generated
//! ```

#[cfg(any(not(feature = "derive_former"), not(feature = "enabled")))]
fn main() {
  println!("This example requires the 'derive_former' and 'enabled' features");
}

#[cfg(all(feature = "derive_former", feature = "enabled"))]
fn main() {
  use former::Former;

  println!("=== Former Debug Attribute Comprehensive Example ===");
  println!();

  // Example 1: Simple struct with debug - shows basic input analysis
  #[ derive( Debug, PartialEq, Former ) ]
  // #[ debug ] // <-- Commented out - debug attribute only for temporary debugging
  pub struct UserProfile {
    age: i32,
    username: String,
    bio_optional: Option<String>,
  }

  // Example 2: Generic struct with debug - shows generic parameter analysis
  #[ derive( Debug, PartialEq, Former ) ]
  // #[ debug ] // <-- Commented out - debug attribute only for temporary debugging
  pub struct GenericContainer<T, U>
  where
    T: Clone + core::fmt::Debug,
    U: Default,
  {
    primary: T,
    secondary: U,
    metadata: String,
  }

  // Example 3: Lifetime parameters with debug - shows lifetime handling
  #[ derive( Debug, PartialEq, Former ) ]
  // #[ debug ] // <-- Commented out - debug attribute only for temporary debugging
  pub struct LifetimeStruct<'a> {
    name: &'a str,
    data: String,
  }

  // Example 4: Struct with storage fields and debug
  #[ derive( Debug, PartialEq, Former ) ]
  // #[ debug ] // <-- Commented out - debug attribute only for temporary debugging
  #[ storage_fields( temp_id: u64, processing_state: bool ) ]
  pub struct StorageStruct {
    id: u64,
    name: String,
    tags: Vec<String>,
  }

  println!("Building examples to demonstrate debug attribute functionality...");
  println!();

  // Build example 1: Simple struct
  let profile = UserProfile::former()
    .age(30)
    .username("JohnDoe".to_string())
    .bio_optional("Software Developer".to_string())
    .form();

  println!("1. Simple UserProfile: {profile:?}");

  // Build example 2: Generic struct
  let generic: GenericContainer<String, i32> = GenericContainer::former()
    .primary("test".to_string())
    .secondary(42i32)
    .metadata("example metadata".to_string())
    .form();

  println!("2. Generic Container: {generic:?}");

  // Build example 3: Lifetime struct
  let name = "lifetime_example";
  let lifetime_struct = LifetimeStruct::former()
    .name(name)
    .data("owned data".to_string())
    .form();

  println!("3. Lifetime Struct: {lifetime_struct:?}");

  // Build example 4: Storage struct
  let storage_struct = StorageStruct::former()
    .id(12345u64)
    .name("storage_example".to_string())
    .tags(vec!["storage".to_string(), "debug".to_string()])
    .form();

  println!("4. Storage Struct: {storage_struct:?}");

  println!();
  println!("=== Debug Information ===");

  #[ cfg( feature = "former_diagnostics_print_generated" ) ]
  {
    println!("Debug output should have been displayed above showing:");
    println!("  • Input Analysis: Field types, generic parameters, constraints");
    println!("  • Generic Classification: How generics are categorized and handled");
    println!("  • Components Analysis: What ecosystem components will be generated");
    println!("  • Generated Code: The complete Former pattern implementation");
    println!();
    println!("This comprehensive debug information helps developers:");
    println!("  • Understand macro processing decisions");
    println!("  • Debug complex generic scenarios");
    println!("  • Verify correct trait bound propagation");
    println!("  • Troubleshoot lifetime parameter issues");
  }

  #[cfg(not(feature = "former_diagnostics_print_generated"))]
  {
    println!("To see comprehensive debug information, run with:");
    println!("cargo run --example former_debug --features former_diagnostics_print_generated");
    println!();
    println!("The debug output will show detailed information about:");
    println!("  • Input analysis (generics, lifetimes, fields)");
    println!("  • Code generation process and decisions");
    println!("  • Generated code structure and components");
    println!("  • Transformations and validations performed");
  }
}