rudy4 0.2.0

data/experiments/exp_convert.d

@@ -0,0 +1,93 @@
+/// exp_convert — torture the D↔Ruby conversion layer (rudy/convert.d).
+///
+/// Round-trip property: for every supported type, D→Ruby→D must be
+/// lossless even under adversarial values: long.min, NaN/±0.0/inf,
+/// empty/NUL/binary strings (EUC-JP, non-UTF-8 bytes), frozen strings,
+/// truthiness edge cases, and GC pressure mid-conversion.
+/// Each extern(C) function is registered by test_exp_convert.rb and
+/// driven from Ruby with hostile inputs.
+
+module exp_convert;
+
+import rudy.bind.value;
+import rudy.convert;
+import core.runtime : rt_init;
+import core.memory : GC;
+
+private:
+
+// ---------------------------------------------------------------- round-trip identities
+// Registered directly via rb_define_method: Ruby->D via d_type!T,
+// return D->Ruby via to_ruby_value. Exactly the path def! uses.
+
+extern (C) VALUE conv_long(VALUE self, VALUE v)   { return to_ruby_value(d_type!long(v)); }
+extern (C) VALUE conv_ulong(VALUE self, VALUE v)  { return to_ruby_value(d_type!ulong(v)); }
+extern (C) VALUE conv_int(VALUE self, VALUE v)    { return to_ruby_value(d_type!int(v)); }
+extern (C) VALUE conv_uint(VALUE self, VALUE v)   { return to_ruby_value(d_type!uint(v)); }
+extern (C) VALUE conv_double(VALUE self, VALUE v) { return to_ruby_value(d_type!double(v)); }
+extern (C) VALUE conv_string(VALUE self, VALUE v) { return to_ruby_value(d_type!string(v)); }
+extern (C) VALUE conv_bool(VALUE self, VALUE v)   { return to_ruby_value(d_type!bool(v)); }
+
+// ---------------------------------------------------------------- strings: byte-length probe
+// d_type!string must decode ANY String — empty, NUL-laden, binary,
+// non-UTF-8 — without throwing D-side, and preserve the byte count
+// exactly (finding #12: rb_str_strlen chars-vs-bytes truncation).
+// Non-String inputs raise Ruby-side (rb_str_to_str TypeError).
+
+extern (C) VALUE conv_string_bytesize(VALUE self, VALUE v)
+{
+    auto s = d_type!string(v);        // binary-safe: copies raw bytes
+    return to_ruby_value(s.length);   // byte length of the D copy
+}
+
+// Same probe with a GC.collect() parked between decode and re-encode:
+// the D-side copy must not be the only thing keeping Ruby-side state
+// sane, and the Ruby input String must not be resurrectable-but-stale.
+extern (C) VALUE conv_string_stress(VALUE self, VALUE v)
+{
+    auto s = d_type!string(v);
+    GC.collect();
+    return to_ruby_value(s);
+}
+
+// ---------------------------------------------------------------- symbols: reject, not corrupt
+// There is no symbol branch in d_type!string — it is a compile-time
+// static assert in the library. What must hold at runtime: passing a
+// Symbol raises Ruby-side (rb_str_to_str: TypeError), and Ruby's own
+// symbol<->string traffic through D stays byte-perfect.
+
+extern (C) VALUE conv_sym_to_s(VALUE self, VALUE sym)
+{
+    // rb_sym2str is exported but not bound; ask Ruby instead
+    return rb_funcallv_public(sym, rb_intern("to_s"), 0, null);
+}
+
+extern (C) VALUE conv_sym_roundtrip(VALUE self, VALUE str)
+{
+    // String -> Symbol -> String, all via rb_funcallv_public
+    VALUE sym = rb_funcallv_public(str, rb_intern("to_sym"), 0, null);
+    return rb_funcallv_public(sym, rb_intern("to_s"), 0, null);
+}
+
+// ---------------------------------------------------------------- Init
+
+public:
+
+pragma(mangle, "Init_exp_convert")
+extern (C) void Init_exp_convert()
+{
+    rt_init();   // dlopen'd .so: D runtime init is our job (finding #9)
+
+    VALUE m = rb_define_module("ConvertProbe");
+    rb_define_module_function(m, "long",   cast(AnyMethod) &conv_long,   1);
+    rb_define_module_function(m, "ulong",  cast(AnyMethod) &conv_ulong,  1);
+    rb_define_module_function(m, "int",    cast(AnyMethod) &conv_int,    1);
+    rb_define_module_function(m, "uint",   cast(AnyMethod) &conv_uint,   1);
+    rb_define_module_function(m, "double", cast(AnyMethod) &conv_double, 1);
+    rb_define_module_function(m, "string", cast(AnyMethod) &conv_string, 1);
+    rb_define_module_function(m, "bool",   cast(AnyMethod) &conv_bool,   1);
+    rb_define_module_function(m, "string_bytesize", cast(AnyMethod) &conv_string_bytesize, 1);
+    rb_define_module_function(m, "string_stress",   cast(AnyMethod) &conv_string_stress,   1);
+    rb_define_module_function(m, "sym_to_s",        cast(AnyMethod) &conv_sym_to_s,        1);
+    rb_define_module_function(m, "sym_roundtrip",   cast(AnyMethod) &conv_sym_roundtrip,   1);
+}

data/experiments/exp_cross.d

@@ -0,0 +1,144 @@
+/// EXPERIMENT 2 — Two-way boundary crossing in a single call.
+///
+/// Torture elements:
+/// - D calls *back into Ruby* (rb_funcallv) mid-computation (sort block,
+///   custom to_s)
+/// - rb_protect around Ruby callbacks that raise
+/// - nested data structures built in D, consumed in Ruby
+/// - variadic-shape method (argc/argv) via a variadic D function passed
+///   to rb_define_method with arity -1 — uses raw C varargs shim
+///
+/// We have to hand-roll the varargs trampoline (D variadic != C varargs),
+/// so this also tests how far we can get without library support for
+/// variable arity.
+
+module exp_cross;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.defs;
+import std.string : toStringz;
+
+private:
+
+// ---- D calls a Ruby block for comparison ------------------------------
+// (block invocation happens via rb_funcallv on a registered Proc in
+// cross_sort_protected; kept for reference)
+
+alias VALUE function(VALUE, VALUE) BlockFn;
+
+extern (C) VALUE cross_sort_protected(VALUE data)
+{
+    // data is the ExpCross module; @ary and @blk are set from Ruby
+    VALUE ary = rb_iv_get(data, "@ary");
+    VALUE blk = rb_iv_get(data, "@blk");
+    // sort takes a BLOCK, not a positional arg: rb_funcallv(sort, 1, blk)
+    // raises ArgumentError. rb_funcall_with_block passes blk as the block.
+    return rb_funcall_with_block(ary, rb_intern("sort"), 0, null, blk);
+}
+
+extern (C) VALUE cross_sort(VALUE self)
+{
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("ExpCross"));
+    int state;
+    VALUE res = rb_protect(&cross_sort_protected, mod, &state);
+    if (state)
+    {
+        rudy_raise(rb_eRuntimeError, "Ruby block raised inside D sort");
+        return Qnil_;
+    }
+    return res;
+}
+
+// register_block(holder) — remember block holder for later cross_sort
+extern (C) VALUE cross_register(VALUE self, VALUE blk)
+{
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("ExpCross"));
+    rb_iv_set(mod, "@blk", blk);
+    return blk;
+}
+
+// register_ary(ary) — the array cross_sort will sort
+extern (C) VALUE cross_register_ary(VALUE self, VALUE ary)
+{
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("ExpCross"));
+    rb_iv_set(mod, "@ary", ary);
+    return ary;
+}
+
+// ---- nested structure built in D, deep-equal from Ruby -----------------
+
+struct Point { double x, y; }
+
+Point[] polygon = [ Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1) ];
+
+// Sum via a Ruby-supplied callable (Proc): fold(map)
+extern (C) VALUE cross_polygon_area(VALUE self)
+{
+    // call Ruby: points.inject(0) { |acc, (x, y)| acc + x*y } — do it via
+    // eval'd literal from D to prove full eval round-trip works
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("ExpCross"));
+    VALUE pts = rb_iv_get(mod, "@pts");
+    if (pts == Qnil_)
+    {
+        // build [[x, y], ...] in D
+        pts = rb_ary_new_capa(cast(C_long) polygon.length);
+        foreach (ref p; polygon)
+        {
+            VALUE pair = rb_ary_new_capa(2);
+            rb_ary_push(pair, to_ruby_value(p.x));
+            rb_ary_push(pair, to_ruby_value(p.y));
+            rb_ary_push(pts, pair);
+        }
+        rb_iv_set(mod, "@pts", pts);
+    }
+    // eval inside module context so the bare `pts` local resolves — use a
+    // funcall on the module instead (eval with binding is not bound here)
+    VALUE[1] av = [pts];
+    VALUE code = rb_funcallv(mod, rb_intern("shoelace"), 1, av.ptr);
+    return code;
+}
+
+// ---- variable arity: sum any number of arguments ----------------------
+// D can't receive C varargs directly; use a fixed max and forward.
+
+extern (C) VALUE cross_sum(VALUE self, VALUE a1, VALUE a2, VALUE a3)
+{
+    // registered with fixed arity 3; Ruby fills unsupplied slots with
+    // Qnil_ only when arity is negative. With fixed arity this method
+    // requires exactly 3 args — see experiments/NOTES.md: variable arity
+    // needs an argc/argv trampoline that rudy does not yet generate.
+    VALUE[3] av = [a1, a2, a3];
+    double total = 0.0; // bare `double total;` is NaN in D!
+    foreach (v; av)
+        total += d_type!double(v);
+    return to_ruby_value(total);
+}
+
+// ---- raise from deep inside D recursion -------------------------------
+
+extern (C) VALUE cross_raise(VALUE self, VALUE depth)
+{
+    return to_ruby_value(cross_raise_rec(d_type!long(depth)));
+}
+
+long cross_raise_rec(long d)
+{
+    if (d == 0)
+        rudy_raise(rb_eRangeError, "bottom reached, D unwinds");
+    return cross_raise_rec(d - 1) + 1;
+}
+
+public:
+
+pragma(mangle, "Init_exp_cross")
+extern (C) void Init_exp_cross()
+{
+    VALUE m = rb_define_module("ExpCross");
+    rb_define_module_function(m, "sort_with_block!", cast(AnyMethod) &cross_sort, 0);
+    rb_define_module_function(m, "register_block",  cast(AnyMethod) &cross_register, 1);
+    rb_define_module_function(m, "register_ary",   cast(AnyMethod) &cross_register_ary, 1);
+    rb_define_module_function(m, "polygon_area",   cast(AnyMethod) &cross_polygon_area, 0);
+    rb_define_module_function(m, "sum3",           cast(AnyMethod) &cross_sum, 3);
+    rb_define_module_function(m, "raise_from_deep", cast(AnyMethod) &cross_raise, 1);
+}

data/experiments/exp_defargs.d

@@ -0,0 +1,301 @@
+/// exp_defargs — torture the def! argument-passing extensions (backlog
+/// item 5): block parameters, *rest, **kwargs, receiver Self, visibility
+/// variants (private/protected), and singleton methods.
+///
+/// Every function here is registered by Init_exp_defargs via the
+/// def!/def_private/def_protected/def_singleton interface itself — the
+/// point is to exercise the generated trampolines, not hand-written
+/// extern(C) shims.
+///
+/// Torture elements:
+/// - RubyBlock: call with 0..3 args, given/!given, arity, LocalJumpError
+///   on block-less call, block raising through the D frame, blocks
+///   calling BACK into other def!'d D methods (reentrancy).
+/// - Rest: empty rest, mixed required+rest, hostile values (bignums,
+///   frozen strings), to!T conversion, foreach via opApply, opIndex.
+/// - KwArgs: given/!given, get!T with D defaults, symbol+string key
+///   probing, to!(V,K) walk (symbol keys normalized via to_s),
+///   unknown keys ignored.
+/// - Self: receiver class/identity — module_function self == module,
+///   singleton self == the class object / the named constant.
+/// - Visibility: def_private callable via send() but not directly;
+///   def_protected callable only from inside the class hierarchy.
+/// - Combined layouts: optional+block, rest+block, Raw positional+block.
+///
+/// Layout:
+///   DDefArgs.each_twice(n)         -> yields i*2 for i in 0...n
+///   DDefArgs.map_twice(n)          -> block-mapped array
+///   DDefArgs.block_optional(a, b)  -> block only when given
+///   DDefArgs.raise_walk(n)         -> block raises mid-walk; scope(exit)
+///   DDefArgs.raise_walk_last       -> scope(exit) ran?
+///   DDefArgs.block_arity(blk)      -> Proc#arity passthrough
+///   DDefArgs.rest_sum(first, ...)  -> required + *rest
+///   DDefArgs.rest_join(first, ...) -> rest to!string[] join
+///   DDefArgs.rest_first(...)      -> opIndex into hostile values
+///   DDefArgs.rest_count(...)       -> rest.length
+///   DDefArgs.kw_pick(**kw)         -> get!T with defaults
+///   DDefArgs.kw_all(**kw)          -> to!(V,K) walk (Raw!VALUE out)
+///   DDefArgs.self_class            -> receiver's class name
+///   DDefArgs::TARGET.self_is_const -> singleton_on receiver identity
+///   DDefArgs.hidden_times_two      -> def_private
+///   DDefArgs.shielded_times_three  -> def_protected
+///   DDefArgs.opt_block(a, b=10, blk)     -> optional + block
+///   DDefArgs.rest_block(first, rest, blk)-> rest + block
+///   DDefArgs.raw_block(v, n, blk)        -> Raw + block
+///   DDefArgs.klass_factory(x)      -> def_singleton (class-level)
+///   DDefArgs::COUNTER.bump(by)     -> def_singleton_on (per-object)
+
+module exp_defargs;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.args;
+import rudy.defs;
+
+private:
+
+// lazily-interned to_s (args.d's copy is private to that module)
+private __gshared ID exp_id_to_s;
+private ID id_to_s() { if (!exp_id_to_s) exp_id_to_s = rb_intern("to_s"); return exp_id_to_s; }
+
+// ------------------------------------------------------------------ blocks
+
+// yield i*2 for i in 0...n; returns the block's last value (like times)
+long each_twice(long n, RubyBlock blk)
+{
+    if (!blk.given)
+        rb_raise(rb_eArgError, "block required");
+    VALUE last = Qnil_;
+    foreach (i; 0 .. n)
+    {
+        VALUE[1] av = [rb_ll2inum(i * 2)];
+        last = blk.call(av[0]);
+    }
+    return d_type!long(last);
+}
+
+// map: collect block results into a Ruby array. NB: returns Raw!VALUE —
+// a plain VALUE return value goes through to_ruby_value, which converts
+// it as a machine word (finding #17), not as the object.
+Raw!VALUE map_twice(long n, RubyBlock blk)
+{
+    if (!blk.given)
+        rb_raise(rb_eArgError, "block required");
+    VALUE outv = rb_ary_new();
+    foreach (i; 0 .. n)
+    {
+        VALUE[1] av = [rb_ll2inum(i)];
+        rb_ary_push(outv, blk.call(av[0]));
+    }
+    return Raw!VALUE(outv);
+}
+
+// block optional: different result with and without a block
+string block_optional(long a, long b)
+{
+    import std.conv : to;
+    if (b == 10)
+        return "b-was-default";
+    return "b=" ~ to!string(b);
+}
+
+// block raising through the D frame: the block raises, the longjmp
+// unwinds the D frames; raise_walk_last must show the scope(exit)
+// counter incremented (D cleanup ran despite the Ruby-side raise)
+__gshared long raise_walk_count = 0;
+
+long raise_walk(long n, RubyBlock blk)
+{
+    scope (exit) raise_walk_count++;
+    foreach (i; 0 .. n)
+    {
+        VALUE[1] av = [rb_ll2inum(i)];
+        blk.call(av[0]);                       // raises when i == 2
+    }
+    return n;
+}
+
+long raise_walk_last() { return raise_walk_count; }
+
+// block arity passthrough (Proc#arity of the caller's block)
+long block_arity(RubyBlock blk)
+{
+    return blk.arity;
+}
+
+// ------------------------------------------------------------------ rest
+
+long rest_sum(long first, Rest rest)
+{
+    long total = first;
+    foreach (v; rest)                          // opApply
+        total += d_type!long(v);
+    return total;
+}
+
+string rest_join(string first, Rest rest)
+{
+    string s = first;
+    foreach (v; rest)
+        s ~= "," ~ d_type!string(v);
+    return s;
+}
+
+// first rest value decoded via opIndex (hostile values: near-long-max
+// fixnums; real bignums raise RangeError — see test)
+long rest_first(Rest rest)
+{
+    if (rest.empty)
+        return -1;
+    return d_type!long(rest[0]);               // opIndex
+}
+
+long rest_count(Rest rest)
+{
+    return cast(long) rest.length;
+}
+
+// ------------------------------------------------------------------ kwargs
+
+// kw.get!T with D defaults; compact fingerprint of what was seen
+string kw_pick(KwArgs kw)
+{
+    import std.conv : to;
+    long n = kw.get!long("n", 0);
+    string sep = kw.get!string("sep", "-");
+    bool flag = kw.get!bool("flag", false);
+    return "n=" ~ to!string(n) ~ " sep=" ~ sep ~ " flag=" ~ (flag ? "y" : "n");
+}
+
+// every key => value as flat "key=value" array (symbol AND string keys
+// both surface; symbol keys are normalized via to_s inside KwArgs.to!).
+// Values go through Ruby to_s (Object#to_s fallback) so any value type
+// fingerprints — the D-side AA is V=string, and d_type!string of a
+// non-String VALUE would raise.
+Raw!VALUE kw_all(KwArgs kw)
+{
+    import std.conv : to;
+    VALUE outv = rb_ary_new();
+    // to!(Raw!VALUE, string): keys normalized to D strings (symbol->to_s
+    // inside KwArgs.to!), values stay raw VALUEs. NB: plain VALUE as V
+    // would route values through d_type!ulong — rudy_check_unsigned
+    // probes via rb_num2dbl and a String value dies with "no implicit
+    // conversion to float from string". Raw!VALUE is the raw escape.
+    foreach (key, val; kw.to!(Raw!VALUE, string))
+    {
+        VALUE vs = rb_funcallv(val.value, id_to_s(), 0, null);
+        rb_ary_push(outv, to_ruby_value(key ~ "=" ~ d_type!string(vs)));
+    }
+    return Raw!VALUE(outv);
+}
+
+// kwargs given vs not: block-less style contract
+string kw_given_p(KwArgs kw)
+{
+    return kw.given ? "given" : "none";
+}
+
+// ------------------------------------------------------------------ self
+
+// class name of the receiver — module_function self is the module itself
+string self_class(Self self)
+{
+    return d_type!string(rb_funcallv(
+        rb_funcallv(self.value, rb_intern("class"), 0, null),
+        rb_intern("to_s"), 0, null));
+}
+
+// identity: receiver == the TARGET constant object? (def_singleton_on)
+bool self_is_const(Self self, Raw!VALUE c)
+{
+    return self.value == c.value;
+}
+
+// ------------------------------------------------------------------ visibility
+
+private long hidden_times_two(long n) { return n * 2; }
+private long shielded_times_three(long n) { return n * 3; }
+
+// ------------------------------------------------------------------ combined layouts
+
+// optional args + block: block only when given
+string opt_block(long a, long b = 10, RubyBlock blk)
+{
+    import std.conv : to;
+    if (!blk.given)
+        return "plain:" ~ to!string(a + b);
+    VALUE[1] av = [rb_ll2inum(a + b)];
+    return d_type!string(blk.call(av[0]));
+}
+
+// rest + block: block adds a bonus to the rest total
+long rest_block(long first, Rest rest, RubyBlock blk)
+{
+    long total = first;
+    foreach (v; rest)
+        total += d_type!long(v);
+    if (blk.given)
+    {
+        VALUE[1] av = [rb_ll2inum(total)];
+        total += d_type!long(blk.call(av[0]));
+    }
+    return total;
+}
+
+// raw positional + block
+Raw!VALUE raw_block(Raw!VALUE v, long n, RubyBlock blk)
+{
+    if (!blk.given)
+        return v;
+    VALUE[1] av = [rb_ll2inum(n)];
+    return Raw!VALUE(blk.callv(1, av.ptr));    // block transforms the value
+}
+
+// ------------------------------------------------------------------ singletons
+
+long klass_factory(long x) { return x * 7; }
+
+__gshared long counter_state = 0;
+long counter_bump(long by) { counter_state += by; return counter_state; }
+
+// ------------------------------------------------------------------ registration
+
+pragma(mangle, "Init_exp_defargs")
+extern (C) void Init_exp_defargs()
+{
+    VALUE m = rb_define_module("DDefArgs");
+
+    // constants BEFORE the singleton_on registrations: rb_const_get at
+    // def! time needs the target objects to exist already
+    rb_define_const(m, "TARGET", rb_str_new("target-obj", 10));
+    rb_define_const(m, "COUNTER", rb_str_new("counter-obj", 11));
+
+    def!("DDefArgs", each_twice);
+    def!("DDefArgs", map_twice);
+    def!("DDefArgs", block_optional);
+    def!("DDefArgs", raise_walk);
+    def!("DDefArgs", raise_walk_last);
+    def!("DDefArgs", block_arity);
+
+    def!("DDefArgs", rest_sum);
+    def!("DDefArgs", rest_join);
+    def!("DDefArgs", rest_first);
+    def!("DDefArgs", rest_count);
+
+    def!("DDefArgs", kw_pick);
+    def!("DDefArgs", kw_all);
+    def!("DDefArgs", kw_given_p);
+
+    def!("DDefArgs", self_class);              // module_function: self == module
+    def_singleton_on!("DDefArgs::TARGET", self_is_const);
+
+    def_private!("DDefArgs", hidden_times_two);
+    def_protected!("DDefArgs", shielded_times_three);
+
+    def!("DDefArgs", opt_block);
+    def!("DDefArgs", rest_block);
+    def!("DDefArgs", raw_block);
+
+    def_singleton!("DDefArgs", klass_factory); // class-level on the module object
+    def_singleton_on!("DDefArgs::COUNTER", counter_bump, "bump");
+}