derive-ctor 0.2.0

Adds `#[derive(ctor)]` which allows for the auto-generation of a constructor.
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

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)
}