derive-ctor 1.0.3

Adds `#[derive(ctor)]` which allows for the auto-generation of struct, enum, and union constructors.
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

use derive_ctor::ctor;

#[derive(ctor, Debug, PartialEq)]
struct StructExpr {
    provided: u32,
    #[ctor(expr(10))]
    generated: u32,
}

#[derive(ctor, Debug, PartialEq)]
struct StructManyExpr {
    provided: u32,
    #[ctor(expr(11))]
    generated1: u32,
    #[ctor(expr(false))]
    generated2: bool,
}

#[derive(ctor, Debug, PartialEq)]
struct StructComplexExpr {
    provided: u32,
    #[ctor(expr(String::from("Foo")))]
    generated: String,
}

#[derive(ctor, Debug, PartialEq)]
struct StructReliantExpr {
    provided: u32,
    #[ctor(expr(provided.to_string()))]
    generated: String,
}

#[test]
fn test_struct_expr_field() {
    let test = StructExpr::new(100);
    assert_eq!(
        StructExpr {
            provided: 100,
            generated: 10
        },
        test
    );
}

#[test]
fn test_struct_many_expr_fields() {
    let test = StructManyExpr::new(101);
    assert_eq!(
        StructManyExpr {
            provided: 101,
            generated1: 11,
            generated2: false
        },
        test
    );
}

#[test]
fn test_struct_complex_expr_field() {
    let test = StructComplexExpr::new(102);
    assert_eq!(
        StructComplexExpr {
            provided: 102,
            generated: String::from("Foo")
        },
        test
    );
}

#[test]
fn test_struct_reliant_expr_field() {
    let test = StructReliantExpr::new(103);
    assert_eq!(
        StructReliantExpr {
            provided: 103,
            generated: 103.to_string()
        },
        test
    );
}

#[derive(ctor, Debug, PartialEq)]
struct SelfRefExpr {
    #[ctor(expr!(value - 1))]
    value: u32,
}

#[derive(ctor, Debug, PartialEq)]
struct ComplexSelfRefExpr {
    #[ctor(expr!(n1 - n2))]
    n1: u32,
    n2: u32,
}

#[derive(ctor, Debug, PartialEq)]
struct ChangeInputTypeExpr {
    #[ctor(expr(String -> Box::new(value)))]
    value: Box<String>,
}

#[test]
fn test_self_referencing_expr_field() {
    let test = SelfRefExpr::new(105);
    assert_eq!(SelfRefExpr { value: 104 }, test);
}

#[test]
fn test_complex_self_referencing_expr_field() {
    let test = ComplexSelfRefExpr::new(489, 69);
    assert_eq!(ComplexSelfRefExpr { n1: 420, n2: 69 }, test);
}

#[test]
fn test_changed_input_type() {
    let test = ChangeInputTypeExpr::new(String::from("ABC"));
    assert_eq!(
        ChangeInputTypeExpr {
            value: Box::new(String::from("ABC"))
        },
        test
    )
}