jsonschema_rs 0.42.0

data/src/error_kind.rs

@@ -0,0 +1,302 @@
+//! ValidationErrorKind enum for Ruby.
+use magnus::{
+    gc, method,
+    prelude::*,
+    value::{Opaque, StaticSymbol},
+    Error, RModule, Ruby, TypedData, Value,
+};
+
+use crate::{ser::value_to_ruby, static_id::define_rb_intern};
+
+define_rb_intern!(static ID_NAME: "name");
+define_rb_intern!(static ID_VALUE: "value");
+define_rb_intern!(static ID_LIMIT: "limit");
+define_rb_intern!(static ID_UNEXPECTED: "unexpected");
+define_rb_intern!(static ID_CONTEXT: "context");
+define_rb_intern!(static ID_ERROR: "error");
+define_rb_intern!(static ID_EXPECTED_VALUE: "expected_value");
+define_rb_intern!(static ID_CONTENT_ENCODING: "content_encoding");
+define_rb_intern!(static ID_CONTENT_MEDIA_TYPE: "content_media_type");
+define_rb_intern!(static ID_MESSAGE: "message");
+define_rb_intern!(static ID_OPTIONS: "options");
+define_rb_intern!(static ID_FORMAT: "format");
+define_rb_intern!(static ID_MULTIPLE_OF: "multiple_of");
+define_rb_intern!(static ID_SCHEMA: "schema");
+define_rb_intern!(static ID_REASON: "reason");
+define_rb_intern!(static ID_PROPERTY: "property");
+define_rb_intern!(static ID_TYPES: "types");
+define_rb_intern!(static ID_PATTERN: "pattern");
+define_rb_intern!(static ID_CTX_INSTANCE_PATH: "instance_path");
+define_rb_intern!(static ID_CTX_SCHEMA_PATH: "schema_path");
+define_rb_intern!(static ID_CTX_EVALUATION_PATH: "evaluation_path");
+define_rb_intern!(static ID_CTX_KIND: "kind");
+
+#[derive(TypedData)]
+#[magnus(
+    class = "JSONSchema::ValidationErrorKind",
+    free_immediately,
+    size,
+    mark
+)]
+pub struct ValidationErrorKind {
+    name: String,
+    data: Opaque<Value>,
+}
+
+impl magnus::typed_data::DataTypeFunctions for ValidationErrorKind {
+    fn mark(&self, marker: &gc::Marker) {
+        marker.mark(self.data);
+    }
+}
+
+#[inline]
+fn rb_hash1(ruby: &Ruby, k1: StaticSymbol, v1: Value) -> Result<Value, Error> {
+    let hash = ruby.hash_new_capa(1);
+    hash.aset(k1, v1)?;
+    Ok(hash.as_value())
+}
+
+#[inline]
+fn rb_hash2(
+    ruby: &Ruby,
+    k1: StaticSymbol,
+    v1: Value,
+    k2: StaticSymbol,
+    v2: Value,
+) -> Result<Value, Error> {
+    let hash = ruby.hash_new_capa(2);
+    hash.aset(k1, v1)?;
+    hash.aset(k2, v2)?;
+    Ok(hash.as_value())
+}
+
+/// Convert anyOf/oneOf context into a Ruby array of error branch arrays.
+fn context_to_ruby(
+    ruby: &Ruby,
+    context: &[Vec<jsonschema::ValidationError<'static>>],
+    mask: Option<&str>,
+) -> Result<Value, Error> {
+    let sym_message = ID_MESSAGE.to_symbol();
+    let sym_instance_path = ID_CTX_INSTANCE_PATH.to_symbol();
+    let sym_schema_path = ID_CTX_SCHEMA_PATH.to_symbol();
+    let sym_evaluation_path = ID_CTX_EVALUATION_PATH.to_symbol();
+    let sym_kind = ID_CTX_KIND.to_symbol();
+
+    let branches = ruby.ary_new_capa(context.len());
+    for branch in context {
+        let errors = ruby.ary_new_capa(branch.len());
+        for e in branch {
+            let hash = ruby.hash_new_capa(5);
+            let message = if let Some(mask) = mask {
+                e.masked_with(mask).to_string()
+            } else {
+                e.to_string()
+            };
+            hash.aset(sym_message, ruby.into_value(message.as_str()))?;
+            hash.aset(
+                sym_instance_path,
+                ruby.into_value(e.instance_path().as_str()),
+            )?;
+            hash.aset(sym_schema_path, ruby.into_value(e.schema_path().as_str()))?;
+            hash.aset(
+                sym_evaluation_path,
+                ruby.into_value(e.evaluation_path().as_str()),
+            )?;
+            hash.aset(sym_kind, ruby.into_value(e.kind().keyword()))?;
+            errors.push(hash)?;
+        }
+        branches.push(errors)?;
+    }
+    Ok(branches.as_value())
+}
+
+fn strings_to_ruby(ruby: &Ruby, strings: &[String]) -> Value {
+    ruby.ary_from_iter(strings.iter().map(|s| ruby.into_value(s.as_str())))
+        .as_value()
+}
+
+impl ValidationErrorKind {
+    pub fn new(
+        ruby: &Ruby,
+        kind: &jsonschema::error::ValidationErrorKind,
+        mask: Option<&str>,
+    ) -> Result<Self, Error> {
+        use jsonschema::error::ValidationErrorKind as K;
+
+        let name = kind.keyword();
+
+        let data = match kind {
+            K::AdditionalItems { limit } => rb_hash1(
+                ruby,
+                ID_LIMIT.to_symbol(),
+                ruby.integer_from_u64(*limit as u64).as_value(),
+            )?,
+            K::AdditionalProperties { unexpected }
+            | K::UnevaluatedItems { unexpected }
+            | K::UnevaluatedProperties { unexpected } => rb_hash1(
+                ruby,
+                ID_UNEXPECTED.to_symbol(),
+                strings_to_ruby(ruby, unexpected),
+            )?,
+            K::AnyOf { context } => rb_hash1(
+                ruby,
+                ID_CONTEXT.to_symbol(),
+                context_to_ruby(ruby, context, mask)?,
+            )?,
+            K::BacktrackLimitExceeded { error } => rb_hash1(
+                ruby,
+                ID_ERROR.to_symbol(),
+                ruby.into_value(error.to_string().as_str()),
+            )?,
+            K::Constant { expected_value } => rb_hash1(
+                ruby,
+                ID_EXPECTED_VALUE.to_symbol(),
+                value_to_ruby(ruby, expected_value)?,
+            )?,
+            K::Contains | K::FalseSchema | K::UniqueItems => ruby.hash_new().as_value(),
+            K::ContentEncoding { content_encoding } => rb_hash1(
+                ruby,
+                ID_CONTENT_ENCODING.to_symbol(),
+                ruby.into_value(content_encoding.as_str()),
+            )?,
+            K::ContentMediaType { content_media_type } => rb_hash1(
+                ruby,
+                ID_CONTENT_MEDIA_TYPE.to_symbol(),
+                ruby.into_value(content_media_type.as_str()),
+            )?,
+            K::Custom { message, .. } => rb_hash1(
+                ruby,
+                ID_MESSAGE.to_symbol(),
+                ruby.into_value(message.as_str()),
+            )?,
+            K::Enum { options } => {
+                rb_hash1(ruby, ID_OPTIONS.to_symbol(), value_to_ruby(ruby, options)?)?
+            }
+            K::ExclusiveMaximum { limit }
+            | K::ExclusiveMinimum { limit }
+            | K::Maximum { limit }
+            | K::Minimum { limit } => {
+                rb_hash1(ruby, ID_LIMIT.to_symbol(), value_to_ruby(ruby, limit)?)?
+            }
+            K::Format { format } => rb_hash1(
+                ruby,
+                ID_FORMAT.to_symbol(),
+                ruby.into_value(format.as_str()),
+            )?,
+            K::FromUtf8 { error } => rb_hash1(
+                ruby,
+                ID_ERROR.to_symbol(),
+                ruby.into_value(error.to_string().as_str()),
+            )?,
+            K::MaxItems { limit }
+            | K::MaxLength { limit }
+            | K::MaxProperties { limit }
+            | K::MinItems { limit }
+            | K::MinLength { limit }
+            | K::MinProperties { limit } => rb_hash1(
+                ruby,
+                ID_LIMIT.to_symbol(),
+                ruby.integer_from_u64(*limit).as_value(),
+            )?,
+            K::MultipleOf { multiple_of } => rb_hash1(
+                ruby,
+                ID_MULTIPLE_OF.to_symbol(),
+                value_to_ruby(ruby, multiple_of)?,
+            )?,
+            K::Not { schema } => {
+                rb_hash1(ruby, ID_SCHEMA.to_symbol(), value_to_ruby(ruby, schema)?)?
+            }
+            K::OneOfMultipleValid { context } => rb_hash2(
+                ruby,
+                ID_REASON.to_symbol(),
+                ruby.into_value("multipleValid"),
+                ID_CONTEXT.to_symbol(),
+                context_to_ruby(ruby, context, mask)?,
+            )?,
+            K::OneOfNotValid { context } => rb_hash2(
+                ruby,
+                ID_REASON.to_symbol(),
+                ruby.into_value("notValid"),
+                ID_CONTEXT.to_symbol(),
+                context_to_ruby(ruby, context, mask)?,
+            )?,
+            K::Pattern { pattern } => rb_hash1(
+                ruby,
+                ID_PATTERN.to_symbol(),
+                ruby.into_value(pattern.as_str()),
+            )?,
+            K::PropertyNames { error } => {
+                let message = if let Some(mask) = mask {
+                    error.masked_with(mask).to_string()
+                } else {
+                    error.to_string()
+                };
+                rb_hash1(
+                    ruby,
+                    ID_ERROR.to_symbol(),
+                    ruby.into_value(message.as_str()),
+                )?
+            }
+            K::Referencing(err) => rb_hash1(
+                ruby,
+                ID_ERROR.to_symbol(),
+                ruby.into_value(err.to_string().as_str()),
+            )?,
+            K::Required { property } => rb_hash1(
+                ruby,
+                ID_PROPERTY.to_symbol(),
+                value_to_ruby(ruby, property)?,
+            )?,
+            K::Type { kind } => {
+                let types: Vec<Value> = match kind {
+                    jsonschema::error::TypeKind::Single(ty) => vec![ruby.into_value(ty.as_str())],
+                    jsonschema::error::TypeKind::Multiple(types) => types
+                        .iter()
+                        .map(|ty| ruby.into_value(ty.as_str()))
+                        .collect(),
+                };
+                let rb_types = ruby.ary_from_iter(types);
+                rb_hash1(ruby, ID_TYPES.to_symbol(), rb_types.as_value())?
+            }
+        };
+
+        Ok(ValidationErrorKind {
+            name: name.to_string(),
+            data: data.into(),
+        })
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn value(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.get_inner(rb_self.data)
+    }
+
+    fn as_hash(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let hash = ruby.hash_new_capa(2);
+        hash.aset(ID_NAME.to_symbol(), rb_self.name.as_str())?;
+        hash.aset(ID_VALUE.to_symbol(), ruby.get_inner(rb_self.data))?;
+        Ok(hash.as_value())
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<JSONSchema::ValidationErrorKind name={:?}>", self.name)
+    }
+
+    fn to_s(&self) -> &str {
+        &self.name
+    }
+}
+
+pub fn define_class(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("ValidationErrorKind", ruby.class_object())?;
+    class.define_method("name", method!(ValidationErrorKind::name, 0))?;
+    class.define_method("value", method!(ValidationErrorKind::value, 0))?;
+    class.define_method("to_h", method!(ValidationErrorKind::as_hash, 0))?;
+    class.define_method("inspect", method!(ValidationErrorKind::inspect, 0))?;
+    class.define_method("to_s", method!(ValidationErrorKind::to_s, 0))?;
+
+    Ok(())
+}

data/src/evaluation.rs

@@ -0,0 +1,116 @@
+//! Evaluation output wrapper for Ruby
+//!
+//! Provides full JSON Schema output format support: flag, list, and hierarchical.
+use magnus::{method, prelude::*, Error, RModule, Ruby, Value};
+
+use crate::{
+    ser::{serialize_to_ruby, value_to_ruby},
+    static_id::define_rb_intern,
+};
+
+define_rb_intern!(static ID_SCHEMA_LOCATION: "schemaLocation");
+define_rb_intern!(static ID_ABSOLUTE_KEYWORD_LOCATION: "absoluteKeywordLocation");
+define_rb_intern!(static ID_INSTANCE_LOCATION: "instanceLocation");
+define_rb_intern!(static ID_ANNOTATIONS: "annotations");
+define_rb_intern!(static ID_ERROR: "error");
+define_rb_intern!(static ID_VALID: "valid");
+
+#[magnus::wrap(class = "JSONSchema::Evaluation", free_immediately, size)]
+pub struct Evaluation {
+    inner: jsonschema::Evaluation,
+}
+
+impl Evaluation {
+    pub fn new(output: jsonschema::Evaluation) -> Self {
+        Evaluation { inner: output }
+    }
+
+    fn is_valid(&self) -> bool {
+        self.inner.flag().valid
+    }
+
+    /// Simplest output format — only a "valid" key.
+    fn flag(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let flag_output = rb_self.inner.flag();
+        let hash = ruby.hash_new_capa(1);
+        hash.aset(ID_VALID.to_symbol(), flag_output.valid)?;
+        Ok(hash.as_value())
+    }
+
+    /// Flat list of all evaluation results with annotations and errors.
+    fn list(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let list_output = rb_self.inner.list();
+        serialize_to_ruby(ruby, &list_output)
+    }
+
+    /// Nested tree structure following the schema structure.
+    fn hierarchical(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let hierarchical_output = rb_self.inner.hierarchical();
+        serialize_to_ruby(ruby, &hierarchical_output)
+    }
+
+    fn annotations(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let schema_loc = ID_SCHEMA_LOCATION.to_symbol();
+        let abs_kw_loc = ID_ABSOLUTE_KEYWORD_LOCATION.to_symbol();
+        let inst_loc = ID_INSTANCE_LOCATION.to_symbol();
+        let annotations_key = ID_ANNOTATIONS.to_symbol();
+        let arr = ruby.ary_new();
+        for entry in rb_self.inner.iter_annotations() {
+            let hash = ruby.hash_new_capa(4);
+            hash.aset(schema_loc, entry.schema_location)?;
+            if let Some(uri) = entry.absolute_keyword_location {
+                hash.aset(abs_kw_loc, uri.as_str())?;
+            } else {
+                hash.aset(abs_kw_loc, ruby.qnil())?;
+            }
+            hash.aset(inst_loc, entry.instance_location.as_str())?;
+            hash.aset(
+                annotations_key,
+                value_to_ruby(ruby, entry.annotations.value())?,
+            )?;
+            arr.push(hash)?;
+        }
+        Ok(arr.as_value())
+    }
+
+    fn errors(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let schema_loc = ID_SCHEMA_LOCATION.to_symbol();
+        let abs_kw_loc = ID_ABSOLUTE_KEYWORD_LOCATION.to_symbol();
+        let inst_loc = ID_INSTANCE_LOCATION.to_symbol();
+        let error_key = ID_ERROR.to_symbol();
+        let arr = ruby.ary_new();
+        for entry in rb_self.inner.iter_errors() {
+            let hash = ruby.hash_new_capa(4);
+            hash.aset(schema_loc, entry.schema_location)?;
+            if let Some(uri) = entry.absolute_keyword_location {
+                hash.aset(abs_kw_loc, uri.as_str())?;
+            } else {
+                hash.aset(abs_kw_loc, ruby.qnil())?;
+            }
+            hash.aset(inst_loc, entry.instance_location.as_str())?;
+            hash.aset(error_key, entry.error.to_string())?;
+            arr.push(hash)?;
+        }
+        Ok(arr.as_value())
+    }
+
+    fn inspect(&self) -> String {
+        format!(
+            "#<JSONSchema::Evaluation valid={}>",
+            self.inner.flag().valid
+        )
+    }
+}
+
+pub fn define_class(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("Evaluation", ruby.class_object())?;
+    class.define_method("valid?", method!(Evaluation::is_valid, 0))?;
+    class.define_method("flag", method!(Evaluation::flag, 0))?;
+    class.define_method("list", method!(Evaluation::list, 0))?;
+    class.define_method("hierarchical", method!(Evaluation::hierarchical, 0))?;
+    class.define_method("annotations", method!(Evaluation::annotations, 0))?;
+    class.define_method("errors", method!(Evaluation::errors, 0))?;
+    class.define_method("inspect", method!(Evaluation::inspect, 0))?;
+
+    Ok(())
+}