atom-engine 5.0.2

A component-oriented template engine built on Tera with props, slots, and provide/inject context
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

use atom_engine::Atom;
use serde_json::json;

fn main() {
    let mut engine = Atom::new();

    engine.provide("theme", json!("dark"));
    engine.provide("user", json!({"name": "Alice", "role": "admin"}));
    engine.provide("site_name", json!("My Website"));

    engine
        .add_template(
            "context_basic.html",
            r#"<h1>Context Injection Demo</h1>

<p>Theme: {{ theme }}</p>
<p>Site: {{ site_name }}</p>
<p>User: {{ user.name }} ({{ user.role }})</p>"#,
        )
        .unwrap();

    let result = engine.render("context_basic.html", &json!({})).unwrap();
    println!("=== Basic Context ===\n{}", result);

    let mut engine2 = Atom::new();

    engine2.provide("theme", json!("light"));
    engine2.provide(
        "config",
        json!({
            "title": "My Blog",
            "items_per_page": 10,
            "show_comments": true
        }),
    );

    engine2
        .add_template(
            "nested_context.html",
            r#"<!DOCTYPE html>
<html>
<head>
  <title>{{ config.title }}</title>
  <style>
    body { 
      {% if theme == "dark" %}
      background: #1a1a1a; color: #fff;
      {% else %}
      background: #fff; color: #333;
      {% endif %}
    }
  </style>
</head>
<body>
  <h1>{{ config.title }}</h1>
  
  {% if config.show_comments %}
  <p>Comments are enabled.</p>
  {% endif %}
  
  <p>Items per page: {{ config.items_per_page }}</p>
</body>
</html>"#,
        )
        .unwrap();

    let result = engine2.render("nested_context.html", &json!({})).unwrap();
    println!("\n=== Nested Context ===\n{}", result);

    let mut engine3 = Atom::new();

    engine3
        .add_template(
            "set_context.html",
            r#"<h1>Using provide() in code</h1>

<p>In Rust code:</p>
<pre>
engine.provide("api_url", "https://api.example.com");
engine.provide("version", "1.0.0");
engine.provide("features", ["auth", "payments", "analytics"]);
</pre>

<p>In template:</p>
<ul>
  <li>API URL: {{ api_url }}</li>
  <li>Version: {{ version }}</li>
  <li>Features: {{ features | length }}</li>
  {% for feature in features %}
    <li>{{ feature }}</li>
  {% endfor %}
</ul>"#,
        )
        .unwrap();

    engine3.provide("api_url", json!("https://api.example.com"));
    engine3.provide("version", json!("1.0.0"));
    engine3.provide("features", json!(["auth", "payments", "analytics"]));

    let result = engine3.render("set_context.html", &json!({})).unwrap();
    println!("\n=== Provide in Code ===\n{}", result);

    let mut engine4 = Atom::new();

    engine4
        .add_template(
            "layered_context.html",
            r#"<h1>Layered Context</h1>

<p>Base value: {{ message }}</p>"#,
        )
        .unwrap();

    engine4.provide("message", json!("Base message"));

    let result = engine4
        .render(
            "layered_context.html",
            &json!({
                "message": "Override from render context"
            }),
        )
        .unwrap();

    println!("\n=== Render Context Override ===\n{}", result);
}