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
116
117
118
119

//!
//! Create `enum` objects
//!
//!
//! Example
//! -------
//! ```
//! use proffer::*;
//!
//! let e = Enum::new("Foo")
//!     .add_variant(Variant::new("A"))
//!     .add_variant(Variant::new("B").set_inner(Some("(T)")).to_owned())
//!     .add_generic(Generic::new("T"))
//!     .to_owned();
//!
//! let src_code = e.generate();
//! let expected = r#"
//!     enum Foo<T>
//!         where
//!             T: ,
//!     {
//!         A,
//!         B(T),
//!     }
//! "#;
//! assert_eq!(norm_whitespace(expected), norm_whitespace(&src_code))
//! ```

use serde::Serialize;

use crate::*;
use tera::{Context, Tera};

/// Represent an `enum` object
#[derive(Default, Serialize, Clone)]
pub struct Enum {
    name: String,
    generics: Generics,
    is_pub: bool,
    variants: Vec<Variant>,
}

/// Represent an enum variant/arm
#[derive(Default, Serialize, Clone)]
pub struct Variant {
    name: String,
    inner: Option<String>,
}

impl Enum {
    /// Create a new `Enum`
    pub fn new<S: ToString>(name: S) -> Self {
        let mut e = Enum::default();
        e.name = name.to_string();
        e
    }
    /// Set if this is public
    pub fn set_is_pub(&mut self, is_pub: bool) -> &mut Self {
        self.is_pub = is_pub;
        self
    }
    /// Add a variant
    pub fn add_variant(&mut self, variant: Variant) -> &mut Self {
        self.variants.push(variant);
        self
    }
    /// Add a generic bound to this Enum
    pub fn add_generic(&mut self, generic: Generic) -> &mut Self {
        self.generics.add_generic(generic);
        self
    }
}

impl Variant {
    /// Create a new variant to add to an `Enum`
    pub fn new<S: ToString>(name: S) -> Self {
        let mut v = Variant::default();
        v.name = name.to_string();
        v
    }
    /// Set the inner portion of this variant, expected to be valid Rust source code.
    pub fn set_inner<S: ToString>(&mut self, inner: Option<S>) -> &mut Self {
        self.inner = inner.map(|s| s.to_string());
        self
    }
}

impl SrcCode for Variant {
    fn generate(&self) -> String {
        let template = r#"{{ self.name }}{{ inner }}"#;
        let mut ctx = Context::new();
        ctx.insert("self", &self);
        ctx.insert("inner", &self.inner.as_ref().unwrap_or(&"".to_string()));
        Tera::one_off(template, &ctx, false).unwrap()
    }
}

impl SrcCode for Enum {
    fn generate(&self) -> String {
        let template = r#"
            {% if self.is_pub %}pub {% endif %}enum {{ self.name }}{{ generics }} {
                {% for variant in variants %}{{ variant }},
                {% endfor %}
            }
        "#;
        let mut ctx = Context::new();
        ctx.insert("self", &self);
        ctx.insert("generics", &self.generics.generate());
        ctx.insert(
            "variants",
            &self
                .variants
                .iter()
                .map(|v| v.generate())
                .collect::<Vec<String>>(),
        );
        Tera::one_off(template, &ctx, false).unwrap()
    }
}