jsonschema_rs 0.48.1 → 0.48.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dff84fb88165fc24b6035c6b100e89c83c4b6f7194fc945c3ec73e93f5119178
-  data.tar.gz: feac688548b70b5cc57f455c5f78c76fbe3107f9b38f03220ab98ce110018668
+  metadata.gz: 60ae1d2ffaa7543f17f5a7953a2ed92520f3887f7e92c8c8ac632f7c56e515ef
+  data.tar.gz: 8c3ac5d3f66016a881eed8a6f9f78327e32373e738ab453c39f0449365fce8a9
 SHA512:
-  metadata.gz: 64315bbd608bd3a80a74fa392e15c9eb57a6887dbe913d68a194f2d58c889c35c8e798b7abfb3ef619775ba9e34378de6ae3425ff4221b630f0788b8cebf40d5
-  data.tar.gz: a86e31921a0498b479e841ea25cb4bc5083dd54f9a055513c8fda434c865216992561bd92ec7a6a5543671c919227a5039f976a6f882e1cb7576dc741dedde34
+  metadata.gz: 3878552e31d235939c2fc5f4a7665002fa7ee604d4fed06a899ea78679b5ea76183322524b828376e5d891c154426a2fb1167604444eefcb8509afda8b477501
+  data.tar.gz: 9e6c6b67a2d3bea2ce93c31c1da0947832708ee55941950860ace90959ad4eb1d66c31e6a66273d17a3bd567f6fec739046c7b18deb6335e326cddfaab5fcdf1

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.48.5] - 2026-07-22
+
+### Performance
+
+- Avoid map lookups in some `properties` validators.
+- Faster validation of `{"type": "array", "items": {...}}` schemas.
+
+## [0.48.2] - 2026-07-21
+
+### Fixed
+
+- `Canonical::JSON.to_string` incorrectly emitting exponent form for small `Float` values (e.g. `1e-7` instead of `0.0000001`).
+
+### Performance
+
+- Faster validator compilation by pre-sizing internal caches.
+
 ## [0.48.1] - 2026-07-17
 
 ### Fixed
@@ -182,7 +199,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.1...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.5...HEAD
+[0.48.5]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.2...ruby-v0.48.5
+[0.48.2]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.1...ruby-v0.48.2
 [0.48.1]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.0...ruby-v0.48.1
 [0.48.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.47.0...ruby-v0.48.0
 [0.47.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.46.10...ruby-v0.47.0

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.48.1"
+version = "0.48.5"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,12 +13,13 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.48.1", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.48.5", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
 serde = { workspace = true }
 serde_json = { workspace = true, features = ["arbitrary_precision"] }
 referencing = { version = "*", path = "../jsonschema-referencing" }
+zmij = "1.0.23"
 
 [lints]
 workspace = true

data/ext/jsonschema/Cargo.lock

@@ -387,6 +387,12 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -687,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.48.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9baf521a926fd1e6f94af6922be9686b61c8a89a5fb7e14d6a1e21b79738d4cc"
+checksum = "f05a6cff806294a7699d48761d4ae2bdebab7fa2eef05e4a0b83320f0ff46901"
 dependencies = [
  "ahash",
  "bytecount",
@@ -702,6 +708,7 @@ dependencies = [
  "itoa",
  "jsonschema-macros",
  "jsonschema-regex",
+ "jsonschema-value",
  "num-bigint",
  "num-cmp",
  "num-traits",
@@ -712,15 +719,16 @@ dependencies = [
  "rustls",
  "serde",
  "serde_json",
+ "strum",
  "unicode-general-category",
  "uuid-simd",
 ]
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.48.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11efb171797c352f167fd4f3754b3a5e969d814222e457e63136cffca111b014"
+checksum = "40bda6e08b09b66cc0f70c0768118b51e8da7cef847036c88a68471b15101bcb"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -728,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.48.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3ce6144063dbeca5c841049bc0958d2eaf7d0a20d600be0907c29a2d1a6267a"
+checksum = "5f884bf73113c53f6b1d23f14c68a09faebf118854ce122a1afe91ce73d050d3"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -747,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.48.1"
+version = "0.48.5"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -755,17 +763,33 @@ dependencies = [
  "referencing",
  "serde",
  "serde_json",
+ "zmij",
 ]
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.48.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d668f4775619127513d9a4f190704d20a66d20ccf0efc258f8ed42548e5fd7cd"
+checksum = "84708dd3f6c5327478a96f37378adb27deed6a626cf84d19de780d9e8ae84b17"
 dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "jsonschema-value"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd8c04ab4ce60e42c4e302d3bd9d184652bb56f212495d2eea23573bcbf72556"
+dependencies = [
+ "ahash",
+ "bytecount",
+ "fraction",
+ "num-bigint",
+ "num-cmp",
+ "num-traits",
+ "serde_json",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -1106,9 +1130,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.48.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df843f41f0cb459649f64a8b6b10579cf454f7a7420dc702767c81a26f23d780"
+checksum = "980e77f5cfffc592c0e7dfb6d20770a0b96a6ab94d403de7454ed9799505e4ba"
 dependencies = [
  "ahash",
  "fluent-uri",
@@ -1424,6 +1448,27 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"

data/ext/jsonschema/Cargo.toml

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

data/lib/jsonschema/version.rb

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

data/sig/jsonschema.rbs

@@ -14,8 +14,110 @@ module JSONSchema
       # Main use case: deduplicate equivalent JSON Schemas by using a stable string form.
       def self.to_string: (untyped object) -> String
     end
+
+    # Structural discriminant of a canonical schema, one per view class.
+    type kind = :multi_type | :typed_group | :string | :integer | :const | :enum
+              | :any_of | :true | :false | :raw
+
+    type view = TrueView | FalseView | MultiTypeView | TypedGroupView | StringView
+              | IntegerView | AnyOfView | ConstView | EnumView | RawView
+
+    class CanonicalizationError < StandardError
+    end
+
+    class InvalidSchemaType < 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 definitions: () -> Hash[String, CanonicalSchema]
+      def satisfiable?: () -> bool
+      def inspect: () -> String
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+
+    # Matches any value.
+    class TrueView
+    end
+
+    # Matches no value.
+    class FalseView
+    end
+
+    # A value matches iff its JSON type is in the set.
+    class MultiTypeView
+      def types: () -> Array[Symbol]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # A value matches iff its JSON type is `type_name` and it satisfies `body`.
+    class TypedGroupView
+      def type_name: () -> Symbol
+      def body: () -> CanonicalSchema
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # A string value within a length window, matching every pattern.
+    class StringView
+      def min_length: () -> Integer?
+      def max_length: () -> Integer?
+      def patterns: () -> Array[String]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # An integer value within a closed interval.
+    class IntegerView
+      def minimum: () -> Integer?
+      def maximum: () -> Integer?
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # A value matches iff at least one branch matches.
+    class AnyOfView
+      def branches: () -> Array[CanonicalSchema]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # Exactly one admitted value.
+    class ConstView
+      def value: () -> untyped
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # A sorted, deduplicated finite set of admitted values.
+    class EnumView
+      def values: () -> Array[untyped]
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
+
+    # A schema the canonical form does not model structurally, kept verbatim.
+    class RawView
+      def schema: () -> untyped
+      def inspect: () -> String
+      def deconstruct_keys: (untyped keys) -> Hash[Symbol, untyped]
+    end
   end
 
+  # Reduce a schema to its canonical form.
+  def self.canonicalize: (
+    untyped schema,
+    ?draft: draft?,
+    ?validate_formats: bool?
+  ) -> Canonical::CanonicalSchema
+
   # Create a validator with auto-detected draft version.
   #
   # @param schema The JSON Schema (Hash or JSON string)

data/src/canonical.rs

@@ -0,0 +1,592 @@
+use jsonschema::{
+    canonical::{CanonicalSchema, CanonicalView, CanonicalizationError},
+    JsonType,
+};
+use magnus::{
+    function, method,
+    prelude::*,
+    scan_args::{get_kwargs, scan_args},
+    typed_data,
+    value::Lazy,
+    DataTypeFunctions, Error, ExceptionClass, RClass, RHash, RModule, Ruby, TryConvert, Value,
+};
+
+use crate::{
+    options::parse_draft_symbol,
+    ser::{to_schema_value, value_to_ruby},
+    static_id::define_rb_intern,
+};
+
+define_rb_intern!(static CANONICAL_KW_DRAFT: "draft");
+define_rb_intern!(static CANONICAL_KW_VALIDATE_FORMATS: "validate_formats");
+
+macro_rules! canonical_error_class {
+    ($static_name:ident, $class_name:literal) => {
+        static $static_name: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+            let json_schema: RModule = ruby
+                .class_object()
+                .const_get("JSONSchema")
+                .expect("JSONSchema");
+            let canonical: RModule = json_schema.const_get("Canonical").expect("Canonical");
+            let error_class: RClass = canonical.const_get($class_name).expect($class_name);
+            let exception_class =
+                ExceptionClass::from_value(error_class.as_value()).expect("ExceptionClass");
+            // The cached handle is invisible to Ruby's GC; registration pins it across compaction.
+            magnus::gc::register_mark_object(exception_class);
+            exception_class
+        });
+    };
+}
+
+canonical_error_class!(CANONICALIZATION_ERROR_CLASS, "CanonicalizationError");
+canonical_error_class!(INVALID_SCHEMA_TYPE_CLASS, "InvalidSchemaType");
+
+fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
+    if let CanonicalizationError::ValidationError(validation_error) = error {
+        return crate::raise_validation_error(ruby, validation_error, None, None);
+    }
+    let message = error.to_string();
+    match error {
+        CanonicalizationError::InvalidSchemaType(_) => {
+            Error::new(ruby.get_inner(&INVALID_SCHEMA_TYPE_CLASS), message)
+        }
+        // `ValidationError` returns above; future variants fall back to the base canonical error.
+        _ => Error::new(ruby.get_inner(&CANONICALIZATION_ERROR_CLASS), message),
+    }
+}
+
+#[derive(magnus::TypedData, PartialEq, Eq, Hash)]
+#[magnus(
+    class = "JSONSchema::Canonical::CanonicalSchema",
+    free_immediately,
+    size
+)]
+pub struct RbCanonicalSchema {
+    inner: CanonicalSchema,
+}
+
+impl DataTypeFunctions for RbCanonicalSchema {}
+
+impl RbCanonicalSchema {
+    fn to_json_schema(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        value_to_ruby(ruby, &rb_self.inner.to_json_schema())
+    }
+
+    fn draft(ruby: &Ruby, rb_self: &Self) -> Value {
+        let name = match rb_self.inner.draft() {
+            jsonschema::Draft::Draft4 => "draft4",
+            jsonschema::Draft::Draft6 => "draft6",
+            jsonschema::Draft::Draft7 => "draft7",
+            jsonschema::Draft::Draft201909 => "draft201909",
+            _ => "draft202012",
+        };
+        ruby.sym_new(name).as_value()
+    }
+
+    fn kind(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.sym_new(rb_self.inner.kind().as_str()).as_value()
+    }
+
+    fn satisfiable(rb_self: &Self) -> bool {
+        rb_self.inner.is_satisfiable()
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> String {
+        // Bounded: `inspect` runs implicitly (IRB, error messages) and a full
+        // `to_json_schema` re-emits the whole document.
+        format!(
+            "#<JSONSchema::Canonical::CanonicalSchema kind={} draft={}>",
+            Self::kind(ruby, rb_self).inspect(),
+            Self::draft(ruby, rb_self).inspect()
+        )
+    }
+
+    fn eq(rb_self: &Self, other: Value) -> bool {
+        let Ok(other_ref) = <&RbCanonicalSchema>::try_convert(other) else {
+            return false;
+        };
+        rb_self.inner == other_ref.inner
+    }
+
+    fn view(ruby: &Ruby, rb_self: &Self) -> Value {
+        match rb_self.inner.view() {
+            CanonicalView::MultiType(set) => ruby
+                .obj_wrap(MultiTypeView {
+                    types: set.iter().map(JsonType::as_str).collect(),
+                })
+                .as_value(),
+            CanonicalView::TypedGroup(group) => ruby
+                .obj_wrap(TypedGroupView {
+                    type_name: group.ty.as_str(),
+                    body: group.body,
+                })
+                .as_value(),
+            CanonicalView::Const(value) => ruby.obj_wrap(ConstView { value }).as_value(),
+            CanonicalView::Enum(values) => ruby.obj_wrap(EnumView { values }).as_value(),
+            CanonicalView::True => ruby.obj_wrap(TrueView).as_value(),
+            CanonicalView::False => ruby.obj_wrap(FalseView).as_value(),
+            CanonicalView::String(view) => ruby
+                .obj_wrap(StringView {
+                    min_length: view.min_length,
+                    max_length: view.max_length,
+                    patterns: view.patterns,
+                })
+                .as_value(),
+            CanonicalView::Integer(view) => ruby
+                .obj_wrap(IntegerView {
+                    minimum: view.minimum,
+                    maximum: view.maximum,
+                })
+                .as_value(),
+            CanonicalView::AnyOf(branches) => ruby.obj_wrap(AnyOfView { branches }).as_value(),
+            CanonicalView::Raw(schema) => ruby.obj_wrap(RawView { schema }).as_value(),
+            // TODO(canonical): new `CanonicalView` variants need view classes here.
+            other => unreachable!("unsupported canonical view: {other:?}"),
+        }
+    }
+
+    fn definitions(ruby: &Ruby, rb_self: &Self) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        for (uri, target) in rb_self.inner.definitions() {
+            let wrapped = ruby.obj_wrap(RbCanonicalSchema { inner: target });
+            hash.aset(uri, wrapped)?;
+        }
+        Ok(hash)
+    }
+}
+
+/// A schema the canonical form does not model structurally, kept verbatim.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::RawView", free_immediately)]
+pub struct RawView {
+    schema: serde_json::Value,
+}
+
+impl DataTypeFunctions for RawView {}
+
+impl RawView {
+    fn schema(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        value_to_ruby(ruby, &rb_self.schema)
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::RawView 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"),
+            value_to_ruby(ruby, &rb_self.schema)?,
+        )?;
+        Ok(hash)
+    }
+}
+
+/// Matches any value.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::TrueView", free_immediately)]
+pub struct TrueView;
+
+impl TrueView {
+    fn inspect(_rb_self: &Self) -> String {
+        "#<JSONSchema::Canonical::TrueView>".to_string()
+    }
+}
+
+impl DataTypeFunctions for TrueView {}
+
+/// Matches no value.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::FalseView", free_immediately)]
+pub struct FalseView;
+
+impl FalseView {
+    fn inspect(_rb_self: &Self) -> String {
+        "#<JSONSchema::Canonical::FalseView>".to_string()
+    }
+}
+
+impl DataTypeFunctions for FalseView {}
+
+/// A value matches iff its JSON type is in `types`.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::MultiTypeView", free_immediately)]
+pub struct MultiTypeView {
+    types: Vec<&'static str>,
+}
+
+impl DataTypeFunctions for MultiTypeView {}
+
+impl MultiTypeView {
+    fn types(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.types.len());
+        for type_name in &rb_self.types {
+            array.push(ruby.sym_new(*type_name).as_value())?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::MultiTypeView types={}>",
+            Self::types(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("types"), Self::types(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// A value matches iff its JSON type is `type_name` *and* it satisfies `body`.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::TypedGroupView", free_immediately)]
+pub struct TypedGroupView {
+    type_name: &'static str,
+    body: CanonicalSchema,
+}
+
+impl DataTypeFunctions for TypedGroupView {}
+
+impl TypedGroupView {
+    fn type_name(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.sym_new(rb_self.type_name).as_value()
+    }
+
+    fn body(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.obj_wrap(RbCanonicalSchema {
+            inner: rb_self.body.clone(),
+        })
+        .as_value()
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::TypedGroupView type_name={}>",
+            Self::type_name(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("type_name"), Self::type_name(ruby, rb_self))?;
+        hash.aset(ruby.sym_new("body"), Self::body(ruby, rb_self))?;
+        Ok(hash)
+    }
+}
+
+/// An absent bound is `nil`; a present one keeps its exact value.
+fn bound_to_ruby(ruby: &Ruby, bound: Option<&serde_json::Number>) -> Result<Value, Error> {
+    match bound {
+        Some(number) => value_to_ruby(ruby, &serde_json::Value::Number(number.clone())),
+        None => Ok(ruby.qnil().as_value()),
+    }
+}
+
+/// A string value within a length window, matching every pattern.
+#[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>,
+}
+
+impl DataTypeFunctions for StringView {}
+
+impl StringView {
+    fn min_length(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.min_length.as_ref())
+    }
+
+    fn max_length(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.max_length.as_ref())
+    }
+
+    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).as_value())?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::StringView min_length={} max_length={} patterns={}>",
+            Self::min_length(ruby, rb_self)?.inspect(),
+            Self::max_length(ruby, rb_self)?.inspect(),
+            Self::patterns(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("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)?)?;
+        Ok(hash)
+    }
+}
+
+/// An integer value within a closed interval.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::IntegerView", free_immediately)]
+pub struct IntegerView {
+    minimum: Option<serde_json::Number>,
+    maximum: Option<serde_json::Number>,
+}
+
+impl DataTypeFunctions for IntegerView {}
+
+impl IntegerView {
+    fn minimum(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.minimum.as_ref())
+    }
+
+    fn maximum(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.maximum.as_ref())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::IntegerView minimum={} maximum={}>",
+            Self::minimum(ruby, rb_self)?.inspect(),
+            Self::maximum(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("minimum"), Self::minimum(ruby, rb_self)?)?;
+        hash.aset(ruby.sym_new("maximum"), Self::maximum(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// A value matches iff at least one branch matches.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::AnyOfView", free_immediately)]
+pub struct AnyOfView {
+    branches: Vec<CanonicalSchema>,
+}
+
+impl DataTypeFunctions for AnyOfView {}
+
+impl AnyOfView {
+    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::AnyOfView 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)
+    }
+}
+
+/// Exactly one admitted value.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ConstView", free_immediately)]
+pub struct ConstView {
+    value: serde_json::Value,
+}
+
+impl DataTypeFunctions for ConstView {}
+
+impl ConstView {
+    fn value(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        value_to_ruby(ruby, &rb_self.value)
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::ConstView value={}>",
+            Self::value(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("value"), Self::value(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// A sorted, deduplicated finite set of admitted values.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::EnumView", free_immediately)]
+pub struct EnumView {
+    values: Vec<serde_json::Value>,
+}
+
+impl DataTypeFunctions for EnumView {}
+
+impl EnumView {
+    fn values(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.values.len());
+        for value in &rb_self.values {
+            array.push(value_to_ruby(ruby, value)?)?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::EnumView values={}>",
+            Self::values(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("values"), Self::values(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+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;
+    let base_kwargs: magnus::scan_args::KwArgs<(), (Option<Value>, Option<bool>), ()> = get_kwargs(
+        keywords,
+        &[],
+        &[*CANONICAL_KW_DRAFT, *CANONICAL_KW_VALIDATE_FORMATS],
+    )?;
+    let (draft_val, validate_formats) = 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)?);
+    }
+    if let Some(validate_formats) = validate_formats {
+        options = options.should_validate_formats(validate_formats);
+    }
+    options
+        .canonicalize(&schema_value)
+        .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
+        .map_err(|error| canonicalization_error(ruby, error))
+}
+
+pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let canonical_module = module.define_module("Canonical")?;
+
+    let base_error =
+        canonical_module.define_error("CanonicalizationError", ruby.exception_standard_error())?;
+    canonical_module.define_error("InvalidSchemaType", base_error)?;
+
+    let canonical_schema = canonical_module.define_class("CanonicalSchema", ruby.class_object())?;
+    canonical_schema.define_method(
+        "to_json_schema",
+        method!(RbCanonicalSchema::to_json_schema, 0),
+    )?;
+    canonical_schema.define_method("draft", method!(RbCanonicalSchema::draft, 0))?;
+    canonical_schema.define_method("kind", method!(RbCanonicalSchema::kind, 0))?;
+    canonical_schema.define_method("inspect", method!(RbCanonicalSchema::inspect, 0))?;
+    canonical_schema.define_method("==", method!(RbCanonicalSchema::eq, 1))?;
+    canonical_schema.define_method(
+        "eql?",
+        method!(<RbCanonicalSchema as typed_data::IsEql>::is_eql, 1),
+    )?;
+    canonical_schema.define_method(
+        "hash",
+        method!(<RbCanonicalSchema as typed_data::Hash>::hash, 0),
+    )?;
+    canonical_schema.define_method("view", method!(RbCanonicalSchema::view, 0))?;
+    canonical_schema.define_method("definitions", method!(RbCanonicalSchema::definitions, 0))?;
+    canonical_schema.define_method("satisfiable?", method!(RbCanonicalSchema::satisfiable, 0))?;
+
+    let true_view = canonical_module.define_class("TrueView", ruby.class_object())?;
+    true_view.define_method("inspect", method!(TrueView::inspect, 0))?;
+    let false_view = canonical_module.define_class("FalseView", ruby.class_object())?;
+    false_view.define_method("inspect", method!(FalseView::inspect, 0))?;
+
+    let multi_type_view = canonical_module.define_class("MultiTypeView", ruby.class_object())?;
+    multi_type_view.define_method("types", method!(MultiTypeView::types, 0))?;
+    multi_type_view.define_method("inspect", method!(MultiTypeView::inspect, 0))?;
+    multi_type_view.define_method(
+        "deconstruct_keys",
+        method!(MultiTypeView::deconstruct_keys, 1),
+    )?;
+
+    let typed_group_view = canonical_module.define_class("TypedGroupView", ruby.class_object())?;
+    typed_group_view.define_method("type_name", method!(TypedGroupView::type_name, 0))?;
+    typed_group_view.define_method("body", method!(TypedGroupView::body, 0))?;
+    typed_group_view.define_method("inspect", method!(TypedGroupView::inspect, 0))?;
+    typed_group_view.define_method(
+        "deconstruct_keys",
+        method!(TypedGroupView::deconstruct_keys, 1),
+    )?;
+
+    let const_view = canonical_module.define_class("ConstView", ruby.class_object())?;
+    const_view.define_method("value", method!(ConstView::value, 0))?;
+    const_view.define_method("inspect", method!(ConstView::inspect, 0))?;
+    const_view.define_method("deconstruct_keys", method!(ConstView::deconstruct_keys, 1))?;
+
+    let enum_view = canonical_module.define_class("EnumView", ruby.class_object())?;
+    enum_view.define_method("values", method!(EnumView::values, 0))?;
+    enum_view.define_method("inspect", method!(EnumView::inspect, 0))?;
+    enum_view.define_method("deconstruct_keys", method!(EnumView::deconstruct_keys, 1))?;
+
+    let string_view = canonical_module.define_class("StringView", ruby.class_object())?;
+    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("inspect", method!(StringView::inspect, 0))?;
+    string_view.define_method("deconstruct_keys", method!(StringView::deconstruct_keys, 1))?;
+
+    let integer_view = canonical_module.define_class("IntegerView", ruby.class_object())?;
+    integer_view.define_method("minimum", method!(IntegerView::minimum, 0))?;
+    integer_view.define_method("maximum", method!(IntegerView::maximum, 0))?;
+    integer_view.define_method("inspect", method!(IntegerView::inspect, 0))?;
+    integer_view.define_method(
+        "deconstruct_keys",
+        method!(IntegerView::deconstruct_keys, 1),
+    )?;
+
+    let any_of_view = canonical_module.define_class("AnyOfView", ruby.class_object())?;
+    any_of_view.define_method("branches", method!(AnyOfView::branches, 0))?;
+    any_of_view.define_method("inspect", method!(AnyOfView::inspect, 0))?;
+    any_of_view.define_method("deconstruct_keys", method!(AnyOfView::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))?;
+    raw_view.define_method("deconstruct_keys", method!(RawView::deconstruct_keys, 1))?;
+
+    let json_module = canonical_module.define_module("JSON")?;
+    json_module
+        .define_singleton_method("to_string", function!(crate::canonical_json_to_string, 1))?;
+
+    module.define_singleton_method("canonicalize", function!(canonicalize, -1))?;
+
+    Ok(())
+}

data/src/lib.rs

@@ -5,6 +5,7 @@
 #![allow(clippy::unused_self)]
 #![allow(clippy::struct_field_names)]
 
+mod canonical;
 mod error_kind;
 mod evaluation;
 mod options;
@@ -1513,10 +1514,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("each_error", function!(each_error, -1))?;
     module.define_singleton_method("evaluate", function!(evaluate, -1))?;
 
-    let canonical_module = module.define_module("Canonical")?;
-    let canonical_json_module = canonical_module.define_module("JSON")?;
-    canonical_json_module
-        .define_singleton_method("to_string", function!(canonical_json_to_string, 1))?;
+    canonical::init_canonical(ruby, &module)?;
 
     // Validator class
     let validator_class = module.define_class("Validator", ruby.class_object())?;

data/src/ser.rs

@@ -1,4 +1,5 @@
 //! Serialization between Ruby values and `serde_json::Value`.
+use jsonschema::canonical::json::{canonical_number, BorrowedNumber};
 use magnus::{
     error::ErrorType,
     exception::ExceptionClass,
@@ -435,7 +436,12 @@ impl Serialize for CanonicalRubyValue<'_> {
                 number.serialize(serializer)
             }
             ruby_value_type::RUBY_T_FLOAT => {
-                let number = convert_float_for_canonical(self.ruby, self.value)
+                let float = f64::try_convert(self.value)
+                    .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                if float.fract() != 0.0 && float.is_finite() {
+                    return serialize_fractional_float(float, serializer);
+                }
+                let number = convert_float_for_canonical(self.ruby, float)
                     .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
                 number.serialize(serializer)
             }
@@ -547,9 +553,18 @@ impl Serialize for CanonicalRubyValue<'_> {
     }
 }
 
+fn serialize_fractional_float<S>(float: f64, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut buffer = zmij::Buffer::new();
+    let text = buffer.format_finite(float);
+    let canonical = canonical_number(text);
+    BorrowedNumber(canonical.as_deref().unwrap_or(text)).serialize(serializer)
+}
+
 #[inline]
-fn convert_float_for_canonical(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
-    let float = f64::try_convert(value)?;
+fn convert_float_for_canonical(ruby: &Ruby, float: f64) -> Result<JsonValue, Error> {
     if !float.is_finite() {
         return Ok(JsonValue::Null);
     }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonschema_rs
 version: !ruby/object:Gem::Version
-  version: 0.48.1
+  version: 0.48.5
 platform: ruby
 authors:
 - Dmitry Dygalo
@@ -63,6 +63,7 @@ files:
 - lib/jsonschema/version.rb
 - lib/jsonschema_rs.rb
 - sig/jsonschema.rbs
+- src/canonical.rs
 - src/error_kind.rs
 - src/evaluation.rs
 - src/lib.rs