trowel 0.2.0

Tools for writing HTML in Rust
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

use std::fmt::Write;

pub type Attribute = (String, Option<String>);

pub trait HtmlWriter {
    fn write_tag(&mut self, tag: &str, single: bool, attributes: Vec<Attribute>);
    fn write_end_tag(&mut self, tag: &str);
    fn write_string_lit(&mut self, lit: &str);
}

pub trait ToHtml {
    fn to_html(self, writer: &mut dyn HtmlWriter);
}

impl<F: FnOnce(&mut dyn crate::HtmlWriter)> ToHtml for F {
    fn to_html(self, writer: &mut dyn HtmlWriter) {
        self(writer)
    }
}

impl ToHtml for &str {
    fn to_html(self, writer: &mut dyn HtmlWriter) {
        writer.write_string_lit(self);
    }
}

impl ToHtml for String {
    fn to_html(self, writer: &mut dyn HtmlWriter) {
        writer.write_string_lit(self.as_str());
    }
}

impl<T> ToHtml for Vec<T>
where
    T: Fn(&mut dyn HtmlWriter),
{
    fn to_html(self, writer: &mut dyn HtmlWriter) {
        for el in self {
            el(writer)
        }
    }
}

impl<T: ToHtml> ToHtml for Option<T> {
    fn to_html(self, writer: &mut dyn HtmlWriter) {
        if let Some(x) = self {
            x.to_html(writer)
        }
    }
}

pub struct WriteHtml<T: Write> {
    writer: T,
}

impl<T: Write> WriteHtml<T> {
    pub fn new(writer: T) -> Self {
        WriteHtml { writer }
    }
}

impl<T: Write> HtmlWriter for WriteHtml<T> {
    fn write_tag(&mut self, tag: &str, single: bool, attr: Vec<Attribute>) {
        let end = if single { " /" } else { "" };
        let mut attr_str = String::new();
        for (key, value) in attr {
            attr_str.push(' ');
            attr_str.push_str(&key);
            if let Some(value) = value {
                attr_str.push('=');
                attr_str.push('"');
                attr_str.push_str(&value);
                attr_str.push('"');
            }
        }
        write!(self.writer, "<{tag}{attr_str}{end}>").unwrap();
    }

    fn write_end_tag(&mut self, tag: &str) {
        write!(self.writer, "</{tag}>").unwrap();
    }

    fn write_string_lit(&mut self, lit: &str) {
        writeln!(self.writer, "{lit}").unwrap()
    }
}