robinpath_modules/modules/

diff_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("diff.lines", |args, _| {
        let a = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let b = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let a_tokens: Vec<&str> = a.lines().collect();
        let b_tokens: Vec<&str> = b.lines().collect();
        Ok(Value::Array(diff_tokens(&a_tokens, &b_tokens)))
    });

    rp.register_builtin("diff.chars", |args, _| {
        let a = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let b = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let a_chars: Vec<String> = a.chars().map(|c| c.to_string()).collect();
        let b_chars: Vec<String> = b.chars().map(|c| c.to_string()).collect();
        let a_refs: Vec<&str> = a_chars.iter().map(|s| s.as_str()).collect();
        let b_refs: Vec<&str> = b_chars.iter().map(|s| s.as_str()).collect();
        Ok(Value::Array(diff_tokens(&a_refs, &b_refs)))
    });

    rp.register_builtin("diff.words", |args, _| {
        let a = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let b = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let a_words: Vec<&str> = a.split_whitespace().collect();
        let b_words: Vec<&str> = b.split_whitespace().collect();
        Ok(Value::Array(diff_tokens(&a_words, &b_words)))
    });

    rp.register_builtin("diff.objects", |args, _| {
        let a = args.first().cloned().unwrap_or(Value::Null);
        let b = args.get(1).cloned().unwrap_or(Value::Null);
        Ok(Value::Array(diff_objects(&a, &b, String::new())))
    });

    rp.register_builtin("diff.arrays", |args, _| {
        let a = args.first().cloned().unwrap_or(Value::Null);
        let b = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Array(arr_a), Value::Array(arr_b)) = (&a, &b) {
            let a_keys: Vec<String> = arr_a.iter().map(|v| v.to_json_string()).collect();
            let b_keys: Vec<String> = arr_b.iter().map(|v| v.to_json_string()).collect();

            let added: Vec<Value> = arr_b
                .iter()
                .filter(|v| !a_keys.contains(&v.to_json_string()))
                .cloned()
                .collect();
            let removed: Vec<Value> = arr_a
                .iter()
                .filter(|v| !b_keys.contains(&v.to_json_string()))
                .cloned()
                .collect();
            let common: Vec<Value> = arr_a
                .iter()
                .filter(|v| b_keys.contains(&v.to_json_string()))
                .cloned()
                .collect();

            let mut obj = indexmap::IndexMap::new();
            obj.insert("added".to_string(), Value::Array(added));
            obj.insert("removed".to_string(), Value::Array(removed));
            obj.insert("common".to_string(), Value::Array(common));
            Ok(Value::Object(obj))
        } else {
            let mut obj = indexmap::IndexMap::new();
            obj.insert("added".to_string(), Value::Array(vec![]));
            obj.insert("removed".to_string(), Value::Array(vec![]));
            obj.insert("common".to_string(), Value::Array(vec![]));
            Ok(Value::Object(obj))
        }
    });

    rp.register_builtin("diff.patch", |args, _| {
        let diff_arr = args.first().cloned().unwrap_or(Value::Null);
        if let Value::Array(items) = &diff_arr {
            let mut result = String::new();
            for item in items {
                if let Value::Object(obj) = item {
                    let typ = obj
                        .get("type")
                        .map(|v| v.to_display_string())
                        .unwrap_or_default();
                    let val = obj
                        .get("value")
                        .map(|v| v.to_display_string())
                        .unwrap_or_default();
                    if typ != "removed" {
                        result.push_str(&val);
                    }
                }
            }
            Ok(Value::String(result))
        } else {
            Ok(Value::String(String::new()))
        }
    });

    rp.register_builtin("diff.unified", |args, _| {
        let a = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let b = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let a_lines: Vec<&str> = a.lines().collect();
        let b_lines: Vec<&str> = b.lines().collect();
        let tokens = diff_tokens(&a_lines, &b_lines);

        let mut output = String::new();
        output.push_str("--- a\n");
        output.push_str("+++ b\n");

        for token in &tokens {
            if let Value::Object(obj) = token {
                let typ = obj
                    .get("type")
                    .map(|v| v.to_display_string())
                    .unwrap_or_default();
                let val = obj
                    .get("value")
                    .map(|v| v.to_display_string())
                    .unwrap_or_default();
                match typ.as_str() {
                    "added" => output.push_str(&format!("+{}\n", val)),
                    "removed" => output.push_str(&format!("-{}\n", val)),
                    _ => output.push_str(&format!(" {}\n", val)),
                }
            }
        }
        Ok(Value::String(output.trim_end().to_string()))
    });

    rp.register_builtin("diff.isEqual", |args, _| {
        let a = args.first().cloned().unwrap_or(Value::Null);
        let b = args.get(1).cloned().unwrap_or(Value::Null);
        Ok(Value::Bool(a.deep_eq(&b)))
    });

    rp.register_builtin("diff.stats", |args, _| {
        let diff_arr = args.first().cloned().unwrap_or(Value::Null);
        let mut additions = 0u64;
        let mut deletions = 0u64;
        let mut unchanged = 0u64;
        if let Value::Array(items) = &diff_arr {
            for item in items {
                if let Value::Object(obj) = item {
                    let typ = obj
                        .get("type")
                        .map(|v| v.to_display_string())
                        .unwrap_or_default();
                    match typ.as_str() {
                        "added" => additions += 1,
                        "removed" => deletions += 1,
                        _ => unchanged += 1,
                    }
                }
            }
        }
        let mut obj = indexmap::IndexMap::new();
        obj.insert("additions".to_string(), Value::Number(additions as f64));
        obj.insert("deletions".to_string(), Value::Number(deletions as f64));
        obj.insert("unchanged".to_string(), Value::Number(unchanged as f64));
        Ok(Value::Object(obj))
    });
}

/// LCS-based token diff
fn diff_tokens(a: &[&str], b: &[&str]) -> Vec<Value> {
    let m = a.len();
    let n = b.len();

    // Build LCS table
    let mut dp = vec![vec![0usize; n + 1]; m + 1];
    for i in 1..=m {
        for j in 1..=n {
            if a[i - 1] == b[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = dp[i - 1][j].max(dp[i][j - 1]);
            }
        }
    }

    // Backtrack to produce diff
    let mut result = Vec::new();
    let mut i = m;
    let mut j = n;
    while i > 0 || j > 0 {
        if i > 0 && j > 0 && a[i - 1] == b[j - 1] {
            result.push(make_diff_entry("unchanged", a[i - 1]));
            i -= 1;
            j -= 1;
        } else if j > 0 && (i == 0 || dp[i][j - 1] >= dp[i - 1][j]) {
            result.push(make_diff_entry("added", b[j - 1]));
            j -= 1;
        } else {
            result.push(make_diff_entry("removed", a[i - 1]));
            i -= 1;
        }
    }
    result.reverse();
    result
}

fn make_diff_entry(typ: &str, value: &str) -> Value {
    let mut obj = indexmap::IndexMap::new();
    obj.insert("type".to_string(), Value::String(typ.to_string()));
    obj.insert("value".to_string(), Value::String(value.to_string()));
    Value::Object(obj)
}

fn diff_objects(a: &Value, b: &Value, prefix: String) -> Vec<Value> {
    let mut changes = Vec::new();
    if let (Value::Object(obj_a), Value::Object(obj_b)) = (a, b) {
        for (k, v_a) in obj_a {
            let path = if prefix.is_empty() {
                k.clone()
            } else {
                format!("{}.{}", prefix, k)
            };
            match obj_b.get(k) {
                Some(v_b) => {
                    if let (Value::Object(_), Value::Object(_)) = (v_a, v_b) {
                        changes.extend(diff_objects(v_a, v_b, path));
                    } else if !v_a.deep_eq(v_b) {
                        let mut obj = indexmap::IndexMap::new();
                        obj.insert("path".to_string(), Value::String(path));
                        obj.insert("type".to_string(), Value::String("changed".to_string()));
                        obj.insert("oldValue".to_string(), v_a.clone());
                        obj.insert("newValue".to_string(), v_b.clone());
                        changes.push(Value::Object(obj));
                    }
                }
                None => {
                    let mut obj = indexmap::IndexMap::new();
                    obj.insert("path".to_string(), Value::String(path));
                    obj.insert("type".to_string(), Value::String("removed".to_string()));
                    obj.insert("oldValue".to_string(), v_a.clone());
                    changes.push(Value::Object(obj));
                }
            }
        }
        for (k, v_b) in obj_b {
            if !obj_a.contains_key(k) {
                let path = if prefix.is_empty() {
                    k.clone()
                } else {
                    format!("{}.{}", prefix, k)
                };
                let mut obj = indexmap::IndexMap::new();
                obj.insert("path".to_string(), Value::String(path));
                obj.insert("type".to_string(), Value::String("added".to_string()));
                obj.insert("newValue".to_string(), v_b.clone());
                changes.push(Value::Object(obj));
            }
        }
    }
    changes
}