jsonschema_rs 0.49.4 → 0.49.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f9c13c1388f5e57ffff9783a04a15144954e15c0078414321bb7f699a7ebe6a
-  data.tar.gz: 866810b923d5654fc09def7495882a7e82bed9ac248594304885df21a9fb2699
+  metadata.gz: fc5dcd36cc01a2cb2ef7c933f7f3334090a41e16a12b1609fed9a70bdffbb5ec
+  data.tar.gz: e0756f39279f4c2be57811ed001623859264b4068e23817ee7e4c59d9efceb94
 SHA512:
-  metadata.gz: 31bb5ae7145e6dec76c88ad04e38f354abd7cb8853df576e260503d783c324da7cdd921e5472a647354247cd8b370fa79c6ea1c8e653164349b35f13f8ef81e4
-  data.tar.gz: ea2c1a7ec8afed706a4d05504b3f69e58c2ee574b373b64eb828ff1f6c2b977b539bbe4aa45966250e4ea6bab234f9e86cfbd974b72d34c4bc3738f94c3836cd
+  metadata.gz: 6596557fed8063bfb880120ff5a9e8fa7df17995af3cbcad630a6b3839be3cf7d2de5ea57e4bc12f66f34da4dde189129b4a033aeb5b81e602caf278667be511
+  data.tar.gz: 9766e90b8b0d157ba2820d57c127091455a44920667bda2c6bc5716ca2d3df02969baf1e34a0a8d626f0cae73c2e81a78a24754e28ed767f600e99939fa387ec

data/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [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
+
+- Canonicalization of `not` an integer schema under Draft 4, which the number leaf carries as barred integers.
+- Canonicalization of `not` a `multipleOf`, which numeric leaves carry as barred divisors.
+- Canonicalization of `not` an integer schema, where a barred divisor of one spells the non-integer numbers.
+- Canonicalization of `not` a `pattern`, which string leaves carry as barred patterns.
+- Canonicalization of `not` a typed value set under Draft 4, such as `{"type": "integer", "enum": [1, 2]}`.
+- `CanonicalSchema#is_subset_of`, whether the other schema admits every value this one admits.
+- Canonicalization of a reference cycle carrying no assertion, which admits every value.
+
+### Fixed
+
+- `CanonicalSchema#is_subset_of` failing to prove a union of array branches a subset of itself.
+- Two spellings of one number canonicalizing to different texts when the fraction exceeds the expansion cap.
+- Numeric bounds and `multipleOf` comparing values through a lossy `f64` conversion, such as `1e-400` passing `{"maximum": 0}`.
+
 ## [0.49.4] - 2026-08-04
 
 ### Added
@@ -286,7 +327,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.4...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.6...HEAD
+[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
 [0.49.2]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.1...ruby-v0.49.2

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.49.4"
+version = "0.49.6"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.49.4", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.6", 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

@@ -220,9 +220,9 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "fancy-regex"
-version = "0.18.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1e1dacd0d2082dfcf1351c4bdd566bbe89a2b263235a2b50058f1e130a47277"
+checksum = "476de73bddf2ef8490aa4ee8f1cf40b430bf1d56c48c22080e5186952cd580e6"
 dependencies = [
  "bit-set",
  "regex-automata",
@@ -693,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "257549c093d8f3d043337ba0d507e8eeace2447dfae3f0ee37eb0f57d3df7655"
+checksum = "7e17384278234b10419a63c93fc85695ac9fc2da0833e3c59167f9986499590c"
 dependencies = [
  "ahash",
  "bytecount",
@@ -726,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b043434e5e987e02043a6fd8d0c2686c8db4fe31a37b373ef9b2a9b1f27b96c6"
+checksum = "c76669fda3185c230671e06740af90404301d31ee5f8375cc0baea4b1d53f01a"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "892e0b0739e173cce25aef424366940b20eebe7dd29304a4b8484bbd1461cc8b"
+checksum = "398e6baeee7f5a5825f80945cc324a385fdec9812516cfd37703822ef46cf80b"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.49.4"
+version = "0.49.6"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -768,18 +768,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "474790e948498099d61ec85c10dc72d459d61298b7975eda7fb163af1934b134"
+checksum = "ac634e339e73bf9629f6fb207f7b064d872253ae3b3f5c6e0ce8fd762b16e40f"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8212315eb8e0bc44959d1af653cd5ec515771a3cdca966cfc0a10999bff144b9"
+checksum = "92b8e258eb4515a3fc912a9c46e3987040dc07280592280097ea2085527870b8"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1132,9 +1132,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.49.4"
+version = "0.49.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bf1a74e036be2546c0c81cdfad6b2def6a25bf31c4e34a468037058d3bd05c6"
+checksum = "42902112f88a27e9afd5683e2ba31956fed2a5d43395f166dd26775ae9c0dedb"
 dependencies = [
  "ahash",
  "fluent-uri",
@@ -1161,9 +1161,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.14"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
 dependencies = [
  "aho-corasick",
  "memchr",

data/ext/jsonschema/Cargo.toml

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

data/sig/jsonschema.rbs

@@ -45,6 +45,7 @@ module JSONSchema
       def kind: () -> kind
       def view: () -> view
       def intersect: (CanonicalSchema other) -> CanonicalSchema
+      def is_subset_of: (CanonicalSchema other) -> bool?
       def negate: () -> CanonicalSchema?
       def definition: (String uri) -> CanonicalSchema?
       def definitions: () -> Hash[String, CanonicalSchema]
@@ -83,7 +84,9 @@ module JSONSchema
       def min_length: () -> Integer?
       def max_length: () -> Integer?
       def patterns: () -> Array[String]
+      def excluded_patterns: () -> Array[String]
       def formats: () -> Array[String]
+      def excluded_formats: () -> Array[String]
       def content_media_types: () -> Array[String]
       def content_encodings: () -> Array[String]
       def excluded: () -> Array[String]
@@ -98,6 +101,8 @@ module JSONSchema
       def maximum: () -> (Integer | Float)?
       def exclusive_maximum: () -> bool
       def multiple_of: () -> Array[Integer | Float]
+      def not_multiple_of: () -> Array[Integer | Float]
+      def excludes_integers: () -> bool
       def inspect: () -> String
       def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
     end
@@ -107,6 +112,7 @@ module JSONSchema
       def minimum: () -> Integer?
       def maximum: () -> Integer?
       def multiple_of: () -> Array[Integer | Float]
+      def not_multiple_of: () -> Array[Integer | Float]
       def inspect: () -> String
       def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
     end
@@ -115,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]
@@ -140,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

data/src/canonical.rs

@@ -1,6 +1,7 @@
 use jsonschema::{
     canonical::{
         CanonicalSchema, CanonicalView, CanonicalizationError, ContainsView as CoreContainsView,
+        ObjectViolationView as CoreObjectViolationView,
     },
     JsonType,
 };
@@ -148,6 +149,7 @@ impl RbCanonicalSchema {
                     min_length: view.min_length,
                     max_length: view.max_length,
                     patterns: view.patterns,
+                    excluded_patterns: view.excluded_patterns,
                     formats: view.formats,
                     excluded_formats: view.excluded_formats,
                     content_media_types: view.content_media_types,
@@ -162,6 +164,8 @@ impl RbCanonicalSchema {
                     maximum: view.maximum,
                     exclusive_maximum: view.exclusive_maximum,
                     multiple_of: view.multiple_of,
+                    not_multiple_of: view.not_multiple_of,
+                    excludes_integers: view.excludes_integers,
                 })
                 .as_value(),
             CanonicalView::Integer(view) => ruby
@@ -169,13 +173,14 @@ impl RbCanonicalSchema {
                     minimum: view.minimum,
                     maximum: view.maximum,
                     multiple_of: view.multiple_of,
+                    not_multiple_of: view.not_multiple_of,
                 })
                 .as_value(),
             CanonicalView::Array(view) => ruby
                 .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,
@@ -190,6 +195,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(),
@@ -209,6 +215,13 @@ impl RbCanonicalSchema {
             .map_err(|error| canonicalization_error(ruby, error))
     }
 
+    fn is_subset_of(ruby: &Ruby, rb_self: &Self, other: &Self) -> Result<Option<bool>, Error> {
+        rb_self
+            .inner
+            .is_subset_of(&other.inner)
+            .map_err(|error| canonicalization_error(ruby, error))
+    }
+
     fn negate(ruby: &Ruby, rb_self: &Self) -> Option<Value> {
         rb_self
             .inner
@@ -387,14 +400,14 @@ fn strings_to_ruby(ruby: &Ruby, values: &[String]) -> Result<Value, Error> {
     Ok(array.as_value())
 }
 
-/// A string value within a length window, matching every pattern, format, media type, and
-/// encoding.
+/// A string value within a length window, matching every required facet and no barred one.
 #[derive(magnus::TypedData)]
 #[magnus(class = "JSONSchema::Canonical::StringView", free_immediately)]
 pub struct StringView {
     min_length: Option<serde_json::Number>,
     max_length: Option<serde_json::Number>,
     patterns: Vec<String>,
+    excluded_patterns: Vec<String>,
     formats: Vec<String>,
     excluded_formats: Vec<String>,
     content_media_types: Vec<String>,
@@ -417,6 +430,10 @@ impl StringView {
         strings_to_ruby(ruby, &rb_self.patterns)
     }
 
+    fn excluded_patterns(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.excluded_patterns)
+    }
+
     fn formats(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         strings_to_ruby(ruby, &rb_self.formats)
     }
@@ -439,10 +456,11 @@ impl StringView {
 
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
-            "#<JSONSchema::Canonical::StringView min_length={} max_length={} patterns={} formats={} excluded_formats={} content_media_types={} content_encodings={} excluded={}>",
+            "#<JSONSchema::Canonical::StringView min_length={} max_length={} patterns={} excluded_patterns={} formats={} excluded_formats={} content_media_types={} content_encodings={} excluded={}>",
             Self::min_length(ruby, rb_self)?.inspect(),
             Self::max_length(ruby, rb_self)?.inspect(),
             Self::patterns(ruby, rb_self)?.inspect(),
+            Self::excluded_patterns(ruby, rb_self)?.inspect(),
             Self::formats(ruby, rb_self)?.inspect(),
             Self::excluded_formats(ruby, rb_self)?.inspect(),
             Self::content_media_types(ruby, rb_self)?.inspect(),
@@ -456,6 +474,10 @@ impl StringView {
         hash.aset(ruby.sym_new("min_length"), Self::min_length(ruby, rb_self)?)?;
         hash.aset(ruby.sym_new("max_length"), Self::max_length(ruby, rb_self)?)?;
         hash.aset(ruby.sym_new("patterns"), Self::patterns(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("excluded_patterns"),
+            Self::excluded_patterns(ruby, rb_self)?,
+        )?;
         hash.aset(ruby.sym_new("formats"), Self::formats(ruby, rb_self)?)?;
         hash.aset(
             ruby.sym_new("excluded_formats"),
@@ -483,6 +505,8 @@ pub struct NumberView {
     maximum: Option<serde_json::Number>,
     exclusive_maximum: bool,
     multiple_of: Vec<serde_json::Number>,
+    not_multiple_of: Vec<serde_json::Number>,
+    excludes_integers: bool,
 }
 
 impl DataTypeFunctions for NumberView {}
@@ -508,14 +532,24 @@ impl NumberView {
         divisors_to_ruby(ruby, &rb_self.multiple_of)
     }
 
+    fn not_multiple_of(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        divisors_to_ruby(ruby, &rb_self.not_multiple_of)
+    }
+
+    fn excludes_integers(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.into_value(rb_self.excludes_integers)
+    }
+
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
-            "#<JSONSchema::Canonical::NumberView minimum={} exclusive_minimum={} maximum={} exclusive_maximum={} multiple_of={}>",
+            "#<JSONSchema::Canonical::NumberView minimum={} exclusive_minimum={} maximum={} exclusive_maximum={} multiple_of={} not_multiple_of={} excludes_integers={}>",
             Self::minimum(ruby, rb_self)?.inspect(),
             Self::exclusive_minimum(ruby, rb_self).inspect(),
             Self::maximum(ruby, rb_self)?.inspect(),
             Self::exclusive_maximum(ruby, rb_self).inspect(),
-            Self::multiple_of(ruby, rb_self)?.inspect()
+            Self::multiple_of(ruby, rb_self)?.inspect(),
+            Self::not_multiple_of(ruby, rb_self)?.inspect(),
+            Self::excludes_integers(ruby, rb_self).inspect()
         ))
     }
 
@@ -535,6 +569,14 @@ impl NumberView {
             ruby.sym_new("multiple_of"),
             Self::multiple_of(ruby, rb_self)?,
         )?;
+        hash.aset(
+            ruby.sym_new("not_multiple_of"),
+            Self::not_multiple_of(ruby, rb_self)?,
+        )?;
+        hash.aset(
+            ruby.sym_new("excludes_integers"),
+            Self::excludes_integers(ruby, rb_self),
+        )?;
         Ok(hash)
     }
 }
@@ -546,6 +588,7 @@ pub struct IntegerView {
     minimum: Option<serde_json::Number>,
     maximum: Option<serde_json::Number>,
     multiple_of: Vec<serde_json::Number>,
+    not_multiple_of: Vec<serde_json::Number>,
 }
 
 impl DataTypeFunctions for IntegerView {}
@@ -563,12 +606,17 @@ impl IntegerView {
         divisors_to_ruby(ruby, &rb_self.multiple_of)
     }
 
+    fn not_multiple_of(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        divisors_to_ruby(ruby, &rb_self.not_multiple_of)
+    }
+
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
-            "#<JSONSchema::Canonical::IntegerView minimum={} maximum={} multiple_of={}>",
+            "#<JSONSchema::Canonical::IntegerView minimum={} maximum={} multiple_of={} not_multiple_of={}>",
             Self::minimum(ruby, rb_self)?.inspect(),
             Self::maximum(ruby, rb_self)?.inspect(),
-            Self::multiple_of(ruby, rb_self)?.inspect()
+            Self::multiple_of(ruby, rb_self)?.inspect(),
+            Self::not_multiple_of(ruby, rb_self)?.inspect()
         ))
     }
 
@@ -580,6 +628,10 @@ impl IntegerView {
             ruby.sym_new("multiple_of"),
             Self::multiple_of(ruby, rb_self)?,
         )?;
+        hash.aset(
+            ruby.sym_new("not_multiple_of"),
+            Self::not_multiple_of(ruby, rb_self)?,
+        )?;
         Ok(hash)
     }
 }
@@ -591,7 +643,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>,
@@ -608,8 +660,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> {
@@ -646,10 +698,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()
@@ -661,8 +713,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"),
@@ -733,6 +785,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)]
@@ -744,6 +906,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 {}
@@ -809,6 +972,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={}>",
@@ -845,6 +1016,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)
     }
 }
@@ -1155,6 +1327,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     )?;
     canonical_schema.define_method("view", method!(RbCanonicalSchema::view, 0))?;
     canonical_schema.define_method("intersect", method!(RbCanonicalSchema::intersect, 1))?;
+    canonical_schema.define_method("is_subset_of", method!(RbCanonicalSchema::is_subset_of, 1))?;
     canonical_schema.define_method("negate", method!(RbCanonicalSchema::negate, 0))?;
     canonical_schema.define_method("definition", method!(RbCanonicalSchema::definition, 1))?;
     canonical_schema.define_method("definitions", method!(RbCanonicalSchema::definitions, 0))?;
@@ -1196,6 +1369,10 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     string_view.define_method("min_length", method!(StringView::min_length, 0))?;
     string_view.define_method("max_length", method!(StringView::max_length, 0))?;
     string_view.define_method("patterns", method!(StringView::patterns, 0))?;
+    string_view.define_method(
+        "excluded_patterns",
+        method!(StringView::excluded_patterns, 0),
+    )?;
     string_view.define_method("formats", method!(StringView::formats, 0))?;
     string_view.define_method("excluded_formats", method!(StringView::excluded_formats, 0))?;
     string_view.define_method(
@@ -1222,6 +1399,11 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         method!(NumberView::exclusive_maximum, 0),
     )?;
     number_view.define_method("multiple_of", method!(NumberView::multiple_of, 0))?;
+    number_view.define_method("not_multiple_of", method!(NumberView::not_multiple_of, 0))?;
+    number_view.define_method(
+        "excludes_integers",
+        method!(NumberView::excludes_integers, 0),
+    )?;
     number_view.define_method("inspect", method!(NumberView::inspect, 0))?;
     number_view.define_method("deconstruct_keys", method!(NumberView::deconstruct_keys, 1))?;
 
@@ -1229,6 +1411,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     integer_view.define_method("minimum", method!(IntegerView::minimum, 0))?;
     integer_view.define_method("maximum", method!(IntegerView::maximum, 0))?;
     integer_view.define_method("multiple_of", method!(IntegerView::multiple_of, 0))?;
+    integer_view.define_method("not_multiple_of", method!(IntegerView::not_multiple_of, 0))?;
     integer_view.define_method("inspect", method!(IntegerView::inspect, 0))?;
     integer_view.define_method(
         "deconstruct_keys",
@@ -1238,7 +1421,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))?;
@@ -1254,6 +1437,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))?;
@@ -1268,6 +1476,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))?;
 

metadata

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