Implement the singular query selector

jg-rp · jg-rp · commit 9a1886eef9a9 · 2025-08-15T12:24:08.000+01:00
diff --git a/jsonpath/selectors.py b/jsonpath/selectors.py
@@ -16,6 +16,7 @@
 
 from .exceptions import JSONPathIndexError
 from .exceptions import JSONPathTypeError
+from .match import NodeList
 from .serialize import canonical_string
 
 if TYPE_CHECKING:
@@ -94,15 +95,7 @@ async def resolve_async(self, node: JSONPathMatch) -> AsyncIterable[JSONPathMatc
 
 
 class IndexSelector(JSONPathSelector):
-    """Select an element from an array by index.
-
-    XXX: Change to make unquoted keys/properties a "singular path selector"
-    https://github.com/ietf-wg-jsonpath/draft-ietf-jsonpath-base/issues/522
-
-    Considering we don't require mapping (JSON object) keys/properties to
-    be quoted, and that we support mappings with numeric keys, we also check
-    to see if the "index" is a mapping key, which is non-standard.
-    """
+    """Select an element from an array by index."""
 
     __slots__ = ("index", "_as_key")
 
@@ -404,12 +397,87 @@ def __hash__(self) -> int:
         return hash((self.query, self.token))
 
     def resolve(self, node: JSONPathMatch) -> Iterable[JSONPathMatch]:
-        # TODO:
-        raise Exception("not implemented")
+        if isinstance(node.obj, Mapping):
+            nodes = NodeList(self.query.finditer(node.root))
+
+            if nodes.empty():
+                return
+
+            value = nodes[0].value
+
+            if not isinstance(value, str):
+                return
+
+            with suppress(KeyError):
+                match = node.new_child(self.env.getitem(node.obj, value), value)
+                node.add_child(match)
+                yield match
+
+        if isinstance(node.obj, Sequence):
+            nodes = NodeList(self.query.finditer(node.root))
+
+            if nodes.empty():
+                return
+
+            value = nodes[0].value
+
+            if not isinstance(value, int):
+                return
+
+            index = self._normalized_index(node.obj, value)
+
+            with suppress(IndexError):
+                match = node.new_child(self.env.getitem(node.obj, index), index)
+                node.add_child(match)
+                yield match
 
     async def resolve_async(self, node: JSONPathMatch) -> AsyncIterable[JSONPathMatch]:
-        # TODO:
-        raise Exception("not implemented")
+        if isinstance(node.obj, Mapping):
+            nodes = NodeList(
+                [match async for match in await self.query.finditer_async(node.root)]
+            )
+
+            if nodes.empty():
+                return
+
+            value = nodes[0].value
+
+            if not isinstance(value, str):
+                return
+
+            with suppress(KeyError):
+                match = node.new_child(
+                    await self.env.getitem_async(node.obj, value), value
+                )
+                node.add_child(match)
+                yield match
+
+        if isinstance(node.obj, Sequence):
+            nodes = NodeList(
+                [match async for match in await self.query.finditer_async(node.root)]
+            )
+
+            if nodes.empty():
+                return
+
+            value = nodes[0].value
+
+            if not isinstance(value, int):
+                return
+
+            index = self._normalized_index(node.obj, value)
+
+            with suppress(IndexError):
+                match = node.new_child(
+                    await self.env.getitem_async(node.obj, index), index
+                )
+                node.add_child(match)
+                yield match
+
+    def _normalized_index(self, obj: Sequence[object], index: int) -> int:
+        if index < 0 and len(obj) >= abs(index):
+            return len(obj) + index
+        return index
 
 
 class Filter(JSONPathSelector):
diff --git a/tests/test_errors.py b/tests/test_errors.py
@@ -44,6 +44,11 @@ def test_root_dot(env: JSONPathEnvironment) -> None:
         env.compile("$.")
 
 
+def test_embedded_query_is_not_singular(env: JSONPathEnvironment) -> None:
+    with pytest.raises(JSONPathSyntaxError):
+        env.compile("$.a[$.*]")
+
+
 class FilterLiteralTestCase(NamedTuple):
     description: str
     query: str
diff --git a/tests/test_find_extra.py b/tests/test_find_extra.py
@@ -111,6 +111,46 @@ class Case:
         data={"some": {"other": "foo", "thing": "bar", "else": {"other": "baz"}}},
         want=[],
     ),
+    Case(
+        description="object name from embedded singular query resolving to nothing",
+        path="$.a[$.foo]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[],
+    ),
+    Case(
+        description="array index from embedded singular query resolving to nothing",
+        path="$.b[$.foo]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[],
+    ),
+    Case(
+        description="array index from embedded singular query is not an int",
+        path="$.b[$.a.z]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}, "z": "foo"},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[],
+    ),
+    Case(
+        description="array index from embedded singular query is negative",
+        path="$.b[$.a.z]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}, "z": -1},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=["q"],
+    ),
 ]
 
 
diff --git a/tests/test_find_extra_examples.py b/tests/test_find_extra_examples.py
@@ -120,6 +120,39 @@ class Case:
         want=[2, 3],
         want_paths=["$['abc'][1]", "$['abc'][2]"],
     ),
+    Case(
+        description="object name from embedded singular query",
+        path="$.a[$.b[1]]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[{"q": [4, 5, 6]}],
+        want_paths=["$['a']['p']"],
+    ),
+    Case(
+        description="array index from embedded singular query",
+        path="$.a.j[$['c d'].x.y]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[2],
+        want_paths=["$['a']['j'][1]"],
+    ),
+    Case(
+        description="embedded singular query does not resolve to a string or int value",
+        path="$.a[$.b]",
+        data={
+            "a": {"j": [1, 2, 3], "p": {"q": [4, 5, 6]}},
+            "b": ["j", "p", "q"],
+            "c d": {"x": {"y": 1}},
+        },
+        want=[],
+        want_paths=[],
+    ),
 ]
 
 
