jsonschema_rs 0.49.5 → 0.49.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14182b3d65f8580de3c3c3b3dab17d0709a70e56b93b519a2095f0d87bbda232
-  data.tar.gz: c43c5b754ef7a41ff8ce3d06ab79f1f29854967446ee6efb76282af7c0186e98
+  metadata.gz: 2b3388bbb4302ddf7e4c108df32d945f68074c7baac52e85aa19964bbd8d8cec
+  data.tar.gz: 9a833159377a6b7673007129536b9d3997f01b1d1cd4226a51efa358c5ef6daa
 SHA512:
-  metadata.gz: 503c06fb04a59e9ca5e38eeb0c360741a9d6a409e4dce784ade9babe4514f19fb1f4668b9f21538e661c5bed1d76600cd32ec92bd4c7d1daa8a6e147de4b3607
-  data.tar.gz: 53b2d54cbbb81a4b2ccba5eaa7a8cf8144f1597c3ccbf0abf55ba0fbee189a85634a936a5571af77d64e4a9351c04ec57f41867decb15b1404beeb93bc7a0abc
+  metadata.gz: dec67420394656cbbaf899553338fa8525680018f548ba94470713bb66a057f6361cc4d93b98763b3c739233eab7df7bfb954eae2d9745fffd41a300df361b9a
+  data.tar.gz: 418f555ee5c68ed4a4932e6c9230ee0a8e3e5e8b5c92739d9007c959b305d99f68e272fc5cda0b2114751e50146528d478bf9c3cfaefb44399ddb97677fa8c23

data/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 ## [Unreleased]
 
+## [0.49.7] - 2026-08-08
+
+### Added
+
+- `retriever`, `registry`, and `base_uri` keyword arguments to `JSONSchema.canonicalize`.
+- Canonicalization of a `oneOf` whose branches name disjoint targets, which degrades to a union.
+- Canonicalization of a vacuous `patternProperties` entry beside schema-valued `additionalProperties`, where matching keys escape its value constraint.
+- Canonicalization of a Draft 4 closed pattern map with a reference nested under a property.
+- Canonicalization of Draft 4 closed pattern maps that meet through an applicator.
+- The complement of a reference back to a target already being negated, which stays symbolic instead of declining.
+- `CanonicalSchema#definition` resolving `#` to the document the schema was read against.
+
+### Performance
+
+- Up to 150x faster canonicalization of `not` over a union of many branches.
+- 2% faster emission of canonical schemas, which no longer formats copied string values.
+- 5% faster emission of canonical schemas, which no longer formats object keys while copying them.
+- Up to 12% faster canonicalization of schemas that repeatedly intersect the same branches.
+- 13% faster canonicalization of a non-dynamic OpenAPI document, which no longer scans every schema object for dynamic references.
+- Faster canonicalization of schemas with local `$defs` references, which avoid decoding unescaped definition names.
+- 23% faster canonicalization of an object whose keys a finite property-name set spells.
+- 3% faster intersection of schemas where one side constrains nothing.
+- Up to 31x faster canonicalization of a `oneOf` whose many branches overlap.
+- Up to 14x faster canonicalization of a union whose object branches share no values.
+- 7% faster canonicalization of schemas that reach the same pair of nodes repeatedly.
+- 5% faster canonicalization of objects, whose property maps no longer reach the allocator.
+- Up to 8% faster canonicalization of schemas that reach `true` and `false` subschemas repeatedly.
+- 2% faster canonicalization of schemas that assert known string formats.
+
+### Fixed
+
+- `CanonicalSchema#definition` and `CanonicalSchema#definitions` handing out a target that names the document root without that document, where `#` points at the target instead.
+- An `items` tail beyond an array's length ceiling surviving canonicalization, where it governs no element.
+- `CanonicalSchema#to_json_schema` leaving the document root out of a node emitted below it, where `#` points at that node instead.
+
+## [0.49.6] - 2026-08-06
+
+### Added
+
+- Canonicalization of a negated `uniqueItems`, where the complement demands a repeated element under the length floor two elements imply.
+- Canonicalization of a negated array tuple, where each position's complement stands under the length that reaches it.
+- Canonicalization of `contains` demands sharing no value, where their counts add up into a length floor.
+- `CanonicalSchema#negate` through references, where the complement of the resolved target takes the reference's place.
+- Canonicalization of negated `propertyNames` and `additionalProperties`, where the complement spells the violating-key demand instead of a `not` residual.
+- Canonicalization of negated `additionalProperties` under Draft 4, where the violating-key demand spells the closed property map.
+- Canonicalization of `not` a reference, where the complement of the resolved target takes the pointer's place.
+- Canonicalization of a negated `oneOf`, where the complement spells the values no branch admits beside the values two branches share.
+- Canonicalization of negated `items` under Draft 4, where the violating-element demand spells the barred element schema.
+
+### Changed
+
+- `ArrayView` reports distinctness in three states, so an array demanding a repeated element reads apart from one demanding distinct elements.
+
+### Fixed
+
+- `CanonicalSchema#negate` keeping a root self-reference in the complement, where it points at the complement instead of the source.
+- An `additionalItems` that tails no tuple keeping the whole document unmodeled under Draft 2020-12.
+
 ## [0.49.5] - 2026-08-05
 
 ### Added
@@ -304,7 +362,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.5...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.7...HEAD
+[0.49.7]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.6...ruby-v0.49.7
+[0.49.6]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.5...ruby-v0.49.6
 [0.49.5]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.4...ruby-v0.49.5
 [0.49.4]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.3...ruby-v0.49.4
 [0.49.3]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.2...ruby-v0.49.3

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.49.5"
+version = "0.49.7"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.49.5", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.7", 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.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da60094fc1968bbd091e2cfa004415cb7b19e25e592376e66a64aa832bb6039"
+checksum = "ca4b985be36e5b3d15162b16ca94ac18c2a0514f5598b23b9d769895cb56bc3c"
 dependencies = [
  "ahash",
  "bytecount",
@@ -726,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.49.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1575f559a96e0cd2b83afd25b868507d39b97e16af2ed7d23074c470b0259627"
+checksum = "de1ff79046715d10fe5fd795c0f562d8f2e41f470bed5fcad74a0c9f5fd5a6b8"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.49.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d2d8f4ec940ac30dc8e85787916ac6a9d34fcfa850b47ffe69205e837dee621"
+checksum = "8888005b18cbb6b61b4cb5fb4ae5f20b45dde81ab59baf37897b4668ba58a6f3"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.49.5"
+version = "0.49.7"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -768,18 +768,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.49.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36539f34ef9e5da418433fbbf7294522d8f930ecf6a540ccd1ec6481c9ff9056"
+checksum = "614c05e01260d4532d9ad28d66185fa1d93d015c5d610cde70d4b7143d7fb98f"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.49.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bc513dfee68c6fe29498451df95a32951ea227801b476f4a1f236433986c891"
+checksum = "8602a6850f24cf05c518f58c9b8d08e32a28b9848115c8e193693db0952353f6"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1132,9 +1132,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.49.5"
+version = "0.49.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05915176d843da9ec5c925e5e2631be9aa61b27430acfdd562e79cae8f559725"
+checksum = "0753550862a089302b186486dfb843f2d547415257d78c32ae0d169e4d6784d1"
 dependencies = [
  "ahash",
  "fluent-uri",

data/ext/jsonschema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb-ext"
-version = "0.49.5"
+version = "0.49.7"
 edition = "2021"
 publish = false
 
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.49.5", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.7", 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.5"
+referencing = "0.49.7"
 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.5"
+  VERSION = "0.49.7"
 end

data/sig/jsonschema.rbs

@@ -121,7 +121,7 @@ module JSONSchema
     class ArrayView
       def min_items: () -> Integer?
       def max_items: () -> Integer?
-      def unique_items: () -> bool
+      def distinctness: () -> (:unconstrained | :all_distinct | :some_repeated)
       def prefix_items: () -> Array[CanonicalSchema]
       def items: () -> CanonicalSchema?
       def contains: () -> Array[ContainsView]
@@ -146,6 +146,24 @@ module JSONSchema
       def property_names: () -> CanonicalSchema?
       def properties: () -> Hash[String, CanonicalSchema]
       def pattern_properties: () -> Hash[String, CanonicalSchema]
+      def additional_properties: () -> CanonicalSchema?
+      def violations: () -> Array[NameFailsView | UndeclaredValueFailsView]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # Some key's name fails the schema.
+    class NameFailsView
+      def schema: () -> CanonicalSchema
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # Some key outside `names` and matching none of `patterns` has a value failing `additional`.
+    class UndeclaredValueFailsView
+      def names: () -> Array[String]
+      def patterns: () -> Array[String]
+      def additional: () -> CanonicalSchema
       def inspect: () -> String
       def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
     end
@@ -184,7 +202,10 @@ module JSONSchema
     untyped schema,
     ?draft: draft?,
     ?validate_formats: bool?,
-    ?pattern_options: (RegexOptions | FancyRegexOptions)?
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?retriever: (^(String) -> untyped)?,
+    ?registry: Registry?,
+    ?base_uri: String?
   ) -> Canonical::CanonicalSchema
 
   # Create a validator with auto-detected draft version.

data/src/canonical.rs

@@ -1,6 +1,7 @@
 use jsonschema::{
     canonical::{
         CanonicalSchema, CanonicalView, CanonicalizationError, ContainsView as CoreContainsView,
+        ObjectViolationView as CoreObjectViolationView,
     },
     JsonType,
 };
@@ -14,7 +15,12 @@ use magnus::{
 };
 
 use crate::{
-    options::{extract_pattern_options, parse_draft_symbol, RbPatternOptions},
+    options::{
+        extract_pattern_options, parse_draft_symbol, RbPatternOptions, KW_BASE_URI, KW_REGISTRY,
+        KW_RETRIEVER,
+    },
+    registry::Registry,
+    retriever::make_retriever,
     ser::{to_schema_value, value_to_ruby},
     static_id::define_rb_intern,
 };
@@ -23,8 +29,18 @@ 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>), ()>;
+type CanonicalKwArgs = magnus::scan_args::KwArgs<
+    (),
+    (
+        Option<Value>,
+        Option<bool>,
+        Option<Value>,
+        Option<Value>,
+        Option<Value>,
+        Option<String>,
+    ),
+    (),
+>;
 
 macro_rules! canonical_error_class {
     ($static_name:ident, $class_name:literal) => {
@@ -179,7 +195,7 @@ impl RbCanonicalSchema {
                 .obj_wrap(ArrayView {
                     min_items: view.min_items,
                     max_items: view.max_items,
-                    unique_items: view.unique_items,
+                    distinctness: view.distinctness.as_str(),
                     prefix_items: view.prefix_items,
                     items: view.items,
                     contains: view.contains,
@@ -194,6 +210,7 @@ impl RbCanonicalSchema {
                     properties: view.properties,
                     pattern_properties: view.pattern_properties,
                     additional_properties: view.additional_properties,
+                    violations: view.violations,
                 })
                 .as_value(),
             CanonicalView::Not(schema) => ruby.obj_wrap(NotView { schema: *schema }).as_value(),
@@ -641,7 +658,7 @@ impl IntegerView {
 pub struct ArrayView {
     min_items: Option<serde_json::Number>,
     max_items: Option<serde_json::Number>,
-    unique_items: bool,
+    distinctness: &'static str,
     prefix_items: Vec<CanonicalSchema>,
     items: Option<CanonicalSchema>,
     contains: Vec<CoreContainsView>,
@@ -658,8 +675,8 @@ impl ArrayView {
         bound_to_ruby(ruby, rb_self.max_items.as_ref())
     }
 
-    fn unique_items(ruby: &Ruby, rb_self: &Self) -> Value {
-        ruby.into_value(rb_self.unique_items)
+    fn distinctness(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.sym_new(rb_self.distinctness).as_value()
     }
 
     fn prefix_items(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
@@ -696,10 +713,10 @@ impl ArrayView {
 
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
-            "#<JSONSchema::Canonical::ArrayView min_items={} max_items={} unique_items={} prefix_items={} items={} contains={}>",
+            "#<JSONSchema::Canonical::ArrayView min_items={} max_items={} distinctness={} prefix_items={} items={} contains={}>",
             Self::min_items(ruby, rb_self)?.inspect(),
             Self::max_items(ruby, rb_self)?.inspect(),
-            Self::unique_items(ruby, rb_self).inspect(),
+            Self::distinctness(ruby, rb_self).inspect(),
             Self::prefix_items(ruby, rb_self)?.inspect(),
             Self::items(ruby, rb_self).inspect(),
             Self::contains(ruby, rb_self)?.inspect()
@@ -711,8 +728,8 @@ impl ArrayView {
         hash.aset(ruby.sym_new("min_items"), Self::min_items(ruby, rb_self)?)?;
         hash.aset(ruby.sym_new("max_items"), Self::max_items(ruby, rb_self)?)?;
         hash.aset(
-            ruby.sym_new("unique_items"),
-            Self::unique_items(ruby, rb_self),
+            ruby.sym_new("distinctness"),
+            Self::distinctness(ruby, rb_self),
         )?;
         hash.aset(
             ruby.sym_new("prefix_items"),
@@ -783,6 +800,116 @@ impl ContainsView {
     }
 }
 
+// The violation list needs the same lazy Ruby-object conversion `ContainsView::from_core` does,
+// so this stays a free function rather than a method on either violation view class.
+fn object_violation_to_ruby(ruby: &Ruby, violation: &CoreObjectViolationView) -> Value {
+    match violation {
+        CoreObjectViolationView::NameFails(schema) => ruby
+            .obj_wrap(NameFailsView {
+                schema: schema.clone(),
+            })
+            .as_value(),
+        CoreObjectViolationView::UndeclaredValueFails {
+            names,
+            patterns,
+            additional,
+        } => ruby
+            .obj_wrap(UndeclaredValueFailsView {
+                names: names.clone(),
+                patterns: patterns.clone(),
+                additional: additional.clone(),
+            })
+            .as_value(),
+    }
+}
+
+/// Some key's name fails the schema.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::NameFailsView", free_immediately)]
+pub struct NameFailsView {
+    schema: CanonicalSchema,
+}
+
+impl DataTypeFunctions for NameFailsView {}
+
+impl NameFailsView {
+    fn schema(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.obj_wrap(RbCanonicalSchema {
+            inner: rb_self.schema.clone(),
+        })
+        .as_value()
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::NameFailsView schema={}>",
+            Self::schema(ruby, rb_self).inspect()
+        )
+    }
+
+    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)
+    }
+}
+
+/// Some key outside `names` and matching none of `patterns` has a value failing `additional`.
+#[derive(magnus::TypedData)]
+#[magnus(
+    class = "JSONSchema::Canonical::UndeclaredValueFailsView",
+    free_immediately
+)]
+pub struct UndeclaredValueFailsView {
+    names: Vec<String>,
+    patterns: Vec<String>,
+    additional: CanonicalSchema,
+}
+
+impl DataTypeFunctions for UndeclaredValueFailsView {}
+
+impl UndeclaredValueFailsView {
+    fn names(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.names.len());
+        for name in &rb_self.names {
+            array.push(ruby.str_new(name))?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn patterns(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.patterns.len());
+        for pattern in &rb_self.patterns {
+            array.push(ruby.str_new(pattern))?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn additional(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.obj_wrap(RbCanonicalSchema {
+            inner: rb_self.additional.clone(),
+        })
+        .as_value()
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::UndeclaredValueFailsView names={} patterns={} additional={}>",
+            Self::names(ruby, rb_self)?.inspect(),
+            Self::patterns(ruby, rb_self)?.inspect(),
+            Self::additional(ruby, rb_self).inspect()
+        ))
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        hash.aset(ruby.sym_new("names"), Self::names(ruby, rb_self)?)?;
+        hash.aset(ruby.sym_new("patterns"), Self::patterns(ruby, rb_self)?)?;
+        hash.aset(ruby.sym_new("additional"), Self::additional(ruby, rb_self))?;
+        Ok(hash)
+    }
+}
+
 /// An object value's constraints.
 #[derive(magnus::TypedData)]
 #[magnus(class = "JSONSchema::Canonical::ObjectView", free_immediately)]
@@ -794,6 +921,7 @@ pub struct ObjectView {
     properties: std::collections::BTreeMap<String, CanonicalSchema>,
     pattern_properties: std::collections::BTreeMap<String, CanonicalSchema>,
     additional_properties: Option<CanonicalSchema>,
+    violations: Vec<CoreObjectViolationView>,
 }
 
 impl DataTypeFunctions for ObjectView {}
@@ -859,6 +987,14 @@ impl ObjectView {
         }
     }
 
+    fn violations(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.violations.len());
+        for violation in &rb_self.violations {
+            array.push(object_violation_to_ruby(ruby, violation))?;
+        }
+        Ok(array.as_value())
+    }
+
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
             "#<JSONSchema::Canonical::ObjectView min_properties={} max_properties={} required={} property_names={} properties={} pattern_properties={}>",
@@ -895,6 +1031,7 @@ impl ObjectView {
             ruby.sym_new("additional_properties"),
             Self::additional_properties(ruby, rb_self),
         )?;
+        hash.aset(ruby.sym_new("violations"), Self::violations(ruby, rb_self)?)?;
         Ok(hash)
     }
 }
@@ -1152,9 +1289,13 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
             *CANONICAL_KW_DRAFT,
             *CANONICAL_KW_VALIDATE_FORMATS,
             *CANONICAL_KW_PATTERN_OPTIONS,
+            *KW_RETRIEVER,
+            *KW_REGISTRY,
+            *KW_BASE_URI,
         ],
     )?;
-    let (draft_val, validate_formats, pattern_options) = base_kwargs.optional;
+    let (draft_val, validate_formats, pattern_options, retriever_val, registry_val, base_uri) =
+        base_kwargs.optional;
 
     let schema_value = to_schema_value(ruby, schema_arg)?;
     let mut options = jsonschema::canonical::options();
@@ -1170,6 +1311,34 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
             RbPatternOptions::Regex(inner) => options = options.with_pattern_options(inner),
         }
     }
+    let mut has_retriever = false;
+    if let Some(val) = retriever_val {
+        if let Some(retriever) = make_retriever(ruby, val)? {
+            options = options.with_retriever(retriever);
+            has_retriever = true;
+        }
+    }
+    if let Some(val) = registry_val {
+        if !val.is_nil() {
+            let registry: &Registry = TryConvert::try_convert(val).map_err(|_| {
+                Error::new(
+                    ruby.exception_type_error(),
+                    "registry must be a JSONSchema::Registry instance",
+                )
+            })?;
+            if !has_retriever {
+                if let Some(value) = registry.retriever_value(ruby) {
+                    if let Some(retriever) = make_retriever(ruby, value)? {
+                        options = options.with_retriever(retriever);
+                    }
+                }
+            }
+            options = options.with_registry(registry.inner.as_ref());
+        }
+    }
+    if let Some(base_uri) = base_uri {
+        options = options.with_base_uri(base_uri);
+    }
     options
         .canonicalize(&schema_value)
         .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
@@ -1299,7 +1468,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     let array_view = canonical_module.define_class("ArrayView", ruby.class_object())?;
     array_view.define_method("min_items", method!(ArrayView::min_items, 0))?;
     array_view.define_method("max_items", method!(ArrayView::max_items, 0))?;
-    array_view.define_method("unique_items", method!(ArrayView::unique_items, 0))?;
+    array_view.define_method("distinctness", method!(ArrayView::distinctness, 0))?;
     array_view.define_method("prefix_items", method!(ArrayView::prefix_items, 0))?;
     array_view.define_method("items", method!(ArrayView::items, 0))?;
     array_view.define_method("contains", method!(ArrayView::contains, 0))?;
@@ -1315,6 +1484,31 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         method!(ContainsView::deconstruct_keys, 1),
     )?;
 
+    let name_fails_view = canonical_module.define_class("NameFailsView", ruby.class_object())?;
+    name_fails_view.define_method("schema", method!(NameFailsView::schema, 0))?;
+    name_fails_view.define_method("inspect", method!(NameFailsView::inspect, 0))?;
+    name_fails_view.define_method(
+        "deconstruct_keys",
+        method!(NameFailsView::deconstruct_keys, 1),
+    )?;
+
+    let undeclared_value_fails_view =
+        canonical_module.define_class("UndeclaredValueFailsView", ruby.class_object())?;
+    undeclared_value_fails_view
+        .define_method("names", method!(UndeclaredValueFailsView::names, 0))?;
+    undeclared_value_fails_view
+        .define_method("patterns", method!(UndeclaredValueFailsView::patterns, 0))?;
+    undeclared_value_fails_view.define_method(
+        "additional",
+        method!(UndeclaredValueFailsView::additional, 0),
+    )?;
+    undeclared_value_fails_view
+        .define_method("inspect", method!(UndeclaredValueFailsView::inspect, 0))?;
+    undeclared_value_fails_view.define_method(
+        "deconstruct_keys",
+        method!(UndeclaredValueFailsView::deconstruct_keys, 1),
+    )?;
+
     let object_view = canonical_module.define_class("ObjectView", ruby.class_object())?;
     object_view.define_method("min_properties", method!(ObjectView::min_properties, 0))?;
     object_view.define_method("max_properties", method!(ObjectView::max_properties, 0))?;
@@ -1329,6 +1523,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         "additional_properties",
         method!(ObjectView::additional_properties, 0),
     )?;
+    object_view.define_method("violations", method!(ObjectView::violations, 0))?;
     object_view.define_method("inspect", method!(ObjectView::inspect, 0))?;
     object_view.define_method("deconstruct_keys", method!(ObjectView::deconstruct_keys, 1))?;
 

data/src/options.rs

@@ -30,8 +30,8 @@ define_rb_intern!(static KW_DRAFT: "draft");
 define_rb_intern!(static KW_VALIDATE_FORMATS: "validate_formats");
 define_rb_intern!(static KW_IGNORE_UNKNOWN_FORMATS: "ignore_unknown_formats");
 define_rb_intern!(static KW_MASK: "mask");
-define_rb_intern!(static KW_BASE_URI: "base_uri");
-define_rb_intern!(static KW_RETRIEVER: "retriever");
+define_rb_intern!(pub(crate) static KW_BASE_URI: "base_uri");
+define_rb_intern!(pub(crate) static KW_RETRIEVER: "retriever");
 define_rb_intern!(static KW_FORMATS: "formats");
 define_rb_intern!(static KW_KEYWORDS: "keywords");
 define_rb_intern!(pub(crate) static KW_REGISTRY: "registry");

metadata

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