json-atom 0.3.0__tar.gz → 0.4.1__tar.gz

{json_atom-0.3.0 → json_atom-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-atom
-Version: 0.3.0
+Version: 0.4.1
 Summary: Python implementation of the JSON Atom v0 specification
 Project-URL: Homepage, https://github.com/ltwlf/json-atom-py
 Project-URL: Repository, https://github.com/ltwlf/json-atom-py

{json_atom-0.3.0 → json_atom-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "json-atom"
-version = "0.3.0"
+version = "0.4.1"
 description = "Python implementation of the JSON Atom v0 specification"
 readme = "README.md"
 license = "MIT"

{json_atom-0.3.0 → json_atom-0.4.1}/src/json_atom/_identity.py

@@ -14,6 +14,7 @@ from typing import Any, Literal
 
 from json_atom._utils import json_equal
 from json_atom.errors import DiffError
+from json_atom.path import _NESTED_PATH_RE
 
 
 @dataclass(frozen=True, slots=True)
@@ -23,20 +24,28 @@ class IdentityResolver:
     The ``property`` name appears in filter paths: ``[?(@.{property}==...)]``.
     The ``resolve`` callable extracts the identity value from an element.
 
+    Supports nested dot paths like ``positionNumber.value`` which resolves
+    via ``elem["positionNumber"]["value"]``.  When a custom resolver is
+    provided, the stored value is validated using the same dot-path
+    semantics for ``property``.
+
     .. important::
 
         The value returned by ``resolve`` **must** match the value actually
-        stored under ``elem[property]`` for that element.  JSON Atom applies
-        keyed-array filters by testing ``elem[property] == literal``, so if
-        the resolver returns a synthetic or composite value that is not
-        literally stored on the element, the generated delta paths will not
-        match during ``apply_delta`` / ``resolve_path``.
+        stored at the ``property`` path on the element.  JSON Atom applies
+        keyed-array filters by resolving the property path, so if the
+        resolver returns a value that doesn't match the stored value, the
+        generated delta paths will not match during ``apply_delta``.
 
     Example::
 
         # Simple key: use the ``id`` field directly
         IdentityResolver("id", lambda e: e["id"])
 
+        # Nested key: use a dot-separated path
+        IdentityResolver("positionNumber.value",
+                         lambda e: e["positionNumber"]["value"])
+
         # Validation: coerce to int, ensuring consistency
         # (only safe when the stored value round-trips through int)
         IdentityResolver("id", lambda e: int(e["id"]))
@@ -125,6 +134,28 @@ def _normalize_identity_value(value: IdentityKey) -> _ResolvedIdentity:
     )
 
 
+_SENTINEL = object()
+
+
+def _resolve_nested(elem: Any, key_property: str) -> Any:
+    """Resolve a possibly-nested dot path on a dict element.
+
+    Returns ``_SENTINEL`` if any segment is missing.
+    For non-nested keys, falls back to a simple dict lookup.
+    """
+    if not isinstance(elem, dict):
+        return _SENTINEL
+    is_nested = "." in key_property and _NESTED_PATH_RE.match(key_property) is not None
+    if not is_nested:
+        return elem.get(key_property, _SENTINEL)
+    current: Any = elem
+    for seg in key_property.split("."):
+        if not isinstance(current, dict) or seg not in current:
+            return _SENTINEL
+        current = current[seg]
+    return current
+
+
 def extract_identity(
     elem: Any,
     key_property: str,
@@ -133,8 +164,11 @@ def extract_identity(
     """Extract the identity value from an array element.
 
     Uses the custom resolver if provided, otherwise reads the key property
-    directly from the element dict.  The returned value must be a JSON scalar
-    (str, int, float, bool, or None) suitable for use in filter paths.
+    directly from the element dict.  Supports nested dot paths like
+    ``positionNumber.value`` → ``elem["positionNumber"]["value"]``.
+
+    The returned value must be a JSON scalar (str, int, float, bool, or None)
+    suitable for use in filter paths.
 
     Raises:
         DiffError: If the element is missing the key property or the resolver
@@ -147,25 +181,25 @@ def extract_identity(
             raise DiffError(
                 f"Identity resolver for '{key_property}' failed on element {elem!r}: {exc}"
             ) from exc
-        # Verify the element is a dict with the key property and that the
-        # stored value matches the resolved value — apply_delta matches
-        # filter paths via elem[key_property] == literal, so a mismatch
-        # would produce unapplyable deltas.
-        if not isinstance(elem, dict) or key_property not in elem:
+        # Verify the element has the key property and that the stored value
+        # matches the resolved value — apply_delta matches filter paths via
+        # the key property, so a mismatch would produce unapplyable deltas.
+        stored = _resolve_nested(elem, key_property)
+        if stored is _SENTINEL:
             raise DiffError(
                 f"Resolver for '{key_property}' returned {value!r} but element "
-                f"is not a dict with '{key_property}': {elem!r}"
+                f"is missing identity path '{key_property}': {elem!r}"
             )
-        stored = elem[key_property]
         if not json_equal(stored, value):
             raise DiffError(
                 f"Resolver for '{key_property}' returned {value!r} but "
-                f"elem['{key_property}'] is {stored!r} — filter path would not match"
+                f"stored value at '{key_property}' is {stored!r} — filter path would not match"
             )
-    elif not isinstance(elem, dict) or key_property not in elem:
-        raise DiffError(f"Array element missing identity key '{key_property}': {elem!r}")
     else:
-        value = elem[key_property]
+        stored = _resolve_nested(elem, key_property)
+        if stored is _SENTINEL:
+            raise DiffError(f"Array element missing identity key '{key_property}': {elem!r}")
+        value = stored
 
     if not isinstance(value, (str, int, float, bool, type(None))):
         raise DiffError(

{json_atom-0.3.0 → json_atom-0.4.1}/src/json_atom/apply.py

@@ -50,6 +50,13 @@ def apply_delta(obj: Any, delta: Delta) -> Any:
 def _apply_operation(obj: Any, op: Operation) -> Any:
     """Apply a single operation and return the (possibly new) root object."""
     op_type = op["op"]
+
+    # Move/copy: two-path operations handled separately
+    if op_type == "move":
+        return _apply_move(obj, op)
+    if op_type == "copy":
+        return _apply_copy(obj, op)
+
     path_str = op["path"]
     segments = parse_path(path_str)
 
@@ -74,6 +81,73 @@ def _apply_operation(obj: Any, op: Operation) -> Any:
     return obj
 
 
+# ---------------------------------------------------------------------------
+# Move / Copy operations (spec Section 6.6, 6.7)
+# ---------------------------------------------------------------------------
+
+
+def _read_value_at_path(obj: Any, path_str: str) -> Any:
+    """Resolve a JSON Atom path to its value in the document."""
+    segments = parse_path(path_str)
+    if not segments:
+        return obj  # root
+    current = obj
+    for seg in segments:
+        if isinstance(seg, PropertySegment):
+            if not isinstance(current, dict) or seg.name not in current:
+                raise ApplyError(f"Property '{seg.name}' not found: {path_str}")
+            current = current[seg.name]
+        elif isinstance(seg, IndexSegment):
+            if not isinstance(current, list) or seg.index >= len(current):
+                raise ApplyError(f"Index {seg.index} out of bounds: {path_str}")
+            current = current[seg.index]
+        elif isinstance(seg, KeyFilterSegment):
+            if not isinstance(current, list):
+                raise ApplyError(f"Cannot apply key filter on {type(current).__name__}: {path_str}")
+            idx = _find_key_filter_match(current, seg, path_str)
+            current = current[idx]
+        elif isinstance(seg, ValueFilterSegment):
+            if not isinstance(current, list):
+                raise ApplyError(f"Cannot apply value filter on {type(current).__name__}: {path_str}")
+            idx = _find_value_filter_match(current, seg, path_str)
+            current = current[idx]
+    return current
+
+
+def _apply_move(obj: Any, op: Operation) -> Any:
+    """Apply a move operation: read from source, remove, add at target."""
+    from_path = op["from"]
+    to_path = op["path"]
+
+    # Read value at source
+    value = _read_value_at_path(obj, from_path)
+
+    # Remove from source
+    remove_op = Operation(op="remove", path=from_path)
+    obj = _apply_operation(obj, remove_op)
+
+    # Add to target — no deepcopy needed, value was removed from source
+    add_op = Operation(op="add", path=to_path, value=value)
+    obj = _apply_operation(obj, add_op)
+
+    return obj
+
+
+def _apply_copy(obj: Any, op: Operation) -> Any:
+    """Apply a copy operation: read from source, deep-clone to target."""
+    from_path = op["from"]
+    to_path = op["path"]
+
+    # Read value at source — add operation handles deep-cloning
+    value = _read_value_at_path(obj, from_path)
+
+    # Add to target
+    add_op = Operation(op="add", path=to_path, value=value)
+    obj = _apply_operation(obj, add_op)
+
+    return obj
+
+
 # ---------------------------------------------------------------------------
 # Root operations (spec Section 6.5)
 # ---------------------------------------------------------------------------

{json_atom-0.3.0 → json_atom-0.4.1}/src/json_atom/invert.py

@@ -18,7 +18,8 @@ def invert_delta(delta: Delta) -> Delta:
 
     The inverse delta, when applied to the target document, recovers the source.
 
-    Requires all ``replace`` and ``remove`` operations to have ``oldValue``.
+    Requires all ``replace`` and ``remove`` operations to have ``oldValue``,
+    and all ``copy`` operations to have ``value``.
     Preserves extension properties at both envelope and operation levels.
 
     Raises InvertError if the delta is not reversible or structurally invalid.
@@ -30,11 +31,13 @@ def invert_delta(delta: Delta) -> Delta:
 
     operations = delta["operations"]
 
-    # Check reversibility: all replace and remove ops must have oldValue
+    # Check reversibility: replace/remove need oldValue, copy needs value
     for i, op in enumerate(operations):
         op_type = op["op"]
         if op_type in ("replace", "remove") and "oldValue" not in op:
             raise InvertError(f"operations[{i}]: '{op_type}' operation missing 'oldValue' (required for inversion)")
+        if op_type == "copy" and "value" not in op:
+            raise InvertError(f"operations[{i}]: 'copy' operation missing 'value' (required for inversion)")
 
     # Build inverted operations in reverse order (spec Section 9.2)
     inverted_ops: list[Operation] = []
@@ -60,6 +63,8 @@ def _invert_operation(op: Operation) -> Operation:
       add(path, value)              -> remove(path, oldValue=value)
       remove(path, oldValue)        -> add(path, value=oldValue)
       replace(path, value, oldValue) -> replace(path, value=oldValue, oldValue=value)
+      move(from, path)              -> move(from=path, path=from)
+      copy(from, path, value)       -> remove(path, oldValue=value)
     """
     op_type = op["op"]
     inverted: dict[str, Any] = {}
@@ -86,6 +91,16 @@ def _invert_operation(op: Operation) -> Operation:
         inverted["value"] = op["oldValue"]
         inverted["oldValue"] = op["value"]
 
+    elif op_type == "move":
+        # move(from, path) -> move(from=path, path=from)
+        inverted["from"] = op["path"]
+        inverted["path"] = op["from"]
+
+    elif op_type == "copy":
+        # copy(from, path, value) -> remove(path, oldValue=value)
+        inverted["op"] = "remove"
+        inverted["oldValue"] = op["value"]
+
     return Operation(inverted)
 
 
@@ -95,7 +110,9 @@ def _inverted_op_type(op_type: str) -> str:
         return "remove"
     if op_type == "remove":
         return "add"
-    return op_type  # replace stays replace
+    if op_type == "copy":
+        return "remove"
+    return op_type  # replace and move stay the same
 
 
 def revert_delta(obj: Any, delta: Delta) -> Any:

{json_atom-0.3.0 → json_atom-0.4.1}/src/json_atom/models.py

@@ -209,10 +209,10 @@ class ComparisonNode:
 # ---------------------------------------------------------------------------
 
 # Fields defined by the spec — everything else is an extension (Section 11)
-_OP_SPEC_KEYS = frozenset({"op", "path", "value", "oldValue"})
+_OP_SPEC_KEYS = frozenset({"op", "path", "from", "value", "oldValue"})
 _DELTA_SPEC_KEYS = frozenset({"format", "version", "operations"})
 
-type OpType = Literal["add", "remove", "replace"]
+type OpType = Literal["add", "remove", "replace", "move", "copy"]
 
 
 class Operation(dict[str, Any]):
@@ -276,9 +276,44 @@ class Operation(dict[str, Any]):
             op["oldValue"] = old_value
         return op
 
+    _MISSING: Any = object()
+
+    @classmethod
+    def move(cls, from_path: str, path: str, **extensions: Any) -> Operation:
+        """Create a ``move`` operation.
+
+        Args:
+            from_path: Source JSON Atom path.
+            path: Target JSON Atom path.
+            **extensions: Extension properties (``x_*`` keys).
+        """
+        return cls(op="move", path=path, **{"from": from_path, **extensions})
+
+    @classmethod
+    def copy_op(cls, from_path: str, path: str, *, value: Any = _MISSING, **extensions: Any) -> Operation:
+        """Create a ``copy`` operation.
+
+        Named ``copy_op`` to avoid conflict with ``dict.copy()``.
+
+        Args:
+            from_path: Source JSON Atom path.
+            path: Target JSON Atom path.
+            value: The copied value (optional, for reversibility).
+            **extensions: Extension properties (``x_*`` keys).
+        """
+        op = cls(op="copy", path=path, **{"from": from_path, **extensions})
+        if value is not cls._MISSING:
+            op["value"] = value
+        return op
+
+    @property
+    def from_path(self) -> str | None:
+        """The source path for ``move`` and ``copy`` operations."""
+        return self.get("from")
+
     @property
     def op(self) -> OpType:
-        """The operation type: ``"add"``, ``"remove"``, or ``"replace"``."""
+        """The operation type."""
         return self["op"]  # type: ignore[no-any-return]
 
     @property
@@ -588,8 +623,10 @@ class Delta(dict[str, Any]):
 
     @property
     def is_reversible(self) -> bool:
-        """``True`` if all ``replace`` and ``remove`` operations include ``oldValue``."""
-        return all("oldValue" in op for op in self.operations if op.op in ("replace", "remove"))
+        """``True`` if all ``replace``/``remove`` include ``oldValue`` and all ``copy`` include ``value``."""
+        return all(
+            "oldValue" in op for op in self.operations if op.op in ("replace", "remove")
+        ) and all("value" in op for op in self.operations if op.op == "copy")
 
     @property
     def is_empty(self) -> bool:

{json_atom-0.3.0 → json_atom-0.4.1}/src/json_atom/validate.py

@@ -13,7 +13,7 @@ from json_atom.models import ValidationResult
 _ENVELOPE_REQUIRED = {"format", "version", "operations"}
 
 # Known operation types
-_VALID_OPS = {"add", "remove", "replace"}
+_VALID_OPS = {"add", "remove", "replace", "move", "copy"}
 
 
 def validate_delta(delta: Any) -> ValidationResult:
@@ -69,7 +69,7 @@ def _validate_operation(op: Any, index: int, errors: list[str]) -> None:
     if "op" not in op:
         errors.append(f"{prefix}: missing required field 'op'")
     elif op["op"] not in _VALID_OPS:
-        errors.append(f"{prefix}: invalid op {op['op']!r}, must be one of: add, remove, replace")
+        errors.append(f"{prefix}: invalid op {op['op']!r}, must be one of: {', '.join(sorted(_VALID_OPS))}")
 
     # Required: path
     if "path" not in op:
@@ -95,3 +95,40 @@ def _validate_operation(op: Any, index: int, errors: list[str]) -> None:
         if "value" not in op:
             errors.append(f"{prefix}: 'replace' operation requires 'value'")
         # Note: oldValue is OPTIONAL on replace per spec
+
+    elif op_type == "move":
+        if "from" not in op:
+            errors.append(f"{prefix}: 'move' operation requires 'from'")
+        elif not isinstance(op["from"], str):
+            errors.append(f"{prefix}: 'from' must be a string")
+        if "value" in op:
+            errors.append(f"{prefix}: 'move' operation must not include 'value'")
+        if "oldValue" in op:
+            errors.append(f"{prefix}: 'move' operation must not include 'oldValue'")
+        # Self-move prevention
+        from_path = op.get("from")
+        to_path = op.get("path")
+        if isinstance(from_path, str) and isinstance(to_path, str):
+            if from_path == to_path:
+                errors.append(f"{prefix}: 'move' 'from' must differ from 'path'")
+            elif _is_path_prefix(from_path, to_path):
+                errors.append(f"{prefix}: 'move' cannot move a value into its own subtree")
+
+    elif op_type == "copy":
+        if "from" not in op:
+            errors.append(f"{prefix}: 'copy' operation requires 'from'")
+        elif not isinstance(op["from"], str):
+            errors.append(f"{prefix}: 'from' must be a string")
+        if "oldValue" in op:
+            errors.append(f"{prefix}: 'copy' operation must not include 'oldValue'")
+        # Note: value is OPTIONAL on copy (for reversibility)
+
+
+def _is_path_prefix(from_path: str, target_path: str) -> bool:
+    """Check if target_path is a descendant of from_path.
+
+    Root path ('$') is excluded — moving from root to a descendant is valid.
+    """
+    if from_path == "$":
+        return False
+    return target_path.startswith(from_path + ".") or target_path.startswith(from_path + "[")

{json_atom-0.3.0 → json_atom-0.4.1}/tests/test_diff.py

@@ -595,6 +595,175 @@ class TestCallableIdentityKeys:
             )
 
 
+class TestNestedPathIdentityKeys:
+    """Nested dot-path identity keys (e.g. positionNumber.value → @.positionNumber.value)."""
+
+    def test_nested_path_string_key(self) -> None:
+        """String key with dots resolves nested path."""
+        old = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "beta"},
+        ]}
+        new = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={"items": "positionNumber.value"})
+        remove_ops = [op for op in delta.operations if op.op == "remove"]
+        assert len(remove_ops) == 1
+        assert remove_ops[0].path == "$.items[?(@.positionNumber.value=='002')]"
+
+    def test_nested_path_resolver(self) -> None:
+        """IdentityResolver with nested path produces dot notation."""
+        old = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "beta"},
+        ]}
+        new = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "003"}, "description": "gamma"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": IdentityResolver(
+                "positionNumber.value",
+                lambda e: e["positionNumber"]["value"],
+            ),
+        })
+        assert len(delta.operations) == 2
+        removes = [op for op in delta.operations if op.op == "remove"]
+        adds = [op for op in delta.operations if op.op == "add"]
+        assert len(removes) == 1
+        assert removes[0].path == "$.items[?(@.positionNumber.value=='002')]"
+        assert len(adds) == 1
+        assert adds[0].path == "$.items[?(@.positionNumber.value=='003')]"
+
+    def test_nested_path_update_within_element(self) -> None:
+        """Update a property inside an element with nested identity path."""
+        old = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "beta"},
+        ]}
+        new = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "updated"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": "positionNumber.value",
+        })
+        assert len(delta.operations) == 1
+        assert delta.operations[0].op == "replace"
+        assert delta.operations[0].path == "$.items[?(@.positionNumber.value=='002')].description"
+        assert delta.operations[0]["value"] == "updated"
+
+    def test_nested_path_roundtrip(self) -> None:
+        """Nested path identity produces deltas that round-trip."""
+        old = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "beta"},
+        ]}
+        new = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "003"}, "description": "gamma"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": "positionNumber.value",
+        })
+        result = apply_delta(deep_clone(old), delta)
+        assert result == new
+
+    def test_nested_path_invert_roundtrip(self) -> None:
+        """Invert + apply round-trip with nested identity paths."""
+        old = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "beta"},
+        ]}
+        new = {"items": [
+            {"positionNumber": {"value": "001"}, "description": "alpha"},
+            {"positionNumber": {"value": "002"}, "description": "updated"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": "positionNumber.value",
+        })
+        applied = apply_delta(deep_clone(old), delta)
+        assert applied == new
+        inverted = invert_delta(delta)
+        reverted = apply_delta(deep_clone(applied), inverted)
+        assert reverted == old
+
+    def test_nested_path_3_levels(self) -> None:
+        """3-level nested identity path (a.b.c)."""
+        old = {"items": [
+            {"meta": {"org": {"id": "X"}}, "val": 10},
+            {"meta": {"org": {"id": "Y"}}, "val": 20},
+        ]}
+        new = {"items": [
+            {"meta": {"org": {"id": "X"}}, "val": 10},
+            {"meta": {"org": {"id": "Y"}}, "val": 30},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": IdentityResolver("meta.org.id", lambda e: e["meta"]["org"]["id"]),
+        })
+        assert len(delta.operations) == 1
+        assert delta.operations[0].path == "$.items[?(@.meta.org.id=='Y')].val"
+        result = apply_delta(deep_clone(old), delta)
+        assert result == new
+        reverted = apply_delta(deep_clone(result), invert_delta(delta))
+        assert reverted == old
+
+    def test_nested_path_numeric_value(self) -> None:
+        """Nested identity path with numeric value."""
+        old = {"items": [
+            {"code": {"num": 1}, "name": "Widget"},
+            {"code": {"num": 2}, "name": "Gadget"},
+        ]}
+        new = {"items": [
+            {"code": {"num": 1}, "name": "Widget"},
+            {"code": {"num": 2}, "name": "Updated"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": IdentityResolver("code.num", lambda e: e["code"]["num"]),
+        })
+        assert len(delta.operations) == 1
+        assert delta.operations[0].path == "$.items[?(@.code.num==2)].name"
+        result = apply_delta(deep_clone(old), delta)
+        assert result == new
+
+    def test_nested_path_boolean_value(self) -> None:
+        """Nested identity path with boolean value."""
+        old = {"items": [
+            {"config": {"active": True}, "label": "on"},
+            {"config": {"active": False}, "label": "off"},
+        ]}
+        new = {"items": [
+            {"config": {"active": True}, "label": "on"},
+            {"config": {"active": False}, "label": "disabled"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": IdentityResolver("config.active", lambda e: e["config"]["active"]),
+        })
+        assert len(delta.operations) == 1
+        assert delta.operations[0].path == "$.items[?(@.config.active==false)].label"
+        result = apply_delta(deep_clone(old), delta)
+        assert result == new
+
+    def test_nested_path_null_value(self) -> None:
+        """Nested identity path with null value."""
+        old = {"items": [
+            {"status": {"code": None}, "label": "pending"},
+            {"status": {"code": "OK"}, "label": "done"},
+        ]}
+        new = {"items": [
+            {"status": {"code": None}, "label": "waiting"},
+            {"status": {"code": "OK"}, "label": "done"},
+        ]}
+        delta = diff_delta(old, new, array_identity_keys={
+            "items": IdentityResolver("status.code", lambda e: e["status"]["code"]),
+        })
+        assert len(delta.operations) == 1
+        assert delta.operations[0].path == "$.items[?(@.status.code==null)].label"
+        result = apply_delta(deep_clone(old), delta)
+        assert result == new
+
+
 # ---------------------------------------------------------------------------
 # Regex-based array key routing
 # ---------------------------------------------------------------------------

json_atom-0.4.1/tests/test_move_copy.py

@@ -0,0 +1,363 @@
+"""Tests for move and copy operations."""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+import pytest
+
+from json_atom.apply import apply_delta
+from json_atom.errors import ApplyError, InvertError
+from json_atom.invert import invert_delta, revert_delta
+from json_atom.models import Delta, Operation
+from json_atom.validate import validate_delta
+
+
+def _delta(*ops: Operation | dict[str, Any], **ext: Any) -> Delta:
+    return Delta.create(*ops, **ext)
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+
+
+class TestValidation:
+    def test_valid_move(self) -> None:
+        d = _delta(Operation.move("$.a", "$.b"))
+        assert validate_delta(d).valid
+
+    def test_valid_copy(self) -> None:
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        assert validate_delta(d).valid
+
+    def test_valid_copy_with_value(self) -> None:
+        d = _delta(Operation.copy_op("$.a", "$.b", value=42))
+        assert validate_delta(d).valid
+
+    def test_move_requires_from(self) -> None:
+        d = _delta({"op": "move", "path": "$.b"})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("requires 'from'" in e for e in r.errors)
+
+    def test_copy_requires_from(self) -> None:
+        d = _delta({"op": "copy", "path": "$.b"})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("requires 'from'" in e for e in r.errors)
+
+    def test_move_rejects_value(self) -> None:
+        d = _delta({"op": "move", "from": "$.a", "path": "$.b", "value": 1})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("must not include 'value'" in e for e in r.errors)
+
+    def test_move_rejects_old_value(self) -> None:
+        d = _delta({"op": "move", "from": "$.a", "path": "$.b", "oldValue": 1})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("must not include 'oldValue'" in e for e in r.errors)
+
+    def test_copy_rejects_old_value(self) -> None:
+        d = _delta({"op": "copy", "from": "$.a", "path": "$.b", "oldValue": 1})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("must not include 'oldValue'" in e for e in r.errors)
+
+    def test_move_rejects_self_move(self) -> None:
+        d = _delta({"op": "move", "from": "$.a", "path": "$.a"})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("must differ" in e for e in r.errors)
+
+    def test_move_rejects_subtree_move(self) -> None:
+        d = _delta({"op": "move", "from": "$.a", "path": "$.a.b"})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("subtree" in e for e in r.errors)
+
+    def test_move_allows_ancestor_target(self) -> None:
+        """Moving from subtree to ancestor is valid (not self-move)."""
+        d = _delta({"op": "move", "from": "$.a.b", "path": "$.c"})
+        assert validate_delta(d).valid
+
+    def test_move_rejects_non_string_from(self) -> None:
+        d = _delta({"op": "move", "from": 42, "path": "$.b"})
+        r = validate_delta(d)
+        assert not r.valid
+        assert any("must be a string" in e for e in r.errors)
+
+    def test_mixed_ops_validate(self) -> None:
+        d = _delta(
+            Operation.replace("$.x", "new", old_value="old"),
+            Operation.move("$.a", "$.b"),
+            Operation.copy_op("$.c", "$.d"),
+            Operation.add("$.e", 1),
+        )
+        assert validate_delta(d).valid
+
+
+# ---------------------------------------------------------------------------
+# Apply — Move
+# ---------------------------------------------------------------------------
+
+
+class TestApplyMove:
+    def test_move_object_property(self) -> None:
+        obj = {"a": 1, "b": 2}
+        d = _delta(Operation.move("$.a", "$.c"))
+        result = apply_delta(obj, d)
+        assert result == {"b": 2, "c": 1}
+
+    def test_move_nested_property(self) -> None:
+        obj = {"user": {"name": "Alice", "role": "admin"}}
+        d = _delta(Operation.move("$.user.name", "$.user.displayName"))
+        result = apply_delta(obj, d)
+        assert result == {"user": {"displayName": "Alice", "role": "admin"}}
+
+    def test_move_array_element_by_index(self) -> None:
+        obj = {"arr": [10, 20, 30]}
+        # Remove index 0 (10), then add at index 2 — but after removal arr is [20,30]
+        # so index 2 appends: [20, 30, 10]
+        d = _delta(Operation.move("$.arr[0]", "$.arr[2]"))
+        result = apply_delta(obj, d)
+        assert result == {"arr": [20, 30, 10]}
+
+    def test_move_keyed_array_element(self) -> None:
+        obj = {
+            "items": [{"id": 1, "v": "a"}, {"id": 2, "v": "b"}],
+            "archive": [],
+        }
+        d = _delta(Operation.move("$.items[?(@.id==2)]", "$.archive[?(@.id==2)]"))
+        result = apply_delta(obj, d)
+        assert result == {
+            "items": [{"id": 1, "v": "a"}],
+            "archive": [{"id": 2, "v": "b"}],
+        }
+
+    def test_move_from_root(self) -> None:
+        obj = {"data": "hello"}
+        d = _delta(Operation.move("$.data", "$.backup"))
+        result = apply_delta(obj, d)
+        assert result == {"backup": "hello"}
+
+    def test_move_complex_object(self) -> None:
+        obj = {"a": {"nested": {"deep": [1, 2, 3]}}, "b": {}}
+        d = _delta(Operation.move("$.a.nested", "$.b.nested"))
+        result = apply_delta(obj, d)
+        assert result == {"a": {}, "b": {"nested": {"deep": [1, 2, 3]}}}
+
+    def test_move_error_nonexistent_source(self) -> None:
+        obj = {"a": 1}
+        d = _delta(Operation.move("$.missing", "$.b"))
+        with pytest.raises(ApplyError):
+            apply_delta(obj, d)
+
+    def test_move_error_existing_target(self) -> None:
+        obj = {"a": 1, "b": 2}
+        d = _delta(Operation.move("$.a", "$.b"))
+        with pytest.raises(ApplyError):
+            apply_delta(obj, d)
+
+
+# ---------------------------------------------------------------------------
+# Apply — Copy
+# ---------------------------------------------------------------------------
+
+
+class TestApplyCopy:
+    def test_copy_object_property(self) -> None:
+        obj = {"a": 1}
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        result = apply_delta(obj, d)
+        assert result == {"a": 1, "b": 1}
+
+    def test_copy_preserves_source(self) -> None:
+        obj = {"a": {"nested": 1}}
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        result = apply_delta(obj, d)
+        assert result["a"] == {"nested": 1}
+        assert result["b"] == {"nested": 1}
+
+    def test_copy_deep_clones(self) -> None:
+        obj = {"a": {"nested": [1, 2]}}
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        result = apply_delta(obj, d)
+        # Mutate the copy — source should be unchanged
+        result["b"]["nested"].append(3)
+        assert result["a"]["nested"] == [1, 2]
+        assert result["b"]["nested"] == [1, 2, 3]
+
+    def test_copy_from_root(self) -> None:
+        obj = {"x": 1}
+        d = _delta(Operation.copy_op("$", "$.snapshot"))
+        result = apply_delta(obj, d)
+        assert result == {"x": 1, "snapshot": {"x": 1}}
+
+    def test_copy_array_element(self) -> None:
+        obj = {"arr": [10, 20], "other": []}
+        d = _delta(Operation.copy_op("$.arr[0]", "$.other[0]"))
+        result = apply_delta(obj, d)
+        assert result == {"arr": [10, 20], "other": [10]}
+
+    def test_copy_error_nonexistent_source(self) -> None:
+        obj = {"a": 1}
+        d = _delta(Operation.copy_op("$.missing", "$.b"))
+        with pytest.raises(ApplyError):
+            apply_delta(obj, d)
+
+    def test_copy_error_existing_target(self) -> None:
+        obj = {"a": 1, "b": 2}
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        with pytest.raises(ApplyError):
+            apply_delta(obj, d)
+
+
+# ---------------------------------------------------------------------------
+# Inversion
+# ---------------------------------------------------------------------------
+
+
+class TestInversion:
+    def test_move_inversion_swaps_paths(self) -> None:
+        d = _delta(Operation.move("$.a", "$.b"))
+        inv = invert_delta(d)
+        assert inv.operations[0]["op"] == "move"
+        assert inv.operations[0]["from"] == "$.b"
+        assert inv.operations[0]["path"] == "$.a"
+
+    def test_move_round_trip(self) -> None:
+        obj = {"a": 1, "b": 2}
+        d = _delta(Operation.move("$.a", "$.c"))
+        target = apply_delta(copy.deepcopy(obj), d)
+        assert target == {"b": 2, "c": 1}
+        restored = revert_delta(target, d)
+        assert restored == obj
+
+    def test_copy_inversion_produces_remove(self) -> None:
+        d = _delta(Operation.copy_op("$.a", "$.b", value=42))
+        inv = invert_delta(d)
+        assert inv.operations[0]["op"] == "remove"
+        assert inv.operations[0]["path"] == "$.b"
+        assert inv.operations[0]["oldValue"] == 42
+
+    def test_copy_round_trip(self) -> None:
+        obj = {"a": 42}
+        d = _delta(Operation.copy_op("$.a", "$.b", value=42))
+        target = apply_delta(copy.deepcopy(obj), d)
+        assert target == {"a": 42, "b": 42}
+        restored = revert_delta(target, d)
+        assert restored == obj
+
+    def test_copy_without_value_raises(self) -> None:
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        with pytest.raises(InvertError, match="missing 'value'"):
+            invert_delta(d)
+
+    def test_extension_preserved(self) -> None:
+        d = _delta({"op": "move", "from": "$.a", "path": "$.b", "x_tag": "test"})
+        inv = invert_delta(d)
+        assert inv.operations[0].get("x_tag") == "test"
+
+    def test_multi_op_inversion_order(self) -> None:
+        d = _delta(
+            Operation.move("$.a", "$.b"),
+            Operation.copy_op("$.c", "$.d", value=1),
+        )
+        inv = invert_delta(d)
+        # Order reversed
+        assert inv.operations[0]["op"] == "remove"  # inverted copy
+        assert inv.operations[0]["path"] == "$.d"
+        assert inv.operations[1]["op"] == "move"  # inverted move
+        assert inv.operations[1]["from"] == "$.b"
+
+
+# ---------------------------------------------------------------------------
+# Sequential semantics
+# ---------------------------------------------------------------------------
+
+
+class TestSequentialSemantics:
+    def test_move_then_operate_on_moved(self) -> None:
+        obj = {"a": {"v": 1}, "b": {}}
+        d = _delta(
+            Operation.move("$.a", "$.c"),
+            Operation.replace("$.c.v", 2, old_value=1),
+        )
+        result = apply_delta(obj, d)
+        assert result == {"b": {}, "c": {"v": 2}}
+
+    def test_copy_then_modify_copy(self) -> None:
+        obj = {"a": {"v": 1}}
+        d = _delta(
+            Operation.copy_op("$.a", "$.b"),
+            Operation.replace("$.b.v", 99, old_value=1),
+        )
+        result = apply_delta(obj, d)
+        assert result == {"a": {"v": 1}, "b": {"v": 99}}
+
+    def test_multiple_moves(self) -> None:
+        obj = {"a": 1, "b": 2, "c": 3}
+        d = _delta(
+            Operation.move("$.a", "$.x"),
+            Operation.move("$.b", "$.y"),
+        )
+        result = apply_delta(obj, d)
+        assert result == {"c": 3, "x": 1, "y": 2}
+
+    def test_mixed_ops(self) -> None:
+        obj = {"a": 1, "b": 2}
+        d = _delta(
+            Operation.copy_op("$.a", "$.c"),
+            Operation.move("$.b", "$.d"),
+            Operation.add("$.e", 5),
+        )
+        result = apply_delta(obj, d)
+        assert result == {"a": 1, "c": 1, "d": 2, "e": 5}
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestEdgeCases:
+    def test_move_null_value(self) -> None:
+        obj = {"a": None, "b": 1}
+        d = _delta(Operation.move("$.a", "$.c"))
+        result = apply_delta(obj, d)
+        assert result == {"b": 1, "c": None}
+
+    def test_copy_null_value(self) -> None:
+        obj = {"a": None}
+        d = _delta(Operation.copy_op("$.a", "$.b"))
+        result = apply_delta(obj, d)
+        assert result == {"a": None, "b": None}
+
+    def test_move_empty_object(self) -> None:
+        obj = {"a": {}, "b": 1}
+        d = _delta(Operation.move("$.a", "$.c"))
+        result = apply_delta(obj, d)
+        assert result == {"b": 1, "c": {}}
+
+    def test_move_empty_array(self) -> None:
+        obj = {"a": [], "b": 1}
+        d = _delta(Operation.move("$.a", "$.c"))
+        result = apply_delta(obj, d)
+        assert result == {"b": 1, "c": []}
+
+    def test_copy_with_value_matches_actual(self) -> None:
+        """The optional value field on copy should match what's actually copied."""
+        obj = {"a": 42}
+        d = _delta(Operation.copy_op("$.a", "$.b", value=42))
+        result = apply_delta(obj, d)
+        # Apply ignores value, reads from source
+        assert result == {"a": 42, "b": 42}
+
+    def test_move_boolean_value(self) -> None:
+        obj = {"a": False, "b": 1}
+        d = _delta(Operation.move("$.a", "$.c"))
+        result = apply_delta(obj, d)
+        assert result == {"b": 1, "c": False}