jsonschema_rs 0.48.2 → 0.49.0

data/src/canonical.rs

@@ -1,5 +1,7 @@
 use jsonschema::{
-    canonical::{CanonicalSchema, CanonicalView, CanonicalizationError},
+    canonical::{
+        CanonicalSchema, CanonicalView, CanonicalizationError, ContainsView as CoreContainsView,
+    },
     JsonType,
 };
 use magnus::{
@@ -91,13 +93,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,9 +127,55 @@ 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,
+                    formats: view.formats,
+                    content_media_types: view.content_media_types,
+                    content_encodings: view.content_encodings,
+                })
+                .as_value(),
+            CanonicalView::Number(view) => ruby
+                .obj_wrap(NumberView {
+                    minimum: view.minimum,
+                    exclusive_minimum: view.exclusive_minimum,
+                    maximum: view.maximum,
+                    exclusive_maximum: view.exclusive_maximum,
+                    multiple_of: view.multiple_of,
+                })
+                .as_value(),
+            CanonicalView::Integer(view) => ruby
+                .obj_wrap(IntegerView {
+                    minimum: view.minimum,
+                    maximum: view.maximum,
+                    multiple_of: view.multiple_of,
+                })
+                .as_value(),
+            CanonicalView::Array(view) => ruby
+                .obj_wrap(ArrayView {
+                    min_items: view.min_items,
+                    max_items: view.max_items,
+                    unique_items: view.unique_items,
+                    prefix_items: view.prefix_items,
+                    items: view.items,
+                    contains: view.contains,
+                })
+                .as_value(),
+            CanonicalView::Object(view) => ruby
+                .obj_wrap(ObjectView {
+                    min_properties: view.min_properties,
+                    max_properties: view.max_properties,
+                    required: view.required,
+                    property_names: view.property_names,
+                    properties: view.properties,
+                    pattern_properties: view.pattern_properties,
+                    additional_properties: view.additional_properties,
+                })
+                .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 +203,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 +225,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 +238,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 +264,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 +300,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 +315,519 @@ 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()),
+    }
+}
+
+fn divisors_to_ruby(ruby: &Ruby, divisors: &[serde_json::Number]) -> Result<Value, Error> {
+    let array = ruby.ary_new_capa(divisors.len());
+    for divisor in divisors {
+        array.push(value_to_ruby(
+            ruby,
+            &serde_json::Value::Number(divisor.clone()),
+        )?)?;
+    }
+    Ok(array.as_value())
+}
+
+fn strings_to_ruby(ruby: &Ruby, values: &[String]) -> Result<Value, Error> {
+    let array = ruby.ary_new_capa(values.len());
+    for value in values {
+        array.push(ruby.str_new(value).as_value())?;
+    }
+    Ok(array.as_value())
+}
+
+/// A string value within a length window, matching every pattern, format, media type, and
+/// encoding.
+#[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>,
+    formats: Vec<String>,
+    content_media_types: Vec<String>,
+    content_encodings: 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> {
+        strings_to_ruby(ruby, &rb_self.patterns)
+    }
+
+    fn formats(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.formats)
+    }
+
+    fn content_media_types(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.content_media_types)
+    }
+
+    fn content_encodings(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        strings_to_ruby(ruby, &rb_self.content_encodings)
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::StringView min_length={} max_length={} patterns={} formats={} content_media_types={} content_encodings={}>",
+            Self::min_length(ruby, rb_self)?.inspect(),
+            Self::max_length(ruby, rb_self)?.inspect(),
+            Self::patterns(ruby, rb_self)?.inspect(),
+            Self::formats(ruby, rb_self)?.inspect(),
+            Self::content_media_types(ruby, rb_self)?.inspect(),
+            Self::content_encodings(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)?)?;
+        hash.aset(ruby.sym_new("formats"), Self::formats(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("content_media_types"),
+            Self::content_media_types(ruby, rb_self)?,
+        )?;
+        hash.aset(
+            ruby.sym_new("content_encodings"),
+            Self::content_encodings(ruby, rb_self)?,
+        )?;
+        Ok(hash)
+    }
+}
+
+/// A number value within a real interval.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::NumberView", free_immediately)]
+pub struct NumberView {
+    minimum: Option<serde_json::Number>,
+    exclusive_minimum: bool,
+    maximum: Option<serde_json::Number>,
+    exclusive_maximum: bool,
+    multiple_of: Vec<serde_json::Number>,
+}
+
+impl DataTypeFunctions for NumberView {}
+
+impl NumberView {
+    fn minimum(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.minimum.as_ref())
+    }
+
+    fn exclusive_minimum(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.into_value(rb_self.exclusive_minimum)
+    }
+
+    fn maximum(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.maximum.as_ref())
+    }
+
+    fn exclusive_maximum(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.into_value(rb_self.exclusive_maximum)
+    }
+
+    fn multiple_of(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        divisors_to_ruby(ruby, &rb_self.multiple_of)
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::NumberView minimum={} exclusive_minimum={} maximum={} exclusive_maximum={} multiple_of={}>",
+            Self::minimum(ruby, rb_self)?.inspect(),
+            Self::exclusive_minimum(ruby, rb_self).inspect(),
+            Self::maximum(ruby, rb_self)?.inspect(),
+            Self::exclusive_maximum(ruby, rb_self).inspect(),
+            Self::multiple_of(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("exclusive_minimum"),
+            Self::exclusive_minimum(ruby, rb_self),
+        )?;
+        hash.aset(ruby.sym_new("maximum"), Self::maximum(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("exclusive_maximum"),
+            Self::exclusive_maximum(ruby, rb_self),
+        )?;
+        hash.aset(
+            ruby.sym_new("multiple_of"),
+            Self::multiple_of(ruby, rb_self)?,
+        )?;
+        Ok(hash)
+    }
+}
+
+/// An integer value within a closed interval, optionally a multiple of a divisor.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::IntegerView", free_immediately)]
+pub struct IntegerView {
+    minimum: Option<serde_json::Number>,
+    maximum: Option<serde_json::Number>,
+    multiple_of: Vec<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 multiple_of(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        divisors_to_ruby(ruby, &rb_self.multiple_of)
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::IntegerView minimum={} maximum={} multiple_of={}>",
+            Self::minimum(ruby, rb_self)?.inspect(),
+            Self::maximum(ruby, rb_self)?.inspect(),
+            Self::multiple_of(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)?)?;
+        hash.aset(
+            ruby.sym_new("multiple_of"),
+            Self::multiple_of(ruby, rb_self)?,
+        )?;
+        Ok(hash)
+    }
+}
+
+/// An array value's constraints.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ArrayView", free_immediately)]
+#[allow(clippy::struct_field_names)]
+pub struct ArrayView {
+    min_items: Option<serde_json::Number>,
+    max_items: Option<serde_json::Number>,
+    unique_items: bool,
+    prefix_items: Vec<CanonicalSchema>,
+    items: Option<CanonicalSchema>,
+    contains: Vec<CoreContainsView>,
+}
+
+impl DataTypeFunctions for ArrayView {}
+
+impl ArrayView {
+    fn min_items(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.min_items.as_ref())
+    }
+
+    fn max_items(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.max_items.as_ref())
+    }
+
+    fn unique_items(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.into_value(rb_self.unique_items)
+    }
+
+    fn prefix_items(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.prefix_items.len());
+        for schema in &rb_self.prefix_items {
+            array.push(
+                ruby.obj_wrap(RbCanonicalSchema {
+                    inner: schema.clone(),
+                })
+                .as_value(),
+            )?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn items(ruby: &Ruby, rb_self: &Self) -> Value {
+        match &rb_self.items {
+            Some(items) => ruby
+                .obj_wrap(RbCanonicalSchema {
+                    inner: items.clone(),
+                })
+                .as_value(),
+            None => ruby.qnil().as_value(),
+        }
+    }
+
+    fn contains(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.contains.len());
+        for facet in &rb_self.contains {
+            array.push(ruby.obj_wrap(ContainsView::from_core(facet)).as_value())?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::ArrayView min_items={} max_items={} unique_items={} prefix_items={} items={} contains={}>",
+            Self::min_items(ruby, rb_self)?.inspect(),
+            Self::max_items(ruby, rb_self)?.inspect(),
+            Self::unique_items(ruby, rb_self).inspect(),
+            Self::prefix_items(ruby, rb_self)?.inspect(),
+            Self::items(ruby, rb_self).inspect(),
+            Self::contains(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_items"), Self::min_items(ruby, rb_self)?)?;
+        hash.aset(ruby.sym_new("max_items"), Self::max_items(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("unique_items"),
+            Self::unique_items(ruby, rb_self),
+        )?;
+        hash.aset(
+            ruby.sym_new("prefix_items"),
+            Self::prefix_items(ruby, rb_self)?,
+        )?;
+        hash.aset(ruby.sym_new("items"), Self::items(ruby, rb_self))?;
+        hash.aset(ruby.sym_new("contains"), Self::contains(ruby, rb_self)?)?;
+        Ok(hash)
+    }
+}
+
+/// One `contains` demand of an array. An absent minimum spells the default of one.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ContainsView", free_immediately)]
+pub struct ContainsView {
+    schema: CanonicalSchema,
+    min_contains: Option<serde_json::Number>,
+    max_contains: Option<serde_json::Number>,
+}
+
+impl DataTypeFunctions for ContainsView {}
+
+impl ContainsView {
+    fn from_core(facet: &CoreContainsView) -> Self {
+        Self {
+            schema: facet.schema.clone(),
+            min_contains: facet.min_contains.clone(),
+            max_contains: facet.max_contains.clone(),
+        }
+    }
+
+    fn schema(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.obj_wrap(RbCanonicalSchema {
+            inner: rb_self.schema.clone(),
+        })
+        .as_value()
+    }
+
+    fn min_contains(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.min_contains.as_ref())
+    }
+
+    fn max_contains(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.max_contains.as_ref())
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::ContainsView schema={} min_contains={} max_contains={}>",
+            Self::schema(ruby, rb_self).inspect(),
+            Self::min_contains(ruby, rb_self)?.inspect(),
+            Self::max_contains(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"), Self::schema(ruby, rb_self))?;
+        hash.aset(
+            ruby.sym_new("min_contains"),
+            Self::min_contains(ruby, rb_self)?,
+        )?;
+        hash.aset(
+            ruby.sym_new("max_contains"),
+            Self::max_contains(ruby, rb_self)?,
+        )?;
+        Ok(hash)
+    }
+}
+
+/// An object value's constraints.
+#[derive(magnus::TypedData)]
+#[magnus(class = "JSONSchema::Canonical::ObjectView", free_immediately)]
+pub struct ObjectView {
+    min_properties: Option<serde_json::Number>,
+    max_properties: Option<serde_json::Number>,
+    required: Vec<String>,
+    property_names: Option<CanonicalSchema>,
+    properties: std::collections::BTreeMap<String, CanonicalSchema>,
+    pattern_properties: std::collections::BTreeMap<String, CanonicalSchema>,
+    additional_properties: Option<CanonicalSchema>,
+}
+
+impl DataTypeFunctions for ObjectView {}
+
+impl ObjectView {
+    fn min_properties(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.min_properties.as_ref())
+    }
+
+    fn max_properties(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        bound_to_ruby(ruby, rb_self.max_properties.as_ref())
+    }
+
+    fn required(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let array = ruby.ary_new_capa(rb_self.required.len());
+        for key in &rb_self.required {
+            array.push(ruby.str_new(key))?;
+        }
+        Ok(array.as_value())
+    }
+
+    fn property_names(ruby: &Ruby, rb_self: &Self) -> Value {
+        match &rb_self.property_names {
+            Some(names) => ruby
+                .obj_wrap(RbCanonicalSchema {
+                    inner: names.clone(),
+                })
+                .as_value(),
+            None => ruby.qnil().as_value(),
+        }
+    }
+
+    fn properties(ruby: &Ruby, rb_self: &Self) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        for (key, schema) in &rb_self.properties {
+            let wrapped = ruby.obj_wrap(RbCanonicalSchema {
+                inner: schema.clone(),
+            });
+            hash.aset(key.as_str(), wrapped)?;
+        }
+        Ok(hash)
+    }
+
+    fn pattern_properties(ruby: &Ruby, rb_self: &Self) -> Result<RHash, Error> {
+        let hash = ruby.hash_new();
+        for (pattern, schema) in &rb_self.pattern_properties {
+            let wrapped = ruby.obj_wrap(RbCanonicalSchema {
+                inner: schema.clone(),
+            });
+            hash.aset(pattern.as_str(), wrapped)?;
+        }
+        Ok(hash)
+    }
+
+    fn additional_properties(ruby: &Ruby, rb_self: &Self) -> Value {
+        match &rb_self.additional_properties {
+            Some(shield) => ruby
+                .obj_wrap(RbCanonicalSchema {
+                    inner: shield.clone(),
+                })
+                .as_value(),
+            None => ruby.qnil().as_value(),
+        }
+    }
+
+    fn inspect(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        Ok(format!(
+            "#<JSONSchema::Canonical::ObjectView min_properties={} max_properties={} required={} property_names={} properties={} pattern_properties={}>",
+            Self::min_properties(ruby, rb_self)?.inspect(),
+            Self::max_properties(ruby, rb_self)?.inspect(),
+            Self::required(ruby, rb_self)?.inspect(),
+            Self::property_names(ruby, rb_self).inspect(),
+            Self::properties(ruby, rb_self)?.inspect(),
+            Self::pattern_properties(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_properties"),
+            Self::min_properties(ruby, rb_self)?,
+        )?;
+        hash.aset(
+            ruby.sym_new("max_properties"),
+            Self::max_properties(ruby, rb_self)?,
+        )?;
+        hash.aset(ruby.sym_new("required"), Self::required(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("property_names"),
+            Self::property_names(ruby, rb_self),
+        )?;
+        hash.aset(ruby.sym_new("properties"), Self::properties(ruby, rb_self)?)?;
+        hash.aset(
+            ruby.sym_new("pattern_properties"),
+            Self::pattern_properties(ruby, rb_self)?,
+        )?;
+        hash.aset(
+            ruby.sym_new("additional_properties"),
+            Self::additional_properties(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 +842,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 +874,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 +941,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 +973,88 @@ 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("formats", method!(StringView::formats, 0))?;
+    string_view.define_method(
+        "content_media_types",
+        method!(StringView::content_media_types, 0),
+    )?;
+    string_view.define_method(
+        "content_encodings",
+        method!(StringView::content_encodings, 0),
+    )?;
+    string_view.define_method("inspect", method!(StringView::inspect, 0))?;
+    string_view.define_method("deconstruct_keys", method!(StringView::deconstruct_keys, 1))?;
+
+    let number_view = canonical_module.define_class("NumberView", ruby.class_object())?;
+    number_view.define_method("minimum", method!(NumberView::minimum, 0))?;
+    number_view.define_method(
+        "exclusive_minimum",
+        method!(NumberView::exclusive_minimum, 0),
+    )?;
+    number_view.define_method("maximum", method!(NumberView::maximum, 0))?;
+    number_view.define_method(
+        "exclusive_maximum",
+        method!(NumberView::exclusive_maximum, 0),
+    )?;
+    number_view.define_method("multiple_of", method!(NumberView::multiple_of, 0))?;
+    number_view.define_method("inspect", method!(NumberView::inspect, 0))?;
+    number_view.define_method("deconstruct_keys", method!(NumberView::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("multiple_of", method!(IntegerView::multiple_of, 0))?;
+    integer_view.define_method("inspect", method!(IntegerView::inspect, 0))?;
+    integer_view.define_method(
+        "deconstruct_keys",
+        method!(IntegerView::deconstruct_keys, 1),
+    )?;
+
+    let array_view = canonical_module.define_class("ArrayView", ruby.class_object())?;
+    array_view.define_method("min_items", method!(ArrayView::min_items, 0))?;
+    array_view.define_method("max_items", method!(ArrayView::max_items, 0))?;
+    array_view.define_method("unique_items", method!(ArrayView::unique_items, 0))?;
+    array_view.define_method("prefix_items", method!(ArrayView::prefix_items, 0))?;
+    array_view.define_method("items", method!(ArrayView::items, 0))?;
+    array_view.define_method("contains", method!(ArrayView::contains, 0))?;
+    array_view.define_method("inspect", method!(ArrayView::inspect, 0))?;
+    array_view.define_method("deconstruct_keys", method!(ArrayView::deconstruct_keys, 1))?;
+    let contains_view = canonical_module.define_class("ContainsView", ruby.class_object())?;
+    contains_view.define_method("schema", method!(ContainsView::schema, 0))?;
+    contains_view.define_method("min_contains", method!(ContainsView::min_contains, 0))?;
+    contains_view.define_method("max_contains", method!(ContainsView::max_contains, 0))?;
+    contains_view.define_method("inspect", method!(ContainsView::inspect, 0))?;
+    contains_view.define_method(
+        "deconstruct_keys",
+        method!(ContainsView::deconstruct_keys, 1),
+    )?;
+
+    let object_view = canonical_module.define_class("ObjectView", ruby.class_object())?;
+    object_view.define_method("min_properties", method!(ObjectView::min_properties, 0))?;
+    object_view.define_method("max_properties", method!(ObjectView::max_properties, 0))?;
+    object_view.define_method("required", method!(ObjectView::required, 0))?;
+    object_view.define_method("property_names", method!(ObjectView::property_names, 0))?;
+    object_view.define_method("properties", method!(ObjectView::properties, 0))?;
+    object_view.define_method(
+        "pattern_properties",
+        method!(ObjectView::pattern_properties, 0),
+    )?;
+    object_view.define_method(
+        "additional_properties",
+        method!(ObjectView::additional_properties, 0),
+    )?;
+    object_view.define_method("inspect", method!(ObjectView::inspect, 0))?;
+    object_view.define_method("deconstruct_keys", method!(ObjectView::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))?;