Merge pull request #1 from Anusha0501/fix/1558-regex-format-uncaught-exceptions

Report regex compile failures as invalid format, not crashes.

Author: Anusha0501

CHANGELOG.rst

@@ -1,6 +1,7 @@
 v4.27.0
 =======
 
+* The ``regex`` format checker now reports conflicting inline flags, deeply nested patterns, and oversized repeat counts as invalid instances instead of letting ``ValueError``, ``RecursionError``, or ``OverflowError`` escape from ``re.compile`` (#1526, #1538, #1558).
 * Improve ``best_match`` for ``anyOf`` / ``oneOf`` errors: the most relevant error is now found within each subschema separately before the deepest of those is picked (#1257, #1300).
   In particular an applicator with a single subschema now produces the same best match as the bare subschema would.
   ``relevance`` no longer considers an error's position amongst its siblings.

jsonschema/_format.py

@@ -413,7 +413,12 @@ def is_time(instance: object) -> bool:
         return is_datetime("1970-01-01T" + instance)
 
 
-@_checks_drafts(name="regex", raises=re.error)
+# re.compile can raise more than re.error (conflicting flags, deep
+# nesting, oversized repeats). Treat those as an invalid regex instance.
+@_checks_drafts(
+    name="regex",
+    raises=(re.error, ValueError, RecursionError, OverflowError),
+)
 def is_regex(instance: object) -> bool:
     if not isinstance(instance, str):
         return True

jsonschema/tests/test_format.py

@@ -89,3 +89,33 @@ def test_repr(self):
             repr(checker),
             "<FormatChecker checkers=['bar', 'baz', 'foo']>",
         )
+
+    def test_regex_format_rejects_unterminated_pattern(self):
+        checker = FormatChecker()
+        with self.assertRaises(FormatError):
+            checker.check("[unterminated", "regex")
+        self.assertFalse(checker.conforms("[unterminated", "regex"))
+
+    def test_regex_format_rejects_conflicting_inline_flags(self):
+        checker = FormatChecker()
+        for pattern in ("(?u)(?a)", "(?a)(?u)"):
+            with self.assertRaises(FormatError):
+                checker.check(pattern, "regex")
+            self.assertFalse(checker.conforms(pattern, "regex"))
+
+    def test_regex_format_rejects_deeply_nested_pattern(self):
+        checker = FormatChecker()
+        pattern = "(" * 500
+        with self.assertRaises(FormatError):
+            checker.check(pattern, "regex")
+        self.assertFalse(checker.conforms(pattern, "regex"))
+
+    def test_regex_format_rejects_overflowing_repeat_count(self):
+        checker = FormatChecker()
+        with self.assertRaises(FormatError):
+            checker.check("a{99999999999999}", "regex")
+        self.assertFalse(checker.conforms("a{99999999999999}", "regex"))
+
+    def test_regex_format_accepts_valid_pattern(self):
+        checker = FormatChecker()
+        self.assertTrue(checker.conforms(r"^\d+$", "regex"))