diffx-core 0.7.1

Core library for diffx - blazing fast semantic diff engine for structured data. Zero-copy parsing, streaming support, memory-efficient algorithms
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

// Utility functions - FOR INTERNAL USE ONLY
// These functions are public only for CLI and language bindings.
// External users should use the main diff() function.

use crate::{DiffOptions, DiffResult, OutputFormat};
use anyhow::{anyhow, Result};
use serde::Serialize;
use serde_json::Value;

/// Get type name of a JSON value - FOR INTERNAL USE ONLY
pub fn value_type_name(value: &Value) -> &str {
    match value {
        Value::Null => "Null",
        Value::Bool(_) => "Boolean",
        Value::Number(_) => "Number",
        Value::String(_) => "String",
        Value::Array(_) => "Array",
        Value::Object(_) => "Object",
    }
}

/// Format output to string - FOR INTERNAL USE ONLY
pub fn format_output<T: Serialize>(results: &[T], format: OutputFormat) -> Result<String> {
    match format {
        OutputFormat::Json => serde_json::to_string_pretty(results)
            .map_err(|e| anyhow!("JSON serialization error: {e}")),
        OutputFormat::Yaml => {
            serde_yaml::to_string(results).map_err(|e| anyhow!("YAML serialization error: {e}"))
        }
        OutputFormat::Diffx => {
            let mut output = String::new();
            for result in results {
                let json = serde_json::to_string(result)?;
                output.push_str(&json);
                output.push('\n');
            }
            Ok(output)
        }
    }
}

/// Format DiffResult output using proper Display implementation
pub fn format_diff_output(
    results: &[DiffResult],
    format: OutputFormat,
    _options: Option<&DiffOptions>,
) -> Result<String> {
    match format {
        OutputFormat::Json => serde_json::to_string_pretty(results)
            .map_err(|e| anyhow!("JSON serialization error: {e}")),
        OutputFormat::Yaml => {
            let mut output = String::new();
            for result in results {
                match result {
                    DiffResult::Added(path, value) => {
                        output.push_str("- Added:\n");
                        output.push_str(&format!("  - {path}\n"));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(value).unwrap_or_default().trim()
                        ));
                    }
                    DiffResult::Removed(path, value) => {
                        output.push_str("- Removed:\n");
                        output.push_str(&format!("  - {path}\n"));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(value).unwrap_or_default().trim()
                        ));
                    }
                    DiffResult::Modified(path, old_value, new_value) => {
                        output.push_str("- Modified:\n");
                        output.push_str(&format!("  - {path}\n"));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(old_value).unwrap_or_default().trim()
                        ));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(new_value).unwrap_or_default().trim()
                        ));
                    }
                    DiffResult::TypeChanged(path, old_value, new_value) => {
                        output.push_str("- TypeChanged:\n");
                        output.push_str(&format!("  - {path}\n"));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(old_value).unwrap_or_default().trim()
                        ));
                        output.push_str(&format!(
                            "  - {}\n",
                            serde_yaml::to_string(new_value).unwrap_or_default().trim()
                        ));
                    }
                }
            }
            Ok(output)
        }
        OutputFormat::Diffx => {
            let mut output = String::new();
            for result in results {
                output.push_str(&result.to_string());
                output.push('\n');
            }
            Ok(output)
        }
    }
}