jsonschema_rs 0.49.3 → 0.49.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48dc9cf6305e242c8a686a6e1439fcc2d05ce1b2738bfdf1eb42394e05f16d03
-  data.tar.gz: 9e828ed439bb3180094d3c2cdc1cbc0723ea71d385c2861278c7347493dfd900
+  metadata.gz: 14182b3d65f8580de3c3c3b3dab17d0709a70e56b93b519a2095f0d87bbda232
+  data.tar.gz: c43c5b754ef7a41ff8ce3d06ab79f1f29854967446ee6efb76282af7c0186e98
 SHA512:
-  metadata.gz: d41807f218f18e5435a4ec6e01326f5459076c78afd126844dcd03a982e1006514ec613333eac241853e8b83859410ab723f53ffa185f959cfd6209f8a4c6399
-  data.tar.gz: 768c332d2d735999f58bde2a4947568d9e4e7c7cbf818e6ed8ae4177d890810490cf2494b5bfcea547fe7a0c7827775ba83192e465f77207581a9e40d6d21f1f
+  metadata.gz: 503c06fb04a59e9ca5e38eeb0c360741a9d6a409e4dce784ade9babe4514f19fb1f4668b9f21538e661c5bed1d76600cd32ec92bd4c7d1daa8a6e147de4b3607
+  data.tar.gz: 53b2d54cbbb81a4b2ccba5eaa7a8cf8144f1597c3ccbf0abf55ba0fbee189a85634a936a5571af77d64e4a9351c04ec57f41867decb15b1404beeb93bc7a0abc

data/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [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
+
+- Canonicalization of `not` a string format, which the string leaf carries as barred formats.
+- Canonicalization of `not` an existential demand, which an array fails exactly when no element matches.
+- Canonicalization of `not` a string value set, which the string leaf carries as excluded values.
+- Canonicalization of `unevaluatedItems` beside `contains`, where the elements it matches are evaluated and the tail admits either.
+- Canonicalization of `unevaluated*` beside `anyOf` or `oneOf`, where every branch evaluating the same keys or indexes pins what is left over.
+- Canonicalization of `not` an array element schema, which an array fails exactly when one element violates it.
+- `CanonicalSchema#intersect`, the values both schemas admit.
+- `CanonicalSchema#negate`, the values a schema rejects.
+- `CanonicalSchema#definition`, one reference target by URI.
+
+### Fixed
+
+- An integer past `i64` admitted by a fractional bound `f64` rounds it onto, such as `-10000000000000000000000000` under `{"maximum": -10000000000000000000000000.1}`.
+- An integer past `2^53` admitted by a bound `f64` rounds onto it, such as `9007199254740992` under `{"minimum": 9007199254740993}`.
+- A `contains` subschema beside both `minContains` and `maxContains` overwriting a sibling keyword of the same name, such as `items`.
+
+### Performance
+
+- `CanonicalSchema` hashing and equality cost the node instead of the whole document.
+
 ## [0.49.3] - 2026-08-02
 
 ### Added
@@ -262,7 +304,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.3...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.5...HEAD
+[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
 [0.49.1]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.0...ruby-v0.49.1

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.49.3"
+version = "0.49.5"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.49.3", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.5", 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.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "508004a5500f2e1f68af048f70feea2de86d35ab115d85716530860822aef397"
+checksum = "8da60094fc1968bbd091e2cfa004415cb7b19e25e592376e66a64aa832bb6039"
 dependencies = [
  "ahash",
  "bytecount",
@@ -726,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.49.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4e131231bc18676df289bd7634d4353d5b36bced191928bfa2a2dcae91e44a0"
+checksum = "1575f559a96e0cd2b83afd25b868507d39b97e16af2ed7d23074c470b0259627"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.49.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75803a5014f912d5a8f3c8cc24531d19ea06dfadda75ddf1d15af629f7c8468c"
+checksum = "4d2d8f4ec940ac30dc8e85787916ac6a9d34fcfa850b47ffe69205e837dee621"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.49.3"
+version = "0.49.5"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -768,18 +768,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.49.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a8b30cafa78358ae6cd1494a7d6410b89530e28bf567f862c869c667e900d9f"
+checksum = "36539f34ef9e5da418433fbbf7294522d8f930ecf6a540ccd1ec6481c9ff9056"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.49.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5526bd381d230af94908d07e6835a33fd82a465e12f5f1e9c81f5c2aa23b3c21"
+checksum = "8bc513dfee68c6fe29498451df95a32951ea227801b476f4a1f236433986c891"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1132,9 +1132,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.49.3"
+version = "0.49.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7af3eb523cce0df0af3c30d624b829b2dabd233172b5bc2615fcd03ceae8f746"
+checksum = "05915176d843da9ec5c925e5e2631be9aa61b27430acfdd562e79cae8f559725"
 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.3"
+version = "0.49.5"
 edition = "2021"
 publish = false
 
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.49.3", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.5", 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.3"
+referencing = "0.49.5"
 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.3"
+  VERSION = "0.49.5"
 end

data/sig/jsonschema.rbs

@@ -32,12 +32,22 @@ module JSONSchema
     class InvalidPattern < CanonicalizationError
     end
 
+    class IncompatibleOperands < CanonicalizationError
+    end
+
+    class UnmodeledOperand < CanonicalizationError
+    end
+
     # A schema reduced to canonical form: schemas accepting the same values share one form.
     class CanonicalSchema
       def to_json_schema: () -> untyped
       def draft: () -> JSONSchema::draft
       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]
       def satisfiable?: () -> bool
       def inspect: () -> String
@@ -74,9 +84,12 @@ 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]
       def inspect: () -> String
       def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
     end
@@ -88,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
@@ -97,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

data/src/canonical.rs

@@ -47,6 +47,8 @@ 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");
+canonical_error_class!(INCOMPATIBLE_OPERANDS_CLASS, "IncompatibleOperands");
+canonical_error_class!(UNMODELED_OPERAND_CLASS, "UnmodeledOperand");
 
 fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
     if let CanonicalizationError::ValidationError(validation_error) = error {
@@ -60,6 +62,12 @@ fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
         CanonicalizationError::InvalidPattern { .. } => {
             Error::new(ruby.get_inner(&INVALID_PATTERN_CLASS), message)
         }
+        CanonicalizationError::IncompatibleOperands(_) => {
+            Error::new(ruby.get_inner(&INCOMPATIBLE_OPERANDS_CLASS), message)
+        }
+        CanonicalizationError::UnmodeledOperand => {
+            Error::new(ruby.get_inner(&UNMODELED_OPERAND_CLASS), message)
+        }
         // `ValidationError` returns above; future variants fall back to the base canonical error.
         _ => Error::new(ruby.get_inner(&CANONICALIZATION_ERROR_CLASS), message),
     }
@@ -140,9 +148,12 @@ 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,
                     content_encodings: view.content_encodings,
+                    excluded: view.excluded,
                 })
                 .as_value(),
             CanonicalView::Number(view) => ruby
@@ -152,6 +163,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
@@ -159,6 +172,7 @@ 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
@@ -191,6 +205,36 @@ impl RbCanonicalSchema {
         }
     }
 
+    fn intersect(ruby: &Ruby, rb_self: &Self, other: &Self) -> Result<Value, Error> {
+        rb_self
+            .inner
+            .intersect(&other.inner)
+            .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
+            .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
+            .negate()
+            .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn definition(ruby: &Ruby, rb_self: &Self, uri: String) -> Option<Value> {
+        rb_self
+            .inner
+            .definition(&uri)
+            .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
+    }
+
     fn definitions(ruby: &Ruby, rb_self: &Self) -> Result<RHash, Error> {
         let hash = ruby.hash_new();
         for (uri, target) in rb_self.inner.definitions() {
@@ -354,17 +398,19 @@ 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>,
     content_encodings: Vec<String>,
+    excluded: Vec<String>,
 }
 
 impl DataTypeFunctions for StringView {}
@@ -382,10 +428,18 @@ 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)
     }
 
+    fn excluded_formats(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.excluded_formats)
+    }
+
     fn content_media_types(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         strings_to_ruby(ruby, &rb_self.content_media_types)
     }
@@ -394,15 +448,22 @@ impl StringView {
         strings_to_ruby(ruby, &rb_self.content_encodings)
     }
 
+    fn excluded(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.excluded)
+    }
+
     fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
         Ok(format!(
-            "#<JSONSchema::Canonical::StringView min_length={} max_length={} patterns={} formats={} content_media_types={} content_encodings={}>",
+            "#<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(),
-            Self::content_encodings(ruby, rb_self)?.inspect()
+            Self::content_encodings(ruby, rb_self)?.inspect(),
+            Self::excluded(ruby, rb_self)?.inspect()
         ))
     }
 
@@ -411,7 +472,15 @@ 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"),
+            Self::excluded_formats(ruby, rb_self)?,
+        )?;
         hash.aset(
             ruby.sym_new("content_media_types"),
             Self::content_media_types(ruby, rb_self)?,
@@ -420,6 +489,7 @@ impl StringView {
             ruby.sym_new("content_encodings"),
             Self::content_encodings(ruby, rb_self)?,
         )?;
+        hash.aset(ruby.sym_new("excluded"), Self::excluded(ruby, rb_self)?)?;
         Ok(hash)
     }
 }
@@ -433,6 +503,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 {}
@@ -458,14 +530,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()
         ))
     }
 
@@ -485,6 +567,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)
     }
 }
@@ -496,6 +586,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 {}
@@ -513,12 +604,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()
         ))
     }
 
@@ -530,6 +626,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)
     }
 }
@@ -1083,6 +1183,8 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         canonical_module.define_error("CanonicalizationError", ruby.exception_standard_error())?;
     canonical_module.define_error("InvalidSchemaType", base_error)?;
     canonical_module.define_error("InvalidPattern", base_error)?;
+    canonical_module.define_error("IncompatibleOperands", base_error)?;
+    canonical_module.define_error("UnmodeledOperand", base_error)?;
 
     let canonical_schema = canonical_module.define_class("CanonicalSchema", ruby.class_object())?;
     canonical_schema.define_method(
@@ -1102,6 +1204,10 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         method!(<RbCanonicalSchema as typed_data::Hash>::hash, 0),
     )?;
     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))?;
     canonical_schema.define_method("satisfiable?", method!(RbCanonicalSchema::satisfiable, 0))?;
 
@@ -1141,7 +1247,12 @@ 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(
         "content_media_types",
         method!(StringView::content_media_types, 0),
@@ -1150,6 +1261,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
         "content_encodings",
         method!(StringView::content_encodings, 0),
     )?;
+    string_view.define_method("excluded", method!(StringView::excluded, 0))?;
     string_view.define_method("inspect", method!(StringView::inspect, 0))?;
     string_view.define_method("deconstruct_keys", method!(StringView::deconstruct_keys, 1))?;
 
@@ -1165,6 +1277,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))?;
 
@@ -1172,6 +1289,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",

metadata

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