jsonschema_rs 0.48.2 → 0.48.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7091a24d3c4cae1381d2dcc89844c0c9e2752a04e418a94ded9b3e93656fe9f8
-  data.tar.gz: c2367c71d93a857f2520dd345e26222608714868e2941a332eb30d78816f75a4
+  metadata.gz: 60ae1d2ffaa7543f17f5a7953a2ed92520f3887f7e92c8c8ac632f7c56e515ef
+  data.tar.gz: 8c3ac5d3f66016a881eed8a6f9f78327e32373e738ab453c39f0449365fce8a9
 SHA512:
-  metadata.gz: a7dea5681e119df671ac136f7fb9a780e3ac12354487ed763aef6cb7c0f9c68357287a66a17745a2778d78d9aaa5d33faa41de4bbb19f9d7f7b17bbb2285da4a
-  data.tar.gz: 9c8544d8e5379e5d7013fbed284ef7e932894f23900973a5901a6cb6a40022fbb170bd30ecee04555cf2d512fe3a7a5778e9bff5e809556e9c0a2845a21f70da
+  metadata.gz: 3878552e31d235939c2fc5f4a7665002fa7ee604d4fed06a899ea78679b5ea76183322524b828376e5d891c154426a2fb1167604444eefcb8509afda8b477501
+  data.tar.gz: 9e6c6b67a2d3bea2ce93c31c1da0947832708ee55941950860ace90959ad4eb1d66c31e6a66273d17a3bd567f6fec739046c7b18deb6335e326cddfaab5fcdf1

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [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
@@ -192,7 +199,8 @@
 
 - Initial public release
 
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.48.2...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

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.48.2"
+version = "0.48.5"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = { version = "0.48.2", 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 }

data/ext/jsonschema/Cargo.lock

@@ -693,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.48.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39d785c0683d1027839f1ac6a43b6d07c63d58ecd363d8146dda4531d53465a1"
+checksum = "f05a6cff806294a7699d48761d4ae2bdebab7fa2eef05e4a0b83320f0ff46901"
 dependencies = [
  "ahash",
  "bytecount",
@@ -708,6 +708,7 @@ dependencies = [
  "itoa",
  "jsonschema-macros",
  "jsonschema-regex",
+ "jsonschema-value",
  "num-bigint",
  "num-cmp",
  "num-traits",
@@ -725,9 +726,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros"
-version = "0.48.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1c58940755c1f87fc5843b63626867ed8384bc0b6fabf0de2a718ccafb42570"
+checksum = "40bda6e08b09b66cc0f70c0768118b51e8da7cef847036c88a68471b15101bcb"
 dependencies = [
  "jsonschema-macros-core",
  "proc-macro2",
@@ -735,9 +736,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-macros-core"
-version = "0.48.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "110e53690c5d5524b69e557bd286b1c6c9743bfcf13c18fd5e3f21a9708737dc"
+checksum = "5f884bf73113c53f6b1d23f14c68a09faebf118854ce122a1afe91ce73d050d3"
 dependencies = [
  "fancy-regex",
  "indexmap",
@@ -754,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.48.2"
+version = "0.48.5"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -767,13 +768,28 @@ dependencies = [
 
 [[package]]
 name = "jsonschema-regex"
-version = "0.48.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "917b3be16b2662538aafb55201790561e1f1ad1a0454baf42f33bd9de343778b"
+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"
@@ -1114,9 +1130,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.48.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d2b21a85c07fcf1cb95ff7ab8a687fcd37fa70db59975b5a032abdaadfdf42e"
+checksum = "980e77f5cfffc592c0e7dfb6d20770a0b96a6ab94d403de7454ed9799505e4ba"
 dependencies = [
  "ahash",
  "fluent-uri",

data/ext/jsonschema/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb-ext"
-version = "0.48.2"
+version = "0.48.5"
 edition = "2021"
 publish = false
 
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 
 [dependencies]
-jsonschema = { version = "0.48.2", 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.2"
+referencing = "0.48.5"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["arbitrary_precision"] }
 zmij = "1"

data/lib/jsonschema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONSchema
-  VERSION = "0.48.2"
+  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

@@ -91,13 +91,13 @@ impl RbCanonicalSchema {
         rb_self.inner.is_satisfiable()
     }
 
-    fn inspect(rb_self: &Self) -> String {
+    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={:?}>",
-            rb_self.inner.kind().as_str(),
-            rb_self.inner.draft()
+            "#<JSONSchema::Canonical::CanonicalSchema kind={} draft={}>",
+            Self::kind(ruby, rb_self).inspect(),
+            Self::draft(ruby, rb_self).inspect()
         )
     }
 
@@ -125,6 +125,20 @@ impl RbCanonicalSchema {
             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:?}"),
@@ -155,11 +169,11 @@ impl RawView {
         value_to_ruby(ruby, &rb_self.schema)
     }
 
-    fn inspect(rb_self: &Self) -> String {
-        format!(
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
             "#<JSONSchema::Canonical::RawView schema={}>",
-            rb_self.schema
-        )
+            Self::schema(ruby, rb_self)?.inspect()
+        ))
     }
 
     fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
@@ -177,6 +191,12 @@ impl RawView {
 #[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.
@@ -184,6 +204,12 @@ impl DataTypeFunctions for TrueView {}
 #[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`.
@@ -204,11 +230,11 @@ impl MultiTypeView {
         Ok(array.as_value())
     }
 
-    fn inspect(rb_self: &Self) -> String {
-        format!(
-            "#<JSONSchema::Canonical::MultiTypeView types={:?}>",
-            rb_self.types
-        )
+    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> {
@@ -240,10 +266,10 @@ impl TypedGroupView {
         .as_value()
     }
 
-    fn inspect(rb_self: &Self) -> String {
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> String {
         format!(
-            "#<JSONSchema::Canonical::TypedGroupView type_name={:?}>",
-            rb_self.type_name
+            "#<JSONSchema::Canonical::TypedGroupView type_name={}>",
+            Self::type_name(ruby, rb_self).inspect()
         )
     }
 
@@ -255,6 +281,136 @@ impl TypedGroupView {
     }
 }
 
+/// 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)]
@@ -269,11 +425,11 @@ impl ConstView {
         value_to_ruby(ruby, &rb_self.value)
     }
 
-    fn inspect(rb_self: &Self) -> String {
-        format!(
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
             "#<JSONSchema::Canonical::ConstView value={}>",
-            rb_self.value
-        )
+            Self::value(ruby, rb_self)?.inspect()
+        ))
     }
 
     fn deconstruct_keys(ruby: &Ruby, rb_self: &Self, _keys: Value) -> Result<RHash, Error> {
@@ -301,11 +457,11 @@ impl EnumView {
         Ok(array.as_value())
     }
 
-    fn inspect(rb_self: &Self) -> String {
-        format!(
-            "#<JSONSchema::Canonical::EnumView values={:?}>",
-            rb_self.values
-        )
+    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> {
@@ -368,8 +524,10 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     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 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))?;
@@ -398,6 +556,27 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     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))?;

metadata

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