akari 0.2.7

Dynamic & Weakly Typed Programming Powered by Rust
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

use std::env;
use std::fs;
use std::process::exit;
use std::collections::HashMap;

use akari::TemplateManager; 
use akari::Value; 

fn main() {
    // Collect command-line arguments.
    let args: Vec<String> = env::args().collect();

    // We expect at least three arguments: executable name, command, and content (or file path).
    if args.len() < 3 {
        eprintln!("Usage: {} <command> <content|file_path> [key=value ...]", args[0]);
        exit(1);
    }

    let output = match args[1].as_str() {
        "render_string" => {
            // The second argument is the content.
            let content = &args[2]; 

            // Build the arguments HashMap from key=value pairs.
            let mut context: HashMap<String, Value> = HashMap::new();
            for arg in args.iter().skip(3) {
                if let Some(pos) = arg.find('=') {
                    let key = &arg[..pos];
                    let value = &arg[pos + 1..]; 
                    let value = Value::from_json(&value.to_string()).unwrap_or_else(|_| {
                        eprintln!("Failed to parse value: {}", key);
                        exit(1);
                    });  
                    context.insert(key.to_string(), value);
                } else {
                    eprintln!("Warning: ignoring malformed argument '{}'. Expected key=value.", arg);
                }
            }

            let template_manager = TemplateManager::new(""); 
            template_manager.render_string(content.clone(), &context) 
                .unwrap_or_else(|err| {
                    eprintln!("Failed to render template: {}", err);
                    exit(1);
                }) 
        }
        "render" => { 
            // The second argument is the file path.
            let file_path = &args[2]; 

            // Build the arguments HashMap from key=value pairs.
            let mut context: HashMap<String, Value> = HashMap::new();
            for arg in args.iter().skip(3) {
                if let Some(pos) = arg.find('=') {
                    let key = &arg[..pos];
                    let value = &arg[pos + 1..]; 
                    let value = Value::from_json(&value.to_string()).unwrap_or_else(|_| {
                        eprintln!("Failed to parse value: {}", key);
                        exit(1);
                    });  
                    context.insert(key.to_string(), value);
                } else {
                    eprintln!("Warning: ignoring malformed argument '{}'. Expected key=value.", arg);
                }
            } 

            let template_manager = TemplateManager::new(""); 
            template_manager.render(file_path, &context) 
                .unwrap_or_else(|err| {
                    eprintln!("Failed to render template: {}", err);
                    exit(1);
                }) 
        }
        unknown => {
            eprintln!("Unknown command: {}", unknown);
            exit(1);
        } 
    }; 
    
    println!("Output:\n{}", output); 
    exit(0)  
}