use serde::Serialize;
use serde_json::Value;
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "kind", rename_all = "lowercase")]
pub enum ChangeKind {
Added { value: Value },
Removed { value: Value },
Modified { from: Value, to: Value },
}
#[derive(Debug, Clone, Serialize)]
pub struct Change {
pub path: String,
#[serde(flatten)]
pub kind: ChangeKind,
}
impl Change {
pub fn added(path: String, value: Value) -> Self {
Change { path, kind: ChangeKind::Added { value } }
}
pub fn removed(path: String, value: Value) -> Self {
Change { path, kind: ChangeKind::Removed { value } }
}
pub fn modified(path: String, from: Value, to: Value) -> Self {
Change { path, kind: ChangeKind::Modified { from, to } }
}
}
use std::collections::BTreeSet;
use serde_json::{Map, Value};
use crate::change::Change;
pub fn diff(old: &Value, new: &Value) -> Vec<Change> {
let mut changes = Vec::new();
diff_value("", old, new, &mut changes);
changes
}
fn join_path(base: &str, key: &str) -> String {
if base.is_empty() {
key.to_string()
} else {
format!("{}.{}", base, key)
}
}
fn diff_value(path: &str, old: &Value, new: &Value, out: &mut Vec<Change>) {
match (old, new) {
(Value::Object(a), Value::Object(b)) => diff_objects(path, a, b, out),
_ => {
if old != new {
out.push(Change::modified(path.to_string(), old.clone(), new.clone()));
}
}
}
}
fn diff_objects(path: &str, a: &Map<String, Value>, b: &Map<String, Value>, out: &mut Vec<Change>) {
let keys: BTreeSet<&String> = a.keys().chain(b.keys()).collect();
for key in keys {
let child = join_path(path, key);
match (a.get(key), b.get(key)) {
(Some(old), Some(new)) => diff_value(&child, old, new, out),
(None, Some(new)) => out.push(Change::added(child, new.clone())),
(Some(old), None) => out.push(Change::removed(child, old.clone())),
(None, None) => unreachable!(),
}
}
}
mod change;
mod differ;
use serde_json::json;
use change::ChangeKind;
fn main() {
let old = json!({
"service": "api",
"replicas": 3,
"limits": { "cpu": "500m", "mem": "512Mi" },
"flags": ["beta"]
});
let new = json!({
"service": "api",
"replicas": 5,
"limits": { "cpu": "500m", "mem": "1Gi", "gpu": "1" },
"flags": ["beta", "canary"]
});
let changes = differ::diff(&old, &new);
if changes.is_empty() {
println!("no changes");
return;
}
for c in &changes {
match &c.kind {
ChangeKind::Added { value } => println!("+ {} = {}", c.path, value),
ChangeKind::Removed { value } => println!("- {} = {}", c.path, value),
ChangeKind::Modified { from, to } => {
println!("~ {}: {} -> {}", c.path, from, to)
}
}
}
}
This snippet shows how to compare two configuration snapshots and produce a flat, machine-readable list of changes rather than a raw textual diff. The core idea is to treat config as a generic tree of serde_json::Value nodes and walk both trees in lockstep, emitting a typed record whenever a leaf appears, disappears, or changes value. This is the pattern that powers config drift detection, audit logs, and "what changed between deploys" tooling.
In change.rs, a Change struct pairs a dotted path (like server.limits.max_connections) with a ChangeKind enum. Modeling the operation as an enum — Added, Removed, Modified — instead of stashing loose strings makes downstream consumers exhaustive: a formatter or an alert rule must handle every variant. The Modified variant carries both from and to so callers can render before/after without re-reading the snapshots. Deriving Serialize means the whole change list can be shipped as JSON to a UI or a webhook unchanged.
In differ.rs, diff is the public entry point that seeds an empty path and delegates to the recursive diff_value. The recursion has three shapes. When both sides are objects, diff_objects collects the union of keys via a BTreeSet — the sorted set guarantees deterministic output, which matters for stable diffs in tests and audit trails — then recurses per key, extending the path segment by segment. When a key exists on only one side it becomes an Added or Removed. For non-object leaves (or type mismatches, like an object becoming a scalar), the values are compared directly and a single Modified is emitted when they differ.
A deliberate trade-off is that arrays are compared by whole-value equality rather than element-wise. Element diffing requires a matching heuristic (by index? by id?) that has no universal right answer, so treating an array as an opaque leaf keeps the algorithm honest and predictable. join_path builds dotted paths and skips the leading separator so the root's children read cleanly.
In main.rs, two inline JSON snapshots are parsed and diffed, and the sorted results are printed. The empty-diff case is handled explicitly so equal snapshots report "no changes" instead of silence. Because the output is pure data, the same Vec<Change> could just as easily be serialized, filtered by path prefix, or fed into a policy engine.
Related snips
struct Config<'a> {
name: &'a str,
value: &'a str,
}
fn parse_config(line: &str) -> Config {Lifetime annotations for flexible borrowing in structs
use crossbeam::channel::unbounded;
use std::thread;
fn main() {
let (tx, rx) = unbounded();Crossbeam for advanced concurrent data structures
use tracing::{info, instrument};
#[instrument]
fn process_request(user_id: u64) {
info!(user_id, "Processing request");
// Work happens heretracing for structured logging and distributed tracing
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();Channels (mpsc) for message passing between threads
use clap::Parser;
#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
#[arg(short, long)]clap for CLI argument parsing with derive macros
macro_rules! create_function {
($func_name:ident) => {
fn $func_name() {
println!("Called {}", stringify!($func_name));
}
};Declarative macros (macro_rules!) for code generation
Share this code
Here's the card — post it anywhere.
