lewp 0.3.0

Say goodbye to the web template hell. Generate your HTML5 website technically optimized and always valid. In your Rust source.
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

use {
    crate::{
        dom::{Handle, Node, NodeData, NodeExt},
        Charset, LanguageTag,
    },
    html5ever::{namespace_url, ns, tendril::Tendril, Attribute, LocalName, QualName},
    log::error,
    std::{cell::RefCell, rc::Rc},
};

/// Helper struct for creating nodes.
pub struct NodeCreator;

impl NodeCreator {
    /// Creates a HTML tag. If the third argument is given, a TextNode will be
    /// added as subelement to the tag.
    pub fn element(tag_name: &str, attributes: Vec<Attribute>) -> Rc<Node> {
        Node::new(NodeData::Element {
            name: QualName::new(None, ns!(html), LocalName::from(tag_name)),
            attrs: RefCell::new(attributes),
            template_contents: None,
            mathml_annotation_xml_integration_point: false,
        })
    }

    /// Creates a HTML tag. Same as
    /// [NodeCreator::element]
    /// but with more options, see
    /// [markup5ever_rcdom::NodeData::Element].
    pub fn element_ext(
        tag_name: &str,
        attributes: Vec<Attribute>,
        template_contents: Option<Handle>,
        mathml_annotation_xml_integration_point: bool,
    ) -> Rc<Node> {
        Node::new(NodeData::Element {
            name: QualName::new(None, ns!(html), LocalName::from(tag_name)),
            attrs: RefCell::new(attributes),
            template_contents,
            mathml_annotation_xml_integration_point,
        })
    }

    /// Creates an attribute of an HTML element, see [html5ever::interface::Attribute].
    pub fn attribute(name: &str, value: &str) -> Attribute {
        Attribute {
            name: QualName::new(None, ns!(), LocalName::from(name)),
            value: Tendril::from(value),
        }
    }

    /// Creates a HTML text node.
    pub fn text(content: &str) -> Rc<Node> {
        Node::new(NodeData::Text {
            contents: RefCell::new(Tendril::from(content)),
        })
    }

    /// Creates the `<!doctype html>` tag node.
    pub fn doctype_html() -> Rc<Node> {
        Node::new(NodeData::Doctype {
            name: Tendril::from("html"),
            public_id: Tendril::from(""),
            system_id: Tendril::from(""),
        })
    }

    /// Creates a `<html>` tag node.
    pub fn html(language: LanguageTag) -> Rc<Node> {
        let language = match language.language() {
            Some(v) => v.primary().as_str().to_owned(),
            None => {
                error!("Could not find language for creating <html> tag");
                "".to_owned()
            }
        };
        NodeCreator::element("html", vec![NodeCreator::attribute("lang", &language)])
    }

    /// Creates a `<title>` tag node.
    pub fn title(title: &str) -> Rc<Node> {
        let title_tag = NodeCreator::element("title", vec![]);
        title_tag
            .children
            .borrow_mut()
            .push(NodeCreator::text(title));
        title_tag
    }

    /// Creates a `<meta>` tag node with description.
    pub fn description(description: &str) -> Rc<Node> {
        NodeCreator::element(
            "meta",
            vec![
                NodeCreator::attribute("name", "description"),
                NodeCreator::attribute("content", description),
            ],
        )
    }

    /// Creates a `<meta>` viewport tag node.
    pub fn viewport() -> Rc<Node> {
        NodeCreator::element(
            "meta",
            vec![
                NodeCreator::attribute("name", "viewport"),
                NodeCreator::attribute(
                    "content",
                    "width=device-width, initial-scale=1.0, user-scalable=no",
                ),
            ],
        )
    }

    /// Creates a `<meta>` charset tag node.
    pub fn charset(charset: &Charset) -> Rc<Node> {
        NodeCreator::element(
            "meta",
            vec![NodeCreator::attribute("charset", &charset.to_string())],
        )
    }

    /// Creates a `hX` tag, where `X` equals the given level.
    /// If the level is bigger than 6, it will be set to 6.
    /// If 0 is given, 1 is used.
    pub fn headline(level: u8, content: &str, attributes: Vec<Attribute>) -> Rc<Node> {
        let level = match level {
            0 => 1,
            1..=6 => level,
            _ => 6,
        };
        let h = Self::element(&format!("h{}", level), attributes);
        h.add_text(content);
        h
    }

    /// Creates a `p` tag with the given attributes and content.
    pub fn paragraph(content: &str, attributes: Vec<Attribute>) -> Rc<Node> {
        let p = Self::element("p", attributes);
        p.add_text(content);
        p
    }
}