corvus_json_schema 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c2d9281b9ea94c2bb26aee9a8ee85263a955fe854815e40b1c5534de0f46e49
-  data.tar.gz: cb454e6575a895befccfa1c29e82c8863d0e5e24cfddc9a3364d76c00007b6d8
+  metadata.gz: 7e2347892c4bd0c1e41ef9b14747b260c5938d47f1a644f1fdbe0c3992f822a1
+  data.tar.gz: 78e9eda166cac2e81b48f87927299d2c092f45b1269179c58ed65495e9cf278f
 SHA512:
-  metadata.gz: b9c879b1801c552f58955f4de2bab5b2a2fee5eb2a233762ebf038ef19dd87f6431393d4c6fb9a093e02024106b02b2f109dc268889d7a959047dd3d2e97a35f
-  data.tar.gz: dce28a0a4889558d6e3040259bb28c3aa77e1773b04f486dc1aeeffb3b942edf354b7ad326efa45b65ac40573a56d70793793880fc8c9d6590a7645425813e99
+  metadata.gz: b5d369d4df79459748f2eeaf93a1586986ab37d8d112e3095ca22650c0144ca110b6f0d85559c0f4cd82b704ba1bcee3117813785fa796d120e643f500228253
+  data.tar.gz: 9fca29ee3cdf761a2caeebf80a6f8c83f788957d346c0d66fdd1d7af2735c439b6b9a0f7161e5e570a07aef2f91075f2d9077aa0785fd3ecaa194a4642695de2

data/Cargo.lock

@@ -63,15 +63,26 @@ dependencies = [
 
 [[package]]
 name = "corvus-json-schema"
-version = "0.1.7"
+version = "0.2.0"
 dependencies = [
+ "corvus-regex-ecma262",
  "regex",
  "serde_json",
 ]
 
+[[package]]
+name = "corvus-regex-ecma262"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be72de82781404398482a431a88c1d03b82d474a5fad3003cac18f5893fc71ee"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+]
+
 [[package]]
 name = "corvus_json_schema"
-version = "0.1.4"
+version = "0.2.0"
 dependencies = [
  "corvus-json-schema",
  "magnus",

data/README.md

@@ -54,6 +54,8 @@ Its options:
 | `entry_point` | `nil` | A reference to the subschema to validate against, such as `"#/$defs/item"`. |
 | `max_depth` | `128` | The deepest the evaluator recurses in place before it raises `DepthError`. |
 | `pattern_match_limit` | `1.0` | The seconds one match of a `pattern` or `patternProperties` regular expression against one string may take before the validation raises `PatternMatchLimitError`. `nil` or `0` turns the limit off, for a caller who trusts both the schema and the instances. |
+| `regex_edition` | `:dialect` | The edition of ECMA-262 `pattern`, `patternProperties` and the `regex` format are read with: `:dialect` (ECMAScript 2020 for 2019-09 and 2020-12, which name it, today's for the drafts before them), `:current` or `:es2020`. Under ECMAScript 2020 a modifier group such as `(?i:...)` is not valid. |
+| `regex_unicode_version` | `:default` | The version of Unicode patterns are read with: `:default` (the version of the V8 the answers are held to, 17 today), `:latest`, `13`, `17` or `18`. |
 
 A `Validator` is immutable and can be shared between threads.
 
@@ -114,7 +116,7 @@ repository's submodule (or `JSON_SCHEMA_TEST_SUITE`).
 
 Apache-2.0
 
-The gem is built on the `corvus-json-schema` Rust crate, whose Unicode tables are derived from the Unicode Character
-Database, which is under the Unicode License V3. [THIRD-PARTY-NOTICES.txt](THIRD-PARTY-NOTICES.txt) has that notice,
-and the one of the `regress` crate that the tables were first read from. The file is in the source gem and in every
-native gem, beside `LICENSE`.
+The gem is built on the `corvus-json-schema` Rust crate, which matches patterns with the `corvus-regex-ecma262` crate,
+whose Unicode tables are derived from the Unicode Character Database, which is under the Unicode License V3.
+[THIRD-PARTY-NOTICES.txt](THIRD-PARTY-NOTICES.txt) has that notice, and the one of the `regress` crate, from whose
+tables those were written. The file is in the source gem and in every native gem, beside `LICENSE`.

data/THIRD-PARTY-NOTICES.txt

@@ -13,14 +13,16 @@ License notice for the Unicode Character Database
 
 The gem is built on the corvus-json-schema Rust crate. The source gem holds
 the crate's sources (ext/corvus_json_schema/vendor/corvus-json-schema), and a
-native gem holds the extension compiled from them. src/ecmaregex/tables_gen.rs
-of that crate holds tables derived from the data files of the Unicode
-Character Database, version 17.0.0
-(https://www.unicode.org/Public/17.0.0/ucd/): the General_Category values, the
-binary properties, the Script and Script_Extensions values, the simple case
-folding and the simple uppercase mapping. The data files are "© 2025 Unicode®,
-Inc." and are licensed under the Unicode License V3 (SPDX-License-Identifier:
-Unicode-3.0), as https://www.unicode.org/license.txt gives it:
+native gem holds the extension compiled from them. That crate matches patterns
+with the corvus-regex-ecma262 crate, which is compiled in with it.
+corvus-regex-ecma262 holds tables derived from the data files of the Unicode
+Character Database, versions 13.0.0, 17.0.0 and 18.0.0
+(https://www.unicode.org/Public/), and from its emoji sequence files: the
+General_Category values, the binary properties, the Script and
+Script_Extensions values, the simple case folding, the simple uppercase
+mapping and the properties of strings. The data files are licensed under the
+Unicode License V3 (SPDX-License-Identifier: Unicode-3.0), as
+https://www.unicode.org/license.txt gives it:
 
 UNICODE LICENSE V3
 
@@ -65,12 +67,11 @@ authorization of the copyright holder.
 License notice for https://github.com/ridiculousfish/regress
 -------------------------------
 
-The tables of src/ecmaregex/tables_gen.rs of the corvus-json-schema crate were
-written from the tables of the Corvus Go module, which were written from
-src/unicodetables.rs of regress 0.12.0. That crate generates the file from the
-Unicode Character Database. regress is licensed under the MIT license or the
-Apache License, Version 2.0, at the user's option. Neither the gem nor the
-corvus-json-schema crate depends on it.
+The tables of the corvus-regex-ecma262 crate were written, through the tables
+of the Corvus Go module, from the property tables of regress (its gen-unicode
+tool), which are generated from the Unicode Character Database. regress is
+licensed under the MIT license or the Apache License, Version 2.0, at the
+user's option. Neither the gem nor the crates it is built on depend on it.
 
 MIT License
 

data/VERSIONHISTORY.md

@@ -2,6 +2,15 @@
 
 The version history of the `corvus_json_schema` Ruby gem. It is versioned independently of the Corvus NuGet packages and of the [corvus-json-schema](../../src-rs/corvus-json-schema/VERSIONHISTORY.md) Rust crate it is built on.
 
+## V0.2.0
+
+V0.2.0 takes version 0.2.0 of the `corvus-json-schema` crate, which matches patterns with the [`corvus-regex-ecma262`](https://crates.io/crates/corvus-regex-ecma262) crate and reads them in the grammar of the dialect. It is a minor version because under 2019-09 and 2020-12 a pattern that uses what ECMAScript added after 2020 is no longer valid. Everything else that was there is unchanged, and there are two new options.
+
+- **The grammar of the dialect.** JSON Schema 2019-09 and 2020-12 name the grammar of ECMAScript 2020, and patterns under them are now read with it: a modifier group such as `(?i:...)`, or a group name used by two groups, is not valid, and `CorvusJsonSchema.compile` raises `CompilationError` for a schema with one in a `pattern`. A property escape that the tables of 2020 do not have (`\p{Script=Yezidi}`) is not valid with the `u` flag, so the pattern is read without it, where `\p` is the letter `p`, as a pattern with `\&` is. The `regex` format reads only the grammar of the flag. Drafts 4 to 7 read today's grammar, as before.
+- **`regex_edition:`** (`:dialect`, the default, `:current` or `:es2020`) chooses the edition for every dialect, and **`regex_unicode_version:`** (`:default`, the default, `:latest`, `13`, `17` or `18`) the version of Unicode. Another value raises `ArgumentError`.
+- **The engine.** Every pattern that no dedicated matcher of the crate takes is matched by `corvus-regex-ecma262`, whose answers are V8's for the whole of the ECMA-262 regular expression test data. The limits are those of 0.1.4. Over the jsonschema-benchmark corpora the crate validates in 0.98 of the time of 0.1.7 once warm, and takes 1.06 of it for the first validation and 1.05 to compile, since the engine builds a pattern's automaton on its first match.
+- **Notices.** `THIRD-PARTY-NOTICES.txt` names the tables of `corvus-regex-ecma262`, which the native gems now hold in place of the crate's own. The source gem no longer carries a copy of the crate's notice, which the crate no longer has.
+
 ## V0.1.4
 
 V0.1.4 takes version 0.1.7 of the `corvus-json-schema` crate. That fixes wrong results for several forms of pattern and a validation that did not end, replaces the crate's regular expression engine, and gives every match of a pattern a limit of time. The functions and types that were there are unchanged, and there are additions for the limit. Versions 0.1.0 to 0.1.3 are affected.

data/ext/corvus_json_schema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "corvus_json_schema"
-version = "0.1.4"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.89"
 description = "The native extension of the corvus_json_schema gem: the corvus-json-schema crate, reading Ruby values in place."
@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 # The crate, copied in by `rake vendor` (from src-rs/corvus-json-schema) so that the source gem builds on its own.
-corvus = { package = "corvus-json-schema", path = "vendor/corvus-json-schema", version = "0.1.7" }
+corvus = { package = "corvus-json-schema", path = "vendor/corvus-json-schema", version = "0.2.0" }
 magnus = { version = "0.9.1", features = ["rb-sys"] }
 rb-sys = "0.9.130"
 serde_json = { version = "1.0.151", features = ["preserve_order", "float_roundtrip"] }

data/ext/corvus_json_schema/src/lib.rs

@@ -4,7 +4,8 @@
 use std::cell::{Cell, RefCell};
 
 use corvus::{
-    ArrayView, CompileOptions, Dialect, Instance, JsonSchemaResultsCollector, Kind, ObjectView, ResultsLevel, View,
+    ArrayView, CompileOptions, Dialect, Instance, JsonSchemaResultsCollector, Kind, ObjectView, RegexEdition,
+    RegexUnicodeVersion, ResultsLevel, View,
 };
 use magnus::prelude::*;
 use magnus::rb_sys::AsRawValue;
@@ -481,6 +482,8 @@ fn compile(
     entry_point: Option<String>,
     max_depth: u32,
     pattern_match_limit: Option<f64>,
+    regex_edition: String,
+    regex_unicode_version: String,
 ) -> Result<Validator, Error> {
     let schema: Json = match RString::from_value(schema) {
         Some(text) => serde_json::from_str(&text.to_string()?)
@@ -513,6 +516,30 @@ fn compile(
             }
             _ => None,
         },
+        regex_edition: match regex_edition.as_str() {
+            "dialect" => None,
+            "current" => Some(RegexEdition::Current),
+            "es2020" => Some(RegexEdition::Es2020),
+            e => {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    format!("regex_edition is :dialect, :current or :es2020, not {e:?}"),
+                ));
+            }
+        },
+        regex_unicode_version: match regex_unicode_version.as_str() {
+            "default" => RegexUnicodeVersion::Default,
+            "latest" => RegexUnicodeVersion::Latest,
+            "13" => RegexUnicodeVersion::V13,
+            "17" => RegexUnicodeVersion::V17,
+            "18" => RegexUnicodeVersion::V18,
+            v => {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    format!("regex_unicode_version is :default, :latest, 13, 17 or 18, not {v:?}"),
+                ));
+            }
+        },
         ..CompileOptions::default()
     };
     let mut ruby_formats = false;
@@ -649,7 +676,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_error("InvalidJsonError", error)?;
 
     let native = module.define_module("Native")?;
-    native.define_singleton_method("compile", function!(compile, 11))?;
+    native.define_singleton_method("compile", function!(compile, 13))?;
     native.define_singleton_method("crate_version", function!(|| corvus::VERSION, 0))?;
 
     let validator = module.define_class("Validator", ruby.class_object())?;

data/ext/corvus_json_schema/vendor/corvus-json-schema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "corvus-json-schema"
-version = "0.1.7"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.89"
 description = "A high-performance JSON Schema evaluator (draft 4 to 2020-12) with results collection and annotations, ported from the Corvus.Text.Json V5 runtime evaluator."
@@ -13,19 +13,14 @@ keywords = ["json-schema", "validation", "jsonschema", "validator"]
 categories = ["encoding", "parser-implementations"]
 # The published crate: the library and its documents. The tests read the repository's JSON-Schema-Test-Suite
 # submodule and the C# metaschemas, so they only run from a checkout. LICENSE is a copy of the repository's (CI checks
-# it matches). THIRD-PARTY-NOTICES.txt has the notice of the Unicode data that src/ecmaregex/tables_gen.rs is derived
-# from, which must go wherever the crate goes.
-include = ["src/**", "Cargo.toml", "README.md", "LICENSE", "THIRD-PARTY-NOTICES.txt"]
+# it matches).
+include = ["src/**", "Cargo.toml", "README.md", "LICENSE"]
 
 [dependencies]
+corvus-regex-ecma262 = "0.2.7"
 regex = "1.13.1"
 serde_json = { version = "1.0.151", features = ["preserve_order", "float_roundtrip"] }
 
-[lints.rust]
-# A build with this cfg makes every match of the regular expression engine use its memory of failed places from its
-# first step (see src/ecmaregex/vm.rs), which is how the test data is run with the memory in use for every pattern.
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(corvus_memo_from_the_start)'] }
-
 [profile.release]
 codegen-units = 1
 lto = "fat"

data/ext/corvus_json_schema/vendor/corvus-json-schema/README.md

@@ -73,30 +73,35 @@ this way, through CPython's C API.
 - **Patterns:** use ECMA-262 semantics. A pattern is compiled with the `u` flag. One that is not valid with it (it has
   `\&` or `\-`, say) is compiled without it, as many validators accept such patterns, and is then matched as
   ECMA-262 says for it: by UTF-16 code unit, so a character beyond the Basic Multilingual Plane is two. The `regex`
-  format accepts only the grammar of the flag. Common shapes (class sequences, literals and their alternatives,
-  separated lists, line lengths) get dedicated matchers, as in the C# evaluator. Patterns within the common subset of
-  ECMA-262 and the [`regex`](https://crates.io/crates/regex) crate's syntax are translated and run by `regex`.
-  Anything else (lookarounds, backreferences, `\B`, modifier groups) is matched by the crate's own ECMA-262 engine
-  (`src/ecmaregex`), a port of the engine of the Go module, which the Object Pascal and OCaml ports also carry. The
-  crate depends on `regex` and `serde_json` alone.
+  format accepts only the grammar of the flag, and asks the grammar alone, without the engine's limits of size. Common shapes (class sequences, a few literals and alternatives, line
+  lengths) get dedicated matchers, as in the C# evaluator, where each was measured faster than the engine over the
+  strings of the jsonschema-benchmark corpora. Every other pattern is matched by
+  [`corvus-regex-ecma262`](https://crates.io/crates/corvus-regex-ecma262), an ECMA-262 engine. The crate depends
+  on it, `regex` (for the format checks) and `serde_json`.
 
   **What is exact.** Everything. A pattern is matched as it is written, whichever matcher has it, and none is
-  refused for what an engine cannot do. The answers are V8's for every pattern and text of the
-  [ECMA-262 regular expression test data](https://github.com/corvus-dotnet/ecma262-regex-test-data) that a Rust string
-  can hold (98,839 patterns, 4,268,313 texts), the records where V8 itself departs from ECMA-262 apart. That covers
-  lookaheads and lookbehinds, backreferences into and out of repetitions and lookarounds, named groups, a name shared
-  by groups in separate alternatives, modifier groups, repetitions inside repetitions with any count, and
-  case-insensitive matching in both grammars.
+  refused for what an engine cannot do. The engine's answers are V8's for the whole of the
+  [ECMA-262 regular expression test data](https://github.com/corvus-dotnet/ecma262-regex-test-data): lookaheads and
+  lookbehinds, backreferences into and out of repetitions and lookarounds, named groups, a name shared by groups in
+  separate alternatives, modifier groups, repetitions inside repetitions with any count, and case-insensitive
+  matching in both grammars.
+
+  **The grammar of the dialect.** JSON Schema 2019-09 and 2020-12 name the grammar of ECMAScript 2020, so under them a
+  pattern is read with `RegexEdition::Es2020`: what later editions added (modifier groups such as `(?i:...)`, a group
+  name used by two groups) is not valid, and a schema that uses it is refused. A property escape that is not in the
+  tables of 2020 is not valid with the `u` flag, so the pattern is read without it, where `\p` is the letter `p`. Drafts
+  4 to 7 read today's grammar. `CompileOptions::regex_edition` chooses another edition and
+  `CompileOptions::regex_unicode_version` the version of Unicode (by default the version of the V8 the engine's answers
+  are held to, 17 today), for `pattern`, `patternProperties` and the `regex` format alike.
 
   **Limits.** A schema and an instance may both come from outside, so a pattern is bounded in what it costs.
 
   - *A match has a limit of time.* `CompileOptions::pattern_match_limit` is the time one match against one string may
     take. The default is one second (`DEFAULT_PATTERN_MATCH_LIMIT`), and `None` or zero turns it off for a caller who
     trusts both the schema and the instances. A match that reaches it is abandoned, and so is one whose backtracking
-    holds 1,048,576 entries (24 MB). The validation then has no answer: the `try_` functions (`try_validate`,
-    `try_validate_json`, `try_evaluate` and the rest) return `SchemaEvaluationError::PatternMatchLimit` with the
-    pattern and the limit. The engine counts its steps and reads the clock every 4,096 of them, so the limit costs
-    nothing that allocates and is met within tens of microseconds.
+    runs out of the memory the engine allows it. The validation then has no answer: the `try_` functions
+    (`try_validate`, `try_validate_json`, `try_evaluate` and the rest) return
+    `SchemaEvaluationError::PatternMatchLimit` with the pattern and the limit.
   - *The functions without the new error.* `is_valid` returns a `bool` and fails closed: it returns `false` for a
     match that reached its limit, as it does for the maximum depth, and never `true`. `validate`,
     `validate_instance`, `validate_json` and the `evaluate` functions report it as the one error their type has for
@@ -107,34 +112,18 @@ this way, through CPython's C API.
     counted as more than 1,048,576 as it is read (64 for a term, 32 for an alternative, 8 for a range of a class) is
     refused when the schema is compiled. The message says it is too large, not that it is not valid, and
     `SchemaCompilationError::kind` is `PatternTooLarge`. A pattern of plain characters can be 16,384 characters long.
+    These are the engine's limits.
   - *What the crate keeps is bounded.* The cache of compiled patterns of the process holds 1,024 patterns and 64 MiB
-    at most, and the `regex` crate is given no program over 2 MiB.
+    at most.
   - *The format checks take time proportional to the string.* They read strings of the instance and are not under
     the limit of a match. Dates, times, UUIDs, IP addresses and host names are read by scanners that pass over the
     string once, and the others are regular expressions on the `regex` crate, which is linear. `regex` reads the
-    string as a pattern, with the limits of size. `idn-hostname`, and the domain of an `idn-email`, read nothing of
+    string with the engine's grammar-only reader, without the limits of size. `idn-hostname`, and the domain of an `idn-email`, read nothing of
     a string over 1,012 bytes: an internationalized host name has 253 characters at most, and its check decodes and
     encodes Punycode, which takes time that grows with the square of a label.
   - *What is not bounded.* The limit is for each match, not for a validation. The matchers that read a string once
-    are not stopped, and `regex` is given a string only when it can answer within the limit. With the limit turned
-    off, nothing bounds a match: a group read back inside a repetition, as in `^(?:(a+)\1*)+$`, takes time that
-    doubles with each character of some strings.
-
-  **Where V8 departs from ECMA-262,** the crate follows ECMA-262. With the `u` flag V8 starts a match between the two
-  halves of a surrogate pair, compares a case-insensitive backreference to a group of several characters by full
-  case folding, and answers some case-insensitive modifier groups differently from the same pattern with the `i`
-  flag. The test data marks those records. V8 13.6 also differs in what it takes as a pattern. It takes
-  `\p{WSpace}`, a count whose first number is the greater when the numbers are large
-  (`a{2147483648,2147483647}`), and a name of two groups that can both take part in one match
-  (`(|((?<m>))(?<m>|))`), none of which ECMA-262 allows, and the crate refuses them. It refuses the Script value
-  `Hrkt` (`Katakana_Or_Hiragana`), which is in Unicode's list of values, and the crate takes it (no character has
-  it, so it matches nothing).
-
-  **Unicode versions.** Properties and case-insensitive matching use tables of the crate's own, for Unicode 17: the
-  same tables as the Go module, and nothing from the Rust standard library or from the `regex` crate, so the answers
-  do not depend on the toolchain or on a dependency's release. V8 13.6 has Unicode 16. They agree on every
-  character of Unicode 16. The four scripts Unicode 17 adds (`Sidetic`, `Tolong_Siki`, `Beria_Erfe`, `Tai_Yo`) are
-  scripts here, where V8 13.6 does not know them. The tables are generated from the Unicode Character Database.
+    are not stopped. With the limit turned off, nothing bounds a match: a group read back inside a repetition, as in
+    `^(?:(a+)\1*)+$`, takes time that doubles with each character of some strings.
 
   **Lone surrogates.** A JSON string with the escape of half of a surrogate pair (`"\ud800"`) is not a Rust string.
   `validate_json` and `serde_json` both refuse the document as not valid JSON.
@@ -201,22 +190,14 @@ This runs:
 - **`tests/results.rs`:** the results-collection expectations shared with the C# and TypeScript evaluators.
 - **`tests/metaschemas.rs`:** checks that `src/metaschemas.rs` matches `src/Corvus.Text.Json/metaschema`.
   Regenerate it with `UPDATE_METASCHEMAS=1 cargo test --test metaschemas`.
-- **The regular expression engine's own tests** (`src/ecmaregex/tests.rs`): the tests of the Go package it is a port
-  of, with V8's answers read from that package's `testdata` (`v8_cases.json`, `v8_oracle.json`) and the sizes the
-  ports must agree on (`size_cases.json`). One test compares the Unicode tables with the Go module's.
-- **`tests/pattern_engine.rs`, `tests/pattern_anchors.rs` and `tests/pattern_class.rs`:** patterns that an engine
-  or a matcher answered wrongly at some point, with V8's answers.
+- **The tests of `src/pattern.rs`:** every dedicated matcher agrees with the engine on strings made to probe it,
+  and the cache of compiled patterns stays within its bounds.
+- **`tests/pattern_anchors.rs` and `tests/pattern_class.rs`:** patterns that an engine or a matcher answered wrongly
+  at some point, with V8's answers.
 - **`tests/pattern_limits.rs`:** the limit of a match and the limits of size, through the public functions.
 - **`tests/allocations.rs`:** validating JSON text allocates nothing in the steady state, with patterns the engine
   matches and with the limit on or off.
 
-The Unicode tables are `src/ecmaregex/tables_gen.rs`. `pwsh tools/gen-ucd-tables.ps1` writes them from the tables of
-the Go module (`src-go/corvus-json-schema/internal/ucd/tables_gen.go`), so the two ports hold the same data.
-
 ## License
 
 Apache 2.0.
-
-The Unicode tables are derived from the Unicode Character Database, which is under the Unicode License V3.
-[THIRD-PARTY-NOTICES.txt](THIRD-PARTY-NOTICES.txt) has that notice, and the one of the `regress` crate that the
-tables were first read from. The file is in the published crate, beside `LICENSE`.

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/compiler.rs

@@ -271,6 +271,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             (r.dialect, r.vocabularies)
         };
         let legacy = dialect.is_legacy();
+        let grammar = crate::pattern::Grammar::of(dialect, self.options);
 
         if legacy && let Some(Value::String(r)) = e.get("$ref") {
             // In draft 7 and earlier, $ref replaces every sibling keyword.
@@ -344,7 +345,8 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             if let Some(Value::Object(pp)) = e.get("patternProperties") {
                 let mut list = Vec::with_capacity(pp.len());
                 for (pattern, v) in pp {
-                    let compiled = crate::pattern::compile(pattern).map_err(|e| e.of(pattern, "patternProperties"))?;
+                    let compiled =
+                        crate::pattern::compile(pattern, grammar).map_err(|e| e.of(pattern, "patternProperties"))?;
                     let c = self.child(target, v, &format!("/patternProperties/{}", escape_pointer_token(pattern)));
                     list.push(PatternProperty { pattern: compiled, node: c });
                 }
@@ -467,7 +469,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             n.min_length = get_uint(e.get("minLength"));
             n.max_length = get_uint(e.get("maxLength"));
             if let Some(Value::String(p)) = e.get("pattern") {
-                n.pattern = Some(crate::pattern::compile(p).map_err(|e| e.of(p, "pattern"))?);
+                n.pattern = Some(crate::pattern::compile(p, grammar).map_err(|e| e.of(p, "pattern"))?);
             }
             if let Some(Value::Number(m)) = e.get("multipleOf") {
                 n.multiple_of = Some(m.clone());
@@ -510,7 +512,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
 
         if let Some(Value::String(f)) = e.get("format") {
             n.format = Some(f.clone());
-            n.format_kind = FormatKind::of(f, dialect);
+            n.format_kind = FormatKind::of(f, dialect, grammar);
             n.assert_format = format_assert;
         }
 

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/formats.rs

@@ -30,7 +30,8 @@ pub(crate) enum FormatKind {
     UriTemplate,
     JsonPointer,
     RelativeJsonPointer,
-    Regex,
+    /// The regex format, read in the grammar the dialect reads patterns with.
+    Regex(crate::pattern::Grammar),
     // Numeric formats (a Corvus extension).
     Byte,
     UInt16,
@@ -49,7 +50,7 @@ pub(crate) enum FormatKind {
 }
 
 impl FormatKind {
-    pub fn of(format: &str, dialect: Dialect) -> FormatKind {
+    pub fn of(format: &str, dialect: Dialect, grammar: crate::pattern::Grammar) -> FormatKind {
         use FormatKind::*;
         let at_least = |d: Dialect, k: FormatKind| if dialect >= d { k } else { Unknown };
         match format {
@@ -78,7 +79,7 @@ impl FormatKind {
             "json-pointer" => at_least(Dialect::Draft6, JsonPointer),
             "date" => at_least(Dialect::Draft7, Date),
             "time" => at_least(Dialect::Draft7, Time),
-            "regex" => at_least(Dialect::Draft7, Regex),
+            "regex" => at_least(Dialect::Draft7, Regex(grammar)),
             "relative-json-pointer" => at_least(Dialect::Draft7, RelativeJsonPointer),
             "idn-email" => at_least(Dialect::Draft7, IdnEmail),
             "idn-hostname" => at_least(Dialect::Draft7, IdnHostname),
@@ -133,7 +134,7 @@ impl FormatKind {
             UriTemplate => "uri-template",
             JsonPointer => "json-pointer",
             RelativeJsonPointer => "relative-json-pointer",
-            Regex => "regex",
+            Regex(_) => "regex",
             Byte => "byte",
             UInt16 => "uint16",
             UInt32 => "uint32",
@@ -175,7 +176,7 @@ impl FormatKind {
             RelativeJsonPointer => {
                 "Expected a Relative JSON Pointer. (https://json-schema.org/draft/2020-12/relative-json-pointer)."
             }
-            Regex => "Expected a regular expression specification.",
+            Regex(_) => "Expected a regular expression specification.",
             _ => return None,
         })
     }
@@ -208,7 +209,7 @@ impl FormatKind {
             UriTemplate => URI_TEMPLATE_RE.is_match(s),
             JsonPointer => JSON_POINTER_RE.is_match(s),
             RelativeJsonPointer => RELATIVE_JSON_POINTER_RE.is_match(s),
-            Regex => crate::pattern::is_valid_ecma_regex(s),
+            Regex(grammar) => crate::pattern::is_valid_ecma_regex(s, grammar),
             _ => true,
         }
     }

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/lib.rs

@@ -63,7 +63,6 @@
 mod compiler;
 mod dialect;
 mod document;
-mod ecmaregex;
 mod eval;
 mod formats;
 mod instance;
@@ -86,8 +85,8 @@ pub use document::{JsonDocument, JsonDocumentArray, JsonDocumentObject, JsonDocu
 pub use instance::{ArrayView, Instance, Kind, ObjectView, View};
 pub use options::{
     CompileOptions, DEFAULT_PATTERN_MATCH_LIMIT, DocumentResolver, FormatValidator, PatternMatchLimitError,
-    PatternTooLargeError, SchemaCompilationError, SchemaCompilationErrorKind, SchemaEvaluationDepthError,
-    SchemaEvaluationError,
+    PatternTooLargeError, RegexEdition, RegexUnicodeVersion, SchemaCompilationError, SchemaCompilationErrorKind,
+    SchemaEvaluationDepthError, SchemaEvaluationError,
 };
 pub use results::{
     Annotation, JsonSchemaResultsCollector, ResultsLevel, SchemaResult, collect_annotations, encode_pointer_segment,
@@ -106,7 +105,8 @@ pub enum JsonValidationError {
     InvalidJson(JsonParseError),
     /// The validation was abandoned at a limit: it recursed in place beyond the maximum depth, or a match of a
     /// regular expression reached its limit. The name is from when the depth was the one limit, and the message
-    /// names both (see [`without_the_limit`] for why the two are one here).
+    /// names both. [`SchemaEvaluationDepthError`] has one value for the two, and the `try_` functions, which return
+    /// [`SchemaEvaluationError`], say which it was.
     DepthExceeded(SchemaEvaluationDepthError),
 }
 

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/options.rs

@@ -8,6 +8,7 @@ use std::time::Duration;
 use serde_json::Value;
 
 use crate::dialect::Dialect;
+pub use corvus_regex_ecma262::{Edition as RegexEdition, UnicodeVersion as RegexUnicodeVersion};
 
 /// Resolves a schema document by absolute URI; returns `None` if it is unknown.
 pub type DocumentResolver = Arc<dyn Fn(&str) -> Option<Value> + Send + Sync>;
@@ -48,6 +49,13 @@ pub struct CompileOptions {
     /// matchers that take time proportional to the string are not stopped: a string is given to one only when it
     /// can answer within the limit.
     pub pattern_match_limit: Option<Duration>,
+    /// The edition of ECMA-262 whose grammar every `pattern`, `patternProperties` name and `regex` format value is read
+    /// with, or `None` (the default) for each dialect's: ECMAScript 2020 for draft 2019-09 and draft 2020-12, which
+    /// cite it, and today's for the earlier drafts. A pattern that is not valid in it is refused when the schema is
+    /// compiled.
+    pub regex_edition: Option<RegexEdition>,
+    /// The version of Unicode the patterns are read with: by default the version of the V8 the answers are held to.
+    pub regex_unicode_version: RegexUnicodeVersion,
 }
 
 /// The time one match of a `pattern` or `patternProperties` regular expression against one string may take, unless
@@ -67,6 +75,8 @@ impl Default for CompileOptions {
             entry_point: None,
             max_depth: 128,
             pattern_match_limit: Some(DEFAULT_PATTERN_MATCH_LIMIT),
+            regex_edition: None,
+            regex_unicode_version: RegexUnicodeVersion::Default,
         }
     }
 }
@@ -84,6 +94,8 @@ impl fmt::Debug for CompileOptions {
             .field("entry_point", &self.entry_point)
             .field("max_depth", &self.max_depth)
             .field("pattern_match_limit", &self.pattern_match_limit)
+            .field("regex_edition", &self.regex_edition)
+            .field("regex_unicode_version", &self.regex_unicode_version)
             .finish()
     }
 }