More tests and refactor parser.parse_query

Author: jg-rp

jsonpath/parse.py

@@ -338,100 +338,91 @@ def parse_query(self, stream: TokenStream) -> Iterable[JSONPathSegment]:
         This method assumes the root, current or pseudo root identifier has
         already been consumed.
         """
+        if not self.env.strict and stream.current().kind in {
+            TOKEN_NAME,
+            TOKEN_WILD,
+            TOKEN_KEYS,
+            TOKEN_KEY_NAME,
+        }:
+            # A non-standard "bare" path. One that starts with a shorthand selector
+            # without a leading identifier (`$`, `@`, `^` or `_`).
+            #
+            # When no identifier is given, a root query (`$`) is assumed.
+            token = stream.current()
+            selector = self.parse_shorthand_selector(stream)
+            yield JSONPathChildSegment(env=self.env, token=token, selectors=(selector,))
+
         while True:
             stream.skip_whitespace()
-            _token = stream.current()
-            if _token.kind == TOKEN_DOT:
-                stream.eat(TOKEN_DOT)
-                # Assert that dot is followed by shorthand selector without whitespace.
-                stream.expect(TOKEN_NAME, TOKEN_WILD, TOKEN_KEYS, TOKEN_KEY_NAME)
-                token = stream.current()
-                selectors = self.parse_selector(stream)
+            token = stream.next()
+
+            if token.kind == TOKEN_DOT:
+                selector = self.parse_shorthand_selector(stream)
                 yield JSONPathChildSegment(
-                    env=self.env, token=token, selectors=selectors
+                    env=self.env, token=token, selectors=(selector,)
                 )
-            elif _token.kind == TOKEN_DDOT:
-                token = stream.eat(TOKEN_DDOT)
-                selectors = self.parse_selector(stream)
-                if not selectors:
-                    raise JSONPathSyntaxError(
-                        "missing selector for recursive descent segment",
-                        token=stream.current(),
-                    )
+            elif token.kind == TOKEN_DDOT:
+                if stream.current().kind == TOKEN_LBRACKET:
+                    selectors = tuple(self.parse_bracketed_selection(stream))
+                else:
+                    selectors = (self.parse_shorthand_selector(stream),)
+
                 yield JSONPathRecursiveDescentSegment(
                     env=self.env, token=token, selectors=selectors
                 )
-            elif _token.kind == TOKEN_LBRACKET:
-                selectors = self.parse_selector(stream)
-                yield JSONPathChildSegment(
-                    env=self.env, token=_token, selectors=selectors
-                )
-            elif _token.kind in {TOKEN_NAME, TOKEN_WILD, TOKEN_KEYS, TOKEN_KEY_NAME}:
-                # A non-standard "bare" path. One without a leading identifier (`$`,
-                # `@`, `^` or `_`).
-                token = stream.current()
-                selectors = self.parse_selector(stream)
+            elif token.kind == TOKEN_LBRACKET:
+                stream.pos -= 1
                 yield JSONPathChildSegment(
-                    env=self.env, token=token, selectors=selectors
+                    env=self.env,
+                    token=token,
+                    selectors=tuple(self.parse_bracketed_selection(stream)),
                 )
+            elif token.kind == TOKEN_EOF:
+                break
             else:
+                # An embedded query. Put the token back on the stream.
+                stream.pos -= 1
                 break
 
-    def parse_selector(self, stream: TokenStream) -> tuple[JSONPathSelector, ...]:  # noqa: PLR0911
+    def parse_shorthand_selector(self, stream: TokenStream) -> JSONPathSelector:
         token = stream.next()
 
         if token.kind == TOKEN_NAME:
-            return (
-                NameSelector(
-                    env=self.env,
-                    token=token,
-                    name=token.value,
-                ),
+            return NameSelector(
+                env=self.env,
+                token=token,
+                name=token.value,
             )
 
         if token.kind == TOKEN_KEY_NAME:
-            return (
-                KeySelector(
-                    env=self.env,
-                    token=token,
-                    key=token.value,
-                ),
+            return KeySelector(
+                env=self.env,
+                token=token,
+                key=token.value,
             )
 
         if token.kind == TOKEN_WILD:
-            return (
-                WildcardSelector(
-                    env=self.env,
-                    token=token,
-                ),
+            return WildcardSelector(
+                env=self.env,
+                token=token,
             )
 
         if token.kind == TOKEN_KEYS:
             if stream.current().kind == TOKEN_NAME:
-                return (
-                    KeySelector(
-                        env=self.env,
-                        token=token,
-                        key=self._decode_string_literal(stream.next()),
-                    ),
-                )
-
-            return (
-                KeysSelector(
+                return KeySelector(
                     env=self.env,
                     token=token,
-                ),
-            )
+                    key=self._decode_string_literal(stream.next()),
+                )
 
-        if token.kind == TOKEN_LBRACKET:
-            stream.pos -= 1
-            return tuple(self.parse_bracketed_selection(stream))
+            return KeysSelector(
+                env=self.env,
+                token=token,
+            )
 
-        stream.pos -= 1
-        return ()
+        raise JSONPathSyntaxError("expected a shorthand selector", token=token)
 
     def parse_bracketed_selection(self, stream: TokenStream) -> List[JSONPathSelector]:  # noqa: PLR0912, PLR0915
-        """Parse a comma separated list of JSONPath selectors."""
         segment_token = stream.eat(TOKEN_LBRACKET)
         selectors: List[JSONPathSelector] = []
 
@@ -704,7 +695,7 @@ def parse_grouped_expression(self, stream: TokenStream) -> BaseExpression:
         return expr
 
     def parse_absolute_query(self, stream: TokenStream) -> BaseExpression:
-        root = stream.next()
+        root = stream.next()  # Could be TOKEN_ROOT or TOKEN_PSEUDO_ROOT
         return RootFilterQuery(
             JSONPath(
                 env=self.env,

tests/membership_operators.json

@@ -59,6 +59,30 @@
       ],
       "result_paths": ["$[0]"],
       "tags": ["extra"]
+    },
+    {
+      "name": "embedded query in list literal",
+      "selector": "$[?(@.a in ['bar', 'baz'])]",
+      "document": [{ "a": "foo" }, { "a": "bar" }],
+      "result": [
+        {
+          "a": "bar"
+        }
+      ],
+      "result_paths": ["$[1]"],
+      "tags": ["extra"]
+    },
+    {
+      "name": "list literal contains embedded query",
+      "selector": "$[?(['bar', 'baz'] contains @.a)]",
+      "document": [{ "a": "foo" }, { "a": "bar" }],
+      "result": [
+        {
+          "a": "bar"
+        }
+      ],
+      "result_paths": ["$[1]"],
+      "tags": ["extra"]
     }
   ]
 }

tests/test_strictness.py

@@ -38,6 +38,18 @@ def test_alternative_or(env: JSONPathEnvironment) -> None:
     assert env.findall(query, data) == [{"a": True, "b": False}, {"c": 99}]
 
 
+def test_alternative_null(env: JSONPathEnvironment) -> None:
+    query = "$[[email protected]==Null]"
+    data = [{"a": None, "d": "e"}, {"a": "c", "d": "f"}]
+    assert env.findall(query, data) == [{"a": None, "d": "e"}]
+
+
+def test_none(env: JSONPathEnvironment) -> None:
+    query = "$[[email protected]==None]"
+    data = [{"a": None, "d": "e"}, {"a": "c", "d": "f"}]
+    assert env.findall(query, data) == [{"a": None, "d": "e"}]
+
+
 def test_implicit_root_identifier(
     env: JSONPathEnvironment,
 ) -> None:

tests/test_undefined.py

@@ -0,0 +1,46 @@
+import asyncio
+import json
+import operator
+
+import pytest
+
+from jsonpath import JSONPathEnvironment
+from jsonpath import JSONPathSyntaxError
+from jsonpath import NodeList
+
+from ._cts_case import Case
+
+
+@pytest.fixture()
+def env() -> JSONPathEnvironment:
+    return JSONPathEnvironment(strict=False)
+
+
+with open("tests/undefined.json", encoding="utf8") as fd:
+    data = [Case(**case) for case in json.load(fd)["tests"]]
+
+
+@pytest.mark.parametrize("case", data, ids=operator.attrgetter("name"))
+def test_undefined_keyword(env: JSONPathEnvironment, case: Case) -> None:
+    assert case.document is not None
+    nodes = NodeList(env.finditer(case.selector, case.document))
+    case.assert_nodes(nodes)
+
+
+@pytest.mark.parametrize("case", data, ids=operator.attrgetter("name"))
+def test_undefined_keyword_async(env: JSONPathEnvironment, case: Case) -> None:
+    async def coro() -> NodeList:
+        assert case.document is not None
+        it = await env.finditer_async(case.selector, case.document)
+        return NodeList([node async for node in it])
+
+    nodes = asyncio.run(coro())
+    case.assert_nodes(nodes)
+
+
+@pytest.mark.parametrize("case", data, ids=operator.attrgetter("name"))
+def test_comparison_to_undefined_fails_in_strict_mode(case: Case) -> None:
+    env = JSONPathEnvironment(strict=True)
+
+    with pytest.raises(JSONPathSyntaxError):
+        env.compile(case.selector)

tests/undefined.json

@@ -0,0 +1,92 @@
+{
+  "tests": [
+    {
+      "name": "explicit comparison to undefined",
+      "selector": "$[[email protected] == undefined]",
+      "document": [
+        {
+          "a": "b",
+          "d": "e"
+        },
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result": [
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result_paths": ["$[1]"],
+      "tags": ["extra"]
+    },
+    {
+      "name": "explicit comparison to missing",
+      "selector": "$[[email protected] == missing]",
+      "document": [
+        {
+          "a": "b",
+          "d": "e"
+        },
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result": [
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result_paths": ["$[1]"],
+      "tags": ["extra"]
+    },
+    {
+      "name": "explicit undefined is on the left",
+      "selector": "$[?undefined == @.a]",
+      "document": [
+        {
+          "a": "b",
+          "d": "e"
+        },
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result": [
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result_paths": ["$[1]"],
+      "tags": ["extra"]
+    },
+    {
+      "name": "not equal to undefined",
+      "selector": "$[[email protected] != undefined]",
+      "document": [
+        {
+          "a": "b",
+          "d": "e"
+        },
+        {
+          "b": "c",
+          "d": "f"
+        }
+      ],
+      "result": [
+        {
+          "a": "b",
+          "d": "e"
+        }
+      ],
+      "result_paths": ["$[0]"],
+      "tags": ["extra"]
+    }
+  ]
+}