diffo 0.2.0

Semantic diffing for Rust structs via serde
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
109
110
111
112
113
114

//! Semantic diffing for Rust structs.
//!
//! `diffo` computes structural differences between two values of the same type,
//! leveraging serde for serialization. No derive macros needed - just implement
//! `Serialize` and you're ready to go.
//!
//! # Examples
//!
//! Basic usage:
//!
//! ```
//! use diffo::diff;
//! use serde::Serialize;
//!
//! #[derive(Serialize)]
//! struct User {
//!     id: u64,
//!     name: String,
//! }
//!
//! let old = User { id: 1, name: "Alice".into() };
//! let new = User { id: 1, name: "Bob".into() };
//!
//! let d = diff(&old, &new).unwrap();
//! assert!(!d.is_empty());
//! ```
//!
//! With configuration:
//!
//! ```
//! use diffo::{diff_with, DiffConfig};
//! # use serde::Serialize;
//! # #[derive(Serialize)]
//! # struct Config { password: String }
//! # let old = Config { password: "secret".into() };
//! # let new = Config { password: "new_secret".into() };
//!
//! let config = DiffConfig::new()
//!     .mask("password");
//!
//! let d = diff_with(&old, &new, &config).unwrap();
//! ```
//!
//! # Output Formats
//!
//! - [`Diff::to_pretty`]: Human-readable colored output
//! - [`Diff::to_json`]: JSON representation
//! - [`Diff::to_json_patch`]: RFC 6902 JSON Patch
//! - [`Diff::to_markdown`]: Markdown table
//!
//! # Performance
//!
//! Complexity is O(n) for most operations, where n is the number of fields.
//! Sequence diffing is index-based (O(n)), not LCS-based (O(n²)).

#![deny(missing_docs)]

mod apply;
mod change;
mod config;
mod diff;
mod error;
mod path;
mod sequence_diff;
mod value_helpers;

pub mod format;

pub use apply::apply;
pub use change::Change;
pub use config::{Comparator, DiffConfig};
pub use diff::Diff;
pub use error::{Error, FormatError};
pub use path::Path;
pub use sequence_diff::SequenceDiffAlgorithm;
pub use value_helpers::ValueExt;

use serde::Serialize;

/// Compute diff between two values of the same type.
///
/// # Examples
///
/// ```
/// use diffo::diff;
///
/// let old = vec![1, 2, 3];
/// let new = vec![1, 2, 4];
///
/// let d = diff(&old, &new).unwrap();
/// assert!(!d.is_empty());
/// ```
pub fn diff<T: Serialize>(old: &T, new: &T) -> Result<Diff, Error> {
    diff_with(old, new, &DiffConfig::default())
}

/// Compute diff with custom configuration.
///
/// # Examples
///
/// ```
/// use diffo::{diff_with, DiffConfig};
///
/// let config = DiffConfig::new().mask("*.password");
///
/// # let old = vec![1, 2, 3];
/// # let new = vec![1, 2, 4];
/// let d = diff_with(&old, &new, &config).unwrap();
/// ```
pub fn diff_with<T: Serialize>(old: &T, new: &T, config: &DiffConfig) -> Result<Diff, Error> {
    let old_val = serde_value::to_value(old)?;
    let new_val = serde_value::to_value(new)?;
    Ok(diff::diff_values(&old_val, &new_val, Path::root(), config))
}