rshtml_core 0.3.0

RsHtml: A Template Engine for Seamless HTML and Rust Integration.
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

use crate::node::{ComponentParameterValue, Node, SectionDirectiveContent};

fn print_indent(indent: usize) {
    print!("{}", "  ".repeat(indent));
}

pub fn view_node(node: &Node, indent: usize) {
    print_indent(indent);
    match node {
        Node::Template(_, nodes, _) => {
            println!("- Template:");
            for inner_node in nodes {
                view_node(inner_node, indent + 1);
            }
        }
        Node::Text(text) => {
            println!("- Text: {text:?}");
        }
        Node::InnerText(text) => {
            println!("- InnerText: {text:?}");
        }
        Node::Comment(comment) => {
            println!("- Comment: {comment:?}");
        }
        Node::ExtendsDirective(path, _) => {
            println!("- ExtendsDirective: {path:?}");
        }
        Node::RenderDirective(path) => {
            println!("- RenderDirective: {path:?}");
        }
        Node::RustBlock(content, _) => {
            println!("- RustBlock: {content:?}");
        }
        Node::RustExprSimple(expr, _, _) => {
            println!("- RustExprSimple: {expr:?}");
        }
        Node::RustExprParen(expr, _, _) => {
            println!("- RustExprParen: {expr:?}");
        }
        Node::RustExpr(clauses, _) => {
            println!("- RustExpr:");
            for (condition, nodes) in clauses {
                print_indent(indent + 1);
                println!("- Clause: {condition:?}");
                for inner_node in nodes {
                    view_node(inner_node, indent + 2);
                }
            }
        }
        Node::MatchExpr(head, arms, _) => {
            println!("- MatchExpr:");
            print_indent(indent + 1);
            println!("- Clause: {head:?}");
            print_indent(indent + 1);
            println!("- Arms:");
            for (head, values) in arms {
                print_indent(indent + 2);
                println!("- Arm: {head:?}");
                for inner_node in values {
                    view_node(inner_node, indent + 3);
                }
            }
        }
        Node::SectionDirective(name, body, _) => {
            println!("- SectionDirective:");
            print_indent(indent + 1);
            println!("- StringLine: {name:?}");
            print_indent(indent + 1);
            match body {
                SectionDirectiveContent::Text(s) => println!("- StringLine: {s:?}"),
                SectionDirectiveContent::RustExprSimple(s, _) => {
                    println!("- RustExprSimple: {s:?}")
                }
            }
        }
        Node::SectionBlock(section_head, body) => {
            println!("- SectionBlock:");
            print_indent(indent + 1);
            println!("- StringLine: {section_head:?}");
            for inner_node in body {
                view_node(inner_node, indent + 1);
            }
        }
        Node::RenderBody => {
            println!("- RenderBody");
        }
        Node::Component(name, parameters, body, _) => {
            println!("- Component:");
            print_indent(indent + 1);
            println!("- Name: {name:?}");
            print_indent(indent + 1);
            println!("- Parameters:");
            for parameter in parameters {
                print_indent(indent + 2);
                println!("- Name: {:?}", parameter.name);
                print_indent(indent + 2);
                match &parameter.value {
                    ComponentParameterValue::Bool(b) => println!("- Bool: {b:?}"),
                    ComponentParameterValue::Number(b) => println!("- Number: {b:?}"),
                    ComponentParameterValue::String(s) => println!("- String: {s:?}"),
                    ComponentParameterValue::RustExprSimple(s) => {
                        println!("- RustExprSimple: {s:?}")
                    }
                    ComponentParameterValue::RustExprParen(s) => {
                        println!("- RustExprParen: {s:?}")
                    }
                    ComponentParameterValue::Block(nodes) => {
                        println!("- Block:");
                        for node in nodes {
                            view_node(node, indent + 3)
                        }
                    }
                }
            }
            for inner_node in body {
                view_node(inner_node, indent + 1);
            }
        }
        Node::ChildContent => {
            println!("- ChildContent");
        }
        Node::Raw(s) => println!("- Raw: {s:?}"),
        Node::UseDirective(component_name, import_path, component) => {
            println!("- UseDirective:");
            print_indent(indent + 1);
            println!("- ComponentName: {component_name:?}");
            print_indent(indent + 1);
            println!("- ImportPath: {import_path:#?}");
            print_indent(indent + 1);
            println!("- Component:");
            view_node(component, indent + 2);
        }
        Node::ContinueDirective => {
            println!("- ContinueDirective");
        }
        Node::BreakDirective => {
            println!("- BreakDirective");
        }
    }
}