deepdiff-rs 0.5.4__tar.gz → 0.6.0__tar.gz

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/Cargo.lock

@@ -127,7 +127,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-cli"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -135,7 +135,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "proptest",
  "serde",
@@ -145,7 +145,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "onix-core",
  "pyo3",

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/onix-core", "crates/onix-py"]
 
 [workspace.package]
-version = "0.5.4"
+version = "0.6.0"
 edition = "2024"
 license = "MIT"
 

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.5.4
+Version: 0.6.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -122,6 +122,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 - A `str` inside a `tuple` or `frozenset` set item is rendered with Python's `repr()`, which escapes every non-printable character; onix escapes those below `U+0100` (the complete set in that range) and passes higher non-printable code points through literally, since escaping them would mean carrying a Unicode category table. Exact for all of ASCII and all printable text. See [`crates/onix-core/src/path.rs`](crates/onix-core/src/path.rs).
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).
 - `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).
+- A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).
 - Output is byte-identical to DeepDiff except for the cases listed above and two path-rendering quirks; [`tests/golden/README.md`](tests/golden/README.md) enumerates every accepted exception, including integers past `2^53` (the limit of exact `f64` representation) inside ordered scalar lists and `ignore_order` pairing among naive datetimes, which DeepDiff ranks using the *process's local timezone* while onix reads a naive value as UTC everywhere.
 
 ## Performance
@@ -213,3 +214,7 @@ Issues and pull requests are welcome. Open an issue to report a bug, a DeepDiff
 
 MIT: see [LICENSE](LICENSE).
 
+onix reimplements algorithms from CPython's `difflib` (PSF License) and
+reproduces the behavior of DeepDiff (MIT); their notices and license texts are
+in [THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md).
+

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/README.md

@@ -106,6 +106,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 - A `str` inside a `tuple` or `frozenset` set item is rendered with Python's `repr()`, which escapes every non-printable character; onix escapes those below `U+0100` (the complete set in that range) and passes higher non-printable code points through literally, since escaping them would mean carrying a Unicode category table. Exact for all of ASCII and all printable text. See [`crates/onix-core/src/path.rs`](crates/onix-core/src/path.rs).
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).
 - `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).
+- A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).
 - Output is byte-identical to DeepDiff except for the cases listed above and two path-rendering quirks; [`tests/golden/README.md`](tests/golden/README.md) enumerates every accepted exception, including integers past `2^53` (the limit of exact `f64` representation) inside ordered scalar lists and `ignore_order` pairing among naive datetimes, which DeepDiff ranks using the *process's local timezone* while onix reads a naive value as UTC everywhere.
 
 ## Performance
@@ -196,3 +197,7 @@ Issues and pull requests are welcome. Open an issue to report a bug, a DeepDiff
 ## License
 
 MIT: see [LICENSE](LICENSE).
+
+onix reimplements algorithms from CPython's `difflib` (PSF License) and
+reproduces the behavior of DeepDiff (MIT); their notices and license texts are
+in [THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md).

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/crates/onix-core/src/diff/array.rs

@@ -185,6 +185,8 @@ fn insert_lcs_pair_finding(
                 report.insert_values_changed(
                     path.clone(),
                     ValuesChangedEntry {
+                        // Datetimes are never strings, so `_diff_str` never runs.
+                        diff: None,
                         old_value: Value::DateTime(old_value),
                         new_value: Value::DateTime(new_value),
                         new_path,
@@ -199,6 +201,7 @@ fn insert_lcs_pair_finding(
             report.insert_values_changed(
                 path.clone(),
                 ValuesChangedEntry {
+                    diff: crate::unified_diff::str_diff_field(old_value, new_value),
                     old_value: old_value.clone(),
                     new_value: new_value.clone(),
                     new_path,

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/crates/onix-core/src/diff/object.rs

@@ -85,6 +85,8 @@ pub(crate) fn object_diff(
         report.insert_values_changed(
             path.clone(),
             ValuesChangedEntry {
+                // Both sides are dicts here, never strings, so no `diff`.
+                diff: None,
                 old_value,
                 new_value,
                 new_path: None,

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/crates/onix-core/src/diff/scalar.rs

@@ -94,6 +94,7 @@ pub(crate) fn scalar_diff(
     report.insert_values_changed(
         path.to_vec(),
         ValuesChangedEntry {
+            diff: crate::unified_diff::str_diff_field(a, b),
             old_value: a.clone(),
             new_value: b.clone(),
             new_path: None,

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/crates/onix-core/src/lcs.rs

@@ -1,6 +1,13 @@
+// Portions of this module reimplement algorithms from CPython 3.14.6's
+// `difflib` standard-library module (`SequenceMatcher` and its autojunk
+// heuristic), used under the PSF License Agreement version 2. See
+// THIRD-PARTY-NOTICES.md at the repository root.
 //! A faithful, from-scratch port of Python's `difflib.SequenceMatcher`
-//! opcode algorithm, restricted to the one configuration `DeepDiff` actually
-//! uses for ordered-list comparison: `isjunk=None, autojunk=False`.
+//! opcode algorithm, in the two configurations this engine needs: always
+//! `isjunk=None`, and `autojunk` either off ([`compute_opcodes`], for
+//! `DeepDiff`'s ordered-list comparison) or on ([`grouped_opcodes`], for the
+//! multi-line string diff `unified_diff` produces — see
+//! [`mod@crate::unified_diff`]).
 //!
 //! This module is deliberately *pure*: it knows nothing about
 //! [`crate::report::Report`], [`crate::path::PathSegment`], or recursion
@@ -24,19 +31,28 @@
 //! surprising matching-equality and `new_path` details this module's
 //! algorithm alone doesn't explain.
 //!
-//! # No junk, no autojunk
+//! # Junk and autojunk
 //!
-//! `DeepDiff` always constructs its matcher with `isjunk=None` and
-//! `autojunk=False` (`deepdiff/diff.py::_diff_ordered_iterable_by_difflib`).
-//! `autojunk` is `difflib`'s *default-on* heuristic that treats an
-//! element appearing in more than 1% of a ≥200-item sequence as "popular"
-//! and excludes it from matching — `DeepDiff` explicitly opts out, so this
-//! port implements no such thing, and there is no ≥200-item behavior change
-//! to replicate (confirmed empirically against real `deepdiff==9.1.0` with a
-//! 250-item, one-popular-value fixture: the popular value matches exactly
-//! like any other). Skipping junk/autojunk also sidesteps `SequenceMatcher`'s
-//! own two-pass junk-then-popular pruning of its `b2j` index, considerably
-//! simplifying this port relative to the full standard-library algorithm.
+//! `isjunk` is always `None` here — both call sites pass it — so this port
+//! never builds a `bjunk` set and `SequenceMatcher`'s junk-specific branches
+//! (its `b2j` junk pruning and its two junk-extension loops) are all dead.
+//!
+//! `autojunk`, by contrast, differs by call site. It is `difflib`'s
+//! *default-on* heuristic that treats an element appearing in more than 1%
+//! of a ≥200-element sequence as "popular" and drops it from the `b2j`
+//! index. `DeepDiff` explicitly opts out for ordered-list comparison
+//! (`autojunk=False`; `deepdiff/diff.py::_diff_ordered_iterable_by_difflib`),
+//! so [`compute_opcodes`] disables it — confirmed empirically against real
+//! `deepdiff==9.1.0` with a 250-item, one-popular-value fixture: the popular
+//! value matches exactly like any other. But `_diff_str` diffs two strings
+//! with a plain `difflib.unified_diff`, whose `SequenceMatcher(None, a, b)`
+//! keeps `difflib`'s default (`autojunk=True`), so [`grouped_opcodes`]
+//! enables it; a 250-line string with a popular line genuinely aligns
+//! differently, and matching it is what byte-parity on the `diff` field
+//! requires. [`build_b2j`] performs the popular-element purge and
+//! [`find_longest_match`]'s extension step re-bridges a run across a purged
+//! element (the standard-library step this port omits when autojunk is off,
+//! where it is provably a no-op — see [`find_longest_match`]).
 
 use std::collections::HashMap;
 
@@ -258,49 +274,62 @@ struct Match {
 
 /// Finds the longest matching block within `a[alo..ahi]` / `b[blo..bhi]` —
 /// a port of `difflib.SequenceMatcher.find_longest_match`'s core
-/// sparse-DP chaining, with its `isjunk`/`autojunk` branches dropped
-/// (`DeepDiff` never enables either; see this module's doc). Ties (multiple
-/// equal-longest candidates) resolve exactly like `difflib`'s: earliest
-/// `i`, then earliest `j` — a direct consequence of scanning `i` ascending
-/// and only updating on a *strictly greater* `k`.
+/// sparse-DP chaining, with its `isjunk` branches dropped (`isjunk` is
+/// always `None` here; see this module's doc). Ties (multiple equal-longest
+/// candidates) resolve exactly like `difflib`'s: earliest `i`, then earliest
+/// `j` — a direct consequence of scanning `i` ascending and only updating on
+/// a *strictly greater* `k`.
 ///
-/// **Deliberately omits `difflib`'s post-DP greedy-extension step**
-/// (`while ... and not isbjunk(...): besti -= 1; ...`, run twice — backward
-/// then forward). That step exists in the standard library to bridge a
-/// match across an *excluded* `b` element (junk, or an autojunk-pruned
-/// popular one) that the DP's `b2j` chain skips entirely because such
-/// elements are deleted from `b2j` (`__chain_b`). With `isjunk=None` (this
-/// module's only configuration — see its doc), `b2j` never excludes
-/// anything, so the DP chain alone already finds every genuinely
-/// contiguous run the extension step could ever find; re-extending
-/// afterwards can only ever re-derive a run already reflected in some
-/// `run_length` the DP itself computed. Dropping it therefore changes no
-/// opcode output for this configuration — verified by a 400,000-trial
-/// randomized differential test against real `difflib` (zero divergences),
-/// not only by the argument above.
+/// **`difflib`'s post-DP greedy-extension step runs only when `extend` is
+/// set** (`while ... and not isbjunk(...): besti -= 1; ...`, run twice —
+/// backward then forward). That step exists in the standard library to
+/// bridge a match across an *excluded* `b` element (junk, or an
+/// autojunk-pruned popular one) that the DP's `b2j` chain skips entirely
+/// because such elements are deleted from `b2j` (`__chain_b`). When autojunk
+/// is off ([`compute_opcodes`], `extend == false`), `b2j` excludes nothing,
+/// so the DP chain alone already finds every genuinely contiguous run the
+/// extension step could ever find; re-extending afterwards can only re-derive
+/// a run already reflected in some `run_length` the DP computed, so skipping
+/// it changes no opcode output — verified by a 400,000-trial randomized
+/// differential test against real `difflib` (zero divergences), not only by
+/// the argument. When autojunk is on ([`grouped_opcodes`], `extend == true`),
+/// [`build_b2j`] *does* purge popular elements, so the step is load-bearing
+/// and must run.
 ///
 /// `b2j` maps each of `b`'s [`ScalarKey`]s to the (ascending) list of
-/// indices it occurs at in `b`; built once per `a`/`b` pair and reused
-/// across every call this function makes during [`get_matching_blocks`]'s
-/// traversal, exactly like `difflib`'s own `self.b2j`.
+/// indices it occurs at in `b`; built once per `a`/`b` pair (see
+/// [`build_b2j`]) and reused across every call this function makes during
+/// [`get_matching_blocks`]'s traversal, exactly like `difflib`'s own
+/// `self.b2j`.
+///
+/// When `extend` is `true`, `difflib`'s post-DP greedy-extension step runs
+/// (it is gated rather than always on — see [`build_b2j`] and
+/// [`get_matching_blocks`]). It bridges a match across a `b` element the DP
+/// chain skipped because [`build_b2j`] purged it as *popular*: such an
+/// element is absent from `b2j`, so the DP never chains through it, yet it
+/// still equals its `a` counterpart and `difflib` re-extends the run over
+/// it. `difflib`'s `isjunk` is always `None` here (`bjunk` empty), so its
+/// two junk-extension loops are dead and only its two non-junk loops matter;
+/// with an empty `bjunk`, `not isbjunk(...)` is always true, leaving element
+/// equality (by [`ScalarKey`], `difflib`'s `==`) as the sole condition.
 ///
 /// Returns `(best_a, best_b, best_size)`; `best_size == 0` means no match
 /// was found in the given range at all.
 fn find_longest_match(
-    a: &[Value],
-    alo: usize,
-    ahi: usize,
-    blo: usize,
-    bhi: usize,
+    a_keys: &[ScalarKey],
+    b_keys: &[ScalarKey],
+    window: Window,
     b2j: &HashMap<ScalarKey, Vec<usize>>,
+    extend: bool,
 ) -> (usize, usize, usize) {
+    let Window { alo, ahi, blo, bhi } = window;
     let (mut best_a, mut best_b, mut best_size) = (alo, blo, 0);
     let mut run_length_by_b_index: HashMap<usize, usize> = HashMap::new();
 
-    for (offset, item) in a[alo..ahi].iter().enumerate() {
+    for (offset, key) in a_keys[alo..ahi].iter().enumerate() {
         let a_index = alo + offset;
         let mut next_run_length_by_b_index: HashMap<usize, usize> = HashMap::new();
-        if let Some(b_indices) = b2j.get(&scalar_key(item)) {
+        if let Some(b_indices) = b2j.get(key) {
             for &b_index in b_indices {
                 if b_index < blo {
                     continue;
@@ -328,9 +357,57 @@ fn find_longest_match(
         run_length_by_b_index = next_run_length_by_b_index;
     }
 
+    if extend {
+        while best_a > alo && best_b > blo && a_keys[best_a - 1] == b_keys[best_b - 1] {
+            best_a -= 1;
+            best_b -= 1;
+            best_size += 1;
+        }
+        while best_a + best_size < ahi
+            && best_b + best_size < bhi
+            && a_keys[best_a + best_size] == b_keys[best_b + best_size]
+        {
+            best_size += 1;
+        }
+    }
+
     (best_a, best_b, best_size)
 }
 
+/// A half-open search window into `a`/`b`, bundling `difflib`'s
+/// `alo`/`ahi`/`blo`/`bhi` bounds so [`find_longest_match`] takes them as one
+/// argument.
+#[derive(Clone, Copy)]
+struct Window {
+    alo: usize,
+    ahi: usize,
+    blo: usize,
+    bhi: usize,
+}
+
+/// Builds `difflib`'s `b2j` index — each of `b`'s [`ScalarKey`]s mapped to
+/// the ascending list of indices it occurs at.
+///
+/// When `autojunk` is set, this also applies `difflib`'s *autojunk*
+/// heuristic (`SequenceMatcher.__chain_b`): for a `b` of 200 or more
+/// elements, any element occurring more than `len(b) / 100 + 1` times is
+/// "popular" and dropped from the index entirely, so the matcher never
+/// chains a run through it (the run is re-bridged instead by
+/// [`find_longest_match`]'s extension step). See this module's doc for which
+/// call site passes which value. `isjunk` is `None` in both, so no `bjunk`
+/// set is ever built.
+fn build_b2j(b_keys: &[ScalarKey], autojunk: bool) -> HashMap<ScalarKey, Vec<usize>> {
+    let mut b2j: HashMap<ScalarKey, Vec<usize>> = HashMap::new();
+    for (b_index, key) in b_keys.iter().enumerate() {
+        b2j.entry(key.clone()).or_default().push(b_index);
+    }
+    if autojunk && b_keys.len() >= 200 {
+        let ntest = b_keys.len() / 100 + 1;
+        b2j.retain(|_, indices| indices.len() <= ntest);
+    }
+    b2j
+}
+
 /// Returns every non-empty matching block between `a` and `b`, sorted and
 /// with adjacent blocks collapsed, terminated by a dummy zero-size block at
 /// `(a.len(), b.len())` — a direct, iterative (explicit work-stack, no
@@ -338,16 +415,32 @@ fn find_longest_match(
 /// `difflib` itself switched to this iterative shape for the same reason
 /// this whole engine avoids native recursion on untrusted input: naive
 /// recursion here overflowed the stack for some real-world inputs.
-fn get_matching_blocks(a: &[Value], b: &[Value]) -> Vec<Match> {
-    let mut b2j: HashMap<ScalarKey, Vec<usize>> = HashMap::new();
-    for (b_index, item) in b.iter().enumerate() {
-        b2j.entry(scalar_key(item)).or_default().push(b_index);
-    }
+///
+/// `autojunk` is threaded through to [`build_b2j`] (which decides whether to
+/// purge popular elements) and to [`find_longest_match`] (which extends a
+/// match over any purged element); the two must agree, so this is the single
+/// switch that turns the whole heuristic on for the string-diff path and off
+/// for the ordered-list path.
+fn get_matching_blocks(a: &[Value], b: &[Value], autojunk: bool) -> Vec<Match> {
+    // Compute each element's `ScalarKey` once, up front, rather than
+    // recomputing it inside every `find_longest_match` window: for a
+    // string-diff `a`/`b` of long lines this turns the worst case's O(N^2)
+    // key rebuilds (each cloning the line) into O(N).
+    let a_keys: Vec<ScalarKey> = a.iter().map(scalar_key).collect();
+    let b_keys: Vec<ScalarKey> = b.iter().map(scalar_key).collect();
+    let b2j = build_b2j(&b_keys, autojunk);
 
-    let mut stack = vec![(0_usize, a.len(), 0_usize, b.len())];
+    let mut stack = vec![Window {
+        alo: 0,
+        ahi: a.len(),
+        blo: 0,
+        bhi: b.len(),
+    }];
     let mut raw_matches = Vec::new();
-    while let Some((alo, ahi, blo, bhi)) = stack.pop() {
-        let (match_a, match_b, match_size) = find_longest_match(a, alo, ahi, blo, bhi, &b2j);
+    while let Some(window) = stack.pop() {
+        let Window { alo, ahi, blo, bhi } = window;
+        let (match_a, match_b, match_size) =
+            find_longest_match(&a_keys, &b_keys, window, &b2j, autojunk);
         if match_size > 0 {
             raw_matches.push(Match {
                 a: match_a,
@@ -355,10 +448,20 @@ fn get_matching_blocks(a: &[Value], b: &[Value]) -> Vec<Match> {
                 size: match_size,
             });
             if alo < match_a && blo < match_b {
-                stack.push((alo, match_a, blo, match_b));
+                stack.push(Window {
+                    alo,
+                    ahi: match_a,
+                    blo,
+                    bhi: match_b,
+                });
             }
             if match_a + match_size < ahi && match_b + match_size < bhi {
-                stack.push((match_a + match_size, ahi, match_b + match_size, bhi));
+                stack.push(Window {
+                    alo: match_a + match_size,
+                    ahi,
+                    blo: match_b + match_size,
+                    bhi,
+                });
             }
         }
     }
@@ -412,12 +515,11 @@ fn get_matching_blocks(a: &[Value], b: &[Value]) -> Vec<Match> {
 /// Never, for any `a`/`b` for which [`all_basic_scalars`] holds on both —
 /// see [`scalar_key`]'s doc for the sole (structurally unreachable here)
 /// panic path this function's callees have.
-#[must_use]
-pub(crate) fn compute_opcodes(a: &[Value], b: &[Value]) -> Vec<Opcode> {
+fn opcodes_with(a: &[Value], b: &[Value], autojunk: bool) -> Vec<Opcode> {
     let mut opcodes = Vec::new();
     let (mut i, mut j) = (0_usize, 0_usize);
 
-    for m in get_matching_blocks(a, b) {
+    for m in get_matching_blocks(a, b, autojunk) {
         let tag = if i < m.a && j < m.b {
             Some(Tag::Replace)
         } else if i < m.a {
@@ -451,6 +553,81 @@ pub(crate) fn compute_opcodes(a: &[Value], b: &[Value]) -> Vec<Opcode> {
     opcodes
 }
 
+/// Computes the ordered-list [`Opcode`]s turning `a` into `b`, with
+/// `difflib`'s autojunk heuristic disabled — the exact configuration
+/// `DeepDiff` uses for default list comparison (see this module's doc).
+#[must_use]
+pub(crate) fn compute_opcodes(a: &[Value], b: &[Value]) -> Vec<Opcode> {
+    opcodes_with(a, b, false)
+}
+
+/// Groups `a`→`b`'s opcodes into change clusters, each with up to `n` lines
+/// of surrounding context, dropping the long unchanged stretches between
+/// them — a port of `difflib.SequenceMatcher.get_grouped_opcodes`, run with
+/// autojunk **on** because it feeds `unified_diff`, which constructs its
+/// matcher with `difflib`'s default (`SequenceMatcher(None, a, b)`).
+///
+/// Each returned inner `Vec` is one contiguous group of opcodes, exactly as
+/// `difflib` yields them, and is **never empty**: both sites that emit a
+/// group (the long-equal split and the final flush) push at least one opcode
+/// into it first. An empty *outer* `Vec` means the two inputs produced no
+/// change worth a group (identical, or empty).
+#[must_use]
+pub(crate) fn grouped_opcodes(a: &[Value], b: &[Value], n: usize) -> Vec<Vec<Opcode>> {
+    let mut codes = opcodes_with(a, b, true);
+    if codes.is_empty() {
+        codes.push(Opcode {
+            tag: Tag::Equal,
+            a1: 0,
+            a2: 1,
+            b1: 0,
+            b2: 1,
+        });
+    }
+
+    // Fix up a leading/trailing all-equal opcode so a group never carries
+    // more than `n` lines of leading or trailing context.
+    if let Some(first) = codes.first_mut()
+        && first.tag == Tag::Equal
+    {
+        first.a1 = first.a1.max(first.a2.saturating_sub(n));
+        first.b1 = first.b1.max(first.b2.saturating_sub(n));
+    }
+    if let Some(last) = codes.last_mut()
+        && last.tag == Tag::Equal
+    {
+        last.a2 = last.a2.min(last.a1 + n);
+        last.b2 = last.b2.min(last.b1 + n);
+    }
+
+    let nn = n + n;
+    let mut groups: Vec<Vec<Opcode>> = Vec::new();
+    let mut group: Vec<Opcode> = Vec::new();
+    for mut code in codes {
+        // A long unchanged run ends the current group and starts the next,
+        // keeping only `n` lines of context on either side of the boundary.
+        if code.tag == Tag::Equal && code.a2 - code.a1 > nn {
+            group.push(Opcode {
+                tag: Tag::Equal,
+                a1: code.a1,
+                a2: code.a2.min(code.a1 + n),
+                b1: code.b1,
+                b2: code.b2.min(code.b1 + n),
+            });
+            groups.push(std::mem::take(&mut group));
+            code.a1 = code.a1.max(code.a2.saturating_sub(n));
+            code.b1 = code.b1.max(code.b2.saturating_sub(n));
+        }
+        group.push(code);
+    }
+    let trivial_equal = matches!(group.as_slice(), [only] if only.tag == Tag::Equal);
+    if !group.is_empty() && !trivial_equal {
+        groups.push(group);
+    }
+
+    groups
+}
+
 #[cfg(test)]
 #[path = "lcs_tests.rs"]
 mod tests;

{deepdiff_rs-0.5.4 → deepdiff_rs-0.6.0}/crates/onix-core/src/lcs_tests.rs

@@ -15,16 +15,24 @@ fn scalar_key(value: &serde_json::Value) -> super::ScalarKey {
 }
 
 /// Python-`==` equality for two JSON scalars, per [`super::ScalarKey`]'s
-/// doc. Test-only: production code has no remaining use for this as a
-/// standalone function (see [`super::find_longest_match`]'s doc on why
-/// its own extend-by-direct-comparison step was removed) — it survives
+/// doc. Test-only: the engine compares scalars directly by
+/// [`super::ScalarKey`] (including [`super::find_longest_match`]'s autojunk
+/// extension step) rather than through a standalone predicate — this survives
 /// here purely to assert the hashability/cross-type-equality semantics
-/// directly, and to state the `Replace`-opcode non-matching-pair
-/// invariant precisely in [`replace_opcode_ranges_never_share_a_matching_element`].
+/// directly, and to state the `Replace`-opcode non-matching-pair invariant
+/// precisely in [`replace_opcode_ranges_never_share_a_matching_element`].
 fn python_scalar_eq(a: &serde_json::Value, b: &serde_json::Value) -> bool {
     scalar_key(a) == scalar_key(b)
 }
 
+fn grouped_opcodes(
+    a: &[serde_json::Value],
+    b: &[serde_json::Value],
+    n: usize,
+) -> Vec<Vec<super::Opcode>> {
+    super::grouped_opcodes(&cvec(a), &cvec(b), n)
+}
+
 // --- all_basic_scalars ---------------------------------------------
 
 #[test]
@@ -561,3 +569,136 @@ fn mix_float_bits_spreads_low_bits_of_integral_and_half_integer_floats() {
         super::mix_float_bits(2.0_f64.to_bits())
     );
 }
+
+// --- grouped_opcodes -----------------------------------------------
+
+#[test]
+fn grouped_opcodes_of_empty_inputs_yields_no_groups() {
+    // `get_opcodes` is empty for two empty sequences, so the fallback dummy
+    // "equal" opcode is inserted and then dropped as a trivial single-equal
+    // group — no group is emitted. (`unified_diff` never reaches this, since
+    // its trigger requires a newline, but the port mirrors difflib exactly.)
+    assert!(grouped_opcodes(&[], &[], 3).is_empty());
+}
+
+#[test]
+fn grouped_opcodes_of_identical_inputs_yields_no_groups() {
+    let same = vec![json!("a"), json!("b"), json!("c")];
+    assert!(grouped_opcodes(&same, &same, 3).is_empty());
+}
+
+#[test]
+fn grouped_opcodes_splits_far_apart_changes_into_separate_groups() {
+    // Changes at index 1 and 15 with >2n unchanged lines between them, so the
+    // long equal run splits the opcodes into two groups (difflib's cluster
+    // isolation).
+    let a: Vec<serde_json::Value> = (0..20).map(|i| json!(format!("L{i}"))).collect();
+    let b: Vec<serde_json::Value> = (0..20)
+        .map(|i| match i {
+            1 => json!("X1"),
+            15 => json!("X15"),
+            _ => json!(format!("L{i}")),
+        })
+        .collect();
+    assert_eq!(grouped_opcodes(&a, &b, 3).len(), 2);
+}
+
+// --- find_longest_match extension step (autojunk-only) --------------
+//
+// These call `find_longest_match` directly with a `b2j` that deliberately
+// omits a "popular" element (as `build_b2j`'s autojunk purge would), so the
+// DP chain cannot match that element and only the greedy extension step can
+// re-bridge it. The window and match offsets are asymmetric between the two
+// sides so each loop bound (`best_a > alo`, `best_b > blo`, and the two
+// forward `< ahi`/`< bhi` checks) is exercised as the binding constraint.
+
+fn keys(items: &[serde_json::Value]) -> Vec<super::ScalarKey> {
+    items.iter().map(scalar_key).collect()
+}
+
+fn b2j_from(keys: &[super::ScalarKey]) -> std::collections::HashMap<super::ScalarKey, Vec<usize>> {
+    // A b2j built by hand so a chosen key can be omitted (purged).
+    let mut map: std::collections::HashMap<super::ScalarKey, Vec<usize>> =
+        std::collections::HashMap::new();
+    for (i, k) in keys.iter().enumerate() {
+        map.entry(k.clone()).or_default().push(i);
+    }
+    map
+}
+
+#[test]
+fn extension_bridges_a_purged_element_backward() {
+    // a = [P, P, u], b = [P, u]; P is purged from b2j, so the DP only finds
+    // `u` (a[2] == b[1]); the backward extension must re-bridge one `P` to
+    // give the full match a[1..3] == b[0..2].
+    let a_keys = keys(&[json!("P"), json!("P"), json!("u")]);
+    let b_keys = keys(&[json!("P"), json!("u")]);
+    let mut b2j = b2j_from(&b_keys);
+    b2j.remove(&scalar_key(&json!("P")));
+    let window = super::Window {
+        alo: 0,
+        ahi: a_keys.len(),
+        blo: 0,
+        bhi: b_keys.len(),
+    };
+    assert_eq!(
+        super::find_longest_match(&a_keys, &b_keys, window, &b2j, true),
+        (1, 0, 2),
+    );
+}
+
+#[test]
+fn extension_bridges_a_purged_element_forward() {
+    // a = [u, P], b = [u, P, P]; P purged, DP finds only `u` (a[0] == b[0]);
+    // the forward extension must re-bridge one `P`, giving a[0..2] == b[0..2].
+    let a_keys = keys(&[json!("u"), json!("P")]);
+    let b_keys = keys(&[json!("u"), json!("P"), json!("P")]);
+    let mut b2j = b2j_from(&b_keys);
+    b2j.remove(&scalar_key(&json!("P")));
+    let window = super::Window {
+        alo: 0,
+        ahi: a_keys.len(),
+        blo: 0,
+        bhi: b_keys.len(),
+    };
+    assert_eq!(
+        super::find_longest_match(&a_keys, &b_keys, window, &b2j, false),
+        (0, 0, 1),
+        "with extend=false the purged P is not bridged"
+    );
+    assert_eq!(
+        super::find_longest_match(&a_keys, &b_keys, window, &b2j, true),
+        (0, 0, 2),
+        "with extend=true the forward extension bridges one P"
+    );
+}
+
+// --- build_b2j autojunk purge --------------------------------------
+
+#[test]
+fn build_b2j_purges_only_above_the_autojunk_threshold() {
+    // 200 elements: `ntest = 200 / 100 + 1 = 3`. "pop" (4 occurrences) is
+    // purged; "keep3" (exactly 3) is kept, as is every unique filler.
+    let mut items: Vec<serde_json::Value> = Vec::new();
+    items.extend(std::iter::repeat_n(json!("pop"), 4));
+    items.extend(std::iter::repeat_n(json!("keep3"), 3));
+    for i in 0..193 {
+        items.push(json!(format!("u{i}")));
+    }
+    assert_eq!(items.len(), 200);
+    let b_keys = keys(&items);
+
+    let purged = super::build_b2j(&b_keys, true);
+    assert!(
+        !purged.contains_key(&scalar_key(&json!("pop"))),
+        "pop occurs 4 times (> ntest 3) and must be purged"
+    );
+    assert!(
+        purged.contains_key(&scalar_key(&json!("keep3"))),
+        "keep3 occurs exactly 3 times (== ntest) and must be kept"
+    );
+
+    // With autojunk off, nothing is ever purged even past 200 elements.
+    let unpurged = super::build_b2j(&b_keys, false);
+    assert!(unpurged.contains_key(&scalar_key(&json!("pop"))));
+}