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

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 tr8t = Trait::new("Foo").set_is_pub(true).to_owned();
    let expected = r#"
        pub trait Foo
        {
        }
    "#;

    let src_code = tr8t.generate();
    println!("{}", &src_code);

    assert_eq!(
        normalize_whitespace(expected),
        normalize_whitespace(&src_code)
    );
}

#[test]
fn gen_with_method_signatures() {
    let tr8t = Trait::new("Foo")
        .set_is_pub(true)
        .add_signature(FunctionSignature::new("foo"))
        .add_signature(FunctionSignature::new("bar"))
        .to_owned();
    let expected = r#"
        pub trait Foo
        {
            fn foo() -> ();
            fn bar() -> ();
        }
    "#;

    let src_code = tr8t.generate();
    println!("{}", &src_code);

    assert_eq!(
        normalize_whitespace(expected),
        normalize_whitespace(&src_code)
    );
}

#[test]
fn gen_with_generics() {
    let tr8t = Trait::new("Foo")
        .set_is_pub(true)
        .add_signature(
            FunctionSignature::new("foo")
                .add_parameter(Parameter::new("name", "T"))
                .to_owned(),
        )
        .add_signature(FunctionSignature::new("bar"))
        .add_generic(
            Generic::new("T")
                .add_trait_bounds(vec!["ToString"])
                .to_owned(),
        )
        .to_owned();
    let expected = r#"
        pub trait Foo<T>
            where
                T: ToString,
        {
            fn foo(name: T) -> ();
            fn bar() -> ();
        }
    "#;

    let src_code = tr8t.generate();
    println!("{}", &src_code);

    assert_eq!(
        normalize_whitespace(expected),
        normalize_whitespace(&src_code)
    );
}

#[test]
fn gen_with_associated_types() {
    let tr8t = Trait::new("Foo")
        .set_is_pub(true)
        .add_associated_type(AssociatedTypeDeclaration::new("FOO"))
        .add_associated_type(AssociatedTypeDeclaration::new("BAR")
            .add_trait_bounds(vec!["Debug"])
            .to_owned())
        .add_associated_type(AssociatedTypeDeclaration::new("BAZ")
            .add_trait_bounds(vec!["Debug", "Default"])
            .to_owned())
        .to_owned();
    let expected = r#"
        pub trait Foo
        {
            type FOO;
            type BAR: Debug;
            type BAZ: Debug + Default;
        }
    "#;

    let src_code = tr8t.generate();
    println!("{}", &src_code);

    assert_eq!(
        normalize_whitespace(expected),
        normalize_whitespace(&src_code)
    );
}