Use regress and remove 'disabled' regex format

The default regex check mode gets a significant upgrade here to
support ECMAScript standard regexes via the 'regress' package and
underlying crate. This should now fully validate regexes in many more
scenarios, rather than doing a best-effort check.

Since this is a change which touches regex behavior in a significant
way, the opportunity is also taken to remove support for
`--format-regex disabled`.
Users should be converted to the `--disable-formats` flag, which
supports this via `--disable-formats regex`.

Tests are given mild updates to drop the `disabled` value for that
flag, but use `--disable-formats regex` instead.
And the implementation is very mildly refactored to hopefully
support plugging the `regress` implementation into more of
`jsonschema` in the future.

Author: sirosen

CHANGELOG.rst

@@ -9,6 +9,10 @@ Unreleased
 ----------
 
 .. vendor-insert-here
+- The regex format check has been improved to support ECMAScript regexes by
+  default. (:issue:`302`)
+- The ``--format-regex disabled`` option has been removed. Users should use
+  ``--disable-formats regex`` if they wish to disable regex format checking.
 
 0.25.0
 ------
@@ -71,7 +75,7 @@ Unreleased
 - A new option, ``--disable-formats`` replaces and enhances the
   ``--disable-format`` flag. ``--disable-formats`` takes a format to disable
   and may be passed multiple times, allowing users to opt out of any specific
-  format checks. ``--disable-format "*"`` can be used to disable all format
+  format checks. ``--disable-formats "*"`` can be used to disable all format
   checking. ``--disable-format`` is still supported, but is deprecated and
   emits a warning.
 

docs/usage.rst

@@ -198,13 +198,10 @@ follows:
 
    * - mode
      - description
-   * - disabled
-     - Skip checking ``regex``, but leave other formats enabled.
    * - default
-     - Check for known non-python regex syntaxes. If one is found, the expression
-       always passes. Otherwise, check validity in the python engine.
+     - Require the regex to be valid in ECMAScript regex syntax.
    * - python
-     - Require the regex to be valid in python regex syntax.
+     - Require the regex to be valid in Python regex syntax.
 
 Other Options
 --------------

setup.cfg

@@ -21,6 +21,7 @@ install_requires =
     importlib-resources>=1.4.0;python_version<"3.9"
     ruamel.yaml==0.17.32
     jsonschema>=4.18.0,<5.0
+    regress>=0.4.0
     requests<3.0
     click>=8,<9
 package_dir=

src/check_jsonschema/cli/main_command.py

@@ -7,7 +7,7 @@
 
 from ..catalog import CUSTOM_SCHEMA_NAMES, SCHEMA_CATALOG
 from ..checker import SchemaChecker
-from ..formats import KNOWN_FORMATS, RegexFormatBehavior
+from ..formats import KNOWN_FORMATS, RegexVariantName
 from ..instance_loader import InstanceLoader
 from ..parsers import SUPPORTED_FILE_FORMATS
 from ..reporter import REPORTER_BY_NAME, Reporter
@@ -69,8 +69,7 @@ def pretty_helptext_list(values: list[str] | tuple[str, ...]) -> str:
 \b
 For the "regex" format, there are multiple modes which can be specified with
 '--format-regex':
-    default  |  best effort check
-    disabled |  do not check the regex format
+    default  |  check that the string is a valid ECMAScript regex
     python   |  check that the string is a valid python regex
 
 \b
@@ -153,8 +152,8 @@ def pretty_helptext_list(values: list[str] | tuple[str, ...]) -> str:
         "Set the mode of format validation for regexes. "
         "If `--disable-formats regex` is used, this option has no effect."
     ),
-    default=RegexFormatBehavior.default.value,
-    type=click.Choice([x.value for x in RegexFormatBehavior], case_sensitive=False),
+    default=RegexVariantName.default.value,
+    type=click.Choice([x.value for x in RegexVariantName], case_sensitive=False),
 )
 @click.option(
     "--default-filetype",
@@ -249,7 +248,7 @@ def main(
         args.disable_all_formats = True
     else:
         args.disable_formats = normalized_disable_formats
-    args.format_regex = RegexFormatBehavior(format_regex)
+    args.format_regex = RegexVariantName(format_regex)
     args.disable_cache = no_cache
     args.default_filetype = default_filetype
     args.fill_defaults = fill_defaults

src/check_jsonschema/cli/parse_result.py

@@ -4,7 +4,7 @@
 
 import click
 
-from ..formats import FormatOptions, RegexFormatBehavior
+from ..formats import FormatOptions, RegexVariantName
 from ..transforms import Transform
 
 
@@ -33,7 +33,7 @@ def __init__(self) -> None:
         # regex format options
         self.disable_all_formats: bool = False
         self.disable_formats: tuple[str, ...] = ()
-        self.format_regex: RegexFormatBehavior = RegexFormatBehavior.default
+        self.format_regex: RegexVariantName = RegexVariantName.default
         # error and output controls
         self.verbosity: int = 1
         self.traceback_mode: str = "short"
@@ -69,6 +69,6 @@ def set_schema(
     def format_opts(self) -> FormatOptions:
         return FormatOptions(
             enabled=not self.disable_all_formats,
-            regex_behavior=self.format_regex,
+            regex_variant=self.format_regex,
             disabled_formats=self.disable_formats,
         )

src/check_jsonschema/formats.py

@@ -7,6 +7,7 @@
 
 import jsonschema
 import jsonschema.validators
+import regress
 
 # all known format strings except for a selection from draft3 which have either
 # been renamed or removed:
@@ -36,41 +37,43 @@
 )
 
 
-def _regex_check(instance: t.Any) -> bool:
-    if not isinstance(instance, str):
-        return True
-    re.compile(instance)
-    return True
+class RegexVariantName(enum.Enum):
+    default = "default"
+    python = "python"
 
 
-def _gated_regex_check(instance: t.Any) -> bool:
-    if not isinstance(instance, str):
-        return True
-    if re.search(r"\(\?[^!=]", instance):
-        return True
-    re.compile(instance)
-    return True
+class RegexImplementation:
+    def __init__(self, variant: RegexVariantName) -> None:
+        self.variant = variant
 
+    def check_format(self, instance: t.Any) -> bool:
+        if not isinstance(instance, str):
+            return True
 
-class RegexFormatBehavior(enum.Enum):
-    default = "default"
-    disabled = "disabled"
-    python = "python"
+        try:
+            if self.variant == RegexVariantName.default:
+                regress.Regex(instance)
+            else:
+                re.compile(instance)
+        # something is wrong with RegressError getting into the published types
+        # needs investigation... for now, ignore the error
+        except (regress.RegressError, re.error):  # type: ignore[attr-defined]
+            return False
+
+        return True
 
 
 class FormatOptions:
     def __init__(
         self,
         *,
         enabled: bool = True,
-        regex_behavior: RegexFormatBehavior = RegexFormatBehavior.default,
+        regex_variant: RegexVariantName = RegexVariantName.default,
         disabled_formats: tuple[str, ...] = (),
     ) -> None:
         self.enabled = enabled
-        self.regex_behavior = regex_behavior
+        self.regex_variant = regex_variant
         self.disabled_formats = disabled_formats
-        if "regex" in self.disabled_formats:
-            self.regex_behavior = RegexFormatBehavior.disabled
 
 
 def get_base_format_checker(schema_dialect: str | None) -> jsonschema.FormatChecker:
@@ -94,22 +97,15 @@ def make_format_checker(
     base_checker = get_base_format_checker(schema_dialect)
     checker = copy.deepcopy(base_checker)
 
-    # remove the regex check -- it will be re-added if it is enabled
+    # replace the regex check
     del checker.checkers["regex"]
+    regex_impl = RegexImplementation(opts.regex_variant)
+    checker.checks("regex")(regex_impl.check_format)
 
-    # remove the disabled checks
+    # remove the disabled checks, which may include the regex check
     for checkname in opts.disabled_formats:
         if checkname not in checker.checkers:
             continue
         del checker.checkers[checkname]
 
-    if opts.regex_behavior == RegexFormatBehavior.disabled:
-        pass
-    elif opts.regex_behavior == RegexFormatBehavior.default:
-        checker.checks("regex", raises=re.error)(_gated_regex_check)
-    elif opts.regex_behavior == RegexFormatBehavior.python:
-        checker.checks("regex", raises=re.error)(_regex_check)
-    else:  # pragma: no cover
-        raise NotImplementedError
-
     return checker

tests/acceptance/test_format_regex_opts.py

@@ -1,5 +1,4 @@
 # test on a JavaScript regex which is not a valid python regex
-# `--format-regex=disabled` should skip
 # `--format-regex=default` should accept it
 # `--format-regex=python` should reject it
 #
@@ -39,24 +38,28 @@
 }
 
 
-@pytest.fixture(params=["disabled", "default", "python"])
-def regexopt(request):
+@pytest.fixture(
+    params=[
+        ("--disable-formats", "regex"),
+        ("--format-regex", "default"),
+        ("--format-regex", "python"),
+    ]
+)
+def regexopts(request):
     return request.param
 
 
-def test_regex_format_good(run_line_simple, tmp_path, regexopt):
+def test_regex_format_good(run_line_simple, tmp_path, regexopts):
     schemafile = tmp_path / "schema.json"
     schemafile.write_text(json.dumps(FORMAT_SCHEMA))
 
     doc = tmp_path / "doc.json"
     doc.write_text(json.dumps(ALWAYS_PASSING_DOCUMENT))
 
-    run_line_simple(
-        ["--format-regex", regexopt, "--schemafile", str(schemafile), str(doc)]
-    )
+    run_line_simple([*regexopts, "--schemafile", str(schemafile), str(doc)])
 
 
-def test_regex_format_accepts_non_str_inputs(run_line_simple, tmp_path, regexopt):
+def test_regex_format_accepts_non_str_inputs(run_line_simple, tmp_path, regexopts):
     # potentially confusing, but a format checker is allowed to check non-str instances
     # validate the format checker behavior on such a case
     schemafile = tmp_path / "schema.json"
@@ -70,25 +73,22 @@ def test_regex_format_accepts_non_str_inputs(run_line_simple, tmp_path, regexopt
     )
     doc = tmp_path / "doc.json"
     doc.write_text(json.dumps({"pattern": 0}))
-    run_line_simple(
-        ["--format-regex", regexopt, "--schemafile", str(schemafile), str(doc)]
-    )
+    run_line_simple([*regexopts, "--schemafile", str(schemafile), str(doc)])
 
 
-def test_regex_format_bad(run_line, tmp_path, regexopt):
+def test_regex_format_bad(run_line, tmp_path, regexopts):
     schemafile = tmp_path / "schema.json"
     schemafile.write_text(json.dumps(FORMAT_SCHEMA))
 
     doc = tmp_path / "doc.json"
     doc.write_text(json.dumps(ALWAYS_FAILING_DOCUMENT))
 
-    expect_ok = regexopt == "disabled"
+    expect_ok = regexopts == ("--disable-formats", "regex")
 
     res = run_line(
         [
             "check-jsonschema",
-            "--format-regex",
-            regexopt,
+            *regexopts,
             "--schemafile",
             str(schemafile),
             str(doc),
@@ -101,20 +101,19 @@ def test_regex_format_bad(run_line, tmp_path, regexopt):
         assert "is not a 'regex'" in res.stdout
 
 
-def test_regex_format_js_specific(run_line, tmp_path, regexopt):
+def test_regex_format_js_specific(run_line, tmp_path, regexopts):
     schemafile = tmp_path / "schema.json"
     schemafile.write_text(json.dumps(FORMAT_SCHEMA))
 
     doc = tmp_path / "doc.json"
     doc.write_text(json.dumps(JS_REGEX_DOCUMENT))
 
-    expect_ok = regexopt in ("disabled", "default")
+    expect_ok = regexopts != ("--format-regex", "python")
 
     res = run_line(
         [
             "check-jsonschema",
-            "--format-regex",
-            regexopt,
+            *regexopts,
             "--schemafile",
             str(schemafile),
             str(doc),