robinpath_modules/modules/

template_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("template.render", |args, _| {
        let tmpl = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let data = args.get(1).cloned().unwrap_or(Value::Null);
        Ok(Value::String(render_template(&tmpl, &data)))
    });

    rp.register_builtin("template.escape", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::String(html_escape(&s)))
    });

    rp.register_builtin("template.compile", |args, _| {
        let tmpl = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        // In a scripting context, "compile" just validates and returns the template
        // Since we can't return closures, we return the template string for use with render
        let vars = extract_variables(&tmpl);
        let mut obj = indexmap::IndexMap::new();
        obj.insert("template".to_string(), Value::String(tmpl));
        obj.insert("variables".to_string(), Value::Array(vars));
        Ok(Value::Object(obj))
    });

    rp.register_builtin("template.extractVariables", |args, _| {
        let tmpl = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Array(extract_variables(&tmpl)))
    });

    rp.register_builtin("template.renderString", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let data = args.get(1).cloned().unwrap_or(Value::Null);
        Ok(Value::String(render_template(&s, &data)))
    });
}

fn render_template(tmpl: &str, data: &Value) -> String {
    let mut result = String::new();
    let chars: Vec<char> = tmpl.chars().collect();
    let len = chars.len();
    let mut i = 0;

    while i < len {
        if i + 1 < len && chars[i] == '{' && chars[i + 1] == '{' {
            // Find closing }}
            let start = i + 2;
            if let Some(end) = find_closing_braces(&chars, start) {
                let tag = chars[start..end].iter().collect::<String>().trim().to_string();

                if tag.starts_with('!') {
                    // Comment — skip
                } else if tag.starts_with('#') {
                    // Section: {{#name}}...{{/name}}
                    let section_name = tag[1..].trim();
                    let close_tag = format!("{{{{/{}}}}}", section_name);
                    if let Some(close_pos) = tmpl[end + 2..].find(&close_tag) {
                        let inner = &tmpl[end + 2..end + 2 + close_pos];
                        let val = resolve_value(data, section_name);
                        match &val {
                            Value::Bool(true) => {
                                result.push_str(&render_template(inner, data));
                            }
                            Value::Array(arr) => {
                                for item in arr {
                                    result.push_str(&render_template(inner, item));
                                }
                            }
                            Value::Object(_) => {
                                result.push_str(&render_template(inner, &val));
                            }
                            v if v.is_truthy() => {
                                result.push_str(&render_template(inner, data));
                            }
                            _ => {} // Falsy: skip section
                        }
                        i = end + 2 + close_pos + close_tag.len();
                        continue;
                    }
                } else if tag.starts_with('^') {
                    // Inverted section: {{^name}}...{{/name}}
                    let section_name = tag[1..].trim();
                    let close_tag = format!("{{{{/{}}}}}", section_name);
                    if let Some(close_pos) = tmpl[end + 2..].find(&close_tag) {
                        let inner = &tmpl[end + 2..end + 2 + close_pos];
                        let val = resolve_value(data, section_name);
                        if !val.is_truthy() {
                            result.push_str(&render_template(inner, data));
                        }
                        i = end + 2 + close_pos + close_tag.len();
                        continue;
                    }
                } else if tag.starts_with('{') && tag.ends_with('}') {
                    // Unescaped: {{{name}}}
                    let var_name = tag[1..tag.len() - 1].trim();
                    let val = resolve_value(data, var_name);
                    result.push_str(&val.to_display_string());
                    // Skip extra closing brace
                    i = end + 2;
                    if i < len && chars.get(i) == Some(&'}') {
                        i += 1;
                    }
                    continue;
                } else {
                    // Variable: {{name}} — HTML-escaped
                    let val = resolve_value(data, &tag);
                    let display = val.to_display_string();
                    if display != "null" && display != "undefined" {
                        result.push_str(&html_escape(&display));
                    }
                }

                i = end + 2;
                continue;
            }
        }

        result.push(chars[i]);
        i += 1;
    }

    result
}

fn find_closing_braces(chars: &[char], start: usize) -> Option<usize> {
    let len = chars.len();
    let mut i = start;
    while i + 1 < len {
        if chars[i] == '}' && chars[i + 1] == '}' {
            return Some(i);
        }
        i += 1;
    }
    None
}

fn resolve_value(data: &Value, path: &str) -> Value {
    let parts: Vec<&str> = path.split('.').collect();
    let mut current = data.clone();
    for part in parts {
        match &current {
            Value::Object(obj) => {
                current = obj.get(part).cloned().unwrap_or(Value::Null);
            }
            _ => return Value::Null,
        }
    }
    current
}

fn extract_variables(tmpl: &str) -> Vec<Value> {
    let mut vars = Vec::new();
    let mut seen = std::collections::HashSet::new();
    let chars: Vec<char> = tmpl.chars().collect();
    let len = chars.len();
    let mut i = 0;

    while i + 1 < len {
        if chars[i] == '{' && chars[i + 1] == '{' {
            let start = i + 2;
            if let Some(end) = find_closing_braces(&chars, start) {
                let tag = chars[start..end].iter().collect::<String>().trim().to_string();
                // Extract variable names (skip comments, section markers)
                let name = if tag.starts_with('!') || tag.starts_with('/') {
                    None
                } else if tag.starts_with('#') || tag.starts_with('^') {
                    Some(tag[1..].trim().to_string())
                } else if tag.starts_with('{') && tag.ends_with('}') {
                    Some(tag[1..tag.len() - 1].trim().to_string())
                } else {
                    Some(tag)
                };
                if let Some(name) = name {
                    if !name.is_empty() && seen.insert(name.clone()) {
                        vars.push(Value::String(name));
                    }
                }
                i = end + 2;
                continue;
            }
        }
        i += 1;
    }

    vars
}

fn html_escape(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&#39;")
}