Handle some JSONPath sytnax errors

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/test_errors.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,39 @@ 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
+
+
+# TODO: add these to the CTS?
+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)