Add ability to specify custom regex matcher (#325)

This adds the ability to the `Config` object for specifying an optional
custom matcher. If provided, it will be invoked instead of
protovalidate-python's `matches` implementation.

Author: smaye81

gen/tests/example/v1/validations_pb2.py

@@ -93,6 +93,11 @@ message MapKeys {
 message Embed {
   int64 val = 1 [(buf.validate.field).int64.gt = 0];
 }
+
 message RepeatedEmbedSkip {
   repeated Embed val = 1 [(buf.validate.field).repeated.items.ignore = IGNORE_ALWAYS];
 }
+
+message InvalidRESyntax {
+  string value = 1 [(buf.validate.field).string.pattern = "^\\z"];
+}

gen/tests/example/v1/validations_pb2.pyi

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from collections.abc import Callable
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass
@@ -21,6 +23,10 @@ class Config:
 
     Attributes:
         fail_fast (bool): If true, validation will stop after the first violation. Defaults to False.
+        regex_matches_func: An optional regex matcher to use. If specified, this will be used to match
+                            on regex expressions instead of this library's `matches` logic.
     """
 
     fail_fast: bool = False
+
+    regex_matches_func: Optional[Callable[[str, str], bool]] = None

proto/tests/example/v1/validations.proto

@@ -15,13 +15,15 @@
 import math
 import re
 import typing
+from collections.abc import Callable
 from urllib import parse as urlparse
 
 import celpy
 from celpy import celtypes
 
+from protovalidate.config import Config
 from protovalidate.internal import string_format
-from protovalidate.internal.matches import cel_matches
+from protovalidate.internal.matches import matches as protovalidate_matches
 from protovalidate.internal.rules import MessageType, field_to_cel
 
 # See https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
@@ -1554,14 +1556,31 @@ def __peek(self, char: str) -> bool:
         return self._index < len(self._string) and self._string[self._index] == char
 
 
-def make_extra_funcs(locale: str) -> dict[str, celpy.CELFunction]:
-    # For now, ignoring the type.
-    string_fmt = string_format.StringFormat(locale)  # type: ignore
+def get_matches_func(matcher: typing.Optional[Callable[[str, str], bool]]):
+    if matcher is None:
+        matcher = protovalidate_matches
+
+    def cel_matches(text: celtypes.Value, pattern: celtypes.Value) -> celpy.Result:
+        if not isinstance(text, celtypes.StringType):
+            msg = "invalid argument for text, expected string"
+            raise celpy.CELEvalError(msg)
+        if not isinstance(pattern, celtypes.StringType):
+            msg = "invalid argument for pattern, expected string"
+            raise celpy.CELEvalError(msg)
+
+        b = matcher(text, pattern)
+        return celtypes.BoolType(b)
+
+    return cel_matches
+
+
+def make_extra_funcs(config: Config) -> dict[str, celpy.CELFunction]:
+    string_fmt = string_format.StringFormat()
     return {
         # Missing standard functions
         "format": string_fmt.format,
         # Overridden standard functions
-        "matches": cel_matches,
+        "matches": get_matches_func(config.regex_matches_func),
         # protovalidate specific functions
         "getField": cel_get_field,
         "isNan": cel_is_nan,
@@ -1575,6 +1594,3 @@ def make_extra_funcs(locale: str) -> dict[str, celpy.CELFunction]:
         "isHostAndPort": cel_is_host_and_port,
         "unique": cel_unique,
     }
-
-
-EXTRA_FUNCS = make_extra_funcs("en_US")

protovalidate/config.py

@@ -15,7 +15,6 @@
 import re
 
 import celpy
-from celpy import celtypes
 
 # Patterns that are supported in Python's re package and not in re2.
 # RE2: https://github.com/google/re2/wiki/syntax
@@ -30,10 +29,11 @@
     r"\\u[0-9a-fA-F]{4}",  # UTF-16 code-unit
     r"\\0(?!\d)",  # NUL
     r"\[\\b.*\]",  # Backspace eg: [\b]
+    r"\\Z",  # End of text (only lowercase z is supported in re2)
 ]
 
 
-def cel_matches(text: celtypes.Value, pattern: celtypes.Value) -> celpy.Result:
+def matches(text: str, pattern: str) -> bool:
     """Return True if the given pattern matches text. False otherwise.
 
     CEL uses RE2 syntax which diverges from Python re in various ways. Ideally, we
@@ -43,14 +43,13 @@ def cel_matches(text: celtypes.Value, pattern: celtypes.Value) -> celpy.Result:
 
     Instead of foisting this issue on users, we instead mimic re2 syntax by failing
     to compile the regex for patterns not compatible with re2.
-    """
-    if not isinstance(text, celtypes.StringType):
-        msg = "invalid argument for text, expected string"
-        raise celpy.CELEvalError(msg)
-    if not isinstance(pattern, celtypes.StringType):
-        msg = "invalid argument for pattern, expected string"
-        raise celpy.CELEvalError(msg)
 
+    Users can choose to override this behavior by providing their own custom matches
+    function via the Config.
+
+    Raises:
+        celpy.CELEvalError: If pattern contains invalid re2 syntax or if an re.error is raised during matching.
+    """
     # Simulate re2 by failing on any patterns not compatible with re2 syntax
     for invalid_pattern in invalid_patterns:
         r = re.search(invalid_pattern, pattern)
@@ -61,6 +60,7 @@ def cel_matches(text: celtypes.Value, pattern: celtypes.Value) -> celpy.Result:
     try:
         m = re.search(pattern, text)
     except re.error as ex:
-        return celpy.CELEvalError("match error", ex.__class__, ex.args)
+        msg = "match error"
+        raise celpy.CELEvalError(msg, ex.__class__, ex.args) from ex
 
-    return celtypes.BoolType(m is not None)
+    return m is not None

protovalidate/internal/extra_func.py

@@ -15,6 +15,7 @@
 import dataclasses
 import datetime
 import typing
+from collections.abc import Callable
 
 import celpy
 from celpy import celtypes
@@ -44,7 +45,7 @@ def unwrap(msg: message.Message) -> celtypes.Value:
     return field_to_cel(msg, msg.DESCRIPTOR.fields_by_name["value"])
 
 
-_MSG_TYPE_URL_TO_CTOR: dict[str, typing.Callable[..., celtypes.Value]] = {
+_MSG_TYPE_URL_TO_CTOR: dict[str, Callable[..., celtypes.Value]] = {
     "google.protobuf.Duration": make_duration,
     "google.protobuf.Timestamp": make_timestamp,
     "google.protobuf.StringValue": unwrap,

protovalidate/internal/matches.py

@@ -24,8 +24,7 @@
 class StringFormat:
     """An implementation of string.format() in CEL."""
 
-    def __init__(self, locale: str):
-        self.locale = locale
+    def __init__(self):
         self.fmt = None
 
     def format(self, fmt: celtypes.Value, args: celtypes.Value) -> celpy.Result:

protovalidate/internal/rules.py

@@ -39,8 +39,9 @@ class Validator:
     _cfg: Config
 
     def __init__(self, config=None):
-        self._factory = _rules.RuleFactory(extra_func.EXTRA_FUNCS)
         self._cfg = config if config is not None else Config()
+        funcs = extra_func.make_extra_funcs(self._cfg)
+        self._factory = _rules.RuleFactory(funcs)
 
     def validate(
         self,

protovalidate/internal/string_format.py

@@ -21,3 +21,4 @@ class TestConfig(unittest.TestCase):
     def test_defaults(self):
         cfg = Config()
         self.assertFalse(cfg.fail_fast)
+        self.assertIsNone(cfg.regex_matches_func)