former 2.45.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

#![allow(clippy::used_underscore_binding, clippy::all, warnings, missing_docs)]
// Purpose: Simplified replacement for comprehensive_mixed_derive to avoid build timeouts
// This provides mixed enum variant coverage without causing build performance issues

use super::*;
#[ allow( unused_imports ) ]
use ::former::prelude::*;
use ::former::Former;

// Simple inner types for mixed enum testing
#[ derive( Debug, PartialEq, Default, Clone, Former ) ]
pub struct SimpleInner {
  pub data: String,
  pub value: i32,
}

// Simplified mixed enum with unit, tuple, and struct variants
#[ derive( Debug, PartialEq, Former ) ]
pub enum SimplifiedMixedEnum {
  // Unit variants
  UnitVariantA,
  UnitVariantB,
  
  // Tuple variants
  #[ scalar ]
  TupleScalar(String),
  TupleSubform(SimpleInner),
  
  // Struct variants
  StructVariant {
    name: String,
    inner: SimpleInner,
  },
}

impl Default for SimplifiedMixedEnum {
  fn default() -> Self {
    Self::UnitVariantA
  }
}

// SIMPLIFIED MIXED ENUM TESTS - comprehensive coverage without build timeout

#[ test ]
fn simplified_mixed_unit_variants_test() {
  let unit_a = SimplifiedMixedEnum::unit_variant_a();
  let unit_b = SimplifiedMixedEnum::unit_variant_b();
  
  assert_eq!(unit_a, SimplifiedMixedEnum::UnitVariantA);
  assert_eq!(unit_b, SimplifiedMixedEnum::UnitVariantB);
}

#[ test ]
fn simplified_mixed_tuple_scalar_test() {
  let got = SimplifiedMixedEnum::tuple_scalar("tuple_test".to_string());
  let expected = SimplifiedMixedEnum::TupleScalar("tuple_test".to_string());
  assert_eq!(got, expected);
}

#[ test ]
fn simplified_mixed_tuple_subform_test() {
  let inner = SimpleInner {
    data: "subform_data".to_string(),
    value: 42,
  };
  
  let got = SimplifiedMixedEnum::tuple_subform()
    ._0(inner.clone())
    .form();
    
  let expected = SimplifiedMixedEnum::TupleSubform(inner);
  assert_eq!(got, expected);
}

#[ test ]
fn simplified_mixed_struct_variant_test() {
  let inner = SimpleInner {
    data: "struct_data".to_string(),
    value: 100,
  };
  
  let got = SimplifiedMixedEnum::struct_variant()
    .name("struct_test".to_string())
    .inner(inner.clone())
    .form();
    
  let expected = SimplifiedMixedEnum::StructVariant {
    name: "struct_test".to_string(),
    inner,
  };
  
  assert_eq!(got, expected);
}

// Test comprehensive mixed enum patterns
#[ test ]
fn simplified_mixed_comprehensive_test() {
  // Test all variant types work together
  let variants = vec![
    SimplifiedMixedEnum::unit_variant_a(),
    SimplifiedMixedEnum::tuple_scalar("test".to_string()),
    SimplifiedMixedEnum::tuple_subform()
      ._0(SimpleInner { data: "test_data".to_string(), value: 1 })
      .form(),
    SimplifiedMixedEnum::struct_variant()
      .name("test_struct".to_string())
      .inner(SimpleInner { data: "struct_test".to_string(), value: 2 })
      .form(),
  ];
  
  assert_eq!(variants.len(), 4);
  
  // Verify each variant type
  assert!(matches!(variants[0], SimplifiedMixedEnum::UnitVariantA));
  assert!(matches!(variants[1], SimplifiedMixedEnum::TupleScalar(_)));
  assert!(matches!(variants[2], SimplifiedMixedEnum::TupleSubform(_)));
  assert!(matches!(variants[3], SimplifiedMixedEnum::StructVariant { .. }));
}