rshtml_core 0.5.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

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

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

pub fn view_node(node: &Node, indent: usize) {
    print_indent(indent);
    match node {
        Node::Template(_, name, _, nodes, _) => {
            println!("- Template ({name}):");
            for inner_node in nodes {
                view_node(inner_node, indent + 1);
            }
        }
        Node::Text(text) => {
            println!("- Text: {text:?}");
        }
        Node::TemplateParams(props, _) => {
            println!("- Template Params:");
            for prop in props {
                print_indent(indent + 1);
                println!("- Name: {:?}", prop.0);
                print_indent(indent + 1);
                println!("- Type: {:?}", prop.1);
            }
        }
        Node::RustBlock(content, _) => {
            println!("- RustBlock: {content:?}");
        }
        Node::Expr(expr, _, _) => {
            println!("- Expr: {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::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");
        }
    }
}