rudy4 0.2.0

data/scripts/vendor_check.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Fail if vendor/rudy/ has drifted from src/rudy/ (CI guard, and `rake
+# vendor:check` locally). Runs vendor_sync.sh in a scratch copy so the working
+# tree is never touched.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if [[ ! -f "$HERE/vendor/rudy/defs.d" ]]; then
+  echo "vendor_check: vendor/rudy/ is missing — run scripts/vendor_sync.sh" >&2
+  exit 1
+fi
+
+scratch="$(mktemp -d)"
+trap 'rm -rf "$scratch"' EXIT
+
+mkdir -p "$scratch/src" "$scratch/vendor"
+cp -R "$HERE/src/rudy" "$scratch/src/rudy"
+cp -R "$HERE/vendor/rudy" "$scratch/vendor/rudy"
+
+mkdir -p "$scratch/scripts"
+cp "$HERE/scripts/vendor_sync.sh" "$scratch/scripts/"
+
+bash "$scratch/scripts/vendor_sync.sh" >/dev/null
+
+if ! diff -r "$scratch/vendor/rudy" "$HERE/vendor/rudy" >/dev/null; then
+  echo "vendor_check: vendor/rudy/ has drifted from src/rudy/ — run scripts/vendor_sync.sh" >&2
+  diff -r "$scratch/vendor/rudy" "$HERE/vendor/rudy" || true
+  exit 1
+fi
+
+echo "vendor_check: vendor/rudy/ is in sync with src/rudy/"

data/scripts/vendor_sync.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Sync the vendored copy of the rudy4 D library (vendor/rudy/) from src/rudy/.
+#
+# The gem ships the D sources so a scaffolded extension builds without a rudy4
+# checkout. `src/rudy/` stays the single source of truth; this script copies it,
+# and `rake vendor:check` (run in CI) fails if the two have drifted.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SRC="$HERE/src/rudy"
+DEST="$HERE/vendor/rudy"
+
+if [[ ! -f "$SRC/defs.d" ]]; then
+  echo "vendor_sync: source library not found at $SRC" >&2
+  exit 1
+fi
+
+rm -rf "$DEST"
+mkdir -p "$DEST"
+# -R preserves the rudy/bind/ nesting, which the `import rudy.bind.value;`
+# module paths depend on.
+cp -R "$SRC/." "$DEST/"
+
+echo "vendor_sync: copied $(find "$DEST" -name '*.d' | wc -l | tr -d ' ') D sources into vendor/rudy/"

data/src/dexitest.d

@@ -0,0 +1,278 @@
+/// dexitest — acceptance-test extension for the PR#4 missing-API bindings:
+/// rb_yield/rb_yield_values2/rb_yield_splat, rb_block_call, rb_block_given_p,
+/// rb_rescue, rb_ensure, rb_define_singleton_method, rb_scan_args,
+/// rb_thread_call_without_gvl, and the variadic (argc/argv) def! trampoline
+/// for D functions with default arguments.
+///
+/// Also exercises singleton-method registration via the raw
+/// rb_define_singleton_method API and the variadic def! trampoline.
+
+module dexitest;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.defs;
+
+
+private:
+
+// ------------------------------------------------------------------
+// 1. rb_yield — yield to the caller's block from a def!'d method
+// ------------------------------------------------------------------
+
+long sum_to(long n)
+{
+    long total = 0;
+    foreach (i; 1 .. n + 1)
+    {
+        VALUE[1] av = [rb_ll2inum(i)];
+        total += d_type!long(rb_yield(av[0]));   // yield i
+    }
+    return total;
+}
+
+// ------------------------------------------------------------------
+// 2. rb_block_given_p + rb_yield_values2 (multiple yield args)
+// ------------------------------------------------------------------
+
+long pair_sums(long n)
+{
+    if (rb_block_given_p() == 0)
+        return -1;                              // no block: -1
+    long total = 0;
+    foreach (i; 1 .. n + 1)
+    {
+        VALUE[2] av = [rb_ll2inum(i), rb_ll2inum(i * 10)];
+        total += d_type!long(rb_yield_values2(2, av.ptr)); // |a, b| a + b
+    }
+    return total;
+}
+
+// ------------------------------------------------------------------
+// 3. rb_block_call — call obj.each with a C-implemented block
+//    (collects entries into a Ruby Array, D-side accumulation)
+// ------------------------------------------------------------------
+
+__gshared VALUE block_call_sink;                 // rooted Ruby Array
+
+extern (C) VALUE collect_entry(VALUE yielded, VALUE cb, int argc,
+                               const(VALUE)* argv, VALUE blockarg)
+{
+    rb_ary_push(block_call_sink, yielded);
+    return yielded;
+}
+
+// returns Array of elements of the array argument, collected via each
+private VALUE dexitest_block_collect(VALUE self, VALUE ary)
+{
+    block_call_sink = rb_ary_new();
+    rb_block_call(ary, rb_intern("each"), 0, null, &collect_entry, Qnil_);
+    return block_call_sink;
+}
+
+// ------------------------------------------------------------------
+// 4. rb_rescue — structured exception handling across the boundary
+// ------------------------------------------------------------------
+
+extern (C) VALUE risky_body(VALUE data)          // raises ZeroDivisionError
+{
+    VALUE[0] av;
+    return rb_funcallv(rb_int2inum(1), rb_intern("/"), 1,
+                       [rb_int2inum(0)].ptr);
+}
+
+extern (C) VALUE rescue_handler(VALUE data2, VALUE exc)
+{
+    return rb_str_new_cstr("rescued");
+}
+
+private VALUE dexitest_div_rescue(VALUE self, VALUE a, VALUE b)
+{
+    // single-class rescue via rb_rescue (StandardError family)
+    return rb_rescue(&risky_body, Qnil_, &rescue_handler, Qnil_);
+}
+
+// body that succeeds — rb_rescue returns b_proc's value untouched
+extern (C) VALUE safe_body(VALUE data) { return rb_int2inum(42); }
+
+private VALUE dexitest_safe_rescue(VALUE self)
+{
+    return rb_rescue(&safe_body, Qnil_, &rescue_handler, Qnil_);
+}
+
+// ------------------------------------------------------------------
+// 5. rb_ensure — ensure runs after both success and raise paths
+// ------------------------------------------------------------------
+
+__gshared int ensure_ran = 0;
+
+extern (C) VALUE ensure_proc(VALUE data)
+{
+    ensure_ran = 1;
+    return Qnil_;
+}
+
+extern (C) VALUE raising_body(VALUE data)
+{
+    rb_raise(rb_eRuntimeError, "boom");
+    return Qnil_;                                // unreachable
+}
+
+private VALUE dexitest_ensure_success(VALUE self)
+{
+    ensure_ran = 0;
+    VALUE r = rb_ensure(&safe_body, Qnil_, &ensure_proc, Qnil_);
+    return to_ruby_value(r == rb_int2inum(42) && ensure_ran == 1);
+}
+
+private VALUE dexitest_ensure_raise(VALUE self)
+{
+    ensure_ran = 0;
+    VALUE r = rb_ensure(&raising_body, Qnil_, &ensure_proc, Qnil_);
+    return to_ruby_value(false);                 // never reached
+}
+
+// does the ensure run even when the body raises? (call from Ruby rescue)
+private VALUE dexitest_ensure_raised_flag(VALUE self)
+{
+    return to_ruby_value(ensure_ran);
+}
+
+// ------------------------------------------------------------------
+// 6. rb_define_singleton_method — per-object method
+// ------------------------------------------------------------------
+
+private VALUE singleton_hi(VALUE self)
+{
+    return rb_str_new_cstr("hi from singleton");
+}
+
+private VALUE dexitest_make_singleton(VALUE self, VALUE obj)
+{
+    rb_define_singleton_method(obj, "dexitest_greet",
+                                cast(AnyMethod) &singleton_hi, 0);
+    return obj;
+}
+
+// ------------------------------------------------------------------
+// 7. rb_scan_args — the C-style argument scanner, argc/argv style
+// ------------------------------------------------------------------
+
+private VALUE dexitest_scan(int argc, const(VALUE)* argv, VALUE self)
+{
+    VALUE a = Qnil_, b = Qnil_, rest = Qnil_;
+    // "11*": one mandatory, one optional, splat the rest
+    int n = rb_scan_args(argc, argv, "11*", &a, &b, &rest);
+    VALUE res = rb_ary_new_capa(4);
+    rb_ary_push(res, rb_ll2inum(n));
+    rb_ary_push(res, a);
+    rb_ary_push(res, b);
+    rb_ary_push(res, rest);
+    return res;
+}
+
+// ------------------------------------------------------------------
+// 8. rb_thread_call_without_gvl — release the GVL for a pure-D nap
+//    (other Ruby threads keep running; result comes back through)
+// ------------------------------------------------------------------
+
+extern (C) void* nap(void* data)
+{
+    // busy-wait ~30ms without touching Ruby APIs
+    long spins = 30_000_000;
+    long acc = 0;
+    foreach (i; 0 .. spins)
+        acc += i % 7;
+    return cast(void*) acc;
+}
+
+extern (C) void ubf_abort(void* data) {}         // no cancellation support
+
+private VALUE dexitest_nogvl(VALUE self)
+{
+    void* r = rb_thread_call_without_gvl(&nap, null, &ubf_abort, null);
+    return rb_ll2inum(cast(long) r);
+}
+
+// same, but prove another Ruby thread ran *while* the GVL was released
+__gshared int tick_ran = 0;
+
+private VALUE dexitest_tick(VALUE self) { tick_ran = 1; return Qnil_; }
+
+private VALUE dexitest_nogvl_parallel(VALUE self)
+{
+    tick_ran = 0;
+    // Ruby-side caller spawns a thread that calls dexitest_tick; D naps
+    // without the GVL; then we check the flag. See test/exitest.rb.
+    void* r = rb_thread_call_without_gvl(&nap, null, &ubf_abort, null);
+    return to_ruby_value(tick_ran);
+}
+
+// ------------------------------------------------------------------
+// 9. variadic def! — D default arguments become Ruby optional args
+// ------------------------------------------------------------------
+
+long var_sum(long a, long b = 2, long c = 30)
+{
+    return a + b + c;
+}
+
+string var_greet(string name, string greeting = "hello", string punct = "!")
+{
+    return greeting ~ ", " ~ name ~ punct;
+}
+
+// mixed required/optional with raw VALUE passthrough (identity on the
+// VALUE, plus an optional second argument that defaults to 5)
+private Raw!VALUE var_raw(Raw!VALUE v, long n = 5)
+{
+    if (n == 5)
+        return v;                                // default path: identity
+    VALUE[1] av = [rb_ll2inum(n)];
+    return Raw!VALUE(rb_funcallv(v.value, rb_intern("*"), 1, av.ptr));
+}
+
+public:
+
+pragma(mangle, "Init_dexitest")
+extern (C) void Init_dexitest()
+{
+    VALUE mDExitTest = rb_define_module("DExitTest");
+
+    // def!'d, conversion-handled
+    def!("DExitTest", sum_to);
+    def!("DExitTest", pair_sums);
+
+    // raw extern(C) bodies registered directly (argc/argv or VALUE style)
+    rb_define_module_function(mDExitTest, "block_collect",
+                              cast(AnyMethod) &dexitest_block_collect, 1);
+    rb_define_module_function(mDExitTest, "div_rescue",
+                              cast(AnyMethod) &dexitest_div_rescue, 2);
+    rb_define_module_function(mDExitTest, "safe_rescue",
+                              cast(AnyMethod) &dexitest_safe_rescue, 0);
+    rb_define_module_function(mDExitTest, "ensure_success",
+                              cast(AnyMethod) &dexitest_ensure_success, 0);
+    rb_define_module_function(mDExitTest, "ensure_raises",
+                              cast(AnyMethod) &dexitest_ensure_raise, 0);
+    rb_define_module_function(mDExitTest, "ensure_raised_flag",
+                              cast(AnyMethod) &dexitest_ensure_raised_flag, 0);
+    rb_define_module_function(mDExitTest, "make_singleton",
+                              cast(AnyMethod) &dexitest_make_singleton, 1);
+    rb_define_module_function(mDExitTest, "scan",
+                              cast(AnyMethod) &dexitest_scan, -1);
+    rb_define_module_function(mDExitTest, "nogvl",
+                              cast(AnyMethod) &dexitest_nogvl, 0);
+    rb_define_module_function(mDExitTest, "nogvl_parallel",
+                              cast(AnyMethod) &dexitest_nogvl_parallel, 0);
+    rb_define_module_function(mDExitTest, "tick",
+                              cast(AnyMethod) &dexitest_tick, 0);
+
+    // variadic def! — optional args via D default values
+    def!("DExitTest", var_sum);
+    def!("DExitTest", var_greet);
+    def!("DExitTest", var_raw);
+
+    // root the block_call sink
+    block_call_sink = rb_ary_new();
+    rb_gc_register_address(&block_call_sink);
+}

data/src/dextest.d

@@ -0,0 +1,119 @@
+/// dextest — revival of RuDy's old "dexter" playground, now the acceptance
+/// test for rudy-d. Exercises def!, to_ruby_value and d_type with real
+/// type conversions, plus a couple of raw C API calls.
+
+module dextest;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.defs;
+
+// ---------------------------------------------------------------------
+// Raw C API class — dexter-style, no conversion sugar.
+// ---------------------------------------------------------------------
+
+extern(C) VALUE dextest_return_ten(VALUE self)
+{
+    return rb_int2inum(10);
+}
+
+extern(C) VALUE dextest_initialize(VALUE self)
+{
+    rb_iv_set(self, "@arr", rb_ary_new());
+    return self;
+}
+
+extern(C) VALUE dextest_arr(VALUE self)
+{
+    return rb_iv_get(self, "@arr");
+}
+
+extern(C) VALUE dextest_add(VALUE self, VALUE obj)
+{
+    VALUE arr = rb_iv_get(self, "@arr");
+    rb_ary_push(arr, obj);
+    return arr;
+}
+
+extern(C) VALUE dextest_native_add(VALUE self, VALUE obj)
+{
+    VALUE arr = rb_iv_get(self, "@arr");
+    VALUE val = rb_num2long(obj);
+    rb_ary_push(arr, rb_ll2inum(val + 1));
+    return arr;
+}
+
+extern(C) VALUE dextest_add_strings_first_letter(VALUE self, VALUE obj)
+{
+    VALUE str = rb_str_to_str(obj);
+    VALUE letter = rb_str_new(rb_string_value_ptr(&str), 1);
+    VALUE arr = rb_iv_get(self, "@arr");
+    rb_ary_push(arr, letter);
+    return letter;
+}
+
+// ---------------------------------------------------------------------
+// def!'d functions — module scope so trampolines get real pointers.
+// ---------------------------------------------------------------------
+
+int the_new_fifteen()            { return 15; }
+
+long convert_integer_two_ways(long n)    { return n; }
+double convert_float_two_ways(double f)  { return f; }
+string convert_string_two_ways(string s) { return s; }
+bool convert_bool_two_ways(bool b)       { return b; }
+
+long add_five(long n) { return n + 5; }
+
+// issue #1 regression: ulong params used to receive TAGGED VALUEs (5 -> 11)
+ulong double_it_ulong(ulong n) { return n * 2; }
+ulong identity_ulong(ulong n)  { return n; }
+
+// opt-in raw VALUE passthrough: the function sees the tagged bits untouched
+Raw!VALUE raw_value_id(Raw!VALUE v) { return v; }
+
+string greet(string name, int n)
+{
+    import std.conv;
+    return "hi " ~ name ~ " " ~ n.to!string;
+}
+
+pragma(mangle, "Init_dextest")
+extern(C) void Init_dextest()
+{
+    // ---- plain C API class ------------------------------------------
+
+    VALUE DexterClass = rb_define_class("DexterClass", rb_cObject);
+
+    rb_define_method(DexterClass, "return_ten",
+                     cast(AnyMethod) &dextest_return_ten, 0);
+    rb_define_method(DexterClass, "initialize",
+                     cast(AnyMethod) &dextest_initialize, 0);
+    rb_define_method(DexterClass, "arr",
+                     cast(AnyMethod) &dextest_arr, 0);
+    rb_define_method(DexterClass, "add",
+                     cast(AnyMethod) &dextest_add, 1);
+    rb_define_method(DexterClass, "native_add",
+                     cast(AnyMethod) &dextest_native_add, 1);
+    rb_define_method(DexterClass, "add_strings_first_letter",
+                     cast(AnyMethod) &dextest_add_strings_first_letter, 1);
+
+    // ---- def! with automatic conversions ----------------------------
+
+    // global (Object level)
+    def!(the_new_fifteen);
+    def!(convert_integer_two_ways);
+    def!(convert_float_two_ways);
+    def!(convert_string_two_ways);
+    def!(convert_bool_two_ways);
+    def!(add_five);
+
+    // issue #1 regression tests
+    def!(double_it_ulong);
+    def!(identity_ulong);
+    def!(raw_value_id);
+
+    // module function
+    VALUE DexterModule = rb_define_module("DexterModule");
+    def!("DexterModule", greet);
+}

data/src/dtypetest.d

@@ -0,0 +1,159 @@
+/// dtypetest — acceptance-test extension for rudy.typeddata.
+///
+/// Same Matrix as exp_wrap, but wrapped with the TypedData API instead of
+/// rb_data_object_wrap + D-side registry: rb_data_typed_object_wrap provides
+/// the descriptor, rb_check_typeddata does the unwrap with type checking.
+/// Exercises: alloc func, initialize, get/set, det, to_a, GC stress,
+/// TypeError on wrong-type unwrap.
+
+module dtypetest;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+import core.stdc.stdlib : calloc, malloc, free;
+import core.memory : GC;
+
+private:
+
+struct Matrix
+{
+    size_t rows, cols;
+    double* data;   // malloc'd; freed by dfree (rudy_typed_free frees the
+                    // struct itself; data is freed here by matrix_dfree)
+
+    ref double at(size_t r, size_t c) { return data[r * cols + c]; }
+}
+
+// dfree must free data first, then the struct — custom free callback.
+extern (C) void matrix_dfree(void* p)
+{
+    auto m = cast(Matrix*) p;
+    if (m)
+    {
+        if (m.data) free(m.data);
+        free(m);
+    }
+}
+
+mixin RudyTypedData!(Matrix, "matrix");
+
+// ---------------------------------------------------------------- methods
+
+extern (C) VALUE dtypetest_alloc(VALUE klass)
+{
+    auto m = cast(Matrix*) calloc(1, Matrix.sizeof);
+    return matrix_wrap(klass, m);
+}
+
+extern (C) VALUE dtm_initialize(VALUE self, VALUE r, VALUE c)
+{
+    Matrix* m = matrix_get(self);
+    m.rows = cast(size_t) d_type!long(r);
+    m.cols = cast(size_t) d_type!long(c);
+    m.data = cast(double*) calloc(Matrix.sizeof, m.rows * m.cols);
+    return self;
+}
+
+extern (C) VALUE dtm_get(VALUE self, VALUE r, VALUE c)
+{
+    Matrix* m = matrix_get(self);
+    return to_ruby_value(m.at(d_type!long(r), d_type!long(c)));
+}
+
+extern (C) VALUE dtm_set(VALUE self, VALUE r, VALUE c, VALUE v)
+{
+    Matrix* m = matrix_get(self);
+    m.at(d_type!long(r), d_type!long(c)) = d_type!double(v);
+    return v;
+}
+
+double det_rec(Matrix* m)
+{
+    if (m.rows == 1) return m.at(0, 0);
+    if (m.rows == 2)
+        return m.at(0, 0) * m.at(1, 1) - m.at(0, 1) * m.at(1, 0);
+    double det = 0.0;   // NB: bare `double det;` is NaN in D!
+    foreach (j; 0 .. m.cols)
+    {
+        Matrix minor;
+        minor.rows = m.rows - 1;
+        minor.cols = m.cols - 1;
+        minor.data = cast(double*) malloc(double.sizeof * minor.rows * minor.cols);
+        scope (exit) free(minor.data);
+        foreach (ri; 0 .. minor.rows)
+            foreach (ci; 0 .. minor.cols)
+                minor.at(ri, ci) = m.at(ri + 1, ci < j ? ci : ci + 1);
+        double sign = (j % 2) ? -1.0 : 1.0;
+        det += sign * m.at(0, j) * det_rec(&minor);
+    }
+    return det;
+}
+
+extern (C) VALUE dtm_det(VALUE self)
+{
+    Matrix* m = matrix_get(self);
+    return to_ruby_value(det_rec(m));
+}
+
+extern (C) VALUE dtm_to_a(VALUE self)
+{
+    Matrix* m = matrix_get(self);
+    VALUE outer = rb_ary_new_capa(cast(C_long) m.rows);
+    foreach (r; 0 .. m.rows)
+    {
+        VALUE row = rb_ary_new_capa(cast(C_long) m.cols);
+        foreach (c; 0 .. m.cols)
+            rb_ary_push(row, to_ruby_value(m.at(r, c)));
+        rb_ary_push(outer, row);
+    }
+    return outer;
+}
+
+// stress: allocate & drop 100_000 typed wrappers; matrix_dfree must run
+extern (C) VALUE dtm_stress(VALUE self, VALUE n)
+{
+    foreach (i; 0 .. d_type!long(n))
+    {
+        auto m = cast(Matrix*) calloc(1, Matrix.sizeof);
+        m.rows = m.cols = 4;
+        m.data = cast(double*) malloc(double.sizeof * 16);
+        VALUE obj = matrix_wrap(dmatrix_klass, m);
+        rb_ary_store(dtypetest_keep, 0, obj); // keep only last
+    }
+    GC.collect;
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("GC"));
+    rb_funcallv(mod, rb_intern("start"), 0, null);
+    return Qnil_;
+}
+
+// class-level helper: unwrap another object (used to test TypeError)
+extern (C) VALUE dtm_unwrap_other(VALUE self, VALUE obj)
+{
+    Matrix* m = matrix_get(obj);   // raises TypeError if obj isn't ours
+    return to_ruby_value(cast(long) (m.rows * m.cols));
+}
+
+private __gshared VALUE dmatrix_klass;
+private __gshared VALUE dtypetest_keep;
+
+public:
+
+pragma(mangle, "Init_dtypetest")
+extern (C) void Init_dtypetest()
+{
+    VALUE cDTypeMatrix = rb_define_class("DTypeMatrix", rb_cObject);
+    rb_define_alloc_func(cDTypeMatrix, &dtypetest_alloc);
+    rb_define_method(cDTypeMatrix, "initialize", cast(AnyMethod) &dtm_initialize, 2);
+    rb_define_method(cDTypeMatrix, "[]",         cast(AnyMethod) &dtm_get, 2);
+    rb_define_method(cDTypeMatrix, "[]=",         cast(AnyMethod) &dtm_set, 3);
+    rb_define_method(cDTypeMatrix, "det",         cast(AnyMethod) &dtm_det, 0);
+    rb_define_method(cDTypeMatrix, "to_a",        cast(AnyMethod) &dtm_to_a, 0);
+    rb_define_method(cDTypeMatrix, "stress",     cast(AnyMethod) &dtm_stress, 1);
+    rb_define_method(cDTypeMatrix, "unwrap_other",cast(AnyMethod) &dtm_unwrap_other, 1);
+    dmatrix_klass = cDTypeMatrix;
+    dtypetest_keep = rb_ary_new();
+    rb_gc_register_address(&dtypetest_keep);
+    VALUE m = rb_define_module("DTypeTest");
+    rb_define_const(m, "SIZEOF", to_ruby_value(Matrix.sizeof));
+}