jsonschema_rs 0.48.5 → 0.49.1

data/src/canonical.rs

@@ -1,5 +1,7 @@
 use jsonschema::{
-    canonical::{CanonicalSchema, CanonicalView, CanonicalizationError},
+    canonical::{
+        CanonicalSchema, CanonicalView, CanonicalizationError, ContainsView as CoreContainsView,
+    },
     JsonType,
 };
 use magnus::{
@@ -12,13 +14,17 @@ use magnus::{
 };
 
 use crate::{
-    options::parse_draft_symbol,
+    options::{extract_pattern_options, parse_draft_symbol, RbPatternOptions},
     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");
+define_rb_intern!(static CANONICAL_KW_PATTERN_OPTIONS: "pattern_options");
+
+type CanonicalKwArgs =
+    magnus::scan_args::KwArgs<(), (Option<Value>, Option<bool>, Option<Value>), ()>;
 
 macro_rules! canonical_error_class {
     ($static_name:ident, $class_name:literal) => {
@@ -40,6 +46,7 @@ macro_rules! canonical_error_class {
 
 canonical_error_class!(CANONICALIZATION_ERROR_CLASS, "CanonicalizationError");
 canonical_error_class!(INVALID_SCHEMA_TYPE_CLASS, "InvalidSchemaType");
+canonical_error_class!(INVALID_PATTERN_CLASS, "InvalidPattern");
 
 fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
     if let CanonicalizationError::ValidationError(validation_error) = error {
@@ -50,6 +57,9 @@ fn canonicalization_error(ruby: &Ruby, error: CanonicalizationError) -> Error {
         CanonicalizationError::InvalidSchemaType(_) => {
             Error::new(ruby.get_inner(&INVALID_SCHEMA_TYPE_CLASS), message)
         }
+        CanonicalizationError::InvalidPattern { .. } => {
+            Error::new(ruby.get_inner(&INVALID_PATTERN_CLASS), message)
+        }
         // `ValidationError` returns above; future variants fall back to the base canonical error.
         _ => Error::new(ruby.get_inner(&CANONICALIZATION_ERROR_CLASS), message),
     }
@@ -130,18 +140,50 @@ impl RbCanonicalSchema {
                     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:?}"),
         }
     }
 
@@ -289,13 +331,36 @@ fn bound_to_ruby(ruby: &Ruby, bound: Option<&serde_json::Number>) -> Result<Valu
     }
 }
 
-/// A string value within a length window, matching every pattern.
+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 {}
@@ -310,19 +375,30 @@ impl StringView {
     }
 
     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())
+        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={}>",
+            "#<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::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()
         ))
     }
 
@@ -331,16 +407,91 @@ impl StringView {
         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.
+/// 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 {}
@@ -354,11 +505,16 @@ impl IntegerView {
         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={}>",
+            "#<JSONSchema::Canonical::IntegerView minimum={} maximum={} multiple_of={}>",
             Self::minimum(ruby, rb_self)?.inspect(),
-            Self::maximum(ruby, rb_self)?.inspect()
+            Self::maximum(ruby, rb_self)?.inspect(),
+            Self::multiple_of(ruby, rb_self)?.inspect()
         ))
     }
 
@@ -366,6 +522,275 @@ impl IntegerView {
         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)
     }
 }
@@ -475,12 +900,16 @@ 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(
+    let base_kwargs: CanonicalKwArgs = get_kwargs(
         keywords,
         &[],
-        &[*CANONICAL_KW_DRAFT, *CANONICAL_KW_VALIDATE_FORMATS],
+        &[
+            *CANONICAL_KW_DRAFT,
+            *CANONICAL_KW_VALIDATE_FORMATS,
+            *CANONICAL_KW_PATTERN_OPTIONS,
+        ],
     )?;
-    let (draft_val, validate_formats) = base_kwargs.optional;
+    let (draft_val, validate_formats, pattern_options) = base_kwargs.optional;
 
     let schema_value = to_schema_value(ruby, schema_arg)?;
     let mut options = jsonschema::canonical::options();
@@ -490,6 +919,12 @@ fn canonicalize(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
     if let Some(validate_formats) = validate_formats {
         options = options.should_validate_formats(validate_formats);
     }
+    if let Some(val) = pattern_options {
+        match extract_pattern_options(ruby, val)? {
+            RbPatternOptions::Fancy(inner) => options = options.with_pattern_options(inner),
+            RbPatternOptions::Regex(inner) => options = options.with_pattern_options(inner),
+        }
+    }
     options
         .canonicalize(&schema_value)
         .map(|inner| ruby.obj_wrap(RbCanonicalSchema { inner }).as_value())
@@ -502,6 +937,7 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     let base_error =
         canonical_module.define_error("CanonicalizationError", ruby.exception_standard_error())?;
     canonical_module.define_error("InvalidSchemaType", base_error)?;
+    canonical_module.define_error("InvalidPattern", base_error)?;
 
     let canonical_schema = canonical_module.define_class("CanonicalSchema", ruby.class_object())?;
     canonical_schema.define_method(
@@ -560,18 +996,79 @@ pub(crate) fn init_canonical(ruby: &Ruby, module: &RModule) -> Result<(), Error>
     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))?;