jsonschema_rs 0.48.0 → 0.48.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14584b5d0ec590243477a7bef7bd5e1cc81e4c6e356ab92b7db8669514259313
-  data.tar.gz: 4f8e74e0e509692872c01cc1937e7543b9c06baad0d67f10429fc90aa4497513
+  metadata.gz: 7091a24d3c4cae1381d2dcc89844c0c9e2752a04e418a94ded9b3e93656fe9f8
+  data.tar.gz: c2367c71d93a857f2520dd345e26222608714868e2941a332eb30d78816f75a4
 SHA512:
-  metadata.gz: ddc6f15c3bc5fabc4215b0157ab46375cdd46b158f23f41dd908e23861aa4c9f810805354722c65852b19b271e6b7a5c91174eebb37e949ae270f2acec3d90fb
-  data.tar.gz: a6258ba5efa9ab56a0ec3428a89f5f5d0a3683903a73e03458d895bfba6e9d3336f59a0ebbbb59797c17123e14576e149ec2b57122eee173f625caad8290400f
+  metadata.gz: a7dea5681e119df671ac136f7fb9a780e3ac12354487ed763aef6cb7c0f9c68357287a66a17745a2778d78d9aaa5d33faa41de4bbb19f9d7f7b17bbb2285da4a
+  data.tar.gz: 9c8544d8e5379e5d7013fbed284ef7e932894f23900973a5901a6cb6a40022fbb170bd30ecee04555cf2d512fe3a7a5778e9bff5e809556e9c0a2845a21f70da

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [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
+
+- Missing `required` errors in `evaluate` output for schemas with `properties` and a two-entry `required` array. [#1220](https://github.com/Stranger6667/jsonschema/issues/1220)
+- `contentEncoding` errors for invalid UTF-8 after decoding incorrectly had empty `instance_path` and `schema_path`.
+
 ## [0.48.0] - 2026-07-16
 
 ### Fixed
@@ -175,7 +192,9 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.0...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.2...HEAD
+[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
 [0.46.10]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.46.9...ruby-v0.46.10

data/Cargo.toml

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

@@ -64,6 +64,10 @@ The following drafts are supported:
 
 You can check the current status on the [Bowtie Report](https://bowtie.report/#/implementations/rust-jsonschema).
 
+## Playground
+
+If you'd like to try `jsonschema`, you can check the WebAssembly-powered [playground](https://jsonschema.dygalo.dev/) to see the results instantly.
+
 ## Installation
 
 Add to your Gemfile:

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.0"
+version = "0.48.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aef8d91fd7994744fd927438d8a642528d989c4a0248fb3f6208f47bffcefb0d"
+checksum = "39d785c0683d1027839f1ac6a43b6d07c63d58ecd363d8146dda4531d53465a1"
 dependencies = [
  "ahash",
  "bytecount",
@@ -712,15 +718,16 @@ dependencies = [
  "rustls",
  "serde",
  "serde_json",
+ "strum",
  "unicode-general-category",
  "uuid-simd",
 ]
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.48.0"
+version = "0.48.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17fb29ec60ebce38c9bdab49e2980cf590905f74989464ef07dc443d37f92e17"
+checksum = "a1c58940755c1f87fc5843b63626867ed8384bc0b6fabf0de2a718ccafb42570"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -728,9 +735,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.48.0"
+version = "0.48.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd95fd822e8990a734b9b222cf96f4f65c28b210598b0b0deaface517178d8cb"
+checksum = "110e53690c5d5524b69e557bd286b1c6c9743bfcf13c18fd5e3f21a9708737dc"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -747,7 +754,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.48.0"
+version = "0.48.2"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -755,13 +762,14 @@ dependencies = [
  "referencing",
  "serde",
  "serde_json",
+ "zmij",
 ]
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.48.0"
+version = "0.48.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "794a08daa4c4b0e566fae7f2787090d793082eed95e4b46bfdec9817b533df22"
+checksum = "917b3be16b2662538aafb55201790561e1f1ad1a0454baf42f33bd9de343778b"
 dependencies = [
  "regex-syntax",
 ]
@@ -1106,9 +1114,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.48.0"
+version = "0.48.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4967fa93675ff599754790711e2f19b6a910739784ac357bd10f34e146616f9"
+checksum = "2d2b21a85c07fcf1cb95ff7ab8a687fcd37fa70db59975b5a032abdaadfdf42e"
 dependencies = [
  "ahash",
  "fluent-uri",
@@ -1424,6 +1432,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.0"
+version = "0.48.2"
 edition = "2021"
 publish = false
 
@@ -10,11 +10,12 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.48.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring", "macros"] }
+jsonschema = { version = "0.48.2", 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.0"
+referencing = "0.48.2"
 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.0"
+  VERSION = "0.48.2"
 end

data/src/canonical.rs

@@ -0,0 +1,413 @@
+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(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={:?}>",
+            rb_self.inner.kind().as_str(),
+            rb_self.inner.draft()
+        )
+    }
+
+    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::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(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::RawView schema={}>",
+            rb_self.schema
+        )
+    }
+
+    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 DataTypeFunctions for TrueView {}
+
+/// Matches no value.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::FalseView", free_immediately)]
+pub struct FalseView;
+
+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(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::MultiTypeView types={:?}>",
+            rb_self.types
+        )
+    }
+
+    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(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::TypedGroupView type_name={:?}>",
+            rb_self.type_name
+        )
+    }
+
+    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)
+    }
+}
+
+/// 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(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::ConstView value={}>",
+            rb_self.value
+        )
+    }
+
+    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(rb_self: &Self) -> String {
+        format!(
+            "#<JSONSchema::Canonical::EnumView values={:?}>",
+            rb_self.values
+        )
+    }
+
+    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))?;
+
+    canonical_module.define_class("TrueView", ruby.class_object())?;
+    canonical_module.define_class("FalseView", ruby.class_object())?;
+
+    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 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.0
+  version: 0.48.2
 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