tron 2.1.0

A rust based template system built for speed and simplicity.
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Builder patterns example showing fluent API usage.
//!
//! This example demonstrates how to use the builder patterns for creating
//! templates with a more ergonomic and fluent API.

use tron::{TronTemplateBuilder, TronRefBuilder, Result};
use std::collections::HashMap;

fn main() -> Result<()> {
    println!("=== Tron Builder Patterns Example ===\n");

    // Example 1: Basic template builder
    example_template_builder()?;
    
    // Example 2: Template reference builder with dependencies
    example_template_ref_builder()?;
    
    // Example 3: Complex template with bulk operations
    example_bulk_operations()?;
    
    // Example 4: Method chaining showcase
    example_method_chaining()?;

    Ok(())
}

fn example_template_builder() -> Result<()> {
    println!("1. Basic Template Builder:");
    
    let template = TronTemplateBuilder::new()
        .content("Hello @[greeting]@ @[name]@! Welcome to @[application]@.")
        .set("greeting", "Hi")
        .set("name", "Alice")
        .set("application", "Tron Template Engine")
        .build()?;
    
    let result = template.render()?;
    println!("   {}", result);
    println!();
    
    Ok(())
}

fn example_template_ref_builder() -> Result<()> {
    println!("2. Template Reference Builder with Dependencies:");
    
    let template_ref = TronRefBuilder::new()
        .content(r#"
use @[serde_crate]@::{Serialize, Deserialize};
use @[uuid_crate]@::Uuid;

#[derive(Debug, Serialize, Deserialize)]
pub struct @[struct_name]@ {
    pub id: Uuid,
    @[fields]@
}

impl @[struct_name]@ {
    pub fn new(@[constructor_params]@) -> Self {
        Self {
            id: Uuid::new_v4(),
            @[field_assignments]@
        }
    }
}
"#)
        .dependency("serde = { version = \"1.0\", features = [\"derive\"] }")
        .dependency("uuid = { version = \"1.0\", features = [\"v4\"] }")
        .set("serde_crate", "serde")
        .set("uuid_crate", "uuid")
        .set("struct_name", "User")
        .set("fields", "pub name: String,\n    pub email: String,")
        .set("constructor_params", "name: String, email: String")
        .set("field_assignments", "name,\n            email,")
        .build()?;
    
    let result = template_ref.render()?;
    println!("{}", result);
    println!("   Dependencies: {:?}", template_ref.dependencies());
    println!();
    
    Ok(())
}

fn example_bulk_operations() -> Result<()> {
    println!("3. Bulk Operations with HashMap:");
    
    let mut values = HashMap::new();
    values.insert("trait_name", "Display");
    values.insert("type_name", "User");
    values.insert("format_string", "{} <{}>\"");
    values.insert("field_access", "self.name, self.email");
    
    let template = TronTemplateBuilder::new()
        .content(r#"impl std::fmt::@[trait_name]@ for @[type_name]@ {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "@[format_string]@, @[field_access]@)
    }
}"#)
        .set_many(values)
        .build()?;
    
    let result = template.render()?;
    println!("{}", result);
    
    Ok(())
}

fn example_method_chaining() -> Result<()> {
    println!("4. Method Chaining Showcase:");
    
    // Build a complete Rust module using method chaining
    let module = TronRefBuilder::new()
        .content(r#"//! @[module_doc]@

@[imports]@

@[main_content]@

#[cfg(test)]
mod tests {
    use super::*;

    @[tests]@
}
"#)
        .dependencies(&[
            "serde = \"1.0\"",
            "tokio = { version = \"1.0\", features = [\"full\"] }",
            "uuid = \"1.0\""
        ])
        .set("module_doc", "User management module with async capabilities")
        .set("imports", "use serde::{Serialize, Deserialize};\nuse uuid::Uuid;\nuse std::collections::HashMap;")
        .set("main_content", r#"#[derive(Debug, Serialize, Deserialize)]
pub struct AsyncUser {
    pub id: Uuid,
    pub name: String,
    pub metadata: HashMap<String, String>,
}

impl AsyncUser {
    pub async fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
        // Simulate async database save
        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
        println!("Saved user: {}", self.name);
        Ok(())
    }
}"#)
        .set("tests", r#"#[tokio::test]
    async fn test_user_save() {
        let user = AsyncUser {
            id: Uuid::new_v4(),
            name: "Test User".to_string(),
            metadata: HashMap::new(),
        };
        
        assert!(user.save().await.is_ok());
    }"#)
        .build()?;
    
    let result = module.render()?;
    println!("{}", result);
    println!("   Dependencies used: {}", module.dependencies().len());
    
    Ok(())
}