dry-validation-rust 0.1.0.pre5

data/ext/dry_validation_rust/src/engine.rs

@@ -0,0 +1,416 @@
+use std::collections::HashSet;
+
+use magnus::{
+    gc::Marker, prelude::*, r_hash::ForEach, typed_data::Obj, DataTypeFunctions, Error, RArray,
+    RHash, Ruby, TypedData, Value,
+};
+
+use crate::{
+    coercion::{coerce, empty_value, null_if_empty_nullable_param, type_matches},
+    error::{type_message, NativeError, PathPart},
+    plan::{parse_plan, FieldPlan, Mode, SchemaPlan},
+    predicates::apply_predicates,
+    ruby_bridge::RuntimeClasses,
+    SchemaResult,
+};
+
+const MAX_TRAVERSAL_DEPTH: u16 = 128;
+const DEPTH_ERROR_CODE: &str = "depth";
+const DEPTH_ERROR_TEXT: &str = "schema nesting depth exceeds limit (128)";
+
+#[derive(TypedData)]
+#[magnus(
+    class = "Dry::Validation::Rust::Native::Engine",
+    free_immediately,
+    mark,
+    size
+)]
+pub(crate) struct Engine {
+    plan: SchemaPlan,
+    classes: RuntimeClasses,
+    plan_bytes: usize,
+    field_count: usize,
+}
+
+impl DataTypeFunctions for Engine {
+    fn mark(&self, marker: &Marker) {
+        self.classes.mark(marker);
+    }
+}
+
+struct Traversal<'a> {
+    ruby: &'a Ruby,
+    classes: &'a RuntimeClasses,
+    mode: Mode,
+    validate_keys: bool,
+    errors: &'a mut Vec<NativeError>,
+}
+
+enum TypeValidation {
+    Valid(Value),
+    Invalid(Value),
+}
+
+impl Engine {
+    pub(crate) fn new(ruby: &Ruby, json: String) -> Result<Self, Error> {
+        let plan = parse_plan(ruby, &json)?;
+        let classes = RuntimeClasses::new(ruby, &plan)?;
+        let field_count = count_fields(&plan.fields);
+        Ok(Self {
+            plan,
+            classes,
+            plan_bytes: json.len(),
+            field_count,
+        })
+    }
+
+    pub(crate) fn call(&self, input: RHash) -> Result<Obj<SchemaResult>, Error> {
+        let ruby = Ruby::get_with(input);
+        let mut errors = Vec::new();
+        let output = {
+            let mut traversal = Traversal {
+                ruby: &ruby,
+                classes: &self.classes,
+                mode: self.plan.mode,
+                validate_keys: self.plan.validate_keys,
+                errors: &mut errors,
+            };
+            process_hash(&mut traversal, &self.plan.fields, input, &mut Vec::new(), 0)?
+        };
+        let ruby_errors = ruby.ary_new();
+        for error in errors {
+            let ruby_error = ruby.hash_new();
+            let path = ruby.ary_new_capa(error.path.len());
+            for part in error.path {
+                match part {
+                    PathPart::Key(key) => path.push(ruby.to_symbol(key))?,
+                    PathPart::Index(index) => path.push(index)?,
+                }
+            }
+            ruby_error.aset(ruby.to_symbol("path"), path)?;
+            ruby_error.aset(ruby.to_symbol("code"), ruby.to_symbol(error.code.as_ref()))?;
+            ruby_error.aset(ruby.to_symbol("text"), ruby.str_new(error.text.as_ref()))?;
+            ruby_errors.push(ruby_error)?;
+        }
+        Ok(ruby.obj_wrap(SchemaResult {
+            output: output.into(),
+            errors: ruby_errors.into(),
+        }))
+    }
+
+    pub(crate) fn field_count(&self) -> usize {
+        self.field_count
+    }
+
+    pub(crate) fn plan_bytes(&self) -> usize {
+        self.plan_bytes
+    }
+}
+
+fn count_fields(fields: &[FieldPlan]) -> usize {
+    fields
+        .iter()
+        .map(|field| {
+            1 + count_fields(&field.children)
+                + field
+                    .member
+                    .as_ref()
+                    .map_or(0, |member| count_fields(&member.children))
+        })
+        .sum()
+}
+
+fn process_hash(
+    traversal: &mut Traversal<'_>,
+    fields: &[FieldPlan],
+    input: RHash,
+    path: &mut Vec<PathPart>,
+    depth: u16,
+) -> Result<RHash, Error> {
+    let output = traversal.ruby.hash_new_capa(fields.len());
+    if !within_depth_limit(depth, path, traversal.errors) {
+        return Ok(output);
+    }
+    for field in fields {
+        process_field(traversal, &output, field, input, path, depth)?;
+    }
+    report_unexpected_keys(traversal, fields, input, path)?;
+    Ok(output)
+}
+
+fn report_unexpected_keys(
+    traversal: &mut Traversal<'_>,
+    fields: &[FieldPlan],
+    input: RHash,
+    path: &[PathPart],
+) -> Result<(), Error> {
+    if !traversal.validate_keys || traversal.mode == Mode::Schema {
+        return Ok(());
+    }
+
+    let declared: HashSet<&str> = fields
+        .iter()
+        .map(|field| field.name.as_deref().unwrap_or_default())
+        .collect();
+
+    input.foreach(|key: Value, _: Value| {
+        let key_name: String = key.funcall("to_s", ())?;
+        if !declared.contains(key_name.as_str()) {
+            let mut error_path = path.to_vec();
+            error_path.push(PathPart::Key(key_name));
+            traversal.errors.push(NativeError::new(
+                &error_path,
+                "unexpected_key",
+                "is not allowed",
+            ));
+        }
+        Ok(ForEach::Continue)
+    })
+}
+
+fn process_field(
+    traversal: &mut Traversal<'_>,
+    output: &RHash,
+    field: &FieldPlan,
+    input: RHash,
+    path: &mut Vec<PathPart>,
+    depth: u16,
+) -> Result<(), Error> {
+    let name = field.name.as_deref().unwrap_or_default();
+    path.push(PathPart::Key(name.to_owned()));
+    let result = match resolve_field_input(input, traversal.ruby, traversal.mode, name) {
+        Some(raw) => process_value(traversal, field, raw, path, depth)
+            .and_then(|processed| output.aset(traversal.ruby.to_symbol(name), processed)),
+        None => {
+            report_missing_field(traversal, field, path);
+            Ok(())
+        }
+    };
+    path.pop();
+    result
+}
+
+fn resolve_field_input(input: RHash, ruby: &Ruby, mode: Mode, name: &str) -> Option<Value> {
+    input.get(ruby.to_symbol(name)).or_else(|| {
+        if mode == Mode::Schema {
+            None
+        } else {
+            input.get(name)
+        }
+    })
+}
+
+fn report_missing_field(traversal: &mut Traversal<'_>, field: &FieldPlan, path: &[PathPart]) {
+    if field.required {
+        traversal
+            .errors
+            .push(NativeError::new(path, "key", "is missing"));
+    }
+}
+
+fn process_value(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    raw: Value,
+    path: &mut Vec<PathPart>,
+    depth: u16,
+) -> Result<Value, Error> {
+    if !within_depth_limit(depth, path, traversal.errors) {
+        return Ok(raw);
+    }
+    if validate_nil_value(traversal, field, raw, path) {
+        return Ok(raw);
+    }
+    if let Some(nil) =
+        null_if_empty_nullable_param(traversal.ruby, traversal.mode, field.nullable, raw)
+    {
+        return Ok(nil);
+    }
+
+    let coerced = match coerce_and_validate_type(traversal, field, raw, path)? {
+        TypeValidation::Valid(value) => value,
+        TypeValidation::Invalid(value) => return Ok(value),
+    };
+    let filled_error = report_filled_error(traversal, field, coerced, path);
+    let value = process_children(traversal, field, coerced, path, depth)?;
+    if !filled_error {
+        apply_field_predicates(traversal, field, value, path)?;
+    }
+    Ok(value)
+}
+
+fn validate_nil_value(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    raw: Value,
+    path: &[PathPart],
+) -> bool {
+    if !raw.is_nil() {
+        return false;
+    }
+
+    if field.filled
+        && (traversal.mode == Mode::Params || field.kind == "nil" || field.kind == "any")
+    {
+        traversal
+            .errors
+            .push(NativeError::new(path, "filled", "must be filled"));
+    } else if !field.nullable && field.kind != "nil" && field.kind != "any" {
+        traversal
+            .errors
+            .push(NativeError::new(path, "type", type_message(&field.kind)));
+    }
+    true
+}
+
+fn coerce_and_validate_type(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    raw: Value,
+    path: &[PathPart],
+) -> Result<TypeValidation, Error> {
+    let Some(coerced) = coerce(
+        traversal.ruby,
+        traversal.classes,
+        traversal.mode,
+        &field.kind,
+        raw,
+    )?
+    else {
+        traversal
+            .errors
+            .push(NativeError::new(path, "type", type_message(&field.kind)));
+        return Ok(TypeValidation::Invalid(raw));
+    };
+
+    if type_matches(traversal.ruby, traversal.classes, &field.kind, coerced) {
+        Ok(TypeValidation::Valid(coerced))
+    } else {
+        traversal
+            .errors
+            .push(NativeError::new(path, "type", type_message(&field.kind)));
+        Ok(TypeValidation::Invalid(coerced))
+    }
+}
+
+fn report_filled_error(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    value: Value,
+    path: &[PathPart],
+) -> bool {
+    let filled_error = field.filled && empty_value(value);
+    if filled_error {
+        traversal
+            .errors
+            .push(NativeError::new(path, "filled", "must be filled"));
+    }
+    filled_error
+}
+
+fn process_children(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    value: Value,
+    path: &mut Vec<PathPart>,
+    depth: u16,
+) -> Result<Value, Error> {
+    if field.kind == "hash" && !field.children.is_empty() {
+        if let Some(hash) = RHash::from_value(value) {
+            return Ok(process_hash(traversal, &field.children, hash, path, depth + 1)?.as_value());
+        }
+    } else if field.kind == "array" {
+        return process_array_members(traversal, field, value, path, depth);
+    }
+    Ok(value)
+}
+
+fn process_array_members(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    value: Value,
+    path: &mut Vec<PathPart>,
+    depth: u16,
+) -> Result<Value, Error> {
+    let (Some(member), Some(array)) = (field.member.as_ref(), RArray::from_value(value)) else {
+        return Ok(value);
+    };
+
+    let output = traversal.ruby.ary_new_capa(array.len());
+    for (index, item) in array.into_iter().enumerate() {
+        path.push(PathPart::Index(index));
+        let processed = process_value(traversal, member, item, path, depth + 1);
+        path.pop();
+        output.push(processed?)?;
+    }
+    Ok(output.as_value())
+}
+
+fn apply_field_predicates(
+    traversal: &mut Traversal<'_>,
+    field: &FieldPlan,
+    value: Value,
+    path: &[PathPart],
+) -> Result<(), Error> {
+    apply_predicates(traversal.ruby, field, value, path, traversal.errors)
+}
+
+fn within_depth_limit(depth: u16, path: &[PathPart], errors: &mut Vec<NativeError>) -> bool {
+    if depth <= MAX_TRAVERSAL_DEPTH {
+        return true;
+    }
+
+    errors.push(NativeError::new(path, DEPTH_ERROR_CODE, DEPTH_ERROR_TEXT));
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn field_count_includes_nested_and_member_fields() {
+        let json = r#"{
+          "engine_version": 1, "mode": "params", "fields": [{
+            "name": "items", "required": true, "nullable": false, "filled": false, "type": "array",
+            "member": {"name": null, "required": true, "nullable": false, "filled": false, "type": "hash", "member": null,
+              "children": [{"name": "id", "required": true, "nullable": false, "filled": false, "type": "integer", "member": null, "children": [], "predicates": []}], "predicates": []},
+            "children": [], "predicates": []
+          }]
+        }"#;
+        let plan: SchemaPlan = serde_json::from_str(json).expect("valid plan");
+        let field_count = count_fields(&plan.fields);
+        let engine = Engine {
+            plan,
+            classes: RuntimeClasses::default(),
+            plan_bytes: json.len(),
+            field_count,
+        };
+        assert_eq!(engine.field_count(), 2);
+        assert_eq!(engine.plan_bytes(), json.len());
+    }
+
+    #[test]
+    fn nested_structure_over_128_levels_returns_a_depth_error() {
+        fn traverse_nested_structure(
+            depth: u16,
+            path: &mut Vec<PathPart>,
+            errors: &mut Vec<NativeError>,
+        ) {
+            if !within_depth_limit(depth, path, errors) || depth == 200 {
+                return;
+            }
+
+            path.push(PathPart::Key(format!("level_{depth}")));
+            traverse_nested_structure(depth + 1, path, errors);
+            path.pop();
+        }
+
+        let mut errors = Vec::new();
+        traverse_nested_structure(0, &mut Vec::new(), &mut errors);
+
+        assert_eq!(errors.len(), 1);
+        assert_eq!(errors[0].code, DEPTH_ERROR_CODE);
+        assert_eq!(errors[0].text, "schema nesting depth exceeds limit (128)");
+    }
+}

data/ext/dry_validation_rust/src/error.rs

@@ -0,0 +1,82 @@
+use std::borrow::Cow;
+
+#[derive(Debug, Clone)]
+pub(crate) enum PathPart {
+    Key(String),
+    Index(usize),
+}
+
+#[derive(Debug)]
+pub(crate) struct NativeError {
+    pub(crate) path: Vec<PathPart>,
+    pub(crate) code: Cow<'static, str>,
+    pub(crate) text: Cow<'static, str>,
+}
+
+impl NativeError {
+    pub(crate) fn new(
+        path: &[PathPart],
+        code: impl Into<Cow<'static, str>>,
+        text: impl Into<Cow<'static, str>>,
+    ) -> Self {
+        Self {
+            path: path.to_vec(),
+            code: code.into(),
+            text: text.into(),
+        }
+    }
+}
+
+#[inline]
+pub(crate) fn type_message(kind: &str) -> &'static str {
+    match kind {
+        "nil" => "must be nil",
+        "bool" => "must be boolean",
+        "true" => "must be true",
+        "false" => "must be false",
+        "integer" => "must be an integer",
+        "float" => "must be a float",
+        "decimal" => "must be a decimal",
+        "string" => "must be a string",
+        "symbol" => "must be a symbol",
+        "array" => "must be an array",
+        "hash" => "must be a hash",
+        "date" => "must be a date",
+        "date_time" => "must be a date time",
+        "time" => "must be a time",
+        _ => "has invalid type",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::borrow::Cow;
+
+    use super::{type_message, NativeError, PathPart};
+
+    #[test]
+    fn native_error_owns_a_clone_of_key_and_index_path_parts() {
+        let mut path = vec![PathPart::Key("profile".to_owned()), PathPart::Index(2)];
+        let error = NativeError::new(&path, "type", "must be a hash");
+        path[0] = PathPart::Key("changed".to_owned());
+
+        assert!(
+            matches!(&error.path[..], [PathPart::Key(key), PathPart::Index(2)] if key == "profile")
+        );
+    }
+
+    #[test]
+    fn type_messages_are_stable() {
+        assert_eq!(type_message("integer"), "must be an integer");
+        assert_eq!(type_message("date_time"), "must be a date time");
+        assert_eq!(type_message("something_new"), "has invalid type");
+    }
+
+    #[test]
+    fn type_errors_borrow_static_code_and_text() {
+        let error = NativeError::new(&[], "type", type_message("integer"));
+
+        assert!(matches!(error.code, Cow::Borrowed("type")));
+        assert!(matches!(error.text, Cow::Borrowed("must be an integer")));
+    }
+}

data/ext/dry_validation_rust/src/extract_primitive.rs

@@ -0,0 +1,23 @@
+use magnus::{Float, Integer, RArray, RHash, RString, Value};
+
+pub(crate) fn extract_i64(value: Value) -> Option<i64> {
+    Integer::from_value(value)?.to_i64().ok()
+}
+
+pub(crate) fn extract_f64(value: Value) -> Option<f64> {
+    Some(Float::from_value(value)?.to_f64())
+}
+
+/// Returns only UTF-8 strings so native ordering and character counts preserve
+/// the Ruby behavior represented by a Rust `String`.
+pub(crate) fn extract_string(value: Value) -> Option<String> {
+    RString::from_value(value)?.to_string().ok()
+}
+
+pub(crate) fn extract_array_len(value: Value) -> Option<usize> {
+    Some(RArray::from_value(value)?.len())
+}
+
+pub(crate) fn extract_hash_len(value: Value) -> Option<usize> {
+    Some(RHash::from_value(value)?.len())
+}

data/ext/dry_validation_rust/src/generated_predicates.rs

@@ -0,0 +1,33 @@
+// This file is generated by `bundle exec rake generate:predicates`.
+// Do not edit it directly; update predicates.yml instead.
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum PredicateOp {
+    Gt,
+    Gteq,
+    Lt,
+    Lteq,
+    MinSize,
+    MaxSize,
+    Size,
+    Odd,
+    Even,
+    Unsupported,
+}
+
+impl PredicateOp {
+    fn from_name(name: &str) -> Self {
+        match name {
+            "gt" => Self::Gt,
+            "gteq" => Self::Gteq,
+            "lt" => Self::Lt,
+            "lteq" => Self::Lteq,
+            "min_size" => Self::MinSize,
+            "max_size" => Self::MaxSize,
+            "size" => Self::Size,
+            "odd" => Self::Odd,
+            "even" => Self::Even,
+            _ => Self::Unsupported,
+        }
+    }
+}