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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json-atom
-Version: 0.4.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.4.0 → json_atom-0.4.1}/pyproject.toml

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

{json_atom-0.4.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.4.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
 # ---------------------------------------------------------------------------