mrml 1.2.2

Rust implementation of MJML renderer
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

use std::collections::{HashMap, HashSet};

pub struct Tag {
    name: String,
    attributes: HashMap<String, String>,
    classes: HashSet<String>,
    // in order to keep the style in the same order the've been added
    styles: Vec<(String, String)>,
}

impl Tag {
    pub fn table() -> Self {
        Self::new("table")
    }
    pub fn table_borderless() -> Self {
        Self::table()
            .add_attribute("border", "0")
            .add_attribute("cellpadding", "0")
            .add_attribute("cellspacing", "0")
    }
    pub fn table_presentation() -> Self {
        Self::table_borderless().add_attribute("role", "presentation")
    }
    pub fn tbody() -> Self {
        Self::new("tbody")
    }
    pub fn tr() -> Self {
        Self::new("tr")
    }
    pub fn td() -> Self {
        Self::new("td")
    }
    pub fn div() -> Self {
        Self::new("div")
    }

    pub fn new<T: ToString>(name: T) -> Self {
        Self {
            name: name.to_string(),
            attributes: HashMap::new(),
            classes: HashSet::new(),
            styles: Vec::new(),
        }
    }

    pub fn add_class<T: ToString>(mut self, value: T) -> Self {
        self.classes.insert(value.to_string());
        self
    }

    pub fn add_suffixed_class<T: AsRef<str>>(self, value: T, suffix: &str) -> Self {
        self.add_class(format!("{}-{}", value.as_ref(), suffix))
    }

    pub fn maybe_add_suffixed_class<T: AsRef<str>>(self, value: Option<T>, suffix: &str) -> Self {
        if let Some(value) = value {
            self.add_suffixed_class(value, suffix)
        } else {
            self
        }
    }

    pub fn maybe_add_class<T: ToString>(self, value: Option<T>) -> Self {
        if let Some(value) = value {
            self.add_class(value)
        } else {
            self
        }
    }

    pub fn add_attribute<V: ToString>(mut self, name: &str, value: V) -> Self {
        self.attributes.insert(name.to_string(), value.to_string());
        self
    }

    pub fn maybe_add_attribute<T: ToString>(self, name: &str, value: Option<T>) -> Self {
        if let Some(value) = value {
            self.add_attribute(name, value)
        } else {
            self
        }
    }

    pub fn add_style<T: ToString>(mut self, name: &str, value: T) -> Self {
        self.styles.push((name.to_string(), value.to_string()));
        self
    }

    pub fn maybe_add_style<T: ToString>(self, name: &str, value: Option<T>) -> Self {
        if let Some(value) = value {
            self.add_style(name, value)
        } else {
            self
        }
    }

    fn opening(&self) -> String {
        let mut res = String::from("<");
        res.push_str(&self.name);
        for (key, value) in self.attributes.iter() {
            res.push(' ');
            res.push_str(key);
            res.push_str("=\"");
            res.push_str(value);
            res.push('"');
        }
        if !self.classes.is_empty() {
            res.push_str(" class=\"");
            for (index, classname) in self.classes.iter().enumerate() {
                if index > 0 {
                    res.push(' ');
                }
                res.push_str(classname);
            }
            res.push('"');
        }
        if !self.styles.is_empty() {
            res.push_str(" style=\"");
            for (key, value) in self.styles.iter() {
                res.push_str(key);
                res.push(':');
                res.push_str(value);
                res.push(';');
            }
            res.push('"');
        }
        res
    }

    pub fn open(&self) -> String {
        self.opening() + ">"
    }

    pub fn close(&self) -> String {
        format!("</{}>", self.name)
    }

    pub fn closed(&self) -> String {
        self.opening() + " />"
    }

    pub fn render<T: AsRef<str>>(&self, input: T) -> String {
        self.open() + input.as_ref() + &self.close()
    }
}