corvus_json_schema 0.1.4 → 0.2.0

data/lib/corvus_json_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CorvusJsonSchema
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/corvus_json_schema.rb

@@ -39,16 +39,21 @@ module CorvusJsonSchema
   # "#/$defs/item"), max_depth (of in-place recursion, default 128) and pattern_match_limit (the seconds one match of
   # a pattern or patternProperties regular expression may take, default 1. A match that takes longer is abandoned and
   # the validation raises PatternMatchLimitError. nil or 0 turns the limit off, for a caller who trusts both the
-  # schema and the instances).
+  # schema and the instances), regex_edition (the edition of ECMA-262 patterns are read with: :dialect, the default,
+  # which is ECMAScript 2020 for 2019-09 and 2020-12 and today's for the drafts before them, :current or :es2020) and
+  # regex_unicode_version (the version of Unicode they are read with: :default, Unicode 17 today, :latest, 13, 17 or
+  # 18).
   #
   # A schema that does not compile raises CompilationError, and one with a regular expression over a limit of size
   # (1,048,576 bytes of pattern, 1,000 levels of groups) raises PatternTooLargeError, which is a CompilationError.
   def self.compile(schema, default_dialect: :draft202012, assert_format: nil, assert_format_in_legacy_drafts: false,
                    assert_content: true, formats: nil, resolver: nil, base_uri: nil, entry_point: nil, max_depth: 128,
-                   pattern_match_limit: DEFAULT_PATTERN_MATCH_LIMIT)
+                   pattern_match_limit: DEFAULT_PATTERN_MATCH_LIMIT, regex_edition: :dialect,
+                   regex_unicode_version: :default)
     dialect = DIALECTS.fetch(default_dialect) { raise ArgumentError, "unknown dialect #{default_dialect.inspect}" }
     Native.compile(schema, dialect, assert_format, assert_format_in_legacy_drafts, assert_content, formats, resolver,
-                   base_uri, entry_point, Integer(max_depth), pattern_match_limit&.to_f)
+                   base_uri, entry_point, Integer(max_depth), pattern_match_limit&.to_f, regex_edition.to_s,
+                   regex_unicode_version.to_s)
   end
 
   # The version of the corvus-json-schema crate the extension was built from.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: corvus_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - endjin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-17 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -47,22 +47,9 @@ files:
 - ext/corvus_json_schema/vendor/corvus-json-schema/Cargo.toml
 - ext/corvus_json_schema/vendor/corvus-json-schema/LICENSE
 - ext/corvus_json_schema/vendor/corvus-json-schema/README.md
-- ext/corvus_json_schema/vendor/corvus-json-schema/THIRD-PARTY-NOTICES.txt
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/compiler.rs
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/dialect.rs
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/document.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/charset.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/compile.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/dfa.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/fold.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/mod.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/parse.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/re2.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/tables_gen.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/tests.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/ucd.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/units.rs
-- ext/corvus_json_schema/vendor/corvus-json-schema/src/ecmaregex/vm.rs
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/eval.rs
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/eval/plan.rs
 - ext/corvus_json_schema/vendor/corvus-json-schema/src/eval/plan/fused.rs

data/ext/corvus_json_schema/vendor/corvus-json-schema/THIRD-PARTY-NOTICES.txt

@@ -1,93 +0,0 @@
-corvus-json-schema uses third-party libraries or other resources that may be
-distributed under licenses different than the corvus-json-schema software.
-
-In the event that we accidentally failed to list a required notice, please
-bring it to our attention. Post an issue or email us:
-
-           licensing@endjin.com
-
-The attached notices are provided for information only.
-
-License notice for the Unicode Character Database
--------------------------------
-
-src/ecmaregex/tables_gen.rs 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:
-
-UNICODE LICENSE V3
-
-COPYRIGHT AND PERMISSION NOTICE
-
-Copyright © 1991-2026 Unicode, Inc.
-
-NOTICE TO USER: Carefully read the following legal agreement. BY
-DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
-SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
-TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
-DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of data files and any associated documentation (the "Data Files") or
-software and any associated documentation (the "Software") to deal in the
-Data Files or Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, and/or sell
-copies of the Data Files or Software, and to permit persons to whom the
-Data Files or Software are furnished to do so, provided that either (a)
-this copyright and permission notice appear with all copies of the Data
-Files or Software, or (b) this copyright and permission notice appear in
-associated Documentation.
-
-THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
-THIRD PARTY RIGHTS.
-
-IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
-BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
-OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
-FILES OR SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder shall
-not be used in advertising or otherwise to promote the sale, use or other
-dealings in these Data Files or Software without prior written
-authorization of the copyright holder.
-
-License notice for https://github.com/ridiculousfish/regress
--------------------------------
-
-The tables of src/ecmaregex/tables_gen.rs were written by
-tools/gen-ucd-tables.ps1 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. This crate
-does not depend on it.
-
-MIT License
-
-Copyright (c) 2020 ridiculous_fish
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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

@@ -1,271 +0,0 @@
-//! Sets of code points, the classes ECMA-262 defines, and the sets of the Unicode properties (`charset.go`).
-
-use std::collections::HashMap;
-use std::sync::{Arc, LazyLock, Mutex};
-
-use super::Rune;
-use super::ucd;
-
-/// The last Unicode code point.
-pub(crate) const MAX_RUNE: Rune = ucd::MAX_RUNE;
-
-/// An immutable set of code points. The ranges are sorted, inclusive, and neither overlap nor touch. The two words
-/// of `ascii` repeat the membership of the code points below 128 so that the common case is one bit test.
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) struct CharSet {
-    pub(crate) ranges: Vec<Rune>,
-    pub(crate) ascii: [u64; 2],
-}
-
-impl CharSet {
-    /// Builds a set from inclusive pairs in any order, which may overlap. With `negate` it builds the complement.
-    pub(crate) fn new(pairs: &[Rune], negate: bool) -> CharSet {
-        let mut idx: Vec<usize> = (0..pairs.len() / 2).collect();
-        idx.sort_by_key(|&i| pairs[2 * i]);
-        let mut merged: Vec<Rune> = Vec::with_capacity(pairs.len());
-        for i in idx {
-            let (lo, hi) = (pairs[2 * i], pairs[2 * i + 1]);
-            if let Some(last) = merged.last_mut()
-                && lo <= *last + 1
-            {
-                if hi > *last {
-                    *last = hi;
-                }
-                continue;
-            }
-            merged.push(lo);
-            merged.push(hi);
-        }
-        if negate {
-            let mut inverse = Vec::with_capacity(merged.len() + 2);
-            let mut next: Rune = 0;
-            for &[lo, hi] in merged.as_chunks::<2>().0 {
-                if lo > next {
-                    inverse.push(next);
-                    inverse.push(lo - 1);
-                }
-                next = hi + 1;
-            }
-            if next <= MAX_RUNE {
-                inverse.push(next);
-                inverse.push(MAX_RUNE);
-            }
-            merged = inverse;
-        }
-        let mut ascii = [0u64; 2];
-        for &[lo, hi] in merged.as_chunks::<2>().0 {
-            if lo >= 128 {
-                break;
-            }
-            let mut c = lo;
-            while c <= hi && c < 128 {
-                ascii[(c >> 6) as usize] |= 1 << (c & 63);
-                c += 1;
-            }
-        }
-        CharSet { ranges: merged, ascii }
-    }
-
-    /// [`CharSet::new`], shared.
-    pub(crate) fn shared(pairs: &[Rune], negate: bool) -> Arc<CharSet> {
-        Arc::new(CharSet::new(pairs, negate))
-    }
-
-    /// Whether the set holds the ASCII character.
-    #[inline(always)]
-    pub(crate) fn has_ascii(&self, c: u8) -> bool {
-        (self.ascii[(c >> 6) as usize & 1] >> (c & 63)) & 1 != 0
-    }
-
-    /// Whether the set holds the code point.
-    #[inline]
-    pub(crate) fn contains(&self, r: Rune) -> bool {
-        if (0..128).contains(&r) {
-            return (self.ascii[(r >> 6) as usize] >> (r & 63)) & 1 != 0;
-        }
-        let ranges = &self.ranges[..];
-        let (mut lo, mut hi) = (0, ranges.len() / 2);
-        while lo < hi {
-            let mid = (lo + hi) >> 1;
-            if r > ranges[2 * mid + 1] {
-                lo = mid + 1;
-            } else if r < ranges[2 * mid] {
-                hi = mid;
-            } else {
-                return true;
-            }
-        }
-        false
-    }
-
-    /// Whether the set holds no code point.
-    pub(crate) fn is_empty(&self) -> bool {
-        self.ranges.is_empty()
-    }
-}
-
-// The classes ECMA-262 defines. \d and \w are ASCII only, \s is WhiteSpace and LineTerminator, and . is everything
-// but the four line terminators.
-pub(crate) const DIGIT_PAIRS: &[Rune] = &[0x30, 0x39];
-pub(crate) const WORD_PAIRS: &[Rune] = &[0x30, 0x39, 0x41, 0x5A, 0x5F, 0x5F, 0x61, 0x7A];
-pub(crate) const SPACE_PAIRS: &[Rune] = &[
-    0x9, 0xD, 0x20, 0x20, 0xA0, 0xA0, 0x1680, 0x1680, 0x2000, 0x200A, 0x2028, 0x2029, 0x202F, 0x202F, 0x205F, 0x205F,
-    0x3000, 0x3000, 0xFEFF, 0xFEFF,
-];
-pub(crate) const LINE_TERMINATOR_PAIRS: &[Rune] = &[0xA, 0xA, 0xD, 0xD, 0x2028, 0x2029];
-
-pub(crate) static DOT_SET: LazyLock<Arc<CharSet>> = LazyLock::new(|| CharSet::shared(LINE_TERMINATOR_PAIRS, true));
-
-/// Whether a byte is an ECMA-262 word character. Every word character is ASCII, so a word boundary can be decided
-/// from the bytes on either side of a position.
-#[inline(always)]
-pub(crate) fn is_word_byte(b: u8) -> bool {
-    b.is_ascii_alphanumeric() || b == b'_'
-}
-
-/// The short name of a General_Category value, from its long name, an alias or the short name itself.
-fn category_name(value: &str) -> Option<&'static str> {
-    Some(match value {
-        "Letter" | "L" => "L",
-        "Lowercase_Letter" | "Ll" => "Ll",
-        "Uppercase_Letter" | "Lu" => "Lu",
-        "Titlecase_Letter" | "Lt" => "Lt",
-        "Cased_Letter" | "LC" => "LC",
-        "Modifier_Letter" | "Lm" => "Lm",
-        "Other_Letter" | "Lo" => "Lo",
-        "Mark" | "Combining_Mark" | "M" => "M",
-        "Nonspacing_Mark" | "Mn" => "Mn",
-        "Spacing_Mark" | "Mc" => "Mc",
-        "Enclosing_Mark" | "Me" => "Me",
-        "Number" | "N" => "N",
-        "Decimal_Number" | "digit" | "Nd" => "Nd",
-        "Letter_Number" | "Nl" => "Nl",
-        "Other_Number" | "No" => "No",
-        "Punctuation" | "punct" | "P" => "P",
-        "Connector_Punctuation" | "Pc" => "Pc",
-        "Dash_Punctuation" | "Pd" => "Pd",
-        "Open_Punctuation" | "Ps" => "Ps",
-        "Close_Punctuation" | "Pe" => "Pe",
-        "Initial_Punctuation" | "Pi" => "Pi",
-        "Final_Punctuation" | "Pf" => "Pf",
-        "Other_Punctuation" | "Po" => "Po",
-        "Symbol" | "S" => "S",
-        "Math_Symbol" | "Sm" => "Sm",
-        "Currency_Symbol" | "Sc" => "Sc",
-        "Modifier_Symbol" | "Sk" => "Sk",
-        "Other_Symbol" | "So" => "So",
-        "Separator" | "Z" => "Z",
-        "Space_Separator" | "Zs" => "Zs",
-        "Line_Separator" | "Zl" => "Zl",
-        "Paragraph_Separator" | "Zp" => "Zp",
-        "Other" | "C" => "C",
-        "Control" | "cntrl" | "Cc" => "Cc",
-        "Format" | "Cf" => "Cf",
-        "Surrogate" | "Cs" => "Cs",
-        "Private_Use" | "Co" => "Co",
-        "Unassigned" | "Cn" => "Cn",
-        _ => return None,
-    })
-}
-
-/// The canonical name of a binary property ECMA-262 lists, from the name or an alias.
-fn binary_name(name: &str) -> Option<&'static str> {
-    Some(match name {
-        "ASCII" => "ASCII",
-        "ASCII_Hex_Digit" | "AHex" => "ASCII_Hex_Digit",
-        "Alphabetic" | "Alpha" => "Alphabetic",
-        "Any" => "Any",
-        "Assigned" => "Assigned",
-        "Bidi_Control" | "Bidi_C" => "Bidi_Control",
-        "Bidi_Mirrored" | "Bidi_M" => "Bidi_Mirrored",
-        "Case_Ignorable" | "CI" => "Case_Ignorable",
-        "Cased" => "Cased",
-        "Changes_When_Casefolded" | "CWCF" => "Changes_When_Casefolded",
-        "Changes_When_Casemapped" | "CWCM" => "Changes_When_Casemapped",
-        "Changes_When_Lowercased" | "CWL" => "Changes_When_Lowercased",
-        "Changes_When_NFKC_Casefolded" | "CWKCF" => "Changes_When_NFKC_Casefolded",
-        "Changes_When_Titlecased" | "CWT" => "Changes_When_Titlecased",
-        "Changes_When_Uppercased" | "CWU" => "Changes_When_Uppercased",
-        "Dash" => "Dash",
-        "Default_Ignorable_Code_Point" | "DI" => "Default_Ignorable_Code_Point",
-        "Deprecated" | "Dep" => "Deprecated",
-        "Diacritic" | "Dia" => "Diacritic",
-        "Emoji" => "Emoji",
-        "Emoji_Component" | "EComp" => "Emoji_Component",
-        "Emoji_Modifier" | "EMod" => "Emoji_Modifier",
-        "Emoji_Modifier_Base" | "EBase" => "Emoji_Modifier_Base",
-        "Emoji_Presentation" | "EPres" => "Emoji_Presentation",
-        "Extended_Pictographic" | "ExtPict" => "Extended_Pictographic",
-        "Extender" | "Ext" => "Extender",
-        "Grapheme_Base" | "Gr_Base" => "Grapheme_Base",
-        "Grapheme_Extend" | "Gr_Ext" => "Grapheme_Extend",
-        "Hex_Digit" | "Hex" => "Hex_Digit",
-        "IDS_Binary_Operator" | "IDSB" => "IDS_Binary_Operator",
-        "IDS_Trinary_Operator" | "IDST" => "IDS_Trinary_Operator",
-        "ID_Continue" | "IDC" => "ID_Continue",
-        "ID_Start" | "IDS" => "ID_Start",
-        "Ideographic" | "Ideo" => "Ideographic",
-        "Join_Control" | "Join_C" => "Join_Control",
-        "Logical_Order_Exception" | "LOE" => "Logical_Order_Exception",
-        "Lowercase" | "Lower" => "Lowercase",
-        "Math" => "Math",
-        "Noncharacter_Code_Point" | "NChar" => "Noncharacter_Code_Point",
-        "Pattern_Syntax" | "Pat_Syn" => "Pattern_Syntax",
-        "Pattern_White_Space" | "Pat_WS" => "Pattern_White_Space",
-        "Quotation_Mark" | "QMark" => "Quotation_Mark",
-        "Radical" => "Radical",
-        "Regional_Indicator" | "RI" => "Regional_Indicator",
-        "Sentence_Terminal" | "STerm" => "Sentence_Terminal",
-        "Soft_Dotted" | "SD" => "Soft_Dotted",
-        "Terminal_Punctuation" | "Term" => "Terminal_Punctuation",
-        "Unified_Ideograph" | "UIdeo" => "Unified_Ideograph",
-        "Uppercase" | "Upper" => "Uppercase",
-        "Variation_Selector" | "VS" => "Variation_Selector",
-        "White_Space" | "space" => "White_Space",
-        "XID_Continue" | "XIDC" => "XID_Continue",
-        "XID_Start" | "XIDS" => "XID_Start",
-        _ => return None,
-    })
-}
-
-/// The sets already built for property expressions. A property set can have hundreds of ranges, and schemas tend to
-/// repeat the same few. Only an expression ECMA-262 defines is kept, and those are a fixed few hundred, so the
-/// cache is bounded.
-static PROPERTY_CACHE: LazyLock<Mutex<HashMap<String, Arc<CharSet>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
-
-/// Resolves the expression between the braces of `\p{...}` to its set. `None` for a name or value that ECMA-262
-/// does not define.
-pub(crate) fn property_set(expr: &str) -> Option<Arc<CharSet>> {
-    if let Some(cached) = PROPERTY_CACHE.lock().unwrap_or_else(|e| e.into_inner()).get(expr) {
-        return Some(cached.clone());
-    }
-    let pairs = property_pairs(expr)?;
-    let set = CharSet::shared(&pairs, false);
-    PROPERTY_CACHE.lock().unwrap_or_else(|e| e.into_inner()).insert(expr.to_string(), set.clone());
-    Some(set)
-}
-
-/// The ranges of a property expression. Every range comes from the tables of `ucd`, which hold one fixed version of
-/// Unicode, so the answer does not depend on the toolchain.
-fn property_pairs(expr: &str) -> Option<Vec<Rune>> {
-    if let Some((name, value)) = expr.split_once('=') {
-        return match name {
-            "General_Category" | "gc" => category_pairs(value),
-            "Script" | "sc" => ucd::script(value).map(|t| t.pairs()),
-            "Script_Extensions" | "scx" => ucd::script_extensions(value).map(|t| t.pairs()),
-            _ => None,
-        };
-    }
-    if let Some(pairs) = category_pairs(expr) {
-        return Some(pairs);
-    }
-    match binary_name(expr)? {
-        "ASCII" => Some(vec![0, 0x7F]),
-        "Any" => Some(vec![0, MAX_RUNE]),
-        canonical => ucd::binary(canonical).map(|t| t.pairs()),
-    }
-}
-
-fn category_pairs(value: &str) -> Option<Vec<Rune>> {
-    ucd::category(category_name(value)?).map(|t| t.pairs())
-}