Add a nonunicode regex mode

This is a variant of the regress engine usage in which the `u` flag is
not set. It is needed for usages which rely on unicode escapes *not*
being interpreted. In particular, the azure pipelines schema won't
pass metaschema validation (let alone apply correctly) if `pattern`
interpretation uses unicode-mode regexes.

Author: sirosen

.pre-commit-hooks.yaml

@@ -24,7 +24,7 @@
 - id: check-azure-pipelines
   name: Validate Azure Pipelines
   description: 'Validate Azure Pipelines config against the schema provided by Microsoft'
-  entry: check-jsonschema --builtin-schema vendor.azure-pipelines --data-transform azure-pipelines
+  entry: check-jsonschema --builtin-schema vendor.azure-pipelines --data-transform azure-pipelines --regex-variant nonunicode
   language: python
   files: ^(\.)?azure-pipelines\.(yml|yaml)$
   types: [yaml]

docs/usage.rst

@@ -197,6 +197,8 @@ for ``"pattern"`` interpretation. The modes are as follows:
      - description
    * - default
      - Use ECMAScript regex syntax.
+   * - nonunicode
+     - Use ECMAScript regex syntax, but without unicode escapes enabled.
    * - python
      - Use Python regex syntax.
 

pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
     'tomli>=2.0;python_version<"3.11"',
     "ruamel.yaml==0.18.6",
     "jsonschema>=4.18.0,<5.0",
-    "regress>=0.4.0",
+    "regress>=2024.11.1",
     "requests<3.0",
     "click>=8,<9",
 ]

src/check_jsonschema/catalog.py

@@ -31,7 +31,12 @@ def _githubusercontent_url(owner: str, repo: str, ref: str, path: str) -> str:
                 "Validate Azure Pipelines config against the schema provided "
                 "by Microsoft"
             ),
-            "add_args": ["--data-transform", "azure-pipelines"],
+            "add_args": [
+                "--data-transform",
+                "azure-pipelines",
+                "--regex-variant",
+                "nonunicode",
+            ],
             "files": r"^(\.)?azure-pipelines\.(yml|yaml)$",
             "types": "yaml",
         },

src/check_jsonschema/cli/main_command.py

@@ -71,8 +71,9 @@ def pretty_helptext_list(values: list[str] | tuple[str, ...]) -> str:
 \b
 For handling of regexes, there are multiple modes which can be specified with
 '--regex-variant':
-    default  |  use ECMAScript regex syntax (via regress)
-    python   |  use python regex syntax
+    default    |  use ECMAScript regex syntax (via regress)
+    nonunicode |  use ECMAScript regex syntax, but in non-unicode mode (via regress)
+    python     |  use python regex syntax
 
 \b
 The '--builtin-schema' flag supports the following schema names:
@@ -238,8 +239,8 @@ def main(
     no_cache: bool,
     cache_filename: str | None,
     disable_formats: tuple[list[str], ...],
-    format_regex: t.Literal["python", "default"] | None,
-    regex_variant: t.Literal["python", "default"] | None,
+    format_regex: t.Literal["python", "nonunicode", "default"] | None,
+    regex_variant: t.Literal["python", "nonunicode", "default"] | None,
     default_filetype: t.Literal["json", "yaml", "toml", "json5"],
     traceback_mode: t.Literal["full", "short"],
     data_transform: t.Literal["azure-pipelines", "gitlab-ci"] | None,

src/check_jsonschema/cli/parse_result.py

@@ -51,11 +51,13 @@ def __init__(self) -> None:
 
     def set_regex_variant(
         self,
-        variant_opt: Literal["python", "default"] | None,
+        variant_opt: Literal["python", "nonunicode", "default"] | None,
         *,
-        legacy_opt: Literal["python", "default"] | None = None,
+        legacy_opt: Literal["python", "nonunicode", "default"] | None = None,
     ) -> None:
-        variant_name: Literal["python", "default"] | None = variant_opt or legacy_opt
+        variant_name: Literal["python", "nonunicode", "default"] | None = (
+            variant_opt or legacy_opt
+        )
         if variant_name:
             self.regex_variant = RegexVariantName(variant_name)
 

src/check_jsonschema/regex_variants.py

@@ -8,6 +8,7 @@
 
 class RegexVariantName(enum.Enum):
     default = "default"
+    nonunicode = "nonunicode"
     python = "python"
 
 
@@ -31,23 +32,47 @@ def __init__(self, variant: RegexVariantName) -> None:
         self.variant = variant
 
         if self.variant == RegexVariantName.default:
-            self._real_implementation = _RegressImplementation()
+            self._real_implementation = _UnicodeRegressImplementation()
+        elif self.variant == RegexVariantName.nonunicode:
+            self._real_implementation = _NonunicodeRegressImplementation()
         else:
             self._real_implementation = _PythonImplementation()
 
         self.check_format = self._real_implementation.check_format
         self.pattern_keyword = self._real_implementation.pattern_keyword
 
 
-class _RegressImplementation:
+class _UnicodeRegressImplementation:
+    def check_format(self, instance: t.Any) -> bool:
+        if not isinstance(instance, str):
+            return True
+        try:
+            regress.Regex(instance, flags="u")
+        except regress.RegressError:
+            return False
+        return True
+
+    def pattern_keyword(
+        self, validator: t.Any, pattern: str, instance: str, schema: t.Any
+    ) -> t.Iterator[jsonschema.ValidationError]:
+        if not validator.is_type(instance, "string"):
+            return
+
+        try:
+            regress_pattern = regress.Regex(pattern, flags="u")
+        except regress.RegressError:
+            yield jsonschema.ValidationError(f"pattern {pattern!r} failed to compile")
+        if not regress_pattern.find(instance):
+            yield jsonschema.ValidationError(f"{instance!r} does not match {pattern!r}")
+
+
+class _NonunicodeRegressImplementation:
     def check_format(self, instance: t.Any) -> bool:
         if not isinstance(instance, str):
             return True
         try:
             regress.Regex(instance)
-        # something is wrong with RegressError getting into the published types
-        # needs investigation... for now, ignore the error
-        except regress.RegressError:  # type: ignore[attr-defined]
+        except regress.RegressError:
             return False
         return True
 
@@ -59,7 +84,7 @@ def pattern_keyword(
 
         try:
             regress_pattern = regress.Regex(pattern)
-        except regress.RegressError:  # type: ignore[attr-defined]
+        except regress.RegressError:
             yield jsonschema.ValidationError(f"pattern {pattern!r} failed to compile")
         if not regress_pattern.find(instance):
             yield jsonschema.ValidationError(f"{instance!r} does not match {pattern!r}")