Merge pull request #60 from jg-rp/syntax-errors

JSONPath syntax errors

Author: jg-rp

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Python JSONPath Change Log
 
+## Version 1.1.2 (unreleased)
+
+- Fixed handling of JSONPath literals in filter expressions. We now raise a `JSONPathSyntaxError` if a filter expression literal is not part of a comparison or function expression. See [jsonpath-compliance-test-suite#81](https://github.com/jsonpath-standard/jsonpath-compliance-test-suite/pull/81).
+
 ## Version 1.1.1
 
 **Fixes**

jsonpath/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present James Prior <[email protected]>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.1.1"
+__version__ = "1.1.2"

jsonpath/parse.py

@@ -30,6 +30,8 @@
 from .filter import InfixExpression
 from .filter import IntegerLiteral
 from .filter import ListLiteral
+from .filter import Literal
+from .filter import Nil
 from .filter import Path
 from .filter import PrefixExpression
 from .filter import RegexLiteral
@@ -191,6 +193,7 @@ class Parser:
             "<=",
             "<",
             "!=",
+            "=~",
         ]
     )
 
@@ -477,6 +480,13 @@ def parse_filter(self, stream: TokenStream) -> Filter:
                     f"result of {expr.name}() must be compared", token=tok
                 )
 
+        if isinstance(expr, (Literal, Nil)):
+            raise JSONPathSyntaxError(
+                "filter expression literals outside of "
+                "function expressions must be compared",
+                token=tok,
+            )
+
         return Filter(env=self.env, token=tok, expression=BooleanExpression(expr))
 
     def parse_boolean(self, stream: TokenStream) -> FilterExpression:
@@ -520,6 +530,20 @@ def parse_infix_expression(
             self._raise_for_non_comparable_function(left, tok)
             self._raise_for_non_comparable_function(right, tok)
 
+        if operator not in self.COMPARISON_OPERATORS:
+            if isinstance(left, Literal):
+                raise JSONPathSyntaxError(
+                    "filter expression literals outside of "
+                    "function expressions must be compared",
+                    token=tok,
+                )
+            if isinstance(right, Literal):
+                raise JSONPathSyntaxError(
+                    "filter expression literals outside of "
+                    "function expressions must be compared",
+                    token=tok,
+                )
+
         return InfixExpression(left, operator, right)
 
     def parse_grouped_expression(self, stream: TokenStream) -> FilterExpression:
@@ -532,14 +556,20 @@ def parse_grouped_expression(self, stream: TokenStream) -> FilterExpression:
                 raise JSONPathSyntaxError(
                     "unbalanced parentheses", token=stream.current
                 )
+
+            if stream.current.kind not in self.BINARY_OPERATORS:
+                raise JSONPathSyntaxError(
+                    f"expected an expression, found '{stream.current.value}'",
+                    token=stream.current,
+                )
+
             expr = self.parse_infix_expression(stream, expr)
 
         stream.expect(TOKEN_RPAREN)
         return expr
 
     def parse_root_path(self, stream: TokenStream) -> FilterExpression:
         root = stream.next_token()
-        assert root.kind in {TOKEN_ROOT, TOKEN_FAKE_ROOT}  # XXX:
         return RootPath(
             JSONPath(
                 env=self.env,

tests/cts

@@ -34,6 +34,11 @@ class Case:
     "basic, no leading whitespace": "flexible whitespace policy",
     "basic, no trailing whitespace": "flexible whitespace policy",
     "basic, bald descendant segment": "almost has a consensus",
+    "filter, index segment on object, selects nothing": "flexible selector policy",
+    "functions, match, dot matcher on \\u2028": "standard library re policy",
+    "functions, match, dot matcher on \\u2029": "standard library re policy",
+    "functions, search, dot matcher on \\u2028": "standard library re policy",
+    "functions, search, dot matcher on \\u2029": "standard library re policy",
     "functions, match, filter, match function, unicode char class, uppercase": "\\p not supported",  # noqa: E501
     "functions, match, filter, match function, unicode char class negated, uppercase": "\\P not supported",  # noqa: E501
     "functions, search, filter, search function, unicode char class, uppercase": "\\p not supported",  # noqa: E501

tests/test_compliance.py

@@ -1,3 +1,7 @@
+from operator import attrgetter
+from typing import List
+from typing import NamedTuple
+
 import pytest
 
 from jsonpath import JSONPathEnvironment
@@ -28,3 +32,38 @@ def test_function_too_many_params(env: JSONPathEnvironment) -> None:
 def test_non_singular_query_is_not_comparable(env: JSONPathEnvironment) -> None:
     with pytest.raises(JSONPathTypeError):
         env.compile("$[?@.* > 2]")
+
+
+def test_unbalanced_parens(env: JSONPathEnvironment) -> None:
+    with pytest.raises(JSONPathSyntaxError):
+        env.compile("$[?((@.foo)]")
+
+
+class FilterLiteralTestCase(NamedTuple):
+    description: str
+    query: str
+
+
+BAD_FILTER_LITERAL_TEST_CASES: List[FilterLiteralTestCase] = [
+    FilterLiteralTestCase("just true", "$[?true]"),
+    FilterLiteralTestCase("just string", "$[?'foo']"),
+    FilterLiteralTestCase("just int", "$[?2]"),
+    FilterLiteralTestCase("just float", "$[?2.2]"),
+    FilterLiteralTestCase("just null", "$[?null]"),
+    FilterLiteralTestCase("literal and literal", "$[?true && false]"),
+    FilterLiteralTestCase("literal or literal", "$[?true || false]"),
+    FilterLiteralTestCase("comparison and literal", "$[?true == false && false]"),
+    FilterLiteralTestCase("comparison or literal", "$[?true == false || false]"),
+    FilterLiteralTestCase("literal and comparison", "$[?true && true == false]"),
+    FilterLiteralTestCase("literal or comparison", "$[?false || true == false]"),
+]
+
+
+@pytest.mark.parametrize(
+    "case", BAD_FILTER_LITERAL_TEST_CASES, ids=attrgetter("description")
+)
+def test_filter_literals_must_be_compared(
+    env: JSONPathEnvironment, case: FilterLiteralTestCase
+) -> None:
+    with pytest.raises(JSONPathSyntaxError):
+        env.compile(case.query)