proffer 0.5.0

Rust code generation
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

use proffer::*;

fn normalize_whitespace(s: &str) -> String {
    s.split("\n")
        .map(|l| l.trim())
        .filter(|l| l.len() > 0)
        .collect::<String>()
}

#[test]
fn basic_gen() {
    let struct_ = Struct::new("Basic")
        .set_is_pub(true)
        .add_field(
            Field::new("field1", "String")
                .set_is_pub(true)
                .add_annotation("#[serde = w]")
                .add_doc("/// Some example documentation")
                .add_docs(vec!["/// Another line", "/// and another"])
                .to_owned(),
        )
        .add_field(Field::new("field2", "usize"))
        .to_owned();
    let expected = r#"
        pub struct Basic {
            /// Some example documentation
            /// Another line
            /// and another
            #[serde = w]
            pub field1: String,
            field2: usize,
         }
        "#
    .to_owned();
    let src_code = struct_.generate();
    println!("{}", &src_code);
    assert_eq!(
        normalize_whitespace(&src_code),
        normalize_whitespace(&expected)
    );
}

#[test]
fn generic_gen() {
    let s = Struct::new("Generic")
        .set_is_pub(true)
        .add_generic(
            Generic::new("T")
                .add_trait_bounds(vec!["ToString"])
                .to_owned(),
        )
        .add_generic(
            Generic::new("S")
                .add_trait_bounds(vec!["ToString", "Number"])
                .to_owned(),
        )
        .add_field(Field::new("field1", "S"))
        .add_field(Field::new("field2", "T"))
        .to_owned();
    let src_code = s.generate();
    println!("{}", &src_code);
    let expected = r#"
        pub struct Generic<T, S>
            where
                T: ToString,
                S: ToString + Number,
        {
            field1: S,
            field2: T,
        }
    "#;
    let src_code = s.generate();
    assert_eq!(
        normalize_whitespace(&src_code),
        normalize_whitespace(&expected)
    );
}