bauer 0.4.0

A derive macro for automatically generating the builder pattern
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use bauer::Builder;

#[test]
fn all_generics() {
    macro_rules! define {
        ($name: ident, $kind: literal) => {
            #[derive(Debug, Builder, PartialEq)]
            #[builder(kind = $kind)]
            struct $name<'a, const N: usize, T: ?Sized> {
                field: [&'a T; N],
            }
        };
    }

    macro_rules! populate {
        ($name: ident) => {
            $name::builder().field(["hello", "world"])
        };
    }

    macro_rules! expected {
        ($name: ident) => {
            $name {
                field: ["hello", "world"],
            }
        };
    }

    define!(BorrowedFoo, "borrowed");
    let foo: BorrowedFoo<2, str> = populate!(BorrowedFoo).build().unwrap();
    assert_eq!(foo, expected!(BorrowedFoo));

    define!(OwnedFoo, "owned");
    let foo: OwnedFoo<2, str> = populate!(OwnedFoo).build().unwrap();
    assert_eq!(foo, expected!(OwnedFoo));

    define!(TypeStateFoo, "type-state");
    let foo: TypeStateFoo<2, str> = populate!(TypeStateFoo).build();
    assert_eq!(foo, expected!(TypeStateFoo));
}

#[test]
fn type_generics() {
    macro_rules! define {
        ($name: ident, $kind: literal) => {
            #[derive(Debug, Builder, PartialEq)]
            #[builder(kind = $kind)]
            struct $name<A, B, C> {
                field: (A, B, C),
            }
        };
    }

    macro_rules! populate {
        ($name: ident) => {
            $name::builder().field((0, "hello", 'c'))
        };
    }

    macro_rules! expected {
        ($name: ident) => {
            $name {
                field: (0, "hello", 'c'),
            }
        };
    }

    define!(BorrowedFoo, "borrowed");
    let foo: BorrowedFoo<i32, &str, char> = populate!(BorrowedFoo).build().unwrap();
    assert_eq!(foo, expected!(BorrowedFoo));

    define!(OwnedFoo, "owned");
    let foo: OwnedFoo<i32, &str, char> = populate!(OwnedFoo).build().unwrap();
    assert_eq!(foo, expected!(OwnedFoo));

    define!(TypeStateFoo, "type-state");
    let foo: TypeStateFoo<i32, &str, char> = populate!(TypeStateFoo).build();
    assert_eq!(foo, expected!(TypeStateFoo));
}

#[test]
fn const_generics() {
    macro_rules! define {
        ($name: ident, $kind: literal) => {
            #[derive(Debug, Builder, PartialEq)]
            #[builder(kind = $kind)]
            struct $name<const A: usize, const B: char, const C: bool> {
                field: [u8; A],
            }
        };
    }

    macro_rules! populate {
        ($name: ident) => {
            $name::builder().field([0, 1, 2, 3])
        };
    }

    macro_rules! expected {
        ($name: ident) => {
            $name {
                field: [0, 1, 2, 3],
            }
        };
    }

    define!(BorrowedFoo, "borrowed");
    let foo: BorrowedFoo<4, 'c', true> = populate!(BorrowedFoo).build().unwrap();
    assert_eq!(foo, expected!(BorrowedFoo));

    define!(OwnedFoo, "owned");
    let foo: OwnedFoo<4, 'c', true> = populate!(OwnedFoo).build().unwrap();
    assert_eq!(foo, expected!(OwnedFoo));

    define!(TypeStateFoo, "type-state");
    let foo: TypeStateFoo<4, 'c', true> = populate!(TypeStateFoo).build();
    assert_eq!(foo, expected!(TypeStateFoo));
}

#[test]
fn lifetimes() {
    let a_string = String::from("hello");
    let a = &a_string;
    let b: &'static str = "world";
    macro_rules! define {
        ($name: ident, $kind: literal) => {
            #[derive(Debug, Builder, PartialEq)]
            #[builder(kind = $kind)]
            struct $name<'a, 'b> {
                short: &'a str,
                statik: &'b str,
            }
        };
    }

    macro_rules! populate {
        ($name: ident) => {
            $name::builder().short(a).statik(b)
        };
    }

    macro_rules! expected {
        ($name: ident) => {
            $name {
                short: a,
                statik: b,
            }
        };
    }

    define!(BorrowedFoo, "borrowed");
    let foo: BorrowedFoo<'_, 'static> = populate!(BorrowedFoo).build().unwrap();
    assert_eq!(foo, expected!(BorrowedFoo));

    define!(OwnedFoo, "owned");
    let foo: OwnedFoo<'_, 'static> = populate!(OwnedFoo).build().unwrap();
    assert_eq!(foo, expected!(OwnedFoo));

    define!(TypeStateFoo, "type-state");
    let foo: TypeStateFoo<'_, 'static> = populate!(TypeStateFoo).build();
    assert_eq!(foo, expected!(TypeStateFoo));

    drop(a_string);
}