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

//! Environment variable access functions for templates
//!
//! This module provides functions for accessing and filtering environment variables:
//! - `get_env`: Get an environment variable with optional default value
//! - `filter_env`: Filter environment variables by glob pattern

use super::metadata::{ArgumentMetadata, FunctionMetadata, SyntaxVariants};
use super::traits::Function;
use minijinja::value::Kwargs;
use minijinja::{Error, ErrorKind, Value};
use std::collections::HashMap;

/// Get environment variable with optional default
pub struct GetEnv;

impl Function for GetEnv {
    const NAME: &'static str = "get_env";
    const METADATA: FunctionMetadata = FunctionMetadata {
        name: "get_env",
        category: "environment",
        description: "Get environment variable with optional default value",
        arguments: &[
            ArgumentMetadata {
                name: "name",
                arg_type: "string",
                required: true,
                default: None,
                description: "Environment variable name",
            },
            ArgumentMetadata {
                name: "default",
                arg_type: "string",
                required: false,
                default: None,
                description: "Default value if variable is not set",
            },
        ],
        return_type: "string",
        examples: &[
            "{{ get_env(name=\"HOME\") }}",
            "{{ get_env(name=\"PORT\", default=\"8080\") }}",
        ],
        syntax: SyntaxVariants::FUNCTION_ONLY,
    };

    fn call(kwargs: Kwargs) -> Result<Value, Error> {
        let name: String = kwargs.get("name")?;
        let default: Option<String> = kwargs.get("default").ok();

        match std::env::var(&name) {
            Ok(value) => Ok(Value::from(value)),
            Err(_) => {
                if let Some(def) = default {
                    Ok(Value::from(def))
                } else {
                    Err(Error::new(
                        ErrorKind::UndefinedError,
                        format!(
                            "Environment variable '{}' is not set and no default provided",
                            name
                        ),
                    ))
                }
            }
        }
    }
}

/// Filter environment variables by glob pattern
pub struct FilterEnv;

impl Function for FilterEnv {
    const NAME: &'static str = "filter_env";
    const METADATA: FunctionMetadata = FunctionMetadata {
        name: "filter_env",
        category: "environment",
        description: "Filter environment variables by glob pattern",
        arguments: &[ArgumentMetadata {
            name: "pattern",
            arg_type: "string",
            required: true,
            default: None,
            description: "Glob pattern to match variable names (e.g., \"SERVER_*\", \"DB_*\")",
        }],
        return_type: "array",
        examples: &[
            "{% for var in filter_env(pattern=\"SERVER_*\") %}{{ var.key }}={{ var.value }}{% endfor %}",
            "{{ filter_env(pattern=\"DB_*\") }}",
        ],
        syntax: SyntaxVariants::FUNCTION_ONLY,
    };

    fn call(kwargs: Kwargs) -> Result<Value, Error> {
        let pattern: String = kwargs.get("pattern")?;

        // Convert glob pattern to regex
        let regex_pattern = glob_to_regex(&pattern);
        let re = regex::Regex::new(&regex_pattern).map_err(|e| {
            Error::new(
                ErrorKind::InvalidOperation,
                format!("Invalid pattern: {}", e),
            )
        })?;

        // Filter environment variables
        let mut results: Vec<HashMap<String, String>> = std::env::vars()
            .filter(|(key, _)| re.is_match(key))
            .map(|(key, value)| {
                let mut map = HashMap::new();
                map.insert("key".to_string(), key);
                map.insert("value".to_string(), value);
                map
            })
            .collect();

        // Sort by key for consistent output
        results.sort_by(|a, b| a.get("key").cmp(&b.get("key")));

        Ok(Value::from_serialize(&results))
    }
}

/// Convert a glob pattern to a regex pattern
fn glob_to_regex(pattern: &str) -> String {
    let mut regex = String::from("^");

    for ch in pattern.chars() {
        match ch {
            '*' => regex.push_str(".*"),
            '?' => regex.push('.'),
            // Escape regex special characters
            '.' | '+' | '^' | '$' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' => {
                regex.push('\\');
                regex.push(ch);
            }
            _ => regex.push(ch),
        }
    }

    regex.push('$');
    regex
}