dry-validation-rust 0.1.0.pre5

data/ext/dry_validation_rust/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "dry_validation_rust_native"
+version = "0.1.0-pre.5"
+edition = "2021"
+rust-version = "1.75"
+license = "MIT"
+publish = false
+
+[lib]
+name = "native"
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+bigdecimal = "0.4"
+chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] }
+magnus = { version = "~0.8.2", default-features = false }
+rb-sys = { version = "~0.9.124", default-features = false, features = ["stable-api-compiled-fallback"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["unbounded_depth"] }
+
+[dev-dependencies]
+criterion = "0.5.1"
+magnus = { version = "~0.8.2", default-features = false, features = ["embed"] }
+
+[[bench]]
+name = "plan_compile"
+harness = false
+
+[[bench]]
+name = "coercion"
+harness = false
+
+[[bench]]
+name = "predicates"
+harness = false
+
+[[bench]]
+name = "full_schema"
+harness = false
+
+[profile.release]
+codegen-units = 1
+lto = "thin"
+strip = "debuginfo"

data/ext/dry_validation_rust/benches/coercion.rs

@@ -0,0 +1,77 @@
+use criterion::{black_box, Criterion};
+use magnus::{Error, Ruby};
+use native::benchmark::CoercionRuntime;
+
+fn bench_coercion(
+    criterion: &mut Criterion,
+    runtime: &CoercionRuntime,
+    ruby: &Ruby,
+    group_name: &str,
+    kind: &str,
+    inputs: &[&str],
+) {
+    let mut group = criterion.benchmark_group(group_name);
+    for input in inputs {
+        group.bench_function(*input, |bencher| {
+            bencher.iter(|| {
+                runtime
+                    .coerce(ruby, black_box(kind), black_box(input))
+                    .expect("benchmark coercion inputs must not raise Ruby errors")
+            });
+        });
+    }
+    group.finish();
+}
+
+fn run(ruby: &Ruby) -> Result<(), Error> {
+    let runtime = CoercionRuntime::new(ruby)?;
+    let mut criterion = Criterion::default().configure_from_args();
+
+    bench_coercion(
+        &mut criterion,
+        &runtime,
+        ruby,
+        "integer_coercion",
+        "integer",
+        &["42", "-99", "1_000", "0xFF"],
+    );
+    bench_coercion(
+        &mut criterion,
+        &runtime,
+        ruby,
+        "float_coercion",
+        "float",
+        &["3.14", "-2.5e10", "Infinity"],
+    );
+    bench_coercion(
+        &mut criterion,
+        &runtime,
+        ruby,
+        "bool_coercion",
+        "bool",
+        &["true", "false", "1", "0", "yes", "no"],
+    );
+    bench_coercion(
+        &mut criterion,
+        &runtime,
+        ruby,
+        "date_coercion",
+        "date",
+        &["2024-01-01", "2024-01-01T12:00:00Z"],
+    );
+    bench_coercion(
+        &mut criterion,
+        &runtime,
+        ruby,
+        "decimal_coercion",
+        "decimal",
+        &["123.456", "0.0000001"],
+    );
+
+    criterion.final_summary();
+    Ok(())
+}
+
+fn main() {
+    Ruby::init(run).expect("embedded Ruby benchmark setup must succeed");
+}

data/ext/dry_validation_rust/benches/full_schema.rs

@@ -0,0 +1,189 @@
+use criterion::{black_box, Criterion};
+use magnus::{gc, Error, RHash, Ruby, Value};
+use native::benchmark::FullSchemaRuntime;
+
+fn field(name: &str, kind: &str, filled: bool, predicate: Option<(&str, i64)>) -> String {
+    let predicates = predicate.map_or_else(
+        || "[]".to_owned(),
+        |(name, argument)| format!(r#"[{{"name":"{name}","argument":{argument}}}]"#),
+    );
+    format!(
+        r#"{{"name":"{name}","required":true,"nullable":false,"filled":{filled},"type":"{kind}","member":null,"children":[],"predicates":{predicates}}}"#
+    )
+}
+
+fn plan(fields: Vec<String>) -> String {
+    format!(
+        r#"{{"engine_version":1,"mode":"params","validate_keys":true,"fields":[{}]}}"#,
+        fields.join(",")
+    )
+}
+
+fn flat_plan(field_count: usize) -> String {
+    plan(
+        (0..field_count)
+            .map(|index| field(&format!("field_{index}"), "integer", false, Some(("gt", 0))))
+            .collect(),
+    )
+}
+
+fn nested_plan(depth: usize) -> String {
+    let mut child = field("value", "integer", false, Some(("gt", 0)));
+    for index in (0..depth).rev() {
+        child = format!(
+            r#"{{"name":"level_{index}","required":true,"nullable":false,"filled":false,"type":"hash","member":null,"children":[{child}],"predicates":[]}}"#
+        );
+    }
+    plan(vec![child])
+}
+
+fn array_plan() -> String {
+    let member_children = [
+        field("id", "integer", false, Some(("gt", 0))),
+        field("name", "string", true, None),
+        field("age", "integer", false, Some(("gteq", 18))),
+        field("active", "bool", false, None),
+        field("role", "string", true, None),
+    ]
+    .join(",");
+    plan(vec![format!(
+        r#"{{"name":"items","required":true,"nullable":false,"filled":false,"type":"array","member":{{"name":null,"required":true,"nullable":false,"filled":false,"type":"hash","member":null,"children":[{member_children}],"predicates":[]}},"children":[],"predicates":[]}}"#
+    )])
+}
+
+fn flat_payload(ruby: &Ruby, field_count: usize, invalid: bool) -> Result<RHash, Error> {
+    let payload = ruby.hash_new_capa(field_count);
+    for index in 0..field_count {
+        let value = if invalid { "invalid" } else { "1" };
+        payload.aset(format!("field_{index}"), value)?;
+    }
+    Ok(payload)
+}
+
+fn nested_payload(ruby: &Ruby, depth: usize) -> Result<RHash, Error> {
+    let mut payload = ruby.hash_from_iter([("value", "1")]);
+    for index in (0..depth).rev() {
+        payload = ruby.hash_from_iter([(format!("level_{index}"), payload)]);
+    }
+    Ok(payload)
+}
+
+fn array_payload(ruby: &Ruby, invalid: bool) -> Result<RHash, Error> {
+    let items = ruby.ary_new_capa(100);
+    for index in 0..100 {
+        let item = ruby.hash_new_capa(5);
+        let invalid_item = invalid && index == 0;
+        item.aset("id", if invalid_item { "invalid" } else { "1" })?;
+        item.aset("name", if invalid_item { "" } else { "person" })?;
+        item.aset("age", if invalid_item { "invalid" } else { "30" })?;
+        item.aset("active", "true")?;
+        item.aset("role", "member")?;
+        items.push(item)?;
+    }
+    Ok(ruby.hash_from_iter([("items", items)]))
+}
+
+fn bench_case(
+    criterion: &mut Criterion,
+    ruby: &Ruby,
+    name: &str,
+    plan_json: String,
+    inputs: Vec<(RHash, usize)>,
+) -> Result<(), Error> {
+    let runtime = FullSchemaRuntime::new(ruby, plan_json)?;
+    for (input, expected_errors) in &inputs {
+        gc::register_mark_object(*input);
+        assert_eq!(
+            runtime.error_count(ruby, *input)?,
+            *expected_errors,
+            "{name} setup"
+        );
+    }
+
+    let mut input_index = 0;
+    criterion.bench_function(name, |bencher| {
+        bencher.iter(|| {
+            let input = inputs[input_index % inputs.len()].0;
+            input_index += 1;
+            runtime
+                .call(black_box(input))
+                .expect("pre-built benchmark inputs must not raise Ruby errors")
+        });
+    });
+    Ok(())
+}
+
+fn run(ruby: &Ruby) -> Result<(), Error> {
+    ruby.eval::<Value>(
+        "module Dry; module Validation; module Rust; module Native; class SchemaResult; end; end; end; end; end",
+    )?;
+    let mut criterion = Criterion::default().configure_from_args();
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/small_form",
+        flat_plan(5),
+        vec![(flat_payload(ruby, 5, false)?, 0)],
+    )?;
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/medium_form",
+        flat_plan(25),
+        vec![
+            (flat_payload(ruby, 25, false)?, 0),
+            (flat_payload(ruby, 25, false)?, 0),
+            (flat_payload(ruby, 25, false)?, 0),
+            (flat_payload(ruby, 25, false)?, 0),
+            (flat_payload(ruby, 25, true)?, 25),
+        ],
+    )?;
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/large_form",
+        flat_plan(100),
+        vec![
+            (flat_payload(ruby, 100, false)?, 0),
+            (flat_payload(ruby, 100, true)?, 100),
+        ],
+    )?;
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/nested_object",
+        nested_plan(10),
+        vec![(nested_payload(ruby, 10)?, 0)],
+    )?;
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/array_of_objects",
+        array_plan(),
+        vec![
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, false)?, 0),
+            (array_payload(ruby, true)?, 3),
+        ],
+    )?;
+    bench_case(
+        &mut criterion,
+        ruby,
+        "full_schema/all_invalid",
+        flat_plan(20),
+        vec![(flat_payload(ruby, 20, true)?, 20)],
+    )?;
+    criterion.final_summary();
+    Ok(())
+}
+
+fn main() {
+    Ruby::init(run).expect("embedded Ruby benchmark setup must succeed");
+}

data/ext/dry_validation_rust/benches/plan_compile.rs

@@ -0,0 +1,37 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+fn plan_json(field_count: usize) -> String {
+    let fields = (0..field_count)
+        .map(|index| {
+            format!(
+                r#"{{"name":"field_{index}","required":true,"nullable":false,"filled":false,"type":"string","member":null,"children":[],"predicates":[{{"name":"min_size","argument":1}}]}}"#
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+
+    format!(r#"{{"engine_version":1,"mode":"params","validate_keys":true,"fields":[{fields}]}}"#)
+}
+
+fn bench_plan_compile(c: &mut Criterion, name: &str, field_count: usize) {
+    let plan = plan_json(field_count);
+
+    c.bench_function(name, |bencher| {
+        bencher.iter(|| black_box(native::fuzzing::parse_plan(black_box(&plan))));
+    });
+}
+
+fn small_schema(c: &mut Criterion) {
+    bench_plan_compile(c, "small_schema", 5);
+}
+
+fn medium_schema(c: &mut Criterion) {
+    bench_plan_compile(c, "medium_schema", 50);
+}
+
+fn large_schema(c: &mut Criterion) {
+    bench_plan_compile(c, "large_schema", 200);
+}
+
+criterion_group!(plan_compile, small_schema, medium_schema, large_schema);
+criterion_main!(plan_compile);

data/ext/dry_validation_rust/benches/predicates.rs

@@ -0,0 +1,105 @@
+use criterion::{black_box, Criterion};
+use magnus::{prelude::*, Error, Ruby, Value};
+use native::benchmark::{PredicateCase, PredicateRuntime};
+
+fn bench_predicate(
+    criterion: &mut Criterion,
+    ruby: &Ruby,
+    runtime: &PredicateRuntime,
+    group_name: &str,
+    case_name: &str,
+    predicate_case: PredicateCase,
+    value: Value,
+) {
+    let mut group = criterion.benchmark_group(group_name);
+    group.bench_function(case_name, |bencher| {
+        bencher.iter(|| {
+            runtime
+                .evaluate(ruby, predicate_case, black_box(value))
+                .expect("benchmark predicate inputs must not raise Ruby errors")
+        });
+    });
+    group.finish();
+}
+
+fn run(ruby: &Ruby) -> Result<(), Error> {
+    let runtime = PredicateRuntime::new();
+    let mut criterion = Criterion::default().configure_from_args();
+    let integer = ruby.integer_from_i64(19).as_value();
+    let even_integer = ruby.integer_from_i64(20).as_value();
+    let float = ruby.float_from_f64(1.5).as_value();
+    let string = ruby.str_new("abc").as_value();
+    let array = ruby.ary_from_iter([1, 2, 3]).as_value();
+    let hash = ruby
+        .hash_from_iter([("one", 1), ("two", 2), ("three", 3)])
+        .as_value();
+
+    for (name, predicate_case, value) in [
+        ("gt_integer", PredicateCase::GtInteger, integer),
+        ("gteq_integer", PredicateCase::GteqInteger, integer),
+        ("lt_integer", PredicateCase::LtInteger, integer),
+        ("lteq_integer", PredicateCase::LteqInteger, integer),
+        ("gt_float", PredicateCase::GtFloat, float),
+        ("gteq_float", PredicateCase::GteqFloat, float),
+        ("lt_float", PredicateCase::LtFloat, float),
+        ("lteq_float", PredicateCase::LteqFloat, float),
+    ] {
+        bench_predicate(
+            &mut criterion,
+            ruby,
+            &runtime,
+            "comparison",
+            name,
+            predicate_case,
+            value,
+        );
+    }
+
+    for (name, predicate_case, value) in [
+        ("size_string", PredicateCase::Size, string),
+        ("min_size_string", PredicateCase::MinSize, string),
+        ("max_size_string", PredicateCase::MaxSize, string),
+        ("size_array", PredicateCase::Size, array),
+        ("min_size_array", PredicateCase::MinSize, array),
+        ("max_size_array", PredicateCase::MaxSize, array),
+        ("size_hash", PredicateCase::Size, hash),
+        ("min_size_hash", PredicateCase::MinSize, hash),
+        ("max_size_hash", PredicateCase::MaxSize, hash),
+    ] {
+        bench_predicate(
+            &mut criterion,
+            ruby,
+            &runtime,
+            "size",
+            name,
+            predicate_case,
+            value,
+        );
+    }
+
+    bench_predicate(
+        &mut criterion,
+        ruby,
+        &runtime,
+        "parity",
+        "odd_integer",
+        PredicateCase::Odd,
+        integer,
+    );
+    bench_predicate(
+        &mut criterion,
+        ruby,
+        &runtime,
+        "parity",
+        "even_integer",
+        PredicateCase::Even,
+        even_integer,
+    );
+
+    criterion.final_summary();
+    Ok(())
+}
+
+fn main() {
+    Ruby::init(run).expect("embedded Ruby benchmark setup must succeed");
+}

data/ext/dry_validation_rust/extconf.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+begin
+  require 'rb_sys/mkmf'
+rescue LoadError
+  local_rb_sys = ENV.fetch('RB_SYS_GEM_LIB', nil)
+  if local_rb_sys && File.directory?(local_rb_sys)
+    $LOAD_PATH.unshift(local_rb_sys)
+    require 'rb_sys/mkmf'
+  else
+    abort 'rb_sys is required to build dry-validation-rust (gem install rb_sys)'
+  end
+end
+
+create_rust_makefile('dry_validation_rust/native') do |config|
+  config.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', 'release').to_sym
+  config.ext_dir = '.'
+  config.env = {
+    'BINDGEN_EXTRA_CLANG_ARGS' => '-include stdbool.h'
+  }
+  config.extra_rustup_targets = %w[
+    aarch64-unknown-linux-gnu
+    x86_64-apple-darwin
+    aarch64-apple-darwin
+  ]
+  config.use_stable_api_compiled_fallback = true
+end