deepdiff-rs 0.5.1__tar.gz → 0.5.3__tar.gz

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/Cargo.lock

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

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/Cargo.toml

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

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.5.1
+Version: 0.5.3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/diff/array.rs

@@ -133,7 +133,7 @@ struct LcsPair<'a> {
 /// function, and must record *nothing* — which is also what keeps
 /// [`lcs_or_positional_array_diff`]'s finding-count comparison matching
 /// `DeepDiff`'s. That branch is also where the pair picks up the
-/// UTC-normalized rendering [`datetime_diff`] documents.
+/// UTC-normalized rendering [`datetime_diff`](super::datetime_diff) documents.
 ///
 /// Checks [`check_traversal_depth`] at `depth + 1` (this pair's own path
 /// depth) before recording anything — the same bound
@@ -312,7 +312,7 @@ fn lcs_array_diff(
 /// own internal dispatch one level deeper with the index appended to the
 /// path (so a changed, type-changed, or further-nested-container
 /// difference at that index surfaces with its own deep path, exactly like
-/// [`object_diff`]'s shared-key recursion). Once the shorter list is
+/// [`object_diff`](super::object_diff)'s shared-key recursion). Once the shorter list is
 /// exhausted, the longer list's surplus tail becomes
 /// `iterable_item_removed` findings (if `a` is longer) or
 /// `iterable_item_added` findings (if `b` is longer), one per surplus index,
@@ -325,15 +325,15 @@ fn lcs_array_diff(
 /// against [`lcs_array_diff`]'s result otherwise — see [`array_diff`]'s
 /// doc.
 ///
-/// Like [`object_diff`], this always recurses into same-index pairs rather
-/// than re-checking [`values_equal`] first — see that function's doc for why
-/// the single top-level equality check in [`diff_with_max_depth`] is enough.
+/// Like [`object_diff`](super::object_diff), this always recurses into same-index pairs rather
+/// than re-checking [`values_equal`](super::values_equal) first — see that function's doc for why
+/// the single top-level equality check in [`diff_with_max_depth`](super::diff_with_max_depth) is enough.
 ///
 /// Every surplus-tail clone is checked with [`check_value_depth`] first,
-/// exactly like [`object_diff`]'s added/removed leaf clones: a surplus
+/// exactly like [`object_diff`](super::object_diff)'s added/removed leaf clones: a surplus
 /// element can itself be an arbitrarily deep value, so the same combined
 /// path-depth-plus-value-depth budget applies here too (see
-/// [`diff_with_max_depth`]'s doc for the full contract).
+/// [`diff_with_max_depth`](super::diff_with_max_depth)'s doc for the full contract).
 ///
 /// `path` is the single buffer shared across the whole traversal (see
 /// [`diff_at`]'s doc): each iteration below runs its work through

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/diff/dispatch.rs

@@ -18,7 +18,7 @@ use super::{
     type_change_report,
 };
 
-/// The recursive core of [`diff_with_max_depth()`]: identical dispatch, but
+/// The recursive core of [`diff_with_max_depth()`](super::diff_with_max_depth): identical dispatch, but
 /// carrying the path and depth accumulated so far, so that nested findings
 /// get their full deep path and the recursion-depth bound can be enforced.
 ///
@@ -153,7 +153,7 @@ pub(crate) fn deeper_than(value: &Value, limit: usize) -> bool {
 /// closes: a value could be accepted at up to `max_depth` deep *in addition
 /// to* however deep the traversal already was, for a combined worst case of
 /// roughly `2 * max_depth` native frames at the `.clone()` call — see
-/// [`diff_with_max_depth`]'s doc for the full contract this restores.
+/// [`diff_with_max_depth`](super::diff_with_max_depth)'s doc for the full contract this restores.
 pub(crate) fn check_value_depth(
     path: &[PathSegment],
     value: &Value,
@@ -217,10 +217,10 @@ pub(crate) fn check_map_depth(
 /// `max_depth`, `Ok(())` otherwise.
 ///
 /// This is [`diff_at`]'s own top check, factored out so
-/// [`insert_lcs_pair_finding`] can enforce the *exact same* bound for an
+/// `insert_lcs_pair_finding` can enforce the *exact same* bound for an
 /// LCS `'replace'`-opcode pairwise comparison as `diff_at` would have
 /// enforced had the pair been reached by ordinary recursion instead (which
-/// is what [`positional_array_diff`]'s equivalent same-index pairs go
+/// is what `positional_array_diff`'s equivalent same-index pairs go
 /// through) — see [`array_diff`]'s module-level "List diffing" doc section.
 /// Deliberately distinct from [`check_value_depth`]: that function bounds a
 /// *value's own nesting* combined with the remaining budget, and is a

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/diff/object.rs

@@ -22,8 +22,8 @@ use super::{DiffOptions, check_map_depth, check_value_depth, diff_at, scoped};
 /// finding (via `array_diff`), all surface with their own deep path.
 ///
 /// This always recurses, even for a key whose value is unchanged — it does
-/// not re-check [`values_equal`] per key. That single top-level check in
-/// [`diff_with_max_depth`] is enough for its documented guarantee (fully
+/// not re-check [`values_equal`](super::values_equal) per key. That single top-level check in
+/// [`diff_with_max_depth`](super::diff_with_max_depth) is enough for its documented guarantee (fully
 /// equal *whole* inputs never hit the bound); re-running it per key would
 /// only rescue one specific edge case (an equal subtree nested arbitrarily
 /// deep under an unrelated shallow change) at the cost of an extra full
@@ -49,7 +49,7 @@ use super::{DiffOptions, check_map_depth, check_value_depth, diff_at, scoped};
 /// [`Report::merge`] documents why the per-key `report.merge(...)` calls
 /// below never collide on a *structural* path (each key here is visited
 /// once, so no traversal ever revisits the same node) — `Report` is keyed
-/// by that structural path, not by [`render_path`]'s rendered string, which
+/// by that structural path, not by [`render_path`](crate::path::render_path)'s rendered string, which
 /// is *not* injective on adversarial keys (see [`crate::path::quote_key`]'s
 /// doc and `Report`'s module doc for how two structurally distinct paths
 /// can render identically, and how that collision is handled at

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/diff/scalar.rs

@@ -173,7 +173,7 @@ pub(crate) fn numeric_diff(
     scalar_diff(path, numbers_equal(old, new), a, b, depth, max_depth)
 }
 /// The single definition of numeric equality shared by [`numeric_diff`] and
-/// [`values_equal`], so there is exactly one place these rules live.
+/// [`values_equal`](super::values_equal), so there is exactly one place these rules live.
 ///
 /// An int and a float are never equal (mirroring `DeepDiff` always reporting
 /// that pairing as a `type_changes`, never a numeric comparison). Within the

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/diff/tests.rs

@@ -749,9 +749,9 @@ fn map_deeper_than_recurses_with_incrementing_not_constant_depth() {
 
 #[test]
 fn deeper_than_handles_a_deeply_nested_value_without_crashing() {
-    // Security-gate regression: `deeper_than` itself must be immune to
-    // the very depth it is measuring — RECURSION_OVERFLOW_DEPTH (see its
-    // doc) reuses this file's own established native-recursion-overflow
+    // Guards `deeper_than` itself against being vulnerable to the very
+    // depth it is measuring — RECURSION_OVERFLOW_DEPTH (see its doc)
+    // reuses this file's own established native-recursion-overflow
     // threshold. Built iteratively (a flat loop, not recursion); the
     // whole test runs on `run_on_a_large_stack` so it is genuinely
     // dropped afterwards instead of leaked.
@@ -761,7 +761,7 @@ fn deeper_than_handles_a_deeply_nested_value_without_crashing() {
     });
 }
 
-// --- Security-gate regression: a shallow finding carrying a deep VALUE
+// --- A shallow finding carrying a deep VALUE
 // (dictionary_item_added/removed/type_changes/values_changed) must
 // error cleanly via check_value_depth, never clone the deep value. ---
 
@@ -917,9 +917,9 @@ fn scalar_diff_rejects_a_value_whose_own_nesting_exceeds_max_depth_on_the_new_si
     );
 }
 
-// --- Compounding-depth regression (security-gate round 3): a value's
-// own nesting and the path depth it is found at share ONE combined
-// max_depth budget, not one each. ---
+// --- Compounding-depth regression: a value reached through a shallow
+// finding must not be allowed its own full max_depth on top of the path
+// depth already consumed to reach it. ---
 
 #[test]
 fn value_depth_full_budget_at_a_shallow_finding_is_accepted() {
@@ -1114,9 +1114,10 @@ fn sibling_after_a_deeply_nested_key_gets_its_own_shallow_path_not_the_deep_ones
 }
 
 #[test]
-fn security_poc_shallow_finding_with_a_value_past_the_guard_errors_cleanly() {
-    // The exact security-gate PoC shape: diff({}, {"x": <deep array>})
-    // at DEFAULT_MAX_DEPTH. `check_value_depth`/`deeper_than` reject a
+fn shallow_finding_with_a_value_past_the_guard_errors_cleanly() {
+    // Exercises the shallow-finding-with-a-too-deep-value shape:
+    // diff({}, {"x": <deep array>}) at DEFAULT_MAX_DEPTH.
+    // `check_value_depth`/`deeper_than` reject a
     // too-deep value by walking at most `max_depth + 1` levels of it
     // before short-circuiting (see `check_value_depth`'s doc), so
     // PAST_DEFAULT_MAX_DEPTH exercises identical behavior to the
@@ -1201,7 +1202,7 @@ fn compounding_depth_regression_max_depth_20_000_traversal_plus_deep_added_value
 
 #[test]
 fn threshold_collapse_rejects_a_deep_side_on_a_constrained_stack_instead_of_crashing() {
-    // Security-gate regression for the `threshold_to_diff_deeper` collapse:
+    // Guards the `threshold_to_diff_deeper` collapse:
     // the collapse clones the whole `a`/`b` dict into a finding,
     // so cloning before checking depth would hand an attacker-controlled,
     // `RECURSION_OVERFLOW_DEPTH`-deep value straight to `serde_json::Value`'s

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/distance.rs

@@ -14,8 +14,8 @@ use super::IgnoreOrderMemo;
 use super::fxhash::HashSet;
 
 /// A total-ordering wrapper for the non-negative, always-finite distances
-/// [`rough_distance`] computes, so they can key a [`BTreeMap`] (ascending
-/// iteration, for [`compute_pairs`]'s greedy loop) and group candidates by
+/// [`rough_distance`] computes, so they can key a [`BTreeMap`](std::collections::BTreeMap) (ascending
+/// iteration, for [`compute_pairs`](super::pairing::compute_pairs)'s greedy loop) and group candidates by
 /// **exact** float equality — matching `DeepDiff`'s own behavior of keying
 /// a plain Python `dict` by the raw `float` distance value.
 #[derive(Debug, Clone, Copy)]
@@ -155,7 +155,7 @@ fn family_distance(removed: &Value, added: &Value, cutoff: f64) -> Option<f64> {
 /// `DeepDiff`'s `_get_numbers_distance` (distance.py), including the
 /// "self-cancellation" quirk (`max_` appears in both the
 /// formula and the rejection threshold, so same-sign numeric pairs are
-/// almost never rejected by [`CUTOFF_DISTANCE_FOR_PAIRS`]) and the
+/// almost never rejected by [`CUTOFF_DISTANCE_FOR_PAIRS`](super::pairing::CUTOFF_DISTANCE_FOR_PAIRS)) and the
 /// opposite-sign zero-sum edge case (`divisor == 0.0` returns `cutoff`
 /// itself, i.e. always-reject, rather than dividing by zero).
 #[allow(
@@ -254,9 +254,9 @@ pub(crate) fn is_length_excluded_key(key: &str) -> bool {
 }
 
 /// A `Report`-free mirror of the recursive diff dispatch, counting exactly
-/// what [`Report::distance_leaf_length`] would sum from the equivalent real
+/// what [`Report::distance_leaf_length`](crate::report::Report::distance_leaf_length) would sum from the equivalent real
 /// diff — used by [`rough_distance`]'s structural fallback so a candidate
-/// pair's `diff_length` never pays for a [`Report`]'s `PathSegment`
+/// pair's `diff_length` never pays for a [`Report`](crate::report::Report)'s `PathSegment`
 /// allocations, `Value` clones, or `BTreeMap` inserts. This matters: a
 /// naive "just call `diff_at` and count its `Report`" implementation would
 /// pay exactly the per-candidate object-construction cost that is the
@@ -648,10 +648,10 @@ fn coerce_to_python_str(value: &Value) -> Option<String> {
 /// dict-vs-dict pair through the real `array_diff`/`object_diff` engine:
 /// when that trial's pairing accepts a dict-vs-dict pair nested inside it,
 /// the *actual Report entry it builds* now already reflects the collapse,
-/// so [`Report::distance_leaf_length`] never inherits an inflated,
+/// so [`Report::distance_leaf_length`](crate::report::Report::distance_leaf_length) never inherits an inflated,
 /// uncollapsed leaf count from it (found by differential fuzzing: a
 /// nested-array-of-dicts candidate pair whose true distance is 0.1364 used
-/// to be measured at 0.3182 — crossing [`CUTOFF_DISTANCE_FOR_PAIRS`] and
+/// to be measured at 0.3182 — crossing [`CUTOFF_DISTANCE_FOR_PAIRS`](super::pairing::CUTOFF_DISTANCE_FOR_PAIRS) and
 /// producing a completely different pairing decision).
 pub(crate) const THRESHOLD_TO_DIFF_DEEPER: f64 = 0.33;
 
@@ -783,7 +783,7 @@ pub(crate) fn count_array_diff_leaves(
 /// `diff_length` comes from [`count_diff_leaves`] — a `Report`-free mirror
 /// of a trial recursive diff between `removed` and `added` (see that
 /// function's own doc for why it deliberately does *not* build a
-/// [`Report`], unlike `DeepDiff`'s own brand-new nested `DeepDiff` object
+/// [`Report`](crate::report::Report), unlike `DeepDiff`'s own brand-new nested `DeepDiff` object
 /// built purely to measure this).
 ///
 /// `depth` is the depth of the *list* doing the pairing (so `removed`/
@@ -797,14 +797,14 @@ pub(crate) fn count_array_diff_leaves(
 ///
 /// **The one place this can still fail is [`count_array_diff_leaves`]'s own
 /// nested trial diff, and it is believed unreachable today, kept anyway as
-/// defense-in-depth.** [`ignore_order_array_diff`]'s own up-front
+/// defense-in-depth.** [`ignore_order_array_diff`](super::ignore_order_array_diff)'s own up-front
 /// [`crate::diff::check_value_depth`] pass already validates `removed`/`added`
 /// individually against this exact same reduced budget
 /// (`max_depth` minus the items' own depth) before pairing ever runs; a
 /// short inductive argument (every subtree's remaining-budget-at-its-relative-depth
 /// transfers exactly from a depth-checked root to a trial restarted at
 /// depth `0` with that same budget as its own `max_depth`) shows the trial
-/// can never need more depth than that. Unlike [`insert_lcs_pair_finding`]'s
+/// can never need more depth than that. Unlike `insert_lcs_pair_finding`'s
 /// equivalent "structurally unreachable" guard (a *static type fact* — a
 /// JSON scalar's nesting is always `0`, true forever), the invariant here
 /// is a *cross-function arithmetic* one, spread across several functions —

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/fxhash.rs

@@ -1,6 +1,6 @@
 //! `FxHash`: a small, fast, non-cryptographic hasher used for this module's
 //! `HashMap`/`HashSet`s ([`HashedList::info`](super::hash::HashedList),
-//! [`AddedCandidates::buckets`](super::pairing::AddedCandidates), the
+//! `AddedCandidates::buckets`, the
 //! pairing/`used` sets in [`compute_pairs`](super::pairing::compute_pairs),
 //! and the [`IgnoreOrderMemo`](super::memo::IgnoreOrderMemo) cache) —
 //! chosen for speed at the cost of hash-flooding resistance. Some of these
@@ -12,7 +12,7 @@
 use std::hash::BuildHasherDefault;
 
 /// A [`std::collections::HashMap`] keyed by this module's own types
-/// ([`ItemKey`], [`Distance`]), using [`FxHasher`] instead of the standard
+/// ([`ItemKey`](super::hash::ItemKey), [`Distance`](super::distance::Distance)), using [`FxHasher`] instead of the standard
 /// library's default (`SipHash`) — see that type's doc for the trade-off.
 pub(crate) type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<FxHasher>>;
 /// The [`HashMap`] equivalent for [`std::collections::HashSet`].
@@ -44,11 +44,11 @@ pub(crate) type HashSet<T> = std::collections::HashSet<T, BuildHasherDefault<FxH
 /// `FxHash` table there would be a crafted-collision `DoS` on the ordinary
 /// path; a `BTreeMap` has no hash to attack (`O(log n)` worst case, always). See
 /// that module's "Set-member digests" section. Every remaining `FxHash` table
-/// in this module — `HashedList`, [`AddedCandidates`](super::pairing::AddedCandidates),
+/// in this module — `HashedList`, `AddedCandidates`,
 /// the pairing/`used` sets, and the distance memo — is reached **only** under
 /// `ignore_order=true`, the pairing hot path already bounded by the `O(N²)`
 /// caveat below; those keep `FxHash`, and their float-carrying keys
-/// ([`ItemKey`](super::hash::ItemKey), [`ScalarKey`](super::hash::ScalarKey),
+/// ([`ItemKey`](super::hash::ItemKey), [`ScalarKey`](crate::lcs::ScalarKey),
 /// and the distance memo's [`DistKey`](super::hash::DistKey)) mix their bits
 /// first ([`mix_float_bits`](crate::lcs::mix_float_bits)) — `DistKey`'s
 /// encoding routes every float through `number_key`, hence `ItemKey::Float`,

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/hash.rs

@@ -169,7 +169,7 @@ pub(crate) enum ItemKey {
     /// value (never collides with `Int`).
     Bool(bool),
     /// A JSON value `serde_json` parsed as an integer (no decimal point or
-    /// exponent) — see [`crate::diff`]'s `python_type_name` for the same
+    /// exponent) — see [`mod@crate::diff`]'s `python_type_name` for the same
     /// int/float split used throughout this crate. Always exact: a
     /// `serde_json::Number`'s non-float representation is always an `i64`
     /// or `u64`, both of which fit losslessly in `i128`.
@@ -400,7 +400,7 @@ pub(crate) enum MemberContent {
 /// `RepId`s are equal.
 ///
 /// Shared by [`crate::diff::set_diff`] and
-/// [`crate::ignore_order::count_set_diff_leaves`] so the two can never drift
+/// `count_set_diff_leaves` so the two can never drift
 /// on what "the same member" means.
 pub(crate) fn set_difference<'a>(
     a: &'a [Value],
@@ -660,7 +660,7 @@ fn number_key(n: &crate::value::Number) -> ItemKey {
 ///
 /// Recurses natively — safe only because
 /// every caller in this module first proves `value`'s nesting is within the
-/// crate's shared depth budget via [`check_value_depth`] (see this module's
+/// crate's shared depth budget via [`check_value_depth`](crate::diff::check_value_depth) (see this module's
 /// "Depth safety" doc section).
 pub(crate) fn item_key(value: &Value, memo: &IgnoreOrderMemo) -> ItemKey {
     keyed(value, memo, false).0
@@ -790,7 +790,7 @@ pub(crate) struct HashedList<'a> {
     /// — this is `SetOrdered(full_t{1,2}_hashtable.keys())`'s own iteration
     /// order (a Python dict's insertion order). Each key sits behind an [`Rc`]
     /// shared with [`Self::info`] and the distance-memo cache keys (see
-    /// [`super::memo::DistanceKey`]).
+    /// `DistanceKey`).
     pub(crate) distinct_order: Vec<Rc<ItemKey>>,
     info: HashMap<Rc<ItemKey>, (usize, &'a Value)>,
 }

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/memo.rs

@@ -139,7 +139,7 @@ use super::hash::{
 /// [`super::hash::DistKey`] for why each side is a value's exact structural
 /// identity (not its order/repetition-insensitive `ItemKey`). Memory per
 /// entry is a refcount bump: each side's value is interned once per candidate
-/// and the `A * R` entries one pairing records just share those [`Rc`]s. The
+/// and the `A * R` entries one pairing records just share those [`Rc`](std::rc::Rc)s. The
 /// *lookup* cost is not constant, though — every probe hashes both keys (a
 /// full walk of each value) and, on a bucket match, compares them structurally
 /// — so per-pair work is proportional to record size (see [`super::hash::DistKey`]).

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/mod.rs

@@ -33,7 +33,7 @@
 //!
 //! For one list level (`a` = `t1`/old, `b` = `t2`/new):
 //!
-//! 1. **Hash every item** ([`item_key`]) into a canonical equivalence key —
+//! 1. **Hash every item** ([`item_key`](hash::item_key)) into a canonical equivalence key —
 //!    see that function's doc for the exact `DeepHash`-matching rules
 //!    (type-tagged numbers, order/count-insensitive nested lists, etc.).
 //!    Reduce each list to its *distinct* keys in first-occurrence order
@@ -70,7 +70,7 @@
 //!    added-hash loop consumed every paired partner) is a plain
 //!    `iterable_item_removed` at its own index.
 //!
-//! After the whole recursive traversal finishes, [`crate::diff`]'s existing
+//! After the whole recursive traversal finishes, [`mod@crate::diff`]'s existing
 //! whole-tree [`crate::report::Report::merge_mutual_add_removes`] pass
 //! still runs exactly once, unchanged — it is what turns many of this
 //! module's own raw adds/removes into `values_changed` on typical small,
@@ -79,21 +79,21 @@
 //!
 //! # Depth safety (this crate's own invariant, not `DeepDiff`'s)
 //!
-//! [`item_key`] and [`rough_length`] both recurse **natively** (no explicit
+//! [`item_key`](hash::item_key) and [`rough_length`](distance::rough_length) both recurse **natively** (no explicit
 //! work-stack) — unlike the rest of this crate's traversal, which is bounded
 //! via [`crate::diff::check_traversal_depth`]/[`crate::diff::check_value_depth`].
 //! [`ignore_order_array_diff`] closes this gap up front: every item of both
 //! `a` and `b` is validated with [`crate::diff::check_value_depth`] (the same
 //! combined path-depth-plus-value-depth budget documented on
 //! [`crate::diff::diff_with_max_depth`]) *before* any hashing happens, so by
-//! the time [`item_key`]/[`rough_length`] run, their native recursion is
+//! the time [`item_key`](hash::item_key)/[`rough_length`](distance::rough_length) run, their native recursion is
 //! already proven to be no deeper than a bound this crate already trusts a
 //! plain `.clone()` to recurse through safely elsewhere. The structural
-//! distance fallback's own trial comparison ([`count_diff_leaves`]) is a
+//! distance fallback's own trial comparison ([`count_diff_leaves`](distance::count_diff_leaves)) is a
 //! `Report`-free mirror of a diff for scalars and dicts (no further native
 //! recursion risk beyond what's already covered above), except for a
 //! genuinely nested array, which still runs a real, small trial
-//! [`crate::diff::array_diff`] call — see [`rough_distance`]'s doc for its
+//! [`crate::diff::array_diff`] call — see [`rough_distance`](distance::rough_distance)'s doc for its
 //! own remaining-budget bound.
 //!
 //! # Two `DeepDiff` behaviors the pairing depends on
@@ -107,7 +107,7 @@
 //!    `float(0) == 0.0`, `int(True) == 1`, `bool(0) == False`) — the general
 //!    rule real `DeepDiff` applies
 //!    (`model.py::TreeResult._from_tree_type_changes`, `DELTA_VIEW` branch).
-//!    See [`coerce_for_type_change`] for the exact matrix.
+//!    See `coerce_for_type_change` for the exact matrix.
 //!    [`type_change_leaf_length`] and `Report::distance_leaf_length` both
 //!    route through it, so this rule lives in exactly one place.
 //! 2. **`new_path` composition across nesting levels.** A paired item whose

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/ignore_order/pairing.rs

@@ -83,7 +83,7 @@ impl AddedCandidates {
 /// Returns added-hash → removed-hash (only that one direction: `DeepDiff`'s
 /// own `pairs` dict is built symmetrically so `get_other_pair` can look it
 /// up from either side, but this port only ever looks up from the added
-/// side — see [`ignore_order_array_diff`] — so the reverse direction is
+/// side — see [`ignore_order_array_diff`](super::ignore_order_array_diff) — so the reverse direction is
 /// never constructed).
 pub(crate) fn compute_pairs(
     hashes_added: &[Rc<ItemKey>],

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/lcs.rs

@@ -44,7 +44,7 @@ use crate::value::Value;
 
 /// A bucket key for grouping list elements that compare equal the way
 /// Python's `==` (and therefore `difflib`'s matcher, and dict/set hashing)
-/// does — **not** the way [`crate::diff`]'s own scalar comparison does.
+/// does — **not** the way [`mod@crate::diff`]'s own scalar comparison does.
 ///
 /// This is the "hashable" finding: Python treats `1 == 1.0 == True` (and
 /// `0 == 0.0 == False`) as equal regardless of type, so `difflib` can match

{deepdiff_rs-0.5.1 → deepdiff_rs-0.5.3}/crates/onix-core/src/report.rs

@@ -588,7 +588,7 @@ impl Report {
     }
 
     /// `DeepDiff`'s `_get_item_length` (distance.py) applied to a whole
-    /// trial-diff report — [`crate::ignore_order::rough_distance`]'s
+    /// trial-diff report — `rough_distance`'s
     /// structural-fallback numerator (`diff_length`).
     ///
     /// Mirrors exactly which sub-value `_get_item_length` would see for