jsonschema_rs 0.56.0 → 0.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e2046dda10b3b0e6109b3f7a55667f9d6cb86a38b0f7ddbb80e7d9bc67b25d
-  data.tar.gz: f3eed3727e42c284573978507158cdd966691a0d55add5a12102bbf206440db3
+  metadata.gz: d283a285d78237b32ea3ddbca89297aa0ff3424b194a59add3dc5d552cbc6b9a
+  data.tar.gz: 7cc45e4701dba75e717b3935b6c94b44cc3b8b18f0aa07d65ab10e1da03ce51e
 SHA512:
-  metadata.gz: '0632192b1860a29b067638bd11e1c70d71e58d39ff5a100514ae72b183c9f46784a466ef59ee80ab5f151e700df4eb8b3a10e3b2a2b7b062b301094b653c07f9'
-  data.tar.gz: b9155ae7dae3ce0b2559733bc53c938f0129a696dc43d7a7913cfc850967583d9144a0c6f63940b44ec2c45b2d3b7b14ec110263f0daed0027a581174630474c
+  metadata.gz: 34521e6ec676f5154e8eadca6b3509a86d6e148dddfd8feda01d2b9463874604c3b340184d0cdfde53e3db9bc85a87d00b509d446463cda2a2ac393c624f038a
+  data.tar.gz: 38f1947bb694578ae871ea38693577d2d6c03fbbbdb6184b708a354de12c9031359ea03244dea147da385ce4ae89f6be645ece567406aaf61b2dced8e71f5913

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.58.0] - 2026-09-25
+
+### Performance
+
+- `oneOf` and `anyOf` whose branches each require a property fixed to a distinct string validate only the branch matching the instance's value.
+- `Meta.valid?` and `Meta.validate!` check a schema against the bundled drafts without converting it first, 2 to 5x faster on the benchmarked schemas.
+
+### Fixed
+
+- `Canonical.find_unsatisfiable` missing a `oneOf` over `$ref` branches beside a sibling none of them admits.
+- A value with no JSON form nested under `type: null` failing validation silently (it should raise `TypeError`).
+
+## [0.57.0] - 2026-09-22
+
+### Added
+
+- `Canonical.find_unsatisfiable`, naming every subschema of a document that admits no value, and the keywords that leave it empty.
+
+### Fixed
+
+- The instance path of a schema build error, which was empty instead of naming the keyword location that failed to compile.
+
 ## [0.56.0] - 2026-09-10
 
 ### Added
@@ -567,7 +589,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.56.0...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.58.0...HEAD
+[0.58.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.57.0...ruby-v0.58.0
+[0.57.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.56.0...ruby-v0.57.0
 [0.56.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.55.1...ruby-v0.56.0
 [0.55.1]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.55.0...ruby-v0.55.1
 [0.55.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.54.0...ruby-v0.55.0

data/Cargo.toml

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

data/README.md

@@ -371,6 +371,33 @@ Compare a request schema new-against-old and a response schema old-against-new:
 
 Both operands must share one setup - the same draft, format policy, regular-expression engine and definitions - or `IncompatibleOperands` is raised. `UnsupportedOperand` means an operand is a `Raw` pass-through, and `UnsupportedResult` that the canonical form does not support the result. All three live under `JSONSchema::Canonical`.
 
+### Finding the dead subschemas of a document
+
+`JSONSchema::Canonical.find_unsatisfiable` walks a whole document and answers which of its subschemas admit no value, and why - the keywords at fault and where they sit:
+
+```ruby
+reasons = JSONSchema::Canonical.find_unsatisfiable(
+  {
+    "properties" => {
+      "tag" => { "type" => "string", "minLength" => 5, "maxLength" => 2 },
+      "name" => { "type" => "string" }
+    }
+  }
+)
+
+case reasons["/properties/tag"]
+in JSONSchema::Canonical::ConflictReason[causes:]
+  causes.map { |cause| [cause.pointer, cause.keywords] }
+  # => [["/properties/tag", ["type"]], ["/properties/tag", ["minLength", "maxLength"]]]
+end
+
+# A live subschema is not reported
+reasons.key?("/properties/name")
+# => false
+```
+
+A reason is a `LiteralReason` (written as `false`), an `EmptyReason` (one part admits nothing by itself) or a `ConflictReason` (each part admits values, together they admit none). A pointer left out is not proven satisfiable: a document canonicalization cannot model reports nothing, as `satisfiability` answers `:unknown`.
+
 ## Schema Bundling and Dereferencing
 
 Produce a Compound Schema Document ([Appendix B](https://json-schema.org/draft/2020-12/json-schema-core#appendix-B)) by embedding all external `$ref` targets into a draft-appropriate container. The result validates identically to the original.
@@ -673,6 +700,18 @@ Valid draft symbols: `:draft4`, `:draft6`, `:draft7`, `:draft201909`, `:draft202
 
 For detailed benchmarks, see our [full performance comparison](https://github.com/Stranger6667/jsonschema/blob/master/crates/jsonschema-rb/BENCHMARKS.md).
 
+### Compile-Time Validators
+
+If you ship your own extension and know the schema at build time, the Rust crate's
+`#[jsonschema::validator(..., backend = Magnus)]` macro compiles it into a validator that reads
+Ruby objects directly, so nothing is parsed or compiled when your extension is loaded, and
+validation runs up to 3.5x faster than with a validator built at run time. See the
+[macro documentation](https://docs.rs/jsonschema/latest/jsonschema/#ruby-extension-modules).
+
+This is not available from the `jsonschema_rs` gem, which takes its schemas at run time.
+A complete extension with its build and test commands lives in
+[`examples/magnus-extension`](https://github.com/Stranger6667/jsonschema/tree/master/examples/magnus-extension).
+
 ## Acknowledgements
 
 This library draws API design inspiration from the Python [`jsonschema`](https://github.com/python-jsonschema/jsonschema) package. We're grateful to the Python `jsonschema` maintainers and contributors for their pioneering work in JSON Schema validation.

data/ext/jsonschema/Cargo.lock

@@ -693,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6a806f80c1f5560431009ce5ec29b59d38f950e0cd7db5f1b8925e6d8104e21"
+checksum = "7b055418f7dbe79d0c3c6236e4c7dc6de804ec25bbacd5eb2df914de42fa6d61"
 dependencies = [
  "ahash",
  "bytecount",
@@ -709,6 +709,7 @@ dependencies = [
  "jsonschema-macros",
  "jsonschema-regex",
  "jsonschema-value",
+ "magnus",
  "num-bigint",
  "num-cmp",
  "num-traits",
@@ -726,9 +727,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97ac41a7411c029f7f9971881ccf12c8190411a0ab5caf53c07b07eabbea253e"
+checksum = "0d5d0dd1510274c2ce3291ef72d8c6f8c56b17d59c3a7eeb10dabd4106dd0daa"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -736,9 +737,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b29ab02b2d2d1b26f9c7709c7985ced2d163cb570dedd38bd8467ef31e5dbc3c"
+checksum = "c643d0e62d2398b6b5faf940dd9bfc5a2ee5307a56231529823e726f497f260c"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -755,7 +756,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.56.0"
+version = "0.58.0"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -769,18 +770,18 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb862addfa7782108933abcf842fe25334523a9df5b89ea4d9620e3dd7b42181"
+checksum = "7c1628929292454a791622b721825f293df733070534a0a89fea620cce1b509d"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "jsonschema-value"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a05cd404c5ff6e2731dbbf7e290a27417750acfb59e329560a1d0af384c93fb0"
+checksum = "5d070064f657124cf7504e20d2ad30ebb58d228c503aace3c3fe98acc8f1c870"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1135,9 +1136,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.56.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3b4a92fac7e28c27de3ad26df2ecb9e652f227b258e845af034052e5b22c96c"
+checksum = "8e0b0f22114d6c321197de72f9800cb2bb0e83b7ddc03d70bb7a83eeae8586e7"
 dependencies = [
  "ahash",
  "fluent-uri",

data/ext/jsonschema/Cargo.toml

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

data/lib/jsonschema/version.rb

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

data/sig/jsonschema.rbs

@@ -306,6 +306,55 @@ module JSONSchema
       def inspect: () -> String
       def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
     end
+
+    # One part of a schema object, as a reason names it.
+    class Cause
+      # JSON Pointer of the schema object holding `keywords`, or of the subschema itself.
+      def pointer: () -> String
+      # Keywords of one family present at `pointer`; empty for a whole subschema.
+      def keywords: () -> Array[String]
+      def ==: (untyped other) -> bool
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # The subschema is written as `false`.
+    class LiteralReason
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # One part every value must satisfy admits nothing by itself. A subschema part has a reason
+    # of its own under its pointer.
+    class EmptyReason
+      def cause: () -> Cause
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # Each part admits values; no value satisfies all of them together.
+    class ConflictReason
+      def causes: () -> Array[Cause]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # Why a subschema admits no value.
+    type unsatisfiable_reason = LiteralReason | EmptyReason | ConflictReason
+
+    # The subschemas that admit no value, by JSON Pointer, each with why.
+    #
+    # A pointer left out is not proven satisfiable: a document the canonical form does not model
+    # reports nothing, as `satisfiability` answers `:unknown`.
+    def self.find_unsatisfiable: (
+      untyped schema,
+      ?draft: JSONSchema::draft?,
+      ?validate_formats: bool?,
+      ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+      ?retriever: (^(String) -> untyped)?,
+      ?registry: Registry?,
+      ?base_uri: String?
+    ) -> Hash[String, unsatisfiable_reason]
   end
 
   # Reduce a schema to its canonical form.

data/src/canonical.rs

@@ -1,8 +1,9 @@
 use jsonschema::{
     canonical::{
-        CanonicalKind, CanonicalSchema, CanonicalView, CanonicalizationError, Containment,
-        ContainsView as CoreContainsView, Distinctness,
+        CanonicalKind, CanonicalSchema, CanonicalView, CanonicalizationError, Cause as CoreCause,
+        Containment, ContainsView as CoreContainsView, Distinctness,
         ObjectViolationView as CoreObjectViolationView, RawReason, Satisfiability,
+        UnsatisfiableReason as CoreUnsatisfiableReason,
     },
     JsonType,
 };
@@ -1374,10 +1375,154 @@ impl EnumView {
     }
 }
 
-fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(Value,), (), (), (), _, ()>(args)?;
-    let (schema_arg,) = parsed.required;
-    let keywords: RHash = parsed.keywords;
+/// One part of a schema object, as a reason names it.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::Cause", free_immediately)]
+pub struct Cause {
+    pointer: String,
+    keywords: Vec<String>,
+}
+
+impl DataTypeFunctions for Cause {}
+
+impl Cause {
+    fn pointer(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.str_new(&rb_self.pointer).as_value()
+    }
+
+    fn keywords(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.keywords.len());
+        for keyword in &rb_self.keywords {
+            array.push(ruby.str_new(keyword))?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn eq(rb_self: &Self, other: Value) -> bool {
+        let Ok(other_ref) = <&Cause>::try_convert(other) else {
+            return false;
+        };
+        rb_self.pointer == other_ref.pointer && rb_self.keywords == other_ref.keywords
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::Cause pointer={} keywords={}>",
+            Self::pointer(ruby, rb_self).inspect(),
+            Self::keywords(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("pointer"), Self::pointer(ruby, rb_self))?;
+        hash.aset(ruby.sym_new("keywords"), Self::keywords(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// The subschema is written as `false`.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::LiteralReason", free_immediately)]
+pub struct LiteralReason;
+
+impl DataTypeFunctions for LiteralReason {}
+
+impl LiteralReason {
+    fn inspect(_rb_self: &Self) -> &'static str {
+        "#<JSONSchema::Canonical::LiteralReason>"
+    }
+
+    fn deconstruct_keys(ruby: &Ruby, _rb_self: &Self, _keys: Value) -> RHash {
+        ruby.hash_new()
+    }
+}
+
+/// One part every value must satisfy admits nothing by itself. A subschema part has a reason of
+/// its own under its pointer.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::EmptyReason", free_immediately)]
+pub struct EmptyReason {
+    cause: CoreCause,
+}
+
+impl DataTypeFunctions for EmptyReason {}
+
+impl EmptyReason {
+    fn cause(ruby: &Ruby, rb_self: &Self) -> Value {
+        cause_to_ruby(ruby, rb_self.cause.clone())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::EmptyReason cause={}>",
+            Self::cause(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("cause"), Self::cause(ruby, rb_self))?;
+        Ok(hash)
+    }
+}
+
+/// Each part admits values; no value satisfies all of them together.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ConflictReason", free_immediately)]
+pub struct ConflictReason {
+    causes: Vec<CoreCause>,
+}
+
+impl DataTypeFunctions for ConflictReason {}
+
+impl ConflictReason {
+    fn causes(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.causes.len());
+        for cause in &rb_self.causes {
+            array.push(cause_to_ruby(ruby, cause.clone()))?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::ConflictReason causes={}>",
+            Self::causes(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("causes"), Self::causes(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+fn cause_to_ruby(ruby: &Ruby, cause: CoreCause) -> Value {
+    ruby.obj_wrap(Cause {
+        pointer: cause.pointer,
+        keywords: cause.keywords,
+    })
+    .as_value()
+}
+
+fn reason_to_ruby(ruby: &Ruby, reason: CoreUnsatisfiableReason) -> Value {
+    match reason {
+        CoreUnsatisfiableReason::Literal => ruby.obj_wrap(LiteralReason).as_value(),
+        CoreUnsatisfiableReason::Empty(cause) => ruby.obj_wrap(EmptyReason { cause }).as_value(),
+        CoreUnsatisfiableReason::Conflict(causes) => {
+            ruby.obj_wrap(ConflictReason { causes }).as_value()
+        }
+    }
+}
+
+/// Read the keyword arguments every canonicalization entry point takes, and run `call` with them.
+fn with_canonical_options<R>(
+    ruby: &Ruby,
+    keywords: RHash,
+    call: impl FnOnce(jsonschema::canonical::CanonicalizeOptions<'_>) -> Result<R, Error>,
+) -> Result<R, Error> {
     let base_kwargs: CanonicalKwArgs = get_kwargs(
         keywords,
         &[],
@@ -1393,7 +1538,6 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     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();
     if let Some(draft) = draft_val {
         options = options.with_draft(parse_draft_symbol(ruby, draft)?);
@@ -1414,31 +1558,61 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
             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())
-        .map_err(|error| canonicalization_error(ruby, error))
+    let Some(val) = registry_val else {
+        return call(options);
+    };
+    if val.is_nil() {
+        return call(options);
+    }
+    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);
+            }
+        }
+    }
+    call(options.with_registry(registry.inner.as_ref()))
+}
+
+/// The subschemas of `schema` that admit no value, by JSON Pointer, each with why.
+fn find_unsatisfiable(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
+    let parsed = scan_args::<(Value,), (), (), (), _, ()>(args)?;
+    let (schema_arg,) = parsed.required;
+    let schema_value = to_schema_value(ruby, schema_arg)?;
+    with_canonical_options(ruby, parsed.keywords, |options| {
+        let prepared = options
+            .prepare(&schema_value)
+            .map_err(|error| canonicalization_error(ruby, error))?;
+        let reasons = prepared
+            .unsatisfiable()
+            .map_err(|error| canonicalization_error(ruby, error))?;
+        let hash = ruby.hash_new();
+        for (pointer, reason) in reasons {
+            hash.aset(ruby.str_new(&pointer), reason_to_ruby(ruby, reason))?;
+        }
+        Ok(hash.as_value())
+    })
+}
+
+fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
+    let parsed = scan_args::<(Value,), (), (), (), _, ()>(args)?;
+    let (schema_arg,) = parsed.required;
+    let schema_value = to_schema_value(ruby, schema_arg)?;
+    with_canonical_options(ruby, parsed.keywords, |options| {
+        options
+            .canonicalize(&schema_value)
+            .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
+            .map_err(|error| canonicalization_error(ruby, error))
+    })
 }
 
 fn define_labels<Label: Copy + Into<&'static str>>(
@@ -1716,6 +1890,39 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     raw_view.define_method("inspect", method!(RawView::inspect, 0))?;
     raw_view.define_method("deconstruct_keys", method!(RawView::deconstruct_keys, 1))?;
 
+    let cause = canonical_module.define_class("Cause", ruby.class_object())?;
+    cause.define_method("pointer", method!(Cause::pointer, 0))?;
+    cause.define_method("keywords", method!(Cause::keywords, 0))?;
+    cause.define_method("==", method!(Cause::eq, 1))?;
+    cause.define_method("inspect", method!(Cause::inspect, 0))?;
+    cause.define_method("deconstruct_keys", method!(Cause::deconstruct_keys, 1))?;
+
+    let literal_reason = canonical_module.define_class("LiteralReason", ruby.class_object())?;
+    literal_reason.define_method("inspect", method!(LiteralReason::inspect, 0))?;
+    literal_reason.define_method(
+        "deconstruct_keys",
+        method!(LiteralReason::deconstruct_keys, 1),
+    )?;
+
+    let empty_reason = canonical_module.define_class("EmptyReason", ruby.class_object())?;
+    empty_reason.define_method("cause", method!(EmptyReason::cause, 0))?;
+    empty_reason.define_method("inspect", method!(EmptyReason::inspect, 0))?;
+    empty_reason.define_method(
+        "deconstruct_keys",
+        method!(EmptyReason::deconstruct_keys, 1),
+    )?;
+
+    let conflict_reason = canonical_module.define_class("ConflictReason", ruby.class_object())?;
+    conflict_reason.define_method("causes", method!(ConflictReason::causes, 0))?;
+    conflict_reason.define_method("inspect", method!(ConflictReason::inspect, 0))?;
+    conflict_reason.define_method(
+        "deconstruct_keys",
+        method!(ConflictReason::deconstruct_keys, 1),
+    )?;
+
+    canonical_module
+        .define_singleton_method("find_unsatisfiable", function!(find_unsatisfiable, -1))?;
+
     let json_module = canonical_module.define_module("JSON")?;
     json_module
         .define_singleton_method("to_string", function!(crate::canonical_json_to_string, 1))?;

data/src/lib.rs

@@ -18,7 +18,7 @@ mod validator_map;
 use jsonschema::{
     json::{
         magnus_child, magnus_invalidate_members_cache, magnus_is_object, magnus_probe_root,
-        magnus_take_pending_error, Magnus, MagnusPendingErrorScope, PendingError, RbNode,
+        magnus_take_pending_error, Magnus, MagnusPendingErrorScope, RbNode,
     },
     paths::LocationSegment,
     ValidationOptions,
@@ -550,19 +550,10 @@ fn handle_callback_panic(ruby: &Ruby, err: Box<dyn std::any::Any + Send>) -> Err
     })
 }
 
-fn pending_error_to_ruby(ruby: &Ruby, error: PendingError) -> Error {
-    match error {
-        PendingError::Type(message) => Error::new(ruby.exception_type_error(), message),
-        PendingError::Encoding(message) => Error::new(ruby.exception_encoding_error(), message),
-        PendingError::Argument(message) => Error::new(ruby.exception_arg_error(), message),
-    }
-}
-
 /// Run validation over `instance` in place, raising anything the representation could only record.
 ///
 /// Accessors cannot fail, so a value the representation cannot read is stashed and surfaced here.
 fn surface_pending_errors<T>(
-    ruby: &Ruby,
     instance: Value,
     run: impl FnOnce(RbNode<'_>) -> Result<T, Error>,
 ) -> Result<T, Error> {
@@ -573,11 +564,11 @@ fn surface_pending_errors<T>(
     let node = RbNode::new(instance.as_raw());
     magnus_probe_root(node);
     if let Some(error) = magnus_take_pending_error() {
-        return Err(pending_error_to_ruby(ruby, error));
+        return Err(Error::from(error));
     }
     let result = run(node)?;
     if let Some(error) = magnus_take_pending_error() {
-        return Err(pending_error_to_ruby(ruby, error));
+        return Err(Error::from(error));
     }
     Ok(result)
 }
@@ -633,14 +624,14 @@ impl Validator {
     }
 
     fn is_valid(ruby: &Ruby, rb_self: &Self, instance: Value) -> Result<bool, Error> {
-        surface_pending_errors(ruby, instance, |node| {
+        surface_pending_errors(instance, |node| {
             let result = catch_unwind_silent(AssertUnwindSafe(|| rb_self.validator.is_valid(node)));
             result.map_err(|err| handle_callback_panic(ruby, err))
         })
     }
 
     fn validate(ruby: &Ruby, rb_self: &Self, instance: Value) -> Result<(), Error> {
-        surface_pending_errors(ruby, instance, |node| {
+        surface_pending_errors(instance, |node| {
             let _scope = KeywordCauseScope::enter();
             let result = catch_unwind_silent(AssertUnwindSafe(|| rb_self.validator.validate(node)));
             match result {
@@ -657,7 +648,7 @@ impl Validator {
     }
 
     fn iter_errors(ruby: &Ruby, rb_self: &Self, instance: Value) -> Result<Value, Error> {
-        surface_pending_errors(ruby, instance, |node| {
+        surface_pending_errors(instance, |node| {
             let _scope = KeywordCauseScope::enter();
 
             if ruby.block_given() {
@@ -704,7 +695,7 @@ impl Validator {
     }
 
     fn evaluate(ruby: &Ruby, rb_self: &Self, instance: Value) -> Result<Evaluation, Error> {
-        surface_pending_errors(ruby, instance, |node| {
+        surface_pending_errors(instance, |node| {
             let _scope = KeywordCauseScope::enter();
             let result = catch_unwind_silent(AssertUnwindSafe(|| rb_self.validator.evaluate(node)));
             match result {
@@ -923,7 +914,7 @@ fn is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
         &json_schema,
     )?;
 
-    surface_pending_errors(ruby, instance, |node| {
+    surface_pending_errors(instance, |node| {
         let _callback_roots =
             has_ruby_callbacks.then(|| CallbackRootGuard::new(ruby, &callback_roots));
         catch_unwind_silent(AssertUnwindSafe(|| validator.is_valid(node)))
@@ -954,7 +945,7 @@ fn validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
         &json_schema,
     )?;
 
-    surface_pending_errors(ruby, instance, |node| {
+    surface_pending_errors(instance, |node| {
         let _callback_roots =
             has_ruby_callbacks.then(|| CallbackRootGuard::new(ruby, &callback_roots));
         match catch_unwind_silent(AssertUnwindSafe(|| validator.validate(node))) {
@@ -993,7 +984,7 @@ fn each_error(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
         &json_schema,
     )?;
 
-    surface_pending_errors(ruby, instance, |node| {
+    surface_pending_errors(instance, |node| {
         let _callback_roots =
             has_ruby_callbacks.then(|| CallbackRootGuard::new(ruby, &callback_roots));
 
@@ -1057,7 +1048,7 @@ fn evaluate(ruby: &Ruby, args: &[Value]) -> Result<Evaluation, Error> {
         &json_schema,
     )?;
 
-    surface_pending_errors(ruby, instance, |node| {
+    surface_pending_errors(instance, |node| {
         let _callback_roots =
             has_ruby_callbacks.then(|| CallbackRootGuard::new(ruby, &callback_roots));
         match catch_unwind_silent(AssertUnwindSafe(|| validator.evaluate(node))) {
@@ -1161,24 +1152,40 @@ define_draft_validator!(
     jsonschema::Draft::Draft202012
 );
 
-fn meta_is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
-    use magnus::scan_args::get_kwargs;
-    let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
-    let (schema,) = parsed_args.required;
-    let kw: magnus::scan_args::KwArgs<(), (Option<Option<&Registry>>,), ()> =
-        get_kwargs(parsed_args.keywords, &[], &[*options::KW_REGISTRY])?;
-    let registry = kw.optional.0.flatten();
+// A Ruby string holds JSON text; anything else is read in place.
+fn json_text_schema(schema: Value) -> Option<serde_json::Value> {
+    let rstring = RString::from_value(schema)?;
+    #[allow(unsafe_code)]
+    let bytes = unsafe { rstring.as_slice() };
+    serde_json::from_slice(bytes).ok()
+}
 
-    let json_schema = to_schema_value(ruby, schema)?;
+// The bundled meta-schemas are compiled in and read the Ruby object in place; `None` sends a
+// `$schema` outside them through its chain.
+fn compiled_meta_is_valid(schema: Value) -> Option<Result<bool, Error>> {
+    #[allow(unsafe_code)]
+    let node = RbNode::new(schema.as_raw());
+    match jsonschema::meta::magnus::draft_of(node) {
+        jsonschema::Draft::Unknown => None,
+        draft => Some(jsonschema::meta::magnus::is_valid_fn(draft)(&schema)),
+    }
+}
 
-    let result = if let Some(registry) = registry {
-        jsonschema::meta::options()
-            .with_registry(registry.inner.as_ref())
-            .validate(&json_schema)
-    } else {
-        jsonschema::meta::validate(&json_schema)
-    };
+fn compiled_meta_validate(
+    schema: &Value,
+) -> Option<Result<Result<(), jsonschema::ValidationError<'_>>, Error>> {
+    #[allow(unsafe_code)]
+    let node = RbNode::new(schema.as_raw());
+    match jsonschema::meta::magnus::draft_of(node) {
+        jsonschema::Draft::Unknown => None,
+        draft => Some(jsonschema::meta::magnus::validate_fn(draft)(schema)),
+    }
+}
 
+fn meta_result_to_bool(
+    ruby: &Ruby,
+    result: Result<(), jsonschema::ValidationError<'_>>,
+) -> Result<bool, Error> {
     match result {
         Ok(()) => Ok(true),
         Err(error) => {
@@ -1190,7 +1197,7 @@ fn meta_is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
     }
 }
 
-fn meta_validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
+fn meta_is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
     use magnus::scan_args::get_kwargs;
     let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
     let (schema,) = parsed_args.required;
@@ -1198,27 +1205,59 @@ fn meta_validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
         get_kwargs(parsed_args.keywords, &[], &[*options::KW_REGISTRY])?;
     let registry = kw.optional.0.flatten();
 
-    let json_schema = to_schema_value(ruby, schema)?;
-
-    let result = if let Some(registry) = registry {
-        jsonschema::meta::options()
+    if let Some(registry) = registry {
+        let json_schema = to_schema_value(ruby, schema)?;
+        let result = jsonschema::meta::options()
             .with_registry(registry.inner.as_ref())
-            .validate(&json_schema)
-    } else {
-        jsonschema::meta::validate(&json_schema)
-    };
+            .validate(&json_schema);
+        return meta_result_to_bool(ruby, result);
+    }
+    if let Some(json_schema) = json_text_schema(schema) {
+        return meta_result_to_bool(ruby, jsonschema::meta::validate(&json_schema));
+    }
+    surface_pending_errors(schema, |node| {
+        if let Some(result) = compiled_meta_is_valid(schema) {
+            return result;
+        }
+        match jsonschema::meta::is_valid_for::<Magnus>(node) {
+            Ok(valid) => Ok(valid),
+            Err(error) => meta_result_to_bool(ruby, Err(error)),
+        }
+    })
+}
 
-    match result {
-        Ok(()) => Ok(()),
-        Err(error) => {
-            if let jsonschema::error::ValidationErrorKind::Referencing(err) = error.kind() {
-                return Err(referencing_error(ruby, err.to_string()));
-            }
-            #[allow(unsafe_code)]
-            let node = RbNode::new(schema.as_raw());
-            Err(raise_validation_error(ruby, error, Some(node), None))
+fn meta_validate(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
+    use magnus::scan_args::get_kwargs;
+    let parsed_args = scan_args::<(Value,), (), (), (), _, ()>(args)?;
+    let (schema,) = parsed_args.required;
+    let kw: magnus::scan_args::KwArgs<(), (Option<Option<&Registry>>,), ()> =
+        get_kwargs(parsed_args.keywords, &[], &[*options::KW_REGISTRY])?;
+    let registry = kw.optional.0.flatten();
+
+    let raise = |error: jsonschema::ValidationError<'_>| {
+        if let jsonschema::error::ValidationErrorKind::Referencing(err) = error.kind() {
+            return referencing_error(ruby, err.to_string());
         }
+        #[allow(unsafe_code)]
+        let node = RbNode::new(schema.as_raw());
+        raise_validation_error(ruby, error, Some(node), None)
+    };
+    if let Some(registry) = registry {
+        let json_schema = to_schema_value(ruby, schema)?;
+        return jsonschema::meta::options()
+            .with_registry(registry.inner.as_ref())
+            .validate(&json_schema)
+            .map_err(raise);
     }
+    if let Some(json_schema) = json_text_schema(schema) {
+        return jsonschema::meta::validate(&json_schema).map_err(raise);
+    }
+    surface_pending_errors(schema, |node| {
+        if let Some(result) = compiled_meta_validate(&schema) {
+            return result?.map_err(raise);
+        }
+        jsonschema::meta::validate_for::<Magnus>(node).map_err(raise)
+    })
 }
 
 // ValidationError instance methods (defined from Rust, called on exception instances)

metadata

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