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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use minijinja::Value;
use minijinja::value::Kwargs;
use std::path::PathBuf;
use std::sync::Arc;
use tmpltool::TemplateContext;
use tmpltool::functions::ContextFunction;
use tmpltool::functions::filesystem::ReadLines;

// Helper to create a trusted context
fn create_trusted_context() -> Arc<TemplateContext> {
    Arc::new(TemplateContext::new(PathBuf::from("."), true))
}

// Note: basename_fn, dirname_fn, file_extension_fn, join_path_fn, normalize_path_fn
// tests removed - these functions are now in filter_functions/path.rs with dual syntax support.
// See tests/test_filters_integration.rs for integration tests of these filters.

// Note: is_file, is_dir, and is_symlink tests have been moved to
// tests/test_is_filesystem.rs as part of the is-functions refactoring.

// read_lines tests
#[test]
fn test_read_lines_basic() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![("path", Value::from("Cargo.toml"))]),
    )
    .unwrap();

    // Should return an array with lines
    let lines: Vec<_> = result.try_iter().unwrap().collect();

    // Default max_lines is 10, so we should get at most 10 lines
    assert!(lines.len() <= 10);

    // Should have at least some content
    assert!(!lines.is_empty());
}

#[test]
fn test_read_lines_with_max() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![
            ("path", Value::from("Cargo.toml")),
            ("max_lines", Value::from(3)),
        ]),
    )
    .unwrap();

    let lines: Vec<_> = result.try_iter().unwrap().collect();
    assert_eq!(lines.len(), 3);
}

#[test]
fn test_read_lines_entire_file() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![
            ("path", Value::from("Cargo.toml")),
            ("max_lines", Value::from(0)),
        ]),
    )
    .unwrap();

    let lines: Vec<_> = result.try_iter().unwrap().collect();
    // Cargo.toml should have more than 3 lines
    assert!(lines.len() > 3);
}

#[test]
fn test_read_lines_invalid_max_large() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![
            ("path", Value::from("Cargo.toml")),
            ("max_lines", Value::from(20000)),
        ]),
    );

    assert!(result.is_err());
    assert!(
        result
            .unwrap_err()
            .to_string()
            .contains("between 0 and 10000")
    );
}

#[test]
fn test_read_lines_last_lines() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![
            ("path", Value::from("Cargo.toml")),
            ("max_lines", Value::from(-3)),
        ]),
    )
    .unwrap();

    let lines: Vec<_> = result.try_iter().unwrap().collect();
    assert_eq!(lines.len(), 3);
}

#[test]
fn test_read_lines_negative_more_than_file() {
    let context = create_trusted_context();

    // Request more lines than the file has
    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![
            ("path", Value::from("Cargo.toml")),
            ("max_lines", Value::from(-10000)),
        ]),
    )
    .unwrap();

    let lines: Vec<_> = result.try_iter().unwrap().collect();
    // Should return all lines when requesting more than available
    assert!(!lines.is_empty());
}

#[test]
fn test_read_lines_nonexistent() {
    let context = create_trusted_context();

    let result = ReadLines::call(
        context.clone(),
        Kwargs::from_iter(vec![("path", Value::from("nonexistent.txt"))]),
    );

    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("Failed to read"));
}