robinpath_modules/modules/

xml_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("xml.parse", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(parse_xml(&s))
    });

    rp.register_builtin("xml.stringify", |args, _| {
        let val = args.first().cloned().unwrap_or(Value::Null);
        let indent = args.get(1).map(|v| v.to_number() as usize).unwrap_or(2);
        Ok(Value::String(stringify_xml(&val, 0, indent)))
    });

    rp.register_builtin("xml.isValid", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let trimmed = s.trim();
        Ok(Value::Bool(
            trimmed.starts_with('<') && trimmed.ends_with('>') && is_balanced_xml(trimmed),
        ))
    });

    rp.register_builtin("xml.query", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let path = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let parsed = parse_xml(&s);
        Ok(get_by_path(&parsed, &path))
    });

    rp.register_builtin("xml.toJSON", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let parsed = parse_xml(&s);
        let json_val: serde_json::Value = parsed.into();
        Ok(Value::String(serde_json::to_string_pretty(&json_val).unwrap_or_default()))
    });

    rp.register_builtin("xml.fromJSON", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match serde_json::from_str::<serde_json::Value>(&s) {
            Ok(v) => {
                let val = Value::from(v);
                Ok(Value::String(stringify_xml(&val, 0, 2)))
            }
            Err(e) => Err(format!("xml.fromJSON error: {}", e)),
        }
    });

    rp.register_builtin("xml.parseFile", |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match std::fs::read_to_string(&path) {
            Ok(content) => Ok(parse_xml(&content)),
            Err(e) => Err(format!("xml.parseFile error: {}", e)),
        }
    });

    rp.register_builtin("xml.writeFile", |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let val = args.get(1).cloned().unwrap_or(Value::Null);
        let xml_str = stringify_xml(&val, 0, 2);
        match std::fs::write(&path, &xml_str) {
            Ok(()) => Ok(Value::Bool(true)),
            Err(e) => Err(format!("xml.writeFile error: {}", e)),
        }
    });

    rp.register_builtin("xml.count", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let tag = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let open_tag = format!("<{}", tag);
        let count = s.matches(&open_tag).count();
        Ok(Value::Number(count as f64))
    });

    rp.register_builtin("xml.getAttribute", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let _element = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let attr = args.get(2).map(|v| v.to_display_string()).unwrap_or_default();
        let pattern = format!("{}=\"", attr);
        if let Some(start) = s.find(&pattern) {
            let rest = &s[start + pattern.len()..];
            if let Some(end) = rest.find('"') {
                return Ok(Value::String(rest[..end].to_string()));
            }
        }
        Ok(Value::Null)
    });
}

fn parse_xml(xml: &str) -> Value {
    let mut result = indexmap::IndexMap::new();
    let trimmed = xml.trim();
    // Skip XML declaration
    let content = if trimmed.starts_with("<?") {
        if let Some(end) = trimmed.find("?>") {
            trimmed[end + 2..].trim()
        } else {
            trimmed
        }
    } else {
        trimmed
    };
    parse_element(content, &mut result);
    Value::Object(result)
}

fn parse_element(xml: &str, result: &mut indexmap::IndexMap<String, Value>) {
    let trimmed = xml.trim();
    if !trimmed.starts_with('<') {
        return;
    }
    // Find tag name
    if let Some(gt) = trimmed.find('>') {
        let tag_part = &trimmed[1..gt];
        let (tag_name, _attrs) = if let Some(sp) = tag_part.find(' ') {
            (&tag_part[..sp], &tag_part[sp..])
        } else {
            (tag_part, "")
        };
        // Self-closing
        if tag_part.ends_with('/') {
            let name = tag_name.trim_end_matches('/');
            result.insert(name.to_string(), Value::String(String::new()));
            return;
        }
        let close_tag = format!("</{}>", tag_name);
        if let Some(close_pos) = trimmed.find(&close_tag) {
            let inner = &trimmed[gt + 1..close_pos];
            let inner_trimmed = inner.trim();
            if inner_trimmed.starts_with('<') {
                // Nested elements
                let mut children = indexmap::IndexMap::new();
                parse_children(inner_trimmed, &mut children);
                result.insert(tag_name.to_string(), Value::Object(children));
            } else {
                result.insert(tag_name.to_string(), Value::String(inner.to_string()));
            }
            // Parse siblings
            let after = &trimmed[close_pos + close_tag.len()..];
            let after_trimmed = after.trim();
            if !after_trimmed.is_empty() && after_trimmed.starts_with('<') {
                parse_element(after_trimmed, result);
            }
        }
    }
}

fn parse_children(xml: &str, result: &mut indexmap::IndexMap<String, Value>) {
    let mut remaining = xml.trim();
    while !remaining.is_empty() && remaining.starts_with('<') {
        if remaining.starts_with("</") {
            break;
        }
        if let Some(gt) = remaining.find('>') {
            let tag_part = &remaining[1..gt];
            let tag_name = if let Some(sp) = tag_part.find(' ') {
                &tag_part[..sp]
            } else {
                tag_part.trim_end_matches('/')
            };
            if tag_part.ends_with('/') {
                result.insert(tag_name.to_string(), Value::String(String::new()));
                remaining = remaining[gt + 1..].trim();
                continue;
            }
            let close_tag = format!("</{}>", tag_name);
            if let Some(close_pos) = remaining.find(&close_tag) {
                let inner = &remaining[gt + 1..close_pos];
                let inner_trimmed = inner.trim();
                if inner_trimmed.starts_with('<') {
                    let mut children = indexmap::IndexMap::new();
                    parse_children(inner_trimmed, &mut children);
                    result.insert(tag_name.to_string(), Value::Object(children));
                } else {
                    result.insert(tag_name.to_string(), Value::String(inner.to_string()));
                }
                remaining = remaining[close_pos + close_tag.len()..].trim();
            } else {
                break;
            }
        } else {
            break;
        }
    }
}

fn stringify_xml(val: &Value, depth: usize, indent: usize) -> String {
    let pad = " ".repeat(depth * indent);
    match val {
        Value::Object(obj) => {
            let mut lines = Vec::new();
            for (key, value) in obj {
                match value {
                    Value::Object(_) => {
                        lines.push(format!("{}<{}>", pad, key));
                        lines.push(stringify_xml(value, depth + 1, indent));
                        lines.push(format!("{}</{}>", pad, key));
                    }
                    _ => {
                        lines.push(format!("{}<{}>{}</{}>", pad, key, value.to_display_string(), key));
                    }
                }
            }
            lines.join("\n")
        }
        _ => format!("{}{}", pad, val.to_display_string()),
    }
}

fn is_balanced_xml(s: &str) -> bool {
    let mut stack: Vec<String> = Vec::new();
    let re = regex::Regex::new(r"<(/?)(\w+)[^>]*/?>").unwrap();
    for cap in re.captures_iter(s) {
        let is_close = &cap[1] == "/";
        let tag = cap[2].to_string();
        let full = &cap[0];
        if full.ends_with("/>") {
            continue; // self-closing
        }
        if is_close {
            if stack.last() == Some(&tag) {
                stack.pop();
            } else {
                return false;
            }
        } else {
            stack.push(tag);
        }
    }
    stack.is_empty()
}

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