Fix re-index of sparse array selections

Author: jg-rp

docs/query.md

@@ -82,7 +82,7 @@ for value in it.values():
 
 ## Tee
 
-And finally there's `tee()`, which creates multiple independent queries from one query iterator. It is not safe to use the initial `Query` instance after calling `tee()`.
+[`tee()`](api.md#jsonpath.Query.tee) creates multiple independent queries from one query iterator. It is not safe to use the initial `Query` instance after calling `tee()`.
 
 ```python
 from jsonpath import query
@@ -92,3 +92,130 @@ it1, it2 = query("$.some[[email protected]]", data).tee()
 head = it1.head(10) # first 10 matches
 tail = it2.tail(10) # last 10 matches
 ```
+
+## Select
+
+[`select(*expressions, projection=Projection.RELATIVE)`](api.md/#jsonpath.Query.select) performs JSONPath match projection, selecting a subset of values according to one or more JSONPath query expressions relative to the match location. For example:
+
+```python
+from jsonpath import query
+
+data = {
+    "categories": [
+        {
+            "name": "footwear",
+            "products": [
+                {
+                    "title": "Trainers",
+                    "description": "Fashionable trainers.",
+                    "price": 89.99,
+                },
+                {
+                    "title": "Barefoot Trainers",
+                    "description": "Running trainers.",
+                    "price": 130.00,
+                    "social": {"likes": 12, "shares": 7},
+                },
+            ],
+        },
+        {
+            "name": "headwear",
+            "products": [
+                {
+                    "title": "Cap",
+                    "description": "Baseball cap",
+                    "price": 15.00,
+                },
+                {
+                    "title": "Beanie",
+                    "description": "Winter running hat.",
+                    "price": 9.00,
+                },
+            ],
+        },
+    ],
+    "price_cap": 10,
+}
+
+for product in query("$..products.*", data).select("title", "price"):
+    print(product)
+```
+
+Which selects just the `title` and `price` fields for each product.
+
+```text
+{'title': 'Trainers', 'price': 89.99}
+{'title': 'Barefoot Trainers', 'price': 130.0}
+{'title': 'Cap', 'price': 15.0}
+{'title': 'Beanie', 'price': 9.0}
+```
+
+Without the call to `select()`, we'd get all fields in each product object.
+
+```python
+# ...
+
+for product in query("$..products.*", data).values():
+    print(product)
+```
+
+```text
+{'title': 'Trainers', 'description': 'Fashionable trainers.', 'price': 89.99}
+{'title': 'Barefoot Trainers', 'description': 'Running trainers.', 'price': 130.0, 'social': {'likes': 12, 'shares': 7}}
+{'title': 'Cap', 'description': 'Baseball cap', 'price': 15.0}
+{'title': 'Beanie', 'description': 'Winter running hat.', 'price': 9.0}
+```
+
+We can select nested values too.
+
+```python
+# ...
+
+for product in query("$..products.*", data).select("title", "social.shares"):
+    print(product)
+```
+
+```text
+{'title': 'Trainers'}
+{'title': 'Barefoot Trainers', 'social': {'shares': 7}}
+{'title': 'Cap'}
+{'title': 'Beanie'}
+```
+
+And flatten the selection into a sequence of values.
+
+```python
+from jsonpath import Projection
+
+# ...
+
+for product in query("$..products.*", data).select(
+    "title", "social.shares", projection=Projection.FLAT
+):
+    print(product)
+```
+
+```text
+['Trainers']
+['Barefoot Trainers', 7]
+['Cap']
+['Beanie']
+```
+
+Or project the selection from the JSON value root.
+
+```python
+# ..
+
+for product in query("$..products[[email protected]]", data).select(
+    "title",
+    "social.shares",
+    projection=Projection.ROOT,
+):
+    print(product)
+
+```
+
+```text
+{'categories': [{'products': [{'title': 'Barefoot Trainers', 'social': {'shares': 7}}]}]}
+```

jsonpath/fluent_api.py

@@ -185,6 +185,8 @@ def _select(
         expressions: Tuple[str, ...],
         projection: Projection,
     ) -> object:
+        if isinstance(match.obj, str):
+            return None
         if isinstance(match.obj, Sequence) or projection == Projection.FLAT:
             obj: Union[List[Any], Dict[str, Any]] = []
         elif isinstance(match.obj, Mapping):
@@ -197,7 +199,7 @@ def _select(
         for expr in expressions:
             self._patch(match, expr, patch, projection)
 
-        return patch.apply(obj)
+        return _sparse_values(patch.apply(obj))
 
     def _patch(
         self,
@@ -217,13 +219,11 @@ def _patch(
                     str(p).replace("~", "~0").replace("/", "~1")
                     for p in rel_match.parts
                 )
-                pointer = root_pointer / rel_pointer
-                _patch_parents(pointer.parent(), patch, match.obj)  # type: ignore
+                pointer = _patch_parents(root_pointer / rel_pointer, patch, match.root)  # type: ignore
                 patch.addap(pointer, rel_match.obj)
             else:
                 # Natural projection
-                pointer = rel_match.pointer()
-                _patch_parents(pointer.parent(), patch, match.obj)  # type: ignore
+                pointer = _patch_parents(rel_match.pointer(), patch, match.obj)  # type: ignore
                 patch.addap(pointer, rel_match.obj)
 
     def first_one(self) -> Optional[JSONPathMatch]:
@@ -266,17 +266,40 @@ def _patch_parents(
     pointer: JSONPointer,
     patch: JSONPatch,
     obj: Union[Sequence[Any], Mapping[str, Any]],
-) -> None:
-    if pointer.parent().parts:
-        _patch_parents(pointer.parent(), patch, obj)
-
-    try:
-        _obj = pointer.resolve(obj)
-    except JSONPointerKeyError:
-        _obj = obj
-
-    if pointer.parts:
-        if isinstance(_obj, Sequence):
-            patch.addne(pointer, [])
-        elif isinstance(_obj, Mapping):
-            patch.addne(pointer, {})
+) -> JSONPointer:
+    parent = pointer.parent()
+    if parent.parent().parts:
+        _patch_parents(parent, patch, obj)
+
+    if parent.parts:
+        try:
+            _obj = parent.resolve(obj)
+        except JSONPointerKeyError:
+            _obj = obj
+
+        # For lack of a better solution, we're patching arrays to dictionaries with
+        # integer keys. This is to handle sparse array selections without having to
+        # keep track of indexes and how they map from the root JSON value to the
+        # selected JSON value.
+        #
+        # We'll fix these "sparse arrays" after the patch has been applied.
+        if isinstance(_obj, (Sequence, Mapping)) and not isinstance(_obj, str):
+            patch.addne(parent, {})
+
+    return pointer
+
+
+def _sparse_values(obj: Any) -> object:
+    """Fix sparse arrays (dictionaries with integer keys)."""
+    if isinstance(obj, str) or not obj:
+        return obj
+
+    if isinstance(obj, Sequence):
+        return [_sparse_values(e) for e in obj]
+
+    if isinstance(obj, Mapping):
+        if isinstance(next(iter(obj)), int):
+            return [_sparse_values(v) for v in obj.values()]
+        return {k: _sparse_values(v) for k, v in obj.items()}
+
+    return obj

jsonpath/patch.py

@@ -112,10 +112,7 @@ def apply(
         target = self.path.parts[-1]
         if isinstance(parent, MutableSequence):
             if obj is UNDEFINED:
-                if target == "-":
-                    parent.append(self.value)
-                else:
-                    raise JSONPatchError("index out of range")
+                parent.append(self.value)
             else:
                 parent.insert(int(target), self.value)
         elif isinstance(parent, MutableMapping) and target not in parent:
@@ -669,6 +666,7 @@ def apply(
                 raise JSONPatchError(f"{err} ({op.name}:{i})") from err
             except (JSONPointerError, JSONPatchError) as err:
                 raise JSONPatchError(f"{err} ({op.name}:{i})") from err
+
         return _data
 
     def asdicts(self) -> List[Dict[str, object]]:

jsonpath/pointer.py

@@ -1,4 +1,5 @@
 """JSON Pointer. See https://datatracker.ietf.org/doc/html/rfc6901."""
+
 from __future__ import annotations
 
 import codecs
@@ -326,6 +327,9 @@ def is_relative_to(self, other: JSONPointer) -> bool:
     def __eq__(self, other: object) -> bool:
         return isinstance(other, JSONPointer) and self.parts == other.parts
 
+    def __hash__(self) -> int:
+        return hash(self.parts)
+
     def __repr__(self) -> str:
         return f"JSONPointer({self._s!r})"