jsonschema_rs 0.49.0 → 0.49.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5089bd59db447c9dd706a0fcaf832dac6832d5be6662e988b7a386c8cd31e6b0
-  data.tar.gz: ed3f7c83e18c5b8eea755a6a814106693ac729a11325946e878daca82afa0a32
+  metadata.gz: 48dc9cf6305e242c8a686a6e1439fcc2d05ce1b2738bfdf1eb42394e05f16d03
+  data.tar.gz: 9e828ed439bb3180094d3c2cdc1cbc0723ea71d385c2861278c7347493dfd900
 SHA512:
-  metadata.gz: f15778547054d8aa3e988d34db28fa5144ed87821f4be792120366dc93ff3f2ae908f64610e72047f111f10617187ea6d0debd859be1cb5de11756af8bf874a0
-  data.tar.gz: 5d9f288ab525665571492a9e6a8f7846b01dc07f78cee128a998777edcfcb2fb8977dcab97735c4bbbb1634f6f3e350904ec9c1d4e1d987de3c86fefc030f24b
+  metadata.gz: d41807f218f18e5435a4ec6e01326f5459076c78afd126844dcd03a982e1006514ec613333eac241853e8b83859410ab723f53ffa185f959cfd6209f8a4c6399
+  data.tar.gz: 768c332d2d735999f58bde2a4947568d9e4e7c7cbf818e6ed8ae4177d890810490cf2494b5bfcea547fe7a0c7827775ba83192e465f77207581a9e40d6d21f1f

data/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## [Unreleased]
 
+## [0.49.3] - 2026-08-02
+
+### Added
+
+- Canonicalization of a recursive schema with no finite witness, which now folds to `false`.
+- Canonicalization of `$dynamicRef` and `$recursiveRef`, which resolve through the dynamic scope and stay symbolic like any other reference. A dangling `$dynamicRef` errors rather than staying `Raw`.
+- Canonicalization of `minContains` under `uniqueItems`, where a demand asking for more matches than its own schema has distinct values now folds to `false`.
+- Canonicalization of a Draft 4 `patternProperties` coverage closed by `additionalProperties: false`, spelled as the closed map it was parsed from.
+- Canonicalization of a `oneOf` whose branches repeat, where a repeated branch can never contribute exactly one match.
+- Canonicalization of a `$ref` whose target is an empty schema, which now folds to `false`.
+- Canonicalization of `unevaluatedItems` beside `allOf`, where every branch must pass and so the indexes they evaluate are known without the instance.
+- Canonicalization of `unevaluatedProperties` beside `allOf`, where every branch must pass and so what they evaluate is known without the instance.
+- Canonicalization of a Draft 4 `type` list holding `integer` beside other types with `enum`, which previously modeled only when spelled as an `allOf`.
+- Canonicalization of `patternProperties` patterns matching finitely many keys, such as `^a$` and `^(a|b)$`.
+- Canonicalization of `unevaluatedProperties` and `unevaluatedItems` when no in-place applicator sits beside them.
+
+### Fixed
+
+- `additionalItems` values that are not schemas silently ignored beside an array-form `items` (they should fail the build like `additionalProperties`).
+- `additionalItems` beside a boolean `items` rejecting every instance, such as `{"additionalItems": false, "items": false}`.
+- Draft 4 rejecting a size bound at or past `2^64`, such as `{"maxItems": 18446744073709551616}`.
+- An integer past the `f64` range admitted by a fractional bound it exceeds, such as `1e400` under `{"exclusiveMaximum": 0.1}`.
+- A `$ref` at the root of an `$id`-bearing subresource dropped as a self-reference when its pointer matched the one that reached that subresource.
+- Canonicalization reusing one definition's body for a same-named definition in another resource, when the name spells a canonical URI.
+- `unevaluatedItems` counting `prefixItems` as evaluating elements before Draft 2020-12, where it is not a keyword.
+
+### Performance
+
+- Up to 70% faster `evaluate`.
+
+## [0.49.2] - 2026-07-28
+
+### Performance
+
+- Faster serialization of canonicalized schemas.
+
+## [0.49.1] - 2026-07-25
+
+### Fixed
+
+- `JSONSchema.canonicalize` rejecting `pattern_options` (it should take the same regex configuration as validators).
+- `InvalidPattern` failures raising the base `CanonicalizationError` (they should raise `JSONSchema::Canonical::InvalidPattern`).
+
 ## [0.49.0] - 2026-07-25
 
 ### Added
@@ -219,7 +262,10 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.0...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.3...HEAD
+[0.49.3]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.2...ruby-v0.49.3
+[0.49.2]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.1...ruby-v0.49.2
+[0.49.1]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.0...ruby-v0.49.1
 [0.49.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.5...ruby-v0.49.0
 [0.48.5]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.2...ruby-v0.48.5
 [0.48.2]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.1...ruby-v0.48.2

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.49.0"
+version = "0.49.3"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.49.0", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.3", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
 serde = { workspace = true }

data/ext/jsonschema/Cargo.lock

@@ -693,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9eb9cf6891f8d15a89f7bcf8e812a62efef1fd8d9e7e4522f455875a1224875a"
+checksum = "508004a5500f2e1f68af048f70feea2de86d35ab115d85716530860822aef397"
 dependencies = [
  "ahash",
  "bytecount",
@@ -726,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78fac461293b8d5484a845adbbfaa263ae76616ceae93283baaa4621736f9c54"
+checksum = "f4e131231bc18676df289bd7634d4353d5b36bced191928bfa2a2dcae91e44a0"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "937a50f77ead02f355faec45d36f0b739da183857002af4f3a2759451dc9aec3"
+checksum = "75803a5014f912d5a8f3c8cc24531d19ea06dfadda75ddf1d15af629f7c8468c"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.49.0"
+version = "0.49.3"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -768,18 +768,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b70811da032e736899c5045ee30f069ba241676739e6ed042c1f9ddd3ad47cde"
+checksum = "5a8b30cafa78358ae6cd1494a7d6410b89530e28bf567f862c869c667e900d9f"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ceacf7ad8e9a1f6229a1354dc0ab238855623d219b6abf0a001c138241ec530"
+checksum = "5526bd381d230af94908d07e6835a33fd82a465e12f5f1e9c81f5c2aa23b3c21"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1132,9 +1132,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.49.0"
+version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbded44c4882a15738bd1bba376609f679292d758c0b3c389a2ef4a0ea6ce9b7"
+checksum = "7af3eb523cce0df0af3c30d624b829b2dabd233172b5bc2615fcd03ceae8f746"
 dependencies = [
  "ahash",
  "fluent-uri",

data/ext/jsonschema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb-ext"
-version = "0.49.0"
+version = "0.49.3"
 edition = "2021"
 publish = false
 
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.49.0", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.3", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
-referencing = "0.49.0"
+referencing = "0.49.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["arbitrary_precision"] }
 zmij = "1"

data/lib/jsonschema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONSchema
-  VERSION = "0.49.0"
+  VERSION = "0.49.3"
 end

data/sig/jsonschema.rbs

@@ -29,6 +29,9 @@ module JSONSchema
     class InvalidSchemaType < CanonicalizationError
     end
 
+    class InvalidPattern < CanonicalizationError
+    end
+
     # A schema reduced to canonical form: schemas accepting the same values share one form.
     class CanonicalSchema
       def to_json_schema: () -> untyped
@@ -164,7 +167,8 @@ module JSONSchema
   def self.canonicalize: (
     untyped schema,
     ?draft: draft?,
-    ?validate_formats: bool?
+    ?validate_formats: bool?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?
   ) -> Canonical::CanonicalSchema
 
   # Create a validator with auto-detected draft version.

data/src/canonical.rs

@@ -14,13 +14,17 @@ use magnus::{
 };
 
 use crate::{
-    options::parse_draft_symbol,
+    options::{extract_pattern_options, parse_draft_symbol, RbPatternOptions},
     ser::{to_schema_value, value_to_ruby},
     static_id::define_rb_intern,
 };
 
 define_rb_intern!(static CANONICAL_KW_DRAFT: "draft");
 define_rb_intern!(static CANONICAL_KW_VALIDATE_FORMATS: "validate_formats");
+define_rb_intern!(static CANONICAL_KW_PATTERN_OPTIONS: "pattern_options");
+
+type CanonicalKwArgs =
+    magnus::scan_args::KwArgs<(), (Option<Value>, Option<bool>, Option<Value>), ()>;
 
 macro_rules! canonical_error_class {
     ($static_name:ident, $class_name:literal) => {
@@ -42,6 +46,7 @@ macro_rules! canonical_error_class {
 
 canonical_error_class!(CANONICALIZATION_ERROR_CLASS, "CanonicalizationError");
 canonical_error_class!(INVALID_SCHEMA_TYPE_CLASS, "InvalidSchemaType");
+canonical_error_class!(INVALID_PATTERN_CLASS, "InvalidPattern");
 
 fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
     if let CanonicalizationError::ValidationError(validation_error) = error {
@@ -52,6 +57,9 @@ fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
         CanonicalizationError::InvalidSchemaType(_) => {
             Error::new(ruby.get_inner(&INVALID_SCHEMA_TYPE_CLASS), message)
         }
+        CanonicalizationError::InvalidPattern { .. } => {
+            Error::new(ruby.get_inner(&INVALID_PATTERN_CLASS), message)
+        }
         // `ValidationError` returns above; future variants fall back to the base canonical error.
         _ => Error::new(ruby.get_inner(&CANONICALIZATION_ERROR_CLASS), message),
     }
@@ -174,7 +182,11 @@ impl RbCanonicalSchema {
                     additional_properties: view.additional_properties,
                 })
                 .as_value(),
+            CanonicalView::Not(schema) => ruby.obj_wrap(NotView { schema: *schema }).as_value(),
+            CanonicalView::AllOf(branches) => ruby.obj_wrap(AllOfView { branches }).as_value(),
             CanonicalView::AnyOf(branches) => ruby.obj_wrap(AnyOfView { branches }).as_value(),
+            CanonicalView::OneOf(branches) => ruby.obj_wrap(OneOfView { branches }).as_value(),
+            CanonicalView::Reference(uri) => ruby.obj_wrap(ReferenceView { uri }).as_value(),
             CanonicalView::Raw(schema) => ruby.obj_wrap(RawView { schema }).as_value(),
         }
     }
@@ -828,6 +840,147 @@ impl AnyOfView {
     }
 }
 
+/// A value matches iff exactly one branch matches.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::OneOfView", free_immediately)]
+pub struct OneOfView {
+    branches: Vec<CanonicalSchema>,
+}
+
+impl DataTypeFunctions for OneOfView {}
+
+impl OneOfView {
+    fn branches(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.branches.len());
+        for branch in &rb_self.branches {
+            array.push(
+                ruby.obj_wrap(RbCanonicalSchema {
+                    inner: branch.clone(),
+                })
+                .as_value(),
+            )?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        let kinds = ruby.ary_new_capa(rb_self.branches.len());
+        for branch in &rb_self.branches {
+            kinds.push(ruby.sym_new(branch.kind().as_str()).as_value())?;
+        }
+        Ok(format!(
+            "#<JSONSchema::Canonical::OneOfView branches={}>",
+            kinds.as_value().inspect()
+        ))
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        hash.aset(ruby.sym_new("branches"), Self::branches(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// A value matches iff every branch matches.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::AllOfView", free_immediately)]
+pub struct AllOfView {
+    branches: Vec<CanonicalSchema>,
+}
+
+impl DataTypeFunctions for AllOfView {}
+
+impl AllOfView {
+    fn branches(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.branches.len());
+        for branch in &rb_self.branches {
+            array.push(
+                ruby.obj_wrap(RbCanonicalSchema {
+                    inner: branch.clone(),
+                })
+                .as_value(),
+            )?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        let kinds = ruby.ary_new_capa(rb_self.branches.len());
+        for branch in &rb_self.branches {
+            kinds.push(ruby.sym_new(branch.kind().as_str()).as_value())?;
+        }
+        Ok(format!(
+            "#<JSONSchema::Canonical::AllOfView branches={}>",
+            kinds.as_value().inspect()
+        ))
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        hash.aset(ruby.sym_new("branches"), Self::branches(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// The complement of `schema`, preserving a symbolic ref under `not`, conditionals, and `oneOf`.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::NotView", free_immediately)]
+pub struct NotView {
+    schema: CanonicalSchema,
+}
+
+impl DataTypeFunctions for NotView {}
+
+impl NotView {
+    fn schema(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.obj_wrap(RbCanonicalSchema {
+            inner: rb_self.schema.clone(),
+        })
+        .as_value()
+    }
+
+    fn inspect(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::NotView schema={}>",
+            rb_self.schema.kind().as_str()
+        )
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        hash.aset(ruby.sym_new("schema"), Self::schema(ruby, rb_self))?;
+        Ok(hash)
+    }
+}
+
+/// A symbolic JSON Schema reference.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ReferenceView", free_immediately)]
+pub struct ReferenceView {
+    uri: String,
+}
+
+impl DataTypeFunctions for ReferenceView {}
+
+impl ReferenceView {
+    fn uri(rb_self: &Self) -> String {
+        rb_self.uri.clone()
+    }
+
+    fn inspect(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::ReferenceView uri={:?}>",
+            rb_self.uri
+        )
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        hash.aset(ruby.sym_new("uri"), rb_self.uri.clone())?;
+        Ok(hash)
+    }
+}
+
 /// Exactly one admitted value.
 #[derive(magnus::TypedData)]
 #[magnus(class = "JSONSchema::Canonical::ConstView", free_immediately)]
@@ -892,12 +1045,16 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     let parsed = scan_args::<(Value,), (), (), (), _, ()>(args)?;
     let (schema_arg,) = parsed.required;
     let keywords: RHash = parsed.keywords;
-    let base_kwargs: magnus::scan_args::KwArgs<(), (Option<Value>, Option<bool>), ()> = get_kwargs(
+    let base_kwargs: CanonicalKwArgs = get_kwargs(
         keywords,
         &[],
-        &[*CANONICAL_KW_DRAFT, *CANONICAL_KW_VALIDATE_FORMATS],
+        &[
+            *CANONICAL_KW_DRAFT,
+            *CANONICAL_KW_VALIDATE_FORMATS,
+            *CANONICAL_KW_PATTERN_OPTIONS,
+        ],
     )?;
-    let (draft_val, validate_formats) = base_kwargs.optional;
+    let (draft_val, validate_formats, pattern_options) = base_kwargs.optional;
 
     let schema_value = to_schema_value(ruby, schema_arg)?;
     let mut options = jsonschema::canonical::options();
@@ -907,6 +1064,12 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     if let Some(validate_formats) = validate_formats {
         options = options.should_validate_formats(validate_formats);
     }
+    if let Some(val) = pattern_options {
+        match extract_pattern_options(ruby, val)? {
+            RbPatternOptions::Fancy(inner) => options = options.with_pattern_options(inner),
+            RbPatternOptions::Regex(inner) => options = options.with_pattern_options(inner),
+        }
+    }
     options
         .canonicalize(&schema_value)
         .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
@@ -919,6 +1082,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     let base_error =
         canonical_module.define_error("CanonicalizationError", ruby.exception_standard_error())?;
     canonical_module.define_error("InvalidSchemaType", base_error)?;
+    canonical_module.define_error("InvalidPattern", base_error)?;
 
     let canonical_schema = canonical_module.define_class("CanonicalSchema", ruby.class_object())?;
     canonical_schema.define_method(
@@ -1055,6 +1219,29 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     any_of_view.define_method("inspect", method!(AnyOfView::inspect, 0))?;
     any_of_view.define_method("deconstruct_keys", method!(AnyOfView::deconstruct_keys, 1))?;
 
+    let one_of_view = canonical_module.define_class("OneOfView", ruby.class_object())?;
+    one_of_view.define_method("branches", method!(OneOfView::branches, 0))?;
+    one_of_view.define_method("inspect", method!(OneOfView::inspect, 0))?;
+    one_of_view.define_method("deconstruct_keys", method!(OneOfView::deconstruct_keys, 1))?;
+
+    let all_of_view = canonical_module.define_class("AllOfView", ruby.class_object())?;
+    all_of_view.define_method("branches", method!(AllOfView::branches, 0))?;
+    all_of_view.define_method("inspect", method!(AllOfView::inspect, 0))?;
+    all_of_view.define_method("deconstruct_keys", method!(AllOfView::deconstruct_keys, 1))?;
+
+    let not_view = canonical_module.define_class("NotView", ruby.class_object())?;
+    not_view.define_method("schema", method!(NotView::schema, 0))?;
+    not_view.define_method("inspect", method!(NotView::inspect, 0))?;
+    not_view.define_method("deconstruct_keys", method!(NotView::deconstruct_keys, 1))?;
+
+    let reference_view = canonical_module.define_class("ReferenceView", ruby.class_object())?;
+    reference_view.define_method("uri", method!(ReferenceView::uri, 0))?;
+    reference_view.define_method("inspect", method!(ReferenceView::inspect, 0))?;
+    reference_view.define_method(
+        "deconstruct_keys",
+        method!(ReferenceView::deconstruct_keys, 1),
+    )?;
+
     let raw_view = canonical_module.define_class("RawView", ruby.class_object())?;
     raw_view.define_method("schema", method!(RawView::schema, 0))?;
     raw_view.define_method("inspect", method!(RawView::inspect, 0))?;

data/src/options.rs

@@ -741,32 +741,9 @@ pub fn make_options_from_kwargs(
     }
 
     if let Some(val) = pattern_options_val {
-        if let Ok(fancy_opts) = <&FancyRegexOptions>::try_convert(val) {
-            let mut po = jsonschema::PatternOptions::fancy_regex();
-            if let Some(limit) = fancy_opts.backtrack_limit {
-                po = po.backtrack_limit(limit);
-            }
-            if let Some(limit) = fancy_opts.size_limit {
-                po = po.size_limit(limit);
-            }
-            if let Some(limit) = fancy_opts.dfa_size_limit {
-                po = po.dfa_size_limit(limit);
-            }
-            opts = opts.with_pattern_options(po);
-        } else if let Ok(regex_opts) = <&RegexOptions>::try_convert(val) {
-            let mut po = jsonschema::PatternOptions::regex();
-            if let Some(limit) = regex_opts.size_limit {
-                po = po.size_limit(limit);
-            }
-            if let Some(limit) = regex_opts.dfa_size_limit {
-                po = po.dfa_size_limit(limit);
-            }
-            opts = opts.with_pattern_options(po);
-        } else {
-            return Err(Error::new(
-                ruby.exception_type_error(),
-                "pattern_options must be a RegexOptions or FancyRegexOptions instance",
-            ));
+        match extract_pattern_options(ruby, val)? {
+            RbPatternOptions::Fancy(inner) => opts = opts.with_pattern_options(inner),
+            RbPatternOptions::Regex(inner) => opts = opts.with_pattern_options(inner),
         }
     }
 
@@ -953,6 +930,42 @@ impl RegexOptions {
     }
 }
 
+/// A `pattern_options` argument converted into [`jsonschema::PatternOptions`].
+pub(crate) enum RbPatternOptions {
+    Fancy(jsonschema::PatternOptions<jsonschema::FancyRegex>),
+    Regex(jsonschema::PatternOptions<jsonschema::Regex>),
+}
+
+pub(crate) fn extract_pattern_options(ruby: &Ruby, val: Value) -> Result<RbPatternOptions, Error> {
+    if let Ok(fancy_opts) = <&FancyRegexOptions>::try_convert(val) {
+        let mut po = jsonschema::PatternOptions::fancy_regex();
+        if let Some(limit) = fancy_opts.backtrack_limit {
+            po = po.backtrack_limit(limit);
+        }
+        if let Some(limit) = fancy_opts.size_limit {
+            po = po.size_limit(limit);
+        }
+        if let Some(limit) = fancy_opts.dfa_size_limit {
+            po = po.dfa_size_limit(limit);
+        }
+        Ok(RbPatternOptions::Fancy(po))
+    } else if let Ok(regex_opts) = <&RegexOptions>::try_convert(val) {
+        let mut po = jsonschema::PatternOptions::regex();
+        if let Some(limit) = regex_opts.size_limit {
+            po = po.size_limit(limit);
+        }
+        if let Some(limit) = regex_opts.dfa_size_limit {
+            po = po.dfa_size_limit(limit);
+        }
+        Ok(RbPatternOptions::Regex(po))
+    } else {
+        Err(Error::new(
+            ruby.exception_type_error(),
+            "pattern_options must be a RegexOptions or FancyRegexOptions instance",
+        ))
+    }
+}
+
 #[magnus::wrap(class = "JSONSchema::FancyRegexOptions", free_immediately, size)]
 pub struct FancyRegexOptions {
     pub backtrack_limit: Option<usize>,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonschema_rs
 version: !ruby/object:Gem::Version
-  version: 0.49.0
+  version: 0.49.3
 platform: ruby
 authors:
 - Dmitry Dygalo