Merge pull request #4 from jg-rp/i-regexp

Map i-regexp pattern to PCRE-like pattern

Author: jg-rp

CHANGELOG.md

@@ -5,6 +5,7 @@
 **Fixes**
 
 - Handle end of query when lexing inside a filter expression.
+- Check patterns passed to `search` and `match` are valid I-Regexp patterns. Both of these functions now return _LogicalFalse_ if the pattern is not valid according to RFC 9485.
 
 ## Version 0.1.1
 

jsonpath_rfc9535/__about__.py

@@ -1 +1 @@
-__version__ = "0.1.1"
+__version__ = "0.1.2"

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

@@ -1,21 +1,27 @@
 """The standard `match` function extension."""
 
 import regex as re
+from iregexp_check import check
 
 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."""
 
     arg_types = [ExpressionType.VALUE, ExpressionType.VALUE]
     return_type = ExpressionType.LOGICAL
 
-    def __call__(self, string: str, pattern: str) -> bool:
+    def __call__(self, string: str, pattern: object) -> bool:
         """Return `True` if _string_ matches _pattern_, or `False` otherwise."""
+        if not isinstance(pattern, str) or not check(pattern):
+            return False
+
         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

@@ -1,21 +1,27 @@
 """The standard `search` function extension."""
 
 import regex as re
+from iregexp_check import check
 
 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."""
 
     arg_types = [ExpressionType.VALUE, ExpressionType.VALUE]
     return_type = ExpressionType.LOGICAL
 
-    def __call__(self, string: str, pattern: str) -> bool:
+    def __call__(self, string: str, pattern: object) -> bool:
         """Return `True` if _string_ contains _pattern_, or `False` otherwise."""
+        if not isinstance(pattern, str) or not check(pattern):
+            return False
+
         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,

pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["regex"]
+dependencies = ["regex", "iregexp-check>=0.1.3"]
 
 [project.urls]
 Documentation = "https://jg-rp.github.io/python-jsonpath-rfc9535/"