chore: after migration improvements

Author: bordeux

src/filters/formatting.rs

@@ -0,0 +1,75 @@
+/// Formatting filters for MiniJinja templates
+use minijinja::Value;
+use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
+
+/// Format file size in human-readable format (bytes, KB, MB, GB, etc.)
+///
+/// # Arguments
+///
+/// * `value` - The file size in bytes (as number)
+///
+/// # Example
+///
+/// ```jinja
+/// {{ 1024 | filesizeformat }}  => "1 KB"
+/// {{ 1048576 | filesizeformat }}  => "1 MB"
+/// ```
+pub fn filesizeformat_filter(value: &Value) -> Result<String, minijinja::Error> {
+    let bytes = if let Some(n) = value.as_i64() {
+        n as f64
+    } else {
+        return Err(minijinja::Error::new(
+            minijinja::ErrorKind::InvalidOperation,
+            "filesizeformat filter requires a number",
+        ));
+    };
+
+    const UNITS: &[&str] = &["bytes", "KB", "MB", "GB", "TB", "PB"];
+    const THRESHOLD: f64 = 1024.0;
+
+    if bytes < THRESHOLD {
+        return Ok(format!("{} bytes", bytes as i64));
+    }
+
+    let mut size = bytes;
+    let mut unit_index = 0;
+
+    while size >= THRESHOLD && unit_index < UNITS.len() - 1 {
+        size /= THRESHOLD;
+        unit_index += 1;
+    }
+
+    // Format with appropriate precision
+    // If it's a whole number (or very close to one), show without decimals
+    if (size - size.round()).abs() < 0.01 {
+        Ok(format!("{:.0} {}", size, UNITS[unit_index]))
+    } else if size < 10.0 {
+        Ok(format!("{:.2} {}", size, UNITS[unit_index]))
+    } else if size < 100.0 {
+        Ok(format!("{:.1} {}", size, UNITS[unit_index]))
+    } else {
+        Ok(format!("{:.0} {}", size, UNITS[unit_index]))
+    }
+}
+
+/// URL encode a string - encode special characters for use in URLs
+///
+/// # Arguments
+///
+/// * `value` - The string to URL encode
+///
+/// # Example
+///
+/// ```jinja
+/// {{ "hello world & foo=bar" | urlencode }}  => "hello%20world%20%26%20foo%3Dbar"
+/// ```
+pub fn urlencode_filter(value: &Value) -> Result<String, minijinja::Error> {
+    let s = value.as_str().ok_or_else(|| {
+        minijinja::Error::new(
+            minijinja::ErrorKind::InvalidOperation,
+            "urlencode filter requires a string",
+        )
+    })?;
+
+    Ok(utf8_percent_encode(s, NON_ALPHANUMERIC).to_string())
+}

src/filters/mod.rs

@@ -0,0 +1,72 @@
+//! Custom filters for MiniJinja templates
+//!
+//! This module contains custom filters organized by category.
+//!
+//! # Filter Categories
+//!
+//! - **String Filters** (`string` module): Text manipulation filters
+//!   - `slugify` - Convert strings to URL-friendly slugs
+//!
+//! - **Formatting Filters** (`formatting` module): Data formatting filters
+//!   - `filesizeformat` - Format bytes as human-readable file sizes
+//!   - `urlencode` - URL-encode strings for safe URL usage
+//!
+//! # Adding Custom Filters
+//!
+//! To add a new custom filter:
+//!
+//! 1. Choose or create an appropriate category module in `src/filters/`
+//! 2. Implement your filter function with signature: `fn my_filter(value: &Value) -> Result<T, Error>`
+//! 3. Add `pub mod category;` to this file if it's a new category
+//! 4. Add your filter to the `register_all()` function below
+//!
+//! # Example
+//!
+//! ```rust
+//! // In src/filters/string.rs
+//! use minijinja::Value;
+//!
+//! pub fn my_filter(value: &Value) -> Result<String, minijinja::Error> {
+//!     let s = value.as_str().ok_or_else(|| {
+//!         minijinja::Error::new(
+//!             minijinja::ErrorKind::InvalidOperation,
+//!             "my_filter requires a string",
+//!         )
+//!     })?;
+//!
+//!     // Your implementation here
+//!     Ok(s.to_uppercase())
+//! }
+//! ```
+
+pub mod formatting;
+pub mod string;
+
+use minijinja::Environment;
+
+/// Register all custom filters with the MiniJinja environment
+///
+/// This function is called when setting up a MiniJinja environment to register
+/// all custom filters.
+///
+/// # Arguments
+///
+/// * `env` - Mutable reference to a MiniJinja Environment
+///
+/// # Example
+///
+/// ```
+/// use minijinja::Environment;
+/// use tmpltool::filters;
+///
+/// let mut env = Environment::new();
+/// filters::register_all(&mut env);
+/// ```
+pub fn register_all(env: &mut Environment) {
+    // String filters
+    env.add_filter("slugify", string::slugify_filter);
+
+    // Formatting filters
+    env.add_filter("filesizeformat", formatting::filesizeformat_filter);
+    env.add_filter("urlencode", formatting::urlencode_filter);
+}

src/filters/string.rs

@@ -0,0 +1,45 @@
+/// String manipulation filters for MiniJinja templates
+use minijinja::Value;
+
+/// Slugify a string - convert to lowercase, replace spaces with hyphens, remove special chars
+///
+/// # Arguments
+///
+/// * `value` - The string to slugify
+///
+/// # Example
+///
+/// ```jinja
+/// {{ "Hello World!" | slugify }}  => "hello-world"
+/// {{ "jane smith" | slugify }}  => "jane-smith"
+/// ```
+pub fn slugify_filter(value: &Value) -> Result<String, minijinja::Error> {
+    let s = value.as_str().ok_or_else(|| {
+        minijinja::Error::new(
+            minijinja::ErrorKind::InvalidOperation,
+            "slugify filter requires a string",
+        )
+    })?;
+
+    let slug = s
+        .to_lowercase()
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() {
+                c
+            } else if c.is_whitespace() || c == '-' || c == '_' {
+                '-'
+            } else {
+                '\0' // Will be filtered out
+            }
+        })
+        .filter(|&c| c != '\0')
+        .collect::<String>()
+        // Remove duplicate hyphens
+        .split('-')
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join("-");
+
+    Ok(slug)
+}

src/functions/builtins.rs

@@ -0,0 +1,19 @@
+/// Date and time functions for templates
+use chrono::Utc;
+use minijinja::{Error, Value};
+
+/// Get current timestamp in ISO 8601 format
+///
+/// Replacement for Tera's built-in now() function
+///
+/// Returns timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SS.sss+00:00
+///
+/// # Example
+///
+/// ```jinja
+/// {{ now() }}  => "2024-12-31T12:34:56.789+00:00"
+/// ```
+pub fn now_fn() -> Result<Value, Error> {
+    let timestamp = Utc::now().to_rfc3339();
+    Ok(Value::from(timestamp))
+}

src/functions/datetime.rs

@@ -1,13 +1,46 @@
+/// Environment variable access functions for templates
 use minijinja::value::Kwargs;
 use minijinja::{Error, ErrorKind, Value};
-/// Filter environment variables by pattern
-///
-/// This module provides a MiniJinja function to filter environment variables
-/// matching a glob pattern (e.g., "SERVER_*", "DB_*", etc.)
 use std::collections::HashMap;
-use std::env;
 
-/// A MiniJinja function that filters environment variables by pattern
+/// Get environment variable with optional default
+///
+/// Replacement for Tera's built-in get_env() function
+///
+/// # Arguments
+///
+/// * `name` - Environment variable name
+/// * `default` - Optional default value if variable is not set
+///
+/// # Example
+///
+/// ```jinja
+/// {{ get_env(name="HOME") }}
+/// {{ get_env(name="MISSING", default="/tmp") }}
+/// ```
+pub fn env_fn(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 pattern
 ///
 /// Returns a list of objects with `key` and `value` fields for all
 /// environment variables matching the given glob pattern.
@@ -46,7 +79,7 @@ pub fn filter_env_fn(kwargs: Kwargs) -> Result<Value, Error> {
     })?;
 
     // Filter environment variables
-    let mut results: Vec<HashMap<String, String>> = env::vars()
+    let mut results: Vec<HashMap<String, String>> = std::env::vars()
         .filter(|(key, _)| re.is_match(key))
         .map(|(key, value)| {
             let mut map = HashMap::new();