robinpath_modules/modules/

yaml_mod.rs

use robinpath::{RobinPath, Value};

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

    rp.register_builtin("yaml.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_yaml(&val, 0, indent)))
    });

    rp.register_builtin("yaml.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_yaml(&content)),
            Err(e) => Err(format!("yaml.parseFile error: {}", e)),
        }
    });

    rp.register_builtin("yaml.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 indent = args.get(2).map(|v| v.to_number() as usize).unwrap_or(2);
        let yaml_str = stringify_yaml(&val, 0, indent);
        match std::fs::write(&path, &yaml_str) {
            Ok(()) => Ok(Value::Bool(true)),
            Err(e) => Err(format!("yaml.writeFile error: {}", e)),
        }
    });

    rp.register_builtin("yaml.isValid", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        // Basic validation: try parsing
        let parsed = parse_yaml(&s);
        Ok(Value::Bool(!matches!(parsed, Value::Null) || s.trim() == "null" || s.trim() == "~"))
    });

    rp.register_builtin("yaml.get", |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_yaml(&s);
        Ok(get_by_path(&parsed, &path))
    });

    rp.register_builtin("yaml.toJSON", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let parsed = parse_yaml(&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("yaml.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_yaml(&val, 0, 2)))
            }
            Err(e) => Err(format!("yaml.fromJSON error: {}", e)),
        }
    });

    rp.register_builtin("yaml.parseAll", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let docs: Vec<Value> = s.split("\n---")
            .map(|doc| parse_yaml(doc.trim_start_matches("---").trim()))
            .collect();
        Ok(Value::Array(docs))
    });
}

fn parse_yaml(s: &str) -> Value {
    let trimmed = s.trim();
    if trimmed.is_empty() {
        return Value::Null;
    }
    // Try JSON first (YAML is superset of JSON)
    if (trimmed.starts_with('{') && trimmed.ends_with('}'))
        || (trimmed.starts_with('[') && trimmed.ends_with(']'))
    {
        if let Ok(v) = serde_json::from_str::<serde_json::Value>(trimmed) {
            return Value::from(v);
        }
    }
    // Parse YAML line by line
    parse_yaml_lines(&trimmed.lines().collect::<Vec<_>>(), 0).0
}

fn parse_yaml_lines(lines: &[&str], base_indent: usize) -> (Value, usize) {
    let mut obj = indexmap::IndexMap::new();
    let mut i = 0;
    let mut is_array = false;
    let mut arr = Vec::new();

    while i < lines.len() {
        let line = lines[i];
        let stripped = line.trim();
        if stripped.is_empty() || stripped.starts_with('#') {
            i += 1;
            continue;
        }

        let indent = line.len() - line.trim_start().len();
        if indent < base_indent {
            break;
        }

        if stripped.starts_with("- ") {
            is_array = true;
            let item_str = stripped[2..].trim();
            if item_str.contains(": ") {
                // Array of objects - inline
                let mut item_obj = indexmap::IndexMap::new();
                let (k, v) = split_kv(item_str);
                item_obj.insert(k, parse_yaml_value(v));
                // Check for continuation lines at deeper indent
                let item_indent = indent + 2;
                i += 1;
                while i < lines.len() {
                    let next = lines[i];
                    let next_stripped = next.trim();
                    let next_indent = next.len() - next.trim_start().len();
                    if next_stripped.is_empty() || next_stripped.starts_with('#') {
                        i += 1;
                        continue;
                    }
                    if next_indent >= item_indent && !next_stripped.starts_with("- ") {
                        let (nk, nv) = split_kv(next_stripped);
                        item_obj.insert(nk, parse_yaml_value(nv));
                        i += 1;
                    } else {
                        break;
                    }
                }
                arr.push(Value::Object(item_obj));
            } else {
                arr.push(parse_yaml_value(item_str));
                i += 1;
            }
            continue;
        }

        if stripped.contains(": ") || stripped.ends_with(':') {
            let (key, value_str) = split_kv(stripped);
            if value_str.is_empty() {
                // Nested object or array
                i += 1;
                let child_indent = if i < lines.len() {
                    lines[i].len() - lines[i].trim_start().len()
                } else {
                    indent + 2
                };
                let (child_val, consumed) = parse_yaml_lines(&lines[i..], child_indent);
                obj.insert(key, child_val);
                i += consumed;
            } else {
                obj.insert(key, parse_yaml_value(value_str));
                i += 1;
            }
        } else {
            i += 1;
        }
    }

    if is_array {
        (Value::Array(arr), i)
    } else if obj.is_empty() {
        (Value::Null, i)
    } else {
        (Value::Object(obj), i)
    }
}

fn split_kv(s: &str) -> (String, &str) {
    if let Some(pos) = s.find(": ") {
        (s[..pos].trim().to_string(), s[pos + 2..].trim())
    } else if s.ends_with(':') {
        (s[..s.len() - 1].trim().to_string(), "")
    } else {
        (s.to_string(), "")
    }
}

fn parse_yaml_value(s: &str) -> Value {
    let trimmed = s.trim();
    match trimmed {
        "true" | "yes" | "on" => Value::Bool(true),
        "false" | "no" | "off" => Value::Bool(false),
        "null" | "~" | "" => Value::Null,
        _ => {
            // Try number
            if let Ok(n) = trimmed.parse::<f64>() {
                Value::Number(n)
            } else {
                // Remove surrounding quotes
                let unquoted = trimmed.trim_matches('"').trim_matches('\'');
                Value::String(unquoted.to_string())
            }
        }
    }
}

fn stringify_yaml(val: &Value, depth: usize, indent: usize) -> String {
    let pad = " ".repeat(depth * indent);
    match val {
        Value::Object(obj) => {
            let mut lines = Vec::new();
            for (k, v) in obj {
                match v {
                    Value::Object(_) => {
                        lines.push(format!("{}{}:", pad, k));
                        lines.push(stringify_yaml(v, depth + 1, indent));
                    }
                    Value::Array(arr) => {
                        lines.push(format!("{}{}:", pad, k));
                        let item_pad = " ".repeat((depth + 1) * indent);
                        for item in arr {
                            match item {
                                Value::Object(_) | Value::Array(_) => {
                                    lines.push(format!("{}- ", item_pad));
                                    lines.push(stringify_yaml(item, depth + 2, indent));
                                }
                                _ => lines.push(format!("{}- {}", item_pad, format_yaml_value(item))),
                            }
                        }
                    }
                    _ => lines.push(format!("{}{}: {}", pad, k, format_yaml_value(v))),
                }
            }
            lines.join("\n")
        }
        Value::Array(arr) => {
            let mut lines = Vec::new();
            for item in arr {
                lines.push(format!("{}- {}", pad, format_yaml_value(item)));
            }
            lines.join("\n")
        }
        _ => format!("{}{}", pad, format_yaml_value(val)),
    }
}

fn format_yaml_value(val: &Value) -> String {
    match val {
        Value::String(s) => {
            if s.contains(':') || s.contains('#') || s.contains('\n') || s.starts_with(' ') {
                format!("\"{}\"", s.replace('"', "\\\""))
            } else {
                s.clone()
            }
        }
        Value::Number(n) => {
            if *n == (*n as i64) as f64 {
                format!("{}", *n as i64)
            } else {
                format!("{}", n)
            }
        }
        Value::Bool(b) => if *b { "true" } else { "false" }.to_string(),
        Value::Null => "null".to_string(),
        _ => val.to_display_string(),
    }
}

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
}