jsonschema_rs 0.49.1 → 0.49.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d150c4402ac7014d11674fba8a3e7ae36638e1a671010b4b8494ede16c03858
-  data.tar.gz: 4af066e13c47db2d317113d3a6454eae0e2ad60f16c52b31648da7889055bef3
+  metadata.gz: 1f9c13c1388f5e57ffff9783a04a15144954e15c0078414321bb7f699a7ebe6a
+  data.tar.gz: 866810b923d5654fc09def7495882a7e82bed9ac248594304885df21a9fb2699
 SHA512:
-  metadata.gz: 75713f7e5827481f37962d21c00ed968c8386f020ad1ec054f33d742b7036ad13354741f62e35eba0b82eb161be1b189a83f71e3a99f3fceacd917c2f56d334c
-  data.tar.gz: a7e7405400ba4dbf94954510ab490372c52258c16c61fe423285d73edcf8837e839601d462fe163bc289a040312d5bb32b9c25a7cd78323bf55b96de52abb613
+  metadata.gz: 31bb5ae7145e6dec76c88ad04e38f354abd7cb8853df576e260503d783c324da7cdd921e5472a647354247cd8b370fa79c6ea1c8e653164349b35f13f8ef81e4
+  data.tar.gz: ea2c1a7ec8afed706a4d05504b3f69e58c2ee574b373b64eb828ff1f6c2b977b539bbe4aa45966250e4ea6bab234f9e86cfbd974b72d34c4bc3738f94c3836cd

data/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 ## [Unreleased]
 
+## [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
+
+- 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
@@ -226,7 +286,10 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.1...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.49.4...HEAD
+[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
 [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

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.49.1"
+version = "0.49.4"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.49.1", default-features = false, features = ["magnus", "arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.49.4", 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.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cc9116a0f75b7336e55eb2a2a0ddef86c37cadf02924a571751aa123d5a0290"
+checksum = "257549c093d8f3d043337ba0d507e8eeace2447dfae3f0ee37eb0f57d3df7655"
 dependencies = [
  "ahash",
  "bytecount",
@@ -726,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.49.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b78efbcc1da165d63e1944fa687b3c2c09e8e418e9481e25aeada6062160c1bf"
+checksum = "b043434e5e987e02043a6fd8d0c2686c8db4fe31a37b373ef9b2a9b1f27b96c6"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.49.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10c6550900b4a6be61392b8ddeb62b5c057975371ce93fca76d92542015f98bf"
+checksum = "892e0b0739e173cce25aef424366940b20eebe7dd29304a4b8484bbd1461cc8b"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.49.1"
+version = "0.49.4"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -768,18 +768,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.49.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628a1f02bda4651d9a6088ee6386a92f0ee96255b0c99e9dfe1be91bf83bd838"
+checksum = "474790e948498099d61ec85c10dc72d459d61298b7975eda7fb163af1934b134"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.49.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75d94a372f8d81d070fd405065c6b1168d8248d1d6adad073ac708de254698c6"
+checksum = "8212315eb8e0bc44959d1af653cd5ec515771a3cdca966cfc0a10999bff144b9"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1132,9 +1132,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.49.1"
+version = "0.49.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978badf4419c9d0e1bc6e7466e99277f829d768257670c46d88121ca75e34bf7"
+checksum = "2bf1a74e036be2546c0c81cdfad6b2def6a25bf31c4e34a468037058d3bd05c6"
 dependencies = [
  "ahash",
  "fluent-uri",

data/ext/jsonschema/Cargo.toml

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

data/sig/jsonschema.rbs

@@ -32,12 +32,21 @@ 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 negate: () -> CanonicalSchema?
+      def definition: (String uri) -> CanonicalSchema?
       def definitions: () -> Hash[String, CanonicalSchema]
       def satisfiable?: () -> bool
       def inspect: () -> String
@@ -77,6 +86,7 @@ module JSONSchema
       def 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

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),
     }
@@ -141,8 +149,10 @@ impl RbCanonicalSchema {
                     max_length: view.max_length,
                     patterns: view.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
@@ -182,11 +192,38 @@ 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(),
         }
     }
 
+    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 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() {
@@ -359,8 +396,10 @@ pub struct StringView {
     max_length: Option<serde_json::Number>,
     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,6 +421,10 @@ impl StringView {
         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)
     }
@@ -390,15 +433,21 @@ 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={} 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::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()
         ))
     }
 
@@ -408,6 +457,10 @@ impl StringView {
         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("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)?,
@@ -416,6 +469,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)
     }
 }
@@ -836,6 +890,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)]
@@ -938,6 +1133,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(
@@ -957,6 +1154,9 @@ 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("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))?;
 
@@ -997,6 +1197,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     string_view.define_method("max_length", method!(StringView::max_length, 0))?;
     string_view.define_method("patterns", method!(StringView::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),
@@ -1005,6 +1206,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))?;
 
@@ -1074,6 +1276,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))?;

metadata

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