Make diff() account for member order in ordered_json objects

[nlohmann]

Summary

basic_json::diff() walks the source object, looks each key up in the target, recurses if present, and emits remove/add for keys missing on either side — but it never considers member order. For nlohmann::json (std::map-backed) that's fine, because operator== is order-insensitive and std::map's iteration order is a pure function of the key set (always sorted by key), so two objects with the same keys always iterate in the same relative order regardless of insertion history.

For nlohmann::ordered_json (ordered_map-backed, insertion-ordered), operator== is order-sensitive (documented in operator==.md), but diff() never emitted patch ops to fix order. As a result, diff() could return a patch that, applied via patch(), does not reproduce a target that only differs in member order — violating the documented round-trip guarantee in diff.md:

source.patch(diff(source, target)) == target;

Fix

In the object case of diff(), detect whether the common keys already appear in the same relative order in source and target, and whether any new key would need to land somewhere other than the end. When both hold (always true for plain json), the original minimal per-key recursive diff is used, unchanged. When they don't (only reachable for ordered_json), every common key is removed and every key (common + new) is re-added, in target's order, with its final value — relying on patch()'s object "add" (which uses operator[]) appending at the end of an ordered_map when the key doesn't already exist, which is exactly what's needed to fix its position.

This is a no-op for plain json (the "reorder" branch is provably unreachable there), so there's no behavior or performance change for the common case.

Test plan

• Added tests/src/unit-ordered_json.cpp regression tests covering: pure reorder, new key inserted at the front, reorder + value change, reorder + delete, reorder + nested recursive diff, 3+ key shuffle, and a minimality check confirming the fast path is unchanged for plain json and same-order ordered_json.
• Property-tested with 20,000 randomly generated ordered_json source/target pairs (shuffled/overlapping key sets, nested values) asserting source.patch(diff(source, target)) == target — 0 failures.
• Ran the existing tests/src/unit-json_patch.cpp suite offline to confirm all inline json::diff/patch assertions on plain json still pass.
• Regenerated single_include/nlohmann/json.hpp via make amalgamate.

Breaking change?

No breaking changes to the public API. ordered_json::diff() now produces different (larger, but correct) patches in the specific case where the target only differs from source in member order — previously it produced an incomplete/incorrect patch there, so this is a bug fix to already-broken behavior, not a change to any documented contract. json::diff() (plain, std::map-backed) is provably unaffected.

🤖 Generated with Claude Code