tmpltool 1.5.0

A fast and simple command-line template rendering tool using MiniJinja templates with environment variables
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 minijinja::Environment;
use std::path::PathBuf;
use tmpltool::{TemplateContext, functions::register_all};

fn render_template(template: &str) -> String {
    let mut env = Environment::new();
    let ctx = TemplateContext::new(PathBuf::from("."), false);
    register_all(&mut env, ctx);

    let tmpl = env.template_from_str(template).unwrap();
    tmpl.render(()).unwrap()
}

// Helper to validate UUID format
fn is_valid_uuid_format(uuid_str: &str) -> bool {
    if uuid_str.len() != 36 {
        return false;
    }
    let chars: Vec<char> = uuid_str.chars().collect();
    chars[8] == '-' && chars[13] == '-' && chars[18] == '-' && chars[23] == '-'
}

// ==================== UUID v4 Tests ====================

#[test]
fn test_uuid_v4_default() {
    let result = render_template("{{ uuid() }}");
    assert!(is_valid_uuid_format(&result));
    // Version should be 4 (14th character)
    assert_eq!(result.chars().nth(14).unwrap(), '4');
}

#[test]
fn test_uuid_v4_explicit() {
    let result = render_template(r#"{{ uuid(version="v4") }}"#);
    assert!(is_valid_uuid_format(&result));
    // Version should be 4
    assert_eq!(result.chars().nth(14).unwrap(), '4');
}

#[test]
fn test_uuid_v4_uniqueness() {
    let result1 = render_template("{{ uuid() }}");
    let result2 = render_template("{{ uuid() }}");
    assert_ne!(result1, result2);
}

#[test]
fn test_uuid_v4_valid_hex() {
    let result = render_template("{{ uuid() }}");
    let hex_part: String = result.chars().filter(|c| *c != '-').collect();
    assert_eq!(hex_part.len(), 32);
    for ch in hex_part.chars() {
        assert!(ch.is_ascii_hexdigit());
    }
}

// ==================== UUID v7 Tests ====================

#[test]
fn test_uuid_v7_explicit() {
    let result = render_template(r#"{{ uuid(version="v7") }}"#);
    assert!(is_valid_uuid_format(&result));
    // Version should be 7 (14th character)
    assert_eq!(result.chars().nth(14).unwrap(), '7');
}

#[test]
fn test_uuid_v7_uniqueness() {
    let result1 = render_template(r#"{{ uuid(version="v7") }}"#);
    let result2 = render_template(r#"{{ uuid(version="v7") }}"#);
    assert_ne!(result1, result2);
}

#[test]
fn test_uuid_v7_valid_hex() {
    let result = render_template(r#"{{ uuid(version="v7") }}"#);
    let hex_part: String = result.chars().filter(|c| *c != '-').collect();
    assert_eq!(hex_part.len(), 32);
    for ch in hex_part.chars() {
        assert!(ch.is_ascii_hexdigit());
    }
}

#[test]
fn test_uuid_v7_is_time_ordered() {
    // UUIDv7 should be roughly time-ordered (lexicographically sortable)
    let result1 = render_template(r#"{{ uuid(version="v7") }}"#);
    std::thread::sleep(std::time::Duration::from_millis(2));
    let result2 = render_template(r#"{{ uuid(version="v7") }}"#);
    // The first part of v7 UUID is timestamp-based, so result2 should be >= result1
    assert!(result2 >= result1);
}

// ==================== Error Cases ====================

#[test]
fn test_uuid_invalid_version() {
    let mut env = Environment::new();
    let ctx = TemplateContext::new(PathBuf::from("."), false);
    register_all(&mut env, ctx);

    let tmpl = env
        .template_from_str(r#"{{ uuid(version="v99") }}"#)
        .unwrap();
    let result = tmpl.render(());
    assert!(result.is_err());
    let err = result.unwrap_err().to_string();
    assert!(err.contains("Invalid UUID version"));
    assert!(err.contains("v99"));
}

#[test]
fn test_uuid_invalid_version_v1() {
    let mut env = Environment::new();
    let ctx = TemplateContext::new(PathBuf::from("."), false);
    register_all(&mut env, ctx);

    let tmpl = env
        .template_from_str(r#"{{ uuid(version="v1") }}"#)
        .unwrap();
    let result = tmpl.render(());
    assert!(result.is_err());
    let err = result.unwrap_err().to_string();
    assert!(err.contains("Invalid UUID version"));
}