Map i-regexp pattern to PCRE-like pattern

Author: jg-rp

jsonpath_rfc9535/environment.py

@@ -217,7 +217,7 @@ def check_well_typedness(
                     )
             elif typ == ExpressionType.LOGICAL:
                 if not isinstance(
-                    arg, (FilterQuery, (LogicalExpression, ComparisonExpression))
+                    arg, (FilterQuery, LogicalExpression, ComparisonExpression)
                 ):
                     raise JSONPathTypeError(
                         f"{token.value}() argument {idx} must be of LogicalType",

jsonpath_rfc9535/filter_expressions.py

@@ -186,6 +186,7 @@ def __eq__(self, other: object) -> bool:
 
     def evaluate(self, context: FilterContext) -> bool:
         """Evaluate the filter expression in the given _context_."""
+        # TODO: sort circuit eval of right if left is false
         return _compare(
             self.left.evaluate(context), self.operator, self.right.evaluate(context)
         )

jsonpath_rfc9535/function_extensions/_pattern.py

@@ -0,0 +1,31 @@
+from typing import List
+
+
+def map_re(pattern: str) -> str:
+    escaped = False
+    char_class = False
+    parts: List[str] = []
+    for ch in pattern:
+        if escaped:
+            parts.append(ch)
+            escaped = False
+            continue
+
+        if ch == ".":
+            if not char_class:
+                parts.append(r"(?:(?![\r\n])\P{Cs}|\\p{Cs}\p{Cs})")
+            else:
+                parts.append(ch)
+        elif ch == "\\":
+            escaped = True
+            parts.append(ch)
+        elif ch == "[":
+            char_class = True
+            parts.append(ch)
+        elif ch == "]":
+            char_class = False
+            parts.append(ch)
+        else:
+            parts.append(ch)
+
+    return "".join(parts)

jsonpath_rfc9535/function_extensions/match.py

@@ -5,6 +5,8 @@
 from jsonpath_rfc9535.function_extensions import ExpressionType
 from jsonpath_rfc9535.function_extensions import FilterFunction
 
+from ._pattern import map_re
+
 
 class Match(FilterFunction):
     """The standard `match` function."""
@@ -16,6 +18,6 @@ def __call__(self, string: str, pattern: str) -> bool:
         """Return `True` if _string_ matches _pattern_, or `False` otherwise."""
         try:
             # re.fullmatch caches compiled patterns internally
-            return bool(re.fullmatch(pattern, string))
+            return bool(re.fullmatch(map_re(pattern), string))
         except (TypeError, re.error):
             return False

jsonpath_rfc9535/function_extensions/search.py

@@ -5,6 +5,8 @@
 from jsonpath_rfc9535.function_extensions import ExpressionType
 from jsonpath_rfc9535.function_extensions import FilterFunction
 
+from ._pattern import map_re
+
 
 class Search(FilterFunction):
     """The standard `search` function."""
@@ -16,6 +18,6 @@ def __call__(self, string: str, pattern: str) -> bool:
         """Return `True` if _string_ contains _pattern_, or `False` otherwise."""
         try:
             # re.search caches compiled patterns internally
-            return bool(re.search(pattern, string))
+            return bool(re.search(map_re(pattern), string, re.VERSION1))
         except (TypeError, re.error):
             return False

jsonpath_rfc9535/parse.py

@@ -114,6 +114,9 @@ def __init__(self, *, env: JSONPathEnvironment) -> None:
             TokenType.TRUE: self.parse_boolean,
         }
 
+        # TODO: can a function argument be a grouped expression?
+        # TODO: can a function argument contain a !?
+
         self.function_argument_map: Dict[
             TokenType, Callable[[TokenStream], Expression]
         ] = {
@@ -412,6 +415,7 @@ def parse_grouped_expression(self, stream: TokenStream) -> Expression:
                 raise JSONPathSyntaxError(
                     "unbalanced parentheses", token=stream.current
                 )
+            # TODO: only if binary op
             expr = self.parse_infix_expression(stream, expr)
 
         stream.expect(TokenType.RPAREN)

jsonpath_rfc9535/query.py

@@ -32,7 +32,7 @@ class JSONPathQuery:
         segments: The `JSONPathSegment` instances that make up this query.
     """
 
-    __slots__ = ("env", "fake_root", "segments")
+    __slots__ = ("env", "segments")
 
     def __init__(
         self,

tests/cts

@@ -97,12 +97,12 @@ class FilterLiteralTestCase(NamedTuple):
     FilterLiteralTestCase("just int", "$[?2]"),
     FilterLiteralTestCase("just float", "$[?2.2]"),
     FilterLiteralTestCase("just null", "$[?null]"),
-    FilterLiteralTestCase("literal and literal", "$[?true and false]"),
-    FilterLiteralTestCase("literal or literal", "$[?true or false]"),
-    FilterLiteralTestCase("comparison and literal", "$[?true == false and false]"),
-    FilterLiteralTestCase("comparison or literal", "$[?true == false or false]"),
-    FilterLiteralTestCase("literal and comparison", "$[?true and true == false]"),
-    FilterLiteralTestCase("literal or comparison", "$[?false or true == false]"),
+    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]"),
 ]
 
 

tests/test_errors.py

@@ -71,11 +71,6 @@ class Case:
         query="$.some[?(@.thing >= 7)]",
         want="$['some'][?@['thing'] >= 7]",
     ),
-    Case(
-        description="filter with >=",
-        query="$.some[?(@.thing >= 7)]",
-        want="$['some'][?@['thing'] >= 7]",
-    ),
     Case(
         description="filter with !=",
         query="$.some[?(@.thing != 7)]",