galaaz 0.5.0 → 2.0.0

data/new_bridge_specs/phase3_callbacks_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Phase 3: R -> Ruby callbacks via CALL/RET.
+# Run: bundle exec rspec specs/new_bridge/phase3_callbacks_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 3 (CALL/RET callbacks)' do
+  let(:phase1_cpp) { File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__) }
+  let(:instance_id) { 'instance-a' }
+
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @client = NewBridge::SessionClient.new(source_path: cpp)
+    @client.start
+  end
+
+  after(:all) do
+    @client&.stop
+  end
+
+  def with_client(instance_id: 'instance-a')
+    yield @client, instance_id
+  end
+
+  it 'callback ping: Ruby callback returns a scalar' do
+    with_client(instance_id: instance_id) do |c, iid|
+      cb_call_id = c.register_callback do |payload|
+        payload.to_i + 1
+      end
+
+      out = c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', '41', 500)",
+                      session_id: 'sess-a', instance_id: iid)
+
+      expect(out['kind']).to eq('double')
+      expect(out['value']).to eq(42)
+    end
+  end
+
+  it 'callback error propagation: Ruby callback raises' do
+    with_client(instance_id: instance_id) do |c, iid|
+      cb_call_id = c.register_callback do |_payload|
+        raise 'boom'
+      end
+
+      expect do
+        c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', '0', 500)",
+                 session_id: 'sess-a', instance_id: iid)
+      end.to raise_error(NewBridge::SessionClient::RProcessError, /boom|evaluation error/)
+    end
+  end
+
+  it 'callback timeout: Ruby callback does not respond in time' do
+    with_client(instance_id: instance_id) do |c, iid|
+      cb_call_id = c.register_callback do |_payload|
+        sleep 0.2
+        999
+      end
+
+      expect do
+        c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', '0', 50)",
+                 session_id: 'sess-a', instance_id: iid, timeout: 2)
+      end.to raise_error(NewBridge::SessionClient::RProcessError, /evaluation error|timeout/)
+    end
+  end
+end
+

data/new_bridge_specs/phase4_2_hardening_spec.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+# Phase 4.2: hardening coverage (edge cases + stress) on current bridge API.
+# Run: bundle exec rspec specs/new_bridge/phase4_2_hardening_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 4.2 (Hardening Coverage)' do
+  let(:phase1_cpp) { File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__) }
+
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @client = NewBridge::SessionClient.new(source_path: cpp)
+    @client.start
+  end
+
+  after(:all) do
+    @client&.stop
+  end
+
+  describe 'edge cases: envelope + eval error paths' do
+    it 'rejects msgpack payload that is not a map' do
+      bytes = MessagePack.pack(['not', 'a', 'map'])
+      expect do
+        NewBridge::Envelope.decode(bytes)
+      end.to raise_error(NewBridge::Envelope::Error, /expected a map/)
+    end
+
+    it 'rejects malformed envelope bytes' do
+      expect do
+        NewBridge::Envelope.decode("\x81\xA4type".b)
+      end.to raise_error(NewBridge::Envelope::Error)
+    end
+
+    it 'rejects envelope with unknown keys on encode' do
+      expect do
+        NewBridge::Envelope.encode(
+          'call_id' => 'abc',
+          'type' => 'REQ',
+          'bogus' => 'x'
+        )
+      end.to raise_error(NewBridge::Envelope::InvalidEnvelope, /unknown keys/)
+    end
+
+    it 'rejects empty envelope bytes' do
+      expect do
+        NewBridge::Envelope.decode(''.b)
+      end.to raise_error(NewBridge::Envelope::InvalidEnvelope, /empty envelope/)
+    end
+
+    it 'raises on invalid R syntax' do
+      expect do
+        @client.eval_r('x <-')
+      end.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+
+    it 'raises on empty R code payload' do
+      expect do
+        @client.eval_r('')
+      end.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+
+    it 'returns nil JSON value for NA integer scalar' do
+      out = @client.eval_r('as.integer(NA)')
+      expect(out['kind']).to eq('integer')
+      expect(out['value']).to be_nil
+    end
+
+    it 'returns nil JSON value for NA logical scalar' do
+      out = @client.eval_r('as.logical(NA)')
+      expect(out['kind']).to eq('logical')
+      expect(out['value']).to be_nil
+    end
+
+    it 'returns nil JSON value for NA double scalar' do
+      out = @client.eval_r('as.numeric(NA)')
+      expect(out['kind']).to eq('double')
+      expect(out['value']).to be_nil
+    end
+
+    it 'raises on non scalar results' do
+      expect do
+        @client.eval_r('1:3')
+      end.to raise_error(NewBridge::SessionClient::RProcessError, /length-1 scalar/)
+    end
+
+    it 'handles very short timeout from Ruby side' do
+      expect do
+        @client.eval_r('Sys.sleep(0.2); 1L', timeout: 0.05)
+      end.to raise_error(NewBridge::SessionClient::TimeoutError)
+    end
+  end
+
+  describe 'concurrency and stress on one instance' do
+    it 'handles 50 concurrent requests with unique sessions' do
+      threads = 50.times.map do |i|
+        Thread.new do
+          sid = "p42-conc-#{i}"
+          @client.eval_r("v <- #{i}L; v", session_id: sid)['value']
+        end
+      end
+
+      values = threads.map(&:value)
+      expect(values.sort).to eq((0..49).to_a)
+    end
+
+    it 'handles repeated calls in same session without leaking type info' do
+      sid = 'p42-same-session'
+      20.times do |i|
+        @client.eval_r("x <- #{i}L", session_id: sid)
+      end
+      out = @client.eval_r('x', session_id: sid)
+      expect(out['kind']).to eq('integer')
+      expect(out['value']).to eq(19)
+    end
+
+    it 'supports larger payload code strings' do
+      big = 'a' * 20_000
+      code = "nchar('#{big}')"
+      out = @client.eval_r(code)
+      expect(out['value']).to eq(20_000)
+    end
+
+    it 'keeps nested callback recursion stable for depth 5' do
+      cb_call_id = @client.register_callback do |_payload, call_id|
+        acc = 0
+        5.times do |i|
+          r = @client.eval_r("#{i}L + 1L", parent_id: call_id)
+          acc += r['value']
+        end
+        acc
+      end
+
+      out = @client.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 5000)")
+      expect(out['kind']).to eq('double')
+      expect(out['value']).to eq(15)
+    end
+
+    it 'handles 200 sequential requests without state corruption' do
+      sid = 'p42-seq'
+      200.times do |i|
+        @client.eval_r("k <- #{i}L", session_id: sid)
+      end
+      out = @client.eval_r('k', session_id: sid)
+      expect(out['value']).to eq(199)
+    end
+
+    it 'supports concurrent requests to the same session deterministically for last write readback' do
+      sid = 'p42-same-session-concurrent'
+      threads = 20.times.map do |i|
+        Thread.new { @client.eval_r("x <- #{i}L", session_id: sid) }
+      end
+      threads.each(&:join)
+      out = @client.eval_r('x', session_id: sid)
+      expect(out['kind']).to eq('integer')
+      expect(out['value']).to be_between(0, 19).inclusive
+    end
+  end
+
+  describe 'multi-instance hardening on current pool API' do
+    before(:all) do
+      cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+      @pool = NewBridge::InstancePoolClient.new(
+        source_path: cpp,
+        instances: ['p42-a', 'p42-b']
+      ).start
+    end
+
+    after(:all) do
+      @pool&.stop
+    end
+
+    it 'maintains session isolation across instances with same session_id' do
+      @pool.eval_r('x <- 101L', session_id: 'same-sid', instance_id: 'p42-a')
+      @pool.eval_r('x <- 202L', session_id: 'same-sid', instance_id: 'p42-b')
+
+      a = @pool.eval_r('x', session_id: 'same-sid', instance_id: 'p42-a')
+      b = @pool.eval_r('x', session_id: 'same-sid', instance_id: 'p42-b')
+
+      expect(a['value']).to eq(101)
+      expect(b['value']).to eq(202)
+    end
+
+    it 'handles 80 pool requests under mixed concurrency' do
+      threads = 8.times.map do |t|
+        Thread.new do
+          inst = t.even? ? 'p42-a' : 'p42-b'
+          10.times.map do |i|
+            n = (t * 10) + i
+            sid = "p42-pool-#{t}-#{i}"
+            @pool.eval_r("z <- #{n}L; z", session_id: sid, instance_id: inst)['value']
+          end
+        end
+      end
+
+      values = threads.flat_map(&:value)
+      expect(values.sort).to eq((0..79).to_a)
+    end
+
+    it 'raises when routing to unknown instance_id' do
+      expect do
+        @pool.eval_r('1L + 1L', session_id: 'x', instance_id: 'unknown-instance')
+      end.to raise_error(KeyError)
+    end
+
+    it 'keeps instance local state isolated after updates on both instances' do
+      @pool.eval_r('counter <- 1L', session_id: 'iso', instance_id: 'p42-a')
+      @pool.eval_r('counter <- 10L', session_id: 'iso', instance_id: 'p42-b')
+
+      @pool.eval_r('counter <- counter + 1L', session_id: 'iso', instance_id: 'p42-a')
+      @pool.eval_r('counter <- counter + 1L', session_id: 'iso', instance_id: 'p42-b')
+
+      a = @pool.eval_r('counter', session_id: 'iso', instance_id: 'p42-a')
+      b = @pool.eval_r('counter', session_id: 'iso', instance_id: 'p42-b')
+      expect(a['value']).to eq(2)
+      expect(b['value']).to eq(11)
+    end
+
+    it 'continues serving healthy instances after an unknown-instance routing error' do
+      expect do
+        @pool.eval_r('1L', session_id: 'err', instance_id: 'nope')
+      end.to raise_error(KeyError)
+
+      ok = @pool.eval_r('7L + 5L', session_id: 'ok', instance_id: 'p42-a')
+      expect(ok['value']).to eq(12)
+    end
+  end
+
+  describe 'rapid lifecycle checks' do
+    it 'supports repeated start/stop cycles' do
+      5.times do
+        c = NewBridge::SessionClient.new(source_path: phase1_cpp)
+        c.start
+        out = c.eval_r('2L + 3L')
+        expect(out['value']).to eq(5)
+        c.stop
+      end
+    end
+
+    it 'allows stop to be called multiple times safely' do
+      c = NewBridge::SessionClient.new(source_path: phase1_cpp)
+      c.start
+      c.stop
+      expect { c.stop }.not_to raise_error
+    end
+  end
+end
+

data/new_bridge_specs/phase4_3_r_instance_manager_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Phase 4.3: local R instance management API (first slice).
+# Run: bundle exec rspec specs/new_bridge/phase4_3_r_instance_manager_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 4.3 (RInstanceManager - local)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    phase1_cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @mgr = NewBridge::RInstanceManager.new(source_path: phase1_cpp)
+    @mgr.spawn_local(instance_id: 'mgr-a', version: 'v-current')
+    @mgr.spawn_local(instance_id: 'mgr-b', version: 'v-legacy')
+  end
+
+  after(:all) do
+    @mgr&.stop
+  end
+
+  it 'evaluates code in isolated instances with routing by instance_id' do
+    @mgr.eval_r('x <- 11L', session_id: 'shared-sid', instance_id: 'mgr-a')
+    @mgr.eval_r('x <- 22L', session_id: 'shared-sid', instance_id: 'mgr-b')
+
+    a = @mgr.eval_r('x', session_id: 'shared-sid', instance_id: 'mgr-a')
+    b = @mgr.eval_r('x', session_id: 'shared-sid', instance_id: 'mgr-b')
+
+    expect(a['value']).to eq(11)
+    expect(b['value']).to eq(22)
+  end
+
+  it 'raises on spawning an existing instance_id' do
+    expect do
+      @mgr.spawn_local(instance_id: 'mgr-a')
+    end.to raise_error(ArgumentError, /instance already exists/)
+  end
+
+  it 'exposes instance metadata including version labels' do
+    list = @mgr.instances
+    ids = list.map { |h| h[:id] }
+    expect(ids).to include('mgr-a', 'mgr-b')
+
+    a = list.find { |h| h[:id] == 'mgr-a' }
+    b = list.find { |h| h[:id] == 'mgr-b' }
+    expect(a[:version]).to eq('v-current')
+    expect(b[:version]).to eq('v-legacy')
+    expect(a[:status]).to eq(:healthy)
+    expect(b[:provider]).to eq('local')
+  end
+
+  it 'routes eval by version with eval_with_version' do
+    out = @mgr.eval_with_version('10L + 5L', version: 'v-current', session_id: 'ver-sess')
+    expect(out['value']).to eq(15)
+  end
+
+  it 'returns one result per version with eval_all_versions' do
+    results = @mgr.eval_all_versions('3L + 4L', session_id: 'all-vers')
+    expect(results.keys.sort).to eq(%w[v-current v-legacy])
+    expect(results['v-current']['value']).to eq(7)
+    expect(results['v-legacy']['value']).to eq(7)
+  end
+
+  it 'stops instances on demand' do
+    @mgr.stop('mgr-a')
+    expect(@mgr.instance_ids).not_to include('mgr-a')
+
+    expect do
+      @mgr.eval_r('1L + 1L', session_id: 's', instance_id: 'mgr-a')
+    end.to raise_error(KeyError)
+
+    # remaining instance still works
+    out = @mgr.eval_r('2L + 2L', session_id: 's', instance_id: 'mgr-b')
+    expect(out['value']).to eq(4)
+  end
+
+  it 'raises when eval_with_version targets unknown version' do
+    expect do
+      @mgr.eval_with_version('1L + 1L', version: 'no-such-version')
+    end.to raise_error(KeyError, /no instance for version/)
+  end
+end
+

data/new_bridge_specs/phase4_nested_callbacks_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Phase 4: Nested Ruby->R during R callback waits.
+# Run: bundle exec rspec specs/new_bridge/phase4_nested_callbacks_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 4 (Nested callbacks)' do
+  let(:phase1_cpp) { File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__) }
+
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @client = NewBridge::SessionClient.new(source_path: cpp)
+    @client.start
+  end
+
+  after(:all) do
+    @client&.stop
+  end
+
+  def with_client
+    yield @client
+  end
+
+  it 'deep recursion: Ruby callback calls back into R and returns correct value' do
+    with_client do |c|
+      # Register callback that does nested eval_r into R
+      cb_call_id = c.register_callback do |_payload, call_id|
+        # Nested call into R - this tests the core Phase 4 scenario
+        nested_result = c.eval_r('41L + 1L', parent_id: call_id)
+        nested_result['value']  # Return 42
+      end
+
+      # R calls the callback via galaaz_callback_call_phase3
+      out = c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 5000)")
+
+      expect(out['kind']).to eq('double')
+      expect(out['value']).to eq(42)
+    end
+  end
+
+  it 'error unwinding: Ruby callback raises, error propagates correctly' do
+    with_client do |c|
+      cb_call_id = c.register_callback do |_payload, _call_id|
+        raise 'callback error from Ruby'
+      end
+
+      # Note: Error message is generic because R_tryEval catches Rcpp::stop
+      # The important thing is that an error is raised, not the specific message
+      expect do
+        c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 5000)")
+      end.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+  end
+
+  it 'timeout: Ruby callback sleeps too long, raises timeout' do
+    with_client do |c|
+      cb_call_id = c.register_callback do |_payload, _call_id|
+        sleep 0.5  # Sleep longer than callback timeout
+        999
+      end
+
+      # The callback times out after 50ms, but the Ruby sleep is 500ms
+      # Note: Error message is generic because R_tryEval catches Rcpp::stop
+      expect do
+        c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 50)", timeout: 2)
+      end.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+  end
+
+  it 'nested ordering: multiple nested calls complete correctly' do
+    with_client do |c|
+      call_count = 0
+
+      cb_call_id = c.register_callback do |_payload, call_id|
+        call_count += 1
+        # Multiple nested calls
+        r1 = c.eval_r('10L + 1L', parent_id: call_id)
+        r2 = c.eval_r('20L + 2L', parent_id: call_id)
+        r3 = c.eval_r('30L + 3L', parent_id: call_id)
+
+        r1['value'] + r2['value'] + r3['value']  # 11 + 22 + 33 = 66
+      end
+
+      out = c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 5000)")
+
+      expect(out['value']).to eq(66)
+      expect(call_count).to eq(1)
+    end
+  end
+
+  # dplyr/rlang fancy errors can lose their causal message under nested callback
+  # stacks (path_trim_prefix/strsplit). Gatekeeper wraps nested evals so Ruby
+  # still sees "object 'a' not found".
+  it 'preserves causal dplyr error messages under nested eval', :slow do
+    with_client do |c|
+      probe = c.eval_r("isTRUE(requireNamespace('dplyr', quietly = TRUE))")
+      skip 'dplyr not installed' unless probe['value'] == true
+
+      nested_msg = nil
+      cb_call_id = c.register_callback do |_payload, call_id|
+        begin
+          c.eval_r(
+            "__G_EVAL_WITH_RESULT__tmp <- { library(dplyr); mutate(data.frame(x = 1:3), y = a + x) }",
+            parent_id: call_id
+          )
+        rescue NewBridge::SessionClient::RProcessError => e
+          nested_msg = e.message.to_s
+        end
+        1.0
+      end
+
+      c.eval_r("galaaz_callback_call_phase3('#{cb_call_id}', 'unused', 15000)", timeout: 30)
+
+      expect(nested_msg).to match(/object 'a' not found/)
+      expect(nested_msg).not_to match(/strsplit|path_trim_prefix/)
+    end
+  end
+end

data/specs/all.rb

@@ -23,14 +23,20 @@
 
 require_relative 'r_eval.spec'
 
-# Specification for Functions
-require_relative 'r_function.spec'
+# Nil/null: nil.is__null and nil.isTRUE (R NULL → Ruby nil)
+require_relative 'nil_null_spec'
+
+# Unboxing: single scalar/list, nested list, depth limit
+require_relative 'unboxing_spec'
+
+# Field access: obj.name uses R [[ not $ (avoids "$ operator is invalid for atomic vectors")
+require_relative 'field_access_spec'
 
-# Specification for Ruby expressions
-require_relative 'ruby_expression.spec'
+# Scalar character: bridge unescapes \n and \" so Ruby gets real newlines/quotes
+require_relative 'scalar_character_spec'
 
-# Specification for R::Environment
-require_relative 'r_environment.spec'
+# Specification for Functions
+require_relative 'r_function.spec'
 
 # Specification for R::Vector
 require_relative 'r_vector_creation.spec'
@@ -40,21 +46,19 @@ require_relative 'r_vector_functions.spec'
 require_relative 'r_vector_operators.spec'
 
 # Specification for R::Lists
-require_relative 'r_list.spec'
 require_relative 'r_list_apply.spec'
 
 # Specification for R::Matrix
 require_relative 'r_matrix.spec'
 
-# Specification for R::Dataframes
-require_relative 'r_dataframe.spec'
-
 # Specification for language features
 require_relative 'r_function.spec'
-require_relative 'r_formula.spec'
 
 # Test file generation
 require_relative 'r_devices.spec'
 
+# Phase 1: NewBridge callback stub + galaaz_bridge_env (see Documentation/Gknit_Generic_Output_Phased_Plan.md)
+require_relative 'phase1_callback_bridge_spec'
+
 # Testes for NSE
 # require_relative 'r_nse.spec'

data/specs/arrow_from_ruby_batches_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'Arrow from Ruby batches' do
+  before(:all) do
+    ok = R::Support.eval("requireNamespace('arrow', quietly=TRUE) && requireNamespace('dplyr', quietly=TRUE)")
+    skip 'R packages arrow/dplyr are not available' unless ok == true
+  end
+
+  it 'builds Arrow table from Ruby-threaded batches and reduces in R' do
+    batches = []
+    mutex = Mutex.new
+    threads = []
+
+    # Simulate parallel Ruby ingestion.
+    [0, 1, 2, 3].each do |tid|
+      threads << Thread.new do
+        start = tid * 1000
+        local = (start...(start + 1000)).map do |i|
+          { id: i, grp: "g#{i % 5}", value: (i % 10) + 1 }
+        end
+        mutex.synchronize { batches << local }
+      end
+    end
+    threads.each(&:join)
+
+    tbl = R::Arrow.from_ruby_batches(batches)
+    expect(tbl.rclass.split(' ')).to include('Table')
+
+    grouped = R.dplyr___group_by(tbl, :grp)
+    summed = R.dplyr___summarise(grouped, total: E.sum(:value))
+    out = R.dplyr___collect(summed)
+
+    groups = out[['grp']]
+    totals = out[['total']]
+    result = {}
+    (1..(groups.length >> 0)).each do |i|
+      grp = groups[i]
+      tot = totals[i]
+      grp = grp.respond_to?(:>>) ? (grp >> 0) : grp
+      tot = tot.respond_to?(:>>) ? (tot >> 0) : tot
+      result[grp] = tot
+    end
+
+    expected = Hash.new(0)
+    batches.flatten.each { |r| expected[r[:grp]] += r[:value] }
+    expect(result).to eq(expected)
+  end
+end