component_model 0.17.0

Revolutionary type-safe component assignment for Rust. Build complex objects with zero boilerplate using derive macros and type-driven field setting. Perfect for configuration builders, fluent APIs, and object composition patterns.
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

//! Test file for `ComponentModel` derive macro
//!
//! ## Test Matrix: `ComponentModel` Derive Functionality
//!
//! ### Test Factors
//! - **Field Count** : One, Multiple
//! - **Field Types** : Basic (String, i32, bool)
//! - **Attributes** : None, Debug
//! - **Assignment Style** : Direct (assign), Fluent (impute)
//! - **Type Conflicts** : None, Conflicting types
//!
//! ### Test Combinations
//!
//! | ID    | Field Count | Field Types     | Attributes | Type Conflicts | Assignment Style | Expected Behavior |
//! |-------|-------------|----------------|------------|----------------|------------------|-------------------|
//! | TCM01 | Multiple    | Basic mixed     | None       | None           | Direct + Fluent  | Multiple Assign impls generated |
//! | TCM02 | Multiple    | Conflicting     | None       | String x2      | Direct           | Only unique types get impls |  
//! | TCM03 | Multiple    | Basic mixed     | None       | None           | Direct           | Sequential assignment works |
//! | TCM04 | Multiple    | Basic mixed     | Debug      | None           | Direct           | Debug output + assignment works |
//!

/// Test module alias for aggregating crate
#[ allow(unused_imports) ]
use component_model as the_module;
use the_module ::Assign;

/// Tests `ComponentModel` derive with multiple basic field types using both direct and fluent assignment.
/// Test Combination: TCM01
#[ test ]
fn test_component_model_basic_derive()
{
  #[ derive(Default, Debug, PartialEq) ]
  #[ derive(the_module ::ComponentModel) ]
  struct TestStruct
  {
  name: String,
  value: i32,
 }

  // Test that all traits are implemented
  let mut obj = TestStruct ::default();
  
  // Should be able to use Assign trait
  Assign ::assign( &mut obj, "test_name".to_string() );
  Assign ::assign( &mut obj, 42i32 );
  
  assert_eq!( obj.name, "test_name" );
  assert_eq!( obj.value, 42 );
  
  // Should be able to use impute (fluent style)
  let obj2 = TestStruct ::default()
  .impute( "fluent_name".to_string() )
  .impute( 100i32 );
  
  assert_eq!( obj2.name, "fluent_name" );
  assert_eq!( obj2.value, 100 );
}

/// Tests `ComponentModel` derive handles conflicting field types by generating only unique type implementations.
/// Test Combination: TCM02
#[ test ]
fn test_component_model_with_conflicting_types()
{
  #[ derive(Default, Debug, PartialEq) ]
  #[ derive(the_module ::ComponentModel) ]
  struct ConflictStruct
  {
  first_string: String,
  second_string: String, // This should cause conflicts for String assignment
  number: i32,
 }

  let mut obj = ConflictStruct ::default();
  
  // With conflicting types, assignment should still work but may be ambiguous
  // The macro should handle this by not generating conflicting implementations
  Assign ::assign( &mut obj, 42i32 );
  assert_eq!( obj.number, 42 );
}

/// Tests `ComponentModel` derive with sequential direct assignment to multiple basic field types.
/// Test Combination: TCM03
#[ test ]
fn test_component_model_tuple_assignment()
{
  #[ derive(Default, Debug, PartialEq) ]
  #[ derive(the_module ::ComponentModel) ]
  struct TupleStruct
  {
  name: String,
  value: i32,
  flag: bool,
 }

  // Should be able to create from tuple components if implemented
  // This test may fail initially until tuple support is added
  let mut obj = TupleStruct ::default();
  Assign ::assign( &mut obj, "tuple_name".to_string() );
  Assign ::assign( &mut obj, 123i32 );
  Assign :: < bool, _ > ::assign( &mut obj, true );
  
  assert_eq!( obj.name, "tuple_name" );
  assert_eq!( obj.value, 123 );
  assert!( obj.flag );
}

/// Tests `ComponentModel` derive with debug attribute processing and direct assignment.
/// Test Combination: TCM04
#[ test ]
fn test_component_model_with_attributes()
{
  #[ derive(Default, Debug, PartialEq) ]
  #[ derive(the_module ::ComponentModel) ]
  // #[ debug ]  // Disabled to keep compilation output clean
  struct AttributedStruct
  {
  #[ component( default = "default_value" ) ]
  name: String,
  value: i32,
 }

  // Test that attributes are processed
  let obj = AttributedStruct ::default();
  
  // For now, just test that the derive compiles with attributes
  // Actual attribute behavior will be implemented later
  let mut obj2 = obj;
  Assign ::assign( &mut obj2, "new_name".to_string() );
  Assign ::assign( &mut obj2, 42i32 );
  
  assert_eq!( obj2.name, "new_name" );
  assert_eq!( obj2.value, 42 );
}