engineer 0.1.6

The engineer is a master builder!
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

extern crate engineer_derive;

pub use engineer_derive::*;

pub trait Builder<T>
where
    T: Engineer,
    T::Builder: Builder<T>,
{
    fn done(self) -> T;
}

pub trait Engineer
where
    Self: Sized,
    Self::Builder: Builder<Self>,
{
    const NORMAL_FIELDS: usize;
    const OPTIONAL_FIELDS: usize;

    type Builder;
    type Params;

    fn builder(required: Self::Params) -> Self::Builder;

    fn build(required: Self::Params) -> Self {
        Self::builder(required).done()
    }

    fn build_default() -> Self
    where
        Self::Params: Default,
    {
        Self::build(Default::default())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[allow(dead_code)]
    #[derive(Debug, Default)]
    enum Gender {
        Male,
        Female,

        #[default]
        NotSaying,
    }

    #[allow(dead_code)]
    #[derive(Debug, Engineer)]
    #[engineer(new, str_retype)]
    struct User {
        id: usize,          // No default.
        first_name: String, // No default.
        // Default on none option.
        #[engineer(default)]
        gender: Gender, // Default should be Default::default() (Gender::NotSaying).
        // Default value on none option.
        #[engineer(default_value = r#"String::from("fa")"#)]
        lang_code: String, // Default should be String("fa").
        last_name: Option<String>, // Default should be None.
        // Default on option.
        #[engineer(default)] // Educated, not educated, no data
        is_educated: Option<bool>, // Default should be Some(Default::default()) (Some(false)).
        // Default value on option.
        #[engineer(default_value = "true")]
        is_human: Option<bool>, // Default should be Some(true).
    }

    #[test]
    fn basic_test() {
        let arash = User::new(1, "Arash").done();

        assert_eq!(arash.id, 1);
        assert_eq!(arash.first_name, "Arash");
        assert_eq!(arash.last_name, None);
        assert!(matches!(arash.gender, Gender::NotSaying));
        assert_eq!(arash.lang_code, "fa".to_string());
        assert!(matches!(arash.is_educated, Some(false)));
        assert!(matches!(arash.is_human, Some(true)));
    }

    #[test]
    fn basic_test_2() {
        let model = User::new(1, "Monkey")
            .last_name("Donkey")
            .gender(Gender::NotSaying)
            .lang_code("en")
            .is_human(false)
            .is_educated(true)
            .done();

        assert_eq!(model.id, 1);
        assert_eq!(model.first_name, "Monkey");
        assert_eq!(model.last_name, Some("Donkey".to_string()));
        assert!(matches!(model.gender, Gender::NotSaying));
        assert_eq!(model.lang_code, "en".to_string());
        assert!(matches!(model.is_educated, Some(true)));
        assert!(matches!(model.is_human, Some(false)));
    }
}