galaaz 0.5.0 → 2.0.0

data/specs/language_expression_semantics_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'Language and expression semantics' do
+  context 'symbol conversion and expression building' do
+    before(:each) do
+      R.len = 10
+      R.sd = 20
+      R.x = 5
+    end
+
+    it "converts Ruby Symbol to R symbol with unary '+'" do
+      sym = +R[:len]
+      expect(sym).to be_a(R::RSymbol)
+      expect(sym.to_s).to eq('len')
+      expect(sym.eval).to eq 10
+    end
+
+    it 'builds language expressions from symbol arithmetic' do
+      expr = R[:len] + R[:sd] + 5
+      expect(expr).to be_a(R::Language)
+      expect(expr.to_s).to eq('len + sd + 5L')
+      expect(expr.eval).to eq R.c(35)
+    end
+
+    it 'supports comparison operators in expressions' do
+      df = R.data__frame(a: (1..5), b: (5..1))
+      e = R[:a] > R[:b]
+      expect(e.to_s).to eq('a > b')
+      expect(e.eval(df)).to eq R.c(false, false, false, true, true)
+    end
+
+    it 'supports custom infix operators with scoped symbols' do
+      e = R[:month]._ :in, R.c(11, 12)
+      expect(e.to_s).to include('month %in%')
+      df = R.data__frame(month: R.c(10, 11, 12, 1))
+      expect(e.eval(df)).to eq R.c(false, true, true, false)
+    end
+
+    it 'supports quoted function construction through E helper' do
+      exp = E.sin(:len)
+      expect(exp).to be_a(R::Language)
+      expect(exp.to_s).to eq('sin(len)')
+      expect(exp.eval).to eq R.c(Math.sin(10))
+    end
+  end
+
+  context 'evaluation with context objects' do
+    it 'evaluates composite arithmetic expression in list context' do
+      ctx = R.list(a: 10, b: 20, c: 30)
+      val = R.eval(R[:a] + R[:b] * R[:c], ctx)
+      expect(val).to eq 610
+    end
+
+    it 'evaluates expression against global binding when no context is provided' do
+      R.x = 5
+      expect(R.eval(R[:x] + 10)).to eq 15
+    end
+
+    it 'evaluates expression in list context via R.eval(expr, ctx)' do
+      ctx = R.list(x: 20)
+      val = R.eval(R[:x] + 10, ctx)
+      expect(val).to be_a(R::Vector)
+      expect(val >> 0).to eq 30
+    end
+
+    it 'uses expression predicates in subset()' do
+      df = R.data__frame(a: (1..5), b: (5..1), c: R.c(5, 3, 1, 4, 1))
+      sub = R.subset(df, R[:a] >= 4)
+      expect(sub).to be_a(R::DataFrame)
+      expect(sub.nrow >> 0).to eq 2
+      expect(sub[1, 1]).to eq 4
+      expect(sub[2, 2]).to eq 1
+    end
+
+    it 'supports scoped arithmetic expressions inside mutate assignments' do
+      ok = R::Support.eval("requireNamespace('dplyr', quietly=TRUE)")
+      skip 'dplyr is not available' unless ok == true
+      R.library('dplyr')
+
+      flights_sm = R.data__frame(
+        dep_delay: R.c(10, 20),
+        arr_delay: R.c(5, 7),
+        distance: R.c(300, 600),
+        air_time: R.c(60, 120)
+      ).mutate(
+        gain: R[:dep_delay] - R[:arr_delay],
+        speed: R[:distance] / R[:air_time] * 60
+      )
+
+      expect(flights_sm[['gain']][1]).to eq 5
+      expect(flights_sm[['gain']][2]).to eq 13
+      expect(flights_sm[['speed']][1]).to eq 300
+      expect(flights_sm[['speed']][2]).to eq 300
+    end
+
+    it 'supports scoped chained list call for column selection expressions' do
+      expr = R[:arr_delay].list
+      expect(expr).to be_a(R::Language)
+      expect(expr.to_s).to eq('list(arr_delay)')
+    end
+  end
+
+  context 'reintroduced rlang helper APIs' do
+    before(:all) do
+      ok = R::Support.eval("requireNamespace('rlang', quietly=TRUE)")
+      skip 'R package rlang is not available' unless ok == true
+    end
+
+    it 'supports R.expr for symbol construction' do
+      R.len = 10
+      exp = R.expr(:len)
+      expect(exp).to be_a(R::RSymbol)
+      expect(exp.eval).to eq 10
+    end
+
+    it 'supports R.expr for boolean literals' do
+      expect(R.expr(true)).to eq R.c(true)
+      expect(R.expr(false)).to eq R.c(false)
+    end
+
+    it 'supports R.call2 for call construction' do
+      e = R.call2('mean', x: +R[:x], na__rm: true)
+      expect(e).to be_a(R::Language)
+      expect(e.to_s).to eq('mean(x = x, na.rm = TRUE)')
+    end
+
+    it 'supports R.call2 for assignment calls' do
+      e = R.call2('<-', R.expr(:x), 10)
+      e.eval
+      expect(~R[:x]).to eq 10
+    end
+
+    it 'supports R.exec for dynamic function execution' do
+      val = R.exec('mean', x: (1..10), na__rm: true, trim: 0.1)
+      expect(val).to eq 5.5
+    end
+
+    it 'supports R.exec with splatted argument hashes' do
+      args = [x: (1..10), na__rm: true, trim: 0.1]
+      expect(R.exec('mean', *args)).to eq 5.5
+    end
+  end
+end

data/specs/list_semantics_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe R::List do
+  context 'creation and unboxing' do
+    it 'creates empty and populated lists' do
+      empty = R.list
+      expect(empty.length).to eq 0
+      expect(empty).to be_a(R::List)
+
+      l = R.list(1, a: 2, b: 3, c: R.list(4, 5, 6))
+      expect(l.length).to eq 4
+      expect(l >> 0).to eq 1
+      expect(l >> 3).to eq [4, 5, 6]
+      expect(l['k'] >> 0).to eq nil
+    end
+  end
+
+  context "subsetting with '[' and '[['" do
+    before(:each) do
+      @l = R.list(a: 1, b: 2, all: 3, d: R.list(i: 4, j: 5, all: 6))
+    end
+
+    it 'returns a list when using []' do
+      expect(@l[1]).to eq R.list(a: 1)
+      expect(@l[-4] == R.list(a: 1, b: 2, all: 3)).to eq true
+      expect(@l[R.c(4, 1)] == R.list(d: R.list(i: 4, j: 5, all: 6), a: 1)).to eq true
+    end
+
+    it 'raises bridge process error when [] receives wrong index dimension' do
+      expect { @l[4, 1] }.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+
+    it 'returns elements when using [[]]' do
+      raw = R.list(1, 2, 3, R.list(4, 5, 6))
+      expect(raw[[1]]).to eq 1
+      expect(raw[[4]].identical(R.list(4, 5, 6))).to eq true
+      expect(raw[[4]][[1]]).to eq 4
+      expect(raw[[R.c(4, 1)]]).to eq 4
+    end
+  end
+
+  context 'named access and assignment' do
+    before(:each) do
+      @l = R.list(a: 1, b: 2, c: 3, d: R.list(i: 4, j: 5, k: 6))
+    end
+
+    it 'supports dot access for named elements' do
+      expect(@l.a).to eq 1
+      expect(@l.d.identical(R.list(i: 4, j: 5, k: 6))).to eq true
+    end
+
+    it 'supports setting and removing named elements' do
+      @l[['a']] = 10
+      @l.b = 20
+      @l.married = true
+      expect(@l[['a']]).to eq 10
+      expect(@l.b).to eq 20
+      expect(@l.married).to eq true
+
+      @l.d = nil
+      expect(@l.length).to eq 4
+      expect(@l[['d']]).to eq nil
+    end
+  end
+
+  context 'iteration and richer assignment paths' do
+    it 'iterates list elements with each and each_with_index' do
+      l = R.list(1, 2, 3, R.list(4, 5, 6))
+
+      got_each = []
+      l.each do |el|
+        got_each << (el.is_a?(R::Object) ? el.to_ruby : el)
+      end
+      expect(got_each).to eq([1, 2, 3, [4, 5, 6]])
+
+      got_each_idx = []
+      l.each_with_index do |el, idx|
+        val = el.is_a?(R::Object) ? el.to_ruby : el
+        got_each_idx << [idx, val]
+      end
+      expect(got_each_idx).to eq([[1, 1], [2, 2], [3, 3], [4, [4, 5, 6]]])
+    end
+
+    it 'supports richer add/modify/remove assignment forms' do
+      l = R.list(a: 1, b: 2, c: 3, d: R.list(i: 4, j: 5, k: 6))
+      l[[1]] = 10
+      expect(l[[1]]).to eq 10
+
+      l[['a']] = 11
+      l.b = 22
+      l.married = true
+      l.number = 5.345
+      l.lst = R.list(100, 200)
+      l.vec = R.c(500, 600)
+
+      expect(l[['a']]).to eq 11
+      expect(l.b).to eq 22
+      expect(l.married).to eq true
+      expect(l.number).to eq 5.345
+      expect(l.lst).to eq R.list(100, 200)
+      expect(l.vec).to eq R.c(500, 600)
+
+      l.d = nil
+      expect(l[['d']]).to eq nil
+      l[['vec']] = nil
+      expect(l[['vec']]).to eq nil
+    end
+  end
+end

data/specs/new_bridge_bulk_dataframe_transfer_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'NewBridge bulk data.frame pull (column-wise + pull_vector)' do
+  it 'unboxes data.frame to Ruby hash with correct columns' do
+    df = R.data__frame(x: R.c(1, 2, 3), y: R.c('a', 'b', 'c'))
+    ruby = df.to_ruby
+    expect(ruby).to be_a(Hash)
+    expect(ruby['x']).to eq([1, 2, 3])
+    expect(ruby['y']).to eq(%w[a b c])
+  end
+
+  it 'preserves NA in numeric and logical columns' do
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- data.frame(a = c(1, NA_real_), b = c(TRUE, NA), stringsAsFactors = FALSE)")
+    raw = R.bridge.pull_dataframe(h)
+    expect(raw['a'][0]).to eq(1.0)
+    expect(raw['a'][1]).to be_nil
+    expect(raw['b'][0]).to eq(true)
+    expect(raw['b'][1]).to eq(R::NA)
+  end
+
+  it 'uses one bulk pull per atomic column (not per cell)' do
+    client = R.bridge.instance_variable_get(:@client)
+    bulk = 0
+    allow(client).to receive(:eval_r).and_wrap_original do |m, code, **kwargs|
+      bulk += 1 if code.to_s.start_with?('__G_PULL_VECTOR__')
+      m.call(code, **kwargs)
+    end
+
+    df = R.data__frame(u: R.c(10, 20), v: R.c(1.5, 2.5), w: R.c(true, false))
+    df.to_ruby
+    expect(bulk).to eq(3)
+  end
+
+  it 'matches manual column bind for zero-row data.frame' do
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- data.frame(x = numeric(0), y = character(0), stringsAsFactors = FALSE)")
+    raw = R.bridge.pull_dataframe(h)
+    expect(raw['x']).to eq([])
+    expect(raw['y']).to eq([])
+  end
+end

data/specs/new_bridge_bulk_vector_transfer_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'NewBridge bulk vector pull (__G_PULL_VECTOR__)' do
+  it 'pulls full integer vector in one gatekeeper call' do
+    client = R.bridge.instance_variable_get(:@client)
+    bulk_cmds = []
+    allow(client).to receive(:eval_r).and_wrap_original do |m, code, **kwargs|
+      bulk_cmds << code.to_s if code.to_s.start_with?('__G_PULL_VECTOR__')
+      m.call(code, **kwargs)
+    end
+
+    v = R.c(7, 8, 9)
+    arr = v >> nil
+    expect(arr).to eq([7, 8, 9])
+    expect(bulk_cmds.any? { |c| c =~ /\A__G_PULL_VECTOR__\|g2_v\d+\z/ }).to eq(true)
+  end
+
+  it 'pulls double vector with NA as nil' do
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- c(1.0, NA_real_, 3.0)")
+    arr = R.bridge.pull_vector(h)
+    expect(arr[0]).to eq(1.0)
+    expect(arr[1]).to be_nil
+    expect(arr[2]).to eq(3.0)
+  end
+
+  it 'pulls logical vector with NA mapped to R::NA' do
+    v = R.c(true, false, R::NA)
+    arr = v >> nil
+    expect(arr[0]).to eq(true)
+    expect(arr[1]).to eq(false)
+    expect(arr[2]).to eq(R::NA)
+  end
+
+  it 'pulls character vector with NA as nil' do
+    v = R.c('x', 'y')
+    arr = v >> nil
+    expect(arr).to eq(%w[x y])
+  end
+
+  it 'matches elementwise pull for medium-length numeric vector' do
+    n = 500
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- 1:#{n}")
+    bridge = R.bridge
+    bulk = bridge.pull_vector(h)
+    elementwise = bridge.send(:pull_vector_elementwise, h)
+    expect(bulk.size).to eq(n)
+    expect(bulk).to eq(elementwise)
+  end
+
+  it 'pull_integer_vector slice matches elementwise' do
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- 10:19")
+    bridge = R.bridge
+    slice = bridge.pull_integer_vector(h, 10, 2, 4)
+    expect(slice).to eq([12, 13, 14, 15])
+    slow = bridge.send(:pull_integer_vector_elementwise, h, 2, 4)
+    expect(slice).to eq(slow)
+  end
+
+  it 'pull_double_vector slice matches elementwise for doubles' do
+    h = R::Support.generate_var_name
+    R.bridge.eval_r("#{h} <- as.numeric(1:5) + 0.5")
+    bridge = R.bridge
+    slice = bridge.pull_double_vector(h, 5, 1, 3)
+    expect(slice.size).to eq(3)
+    slow = bridge.send(:pull_double_vector_elementwise, h, 1, 3)
+    expect(slice).to eq(slow)
+  end
+end

data/specs/new_bridge_callback_timeout_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'NewBridge callback timeout configuration' do
+  it 'embeds GALAAZ_CALLBACK_TIMEOUT_MS into callback stub wait time' do
+    old = ENV['GALAAZ_CALLBACK_TIMEOUT_MS']
+    ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = '123456'
+
+    begin
+      stub = R.bridge.register_callback_proc_stub(proc { |_x| nil })
+      expect(stub).to include('galaaz_callback_call_phase3')
+      expect(stub).to include('123456')
+    ensure
+      ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = old
+    end
+  end
+
+  it 'uses GALAAZ_BRIDGE_TIMEOUT_SEC as default eval timeout' do
+    old = ENV['GALAAZ_BRIDGE_TIMEOUT_SEC']
+    ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = '321'
+
+    begin
+      client = R.bridge.instance_variable_get(:@client)
+      captured = nil
+      allow(client).to receive(:eval_r).and_wrap_original do |m, *args, **kwargs|
+        captured = kwargs[:timeout]
+        m.call(*args, **kwargs)
+      end
+
+      R.bridge.eval_r('1+1')
+      expect(captured).to eq(321)
+    ensure
+      ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = old
+    end
+  end
+
+  it 'uses GALAAZ_BRIDGE_TIMEOUT_SEC in session helper evals' do
+    old = ENV['GALAAZ_BRIDGE_TIMEOUT_SEC']
+    ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = '321'
+
+    begin
+      client = R.bridge.instance_variable_get(:@client)
+      captured = nil
+      allow(client).to receive(:eval_r).and_wrap_original do |m, *args, **kwargs|
+        captured = kwargs[:timeout] if args[0].to_s.include?('galaaz_assign_session')
+        m.call(*args, **kwargs)
+      end
+
+      R.bridge.assign_session('spec_session', 'spec_key', '1L')
+      expect(captured).to eq(321)
+    ensure
+      ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = old
+    end
+  end
+
+  it 'does not clear callback timeout env when no per-call override is provided' do
+    old = ENV['GALAAZ_CALLBACK_TIMEOUT_MS']
+    ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = '7200000'
+
+    begin
+      R.with_callback_timeout_ms(nil) { 1 + 1 }
+      expect(ENV['GALAAZ_CALLBACK_TIMEOUT_MS']).to eq('7200000')
+    ensure
+      ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = old
+    end
+  end
+end
+

data/specs/new_bridge_eval_r_fallback_spec.rb

@@ -0,0 +1,55 @@
+require 'galaaz'
+
+describe R::NewBridgeAdapter do
+  let(:bridge) { R.bridge }
+  let(:client) { bridge.instance_variable_get(:@client) }
+
+  it 'retries in side-effect mode for exact phase1 scalar limitation error' do
+    calls = []
+    err = NewBridge::SessionClient::RProcessError.new('phase1 requires length-1 scalar')
+
+    allow(client).to receive(:eval_r).and_wrap_original do |_m, code, **kwargs|
+      calls << [code, kwargs]
+      if calls.length == 1
+        raise err
+      else
+        { 'kind' => 'integer', 'value' => 0 }
+      end
+    end
+
+    result = bridge.eval_r('function(x) { x }')
+
+    expect(result).to eq('')
+    expect(calls.length).to eq(2)
+    expect(calls[1][0]).to eq('({ function(x) { x }; 0L })')
+  end
+
+  it 'retries in side-effect mode for exact unsupported type error' do
+    calls = []
+    err = NewBridge::SessionClient::RProcessError.new('unsupported type')
+
+    allow(client).to receive(:eval_r).and_wrap_original do |_m, code, **kwargs|
+      calls << [code, kwargs]
+      if calls.length == 1
+        raise err
+      else
+        { 'kind' => 'integer', 'value' => 0 }
+      end
+    end
+
+    result = bridge.eval_r('x <- c(1,2,3)')
+
+    expect(result).to eq('')
+    expect(calls.length).to eq(2)
+    expect(calls[1][0]).to eq('({ x <- c(1,2,3); 0L })')
+  end
+
+  it 'does not swallow unrelated RProcessError even with similar words' do
+    err = NewBridge::SessionClient::RProcessError.new('Error: unrelated unsupported type mismatch on user code')
+    allow(client).to receive(:eval_r).and_raise(err)
+
+    expect do
+      bridge.eval_r('stop("boom")')
+    end.to raise_error(NewBridge::SessionClient::RProcessError, /unrelated unsupported type mismatch/)
+  end
+end

data/specs/nil_null_spec.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Specs for NilClass#is__null and #isTRUE (R NULL becomes Ruby nil; calling
+# .is__null or .isTRUE on nil must not raise and must behave like R's is.null(NULL) / isTRUE(NULL)).
+#
+# Run with: bin/run_rspec specs/nil_null_spec.rb
+# (plain jruby rspec needs JVM flags; use bin/run_rspec, bin/galaaz-jruby, or GALAAZ_JRUBY_OPTS — see lib/galaaz_jruby.rb)
+
+require 'galaaz'
+
+describe "NilClass when used as R NULL (missing list element → Ruby nil)" do
+
+  context "nil.is__null" do
+    it "does not raise" do
+      expect { nil.is__null }.not_to raise_error
+    end
+
+    it "returns an object that responds to unboxed_get" do
+      expect(nil.is__null).to respond_to(:unboxed_get)
+    end
+
+    it "unboxed_get(0) returns true (nil is treated as null)" do
+      expect(nil.is__null.unboxed_get(0)).to eq true
+    end
+  end
+
+  context "nil.isTRUE" do
+    it "does not raise" do
+      expect { nil.isTRUE }.not_to raise_error
+    end
+
+    it "unboxed_get(0) returns false (R's isTRUE(NULL) is FALSE)" do
+      expect(nil.isTRUE.unboxed_get(0)).to eq false
+    end
+  end
+
+  context "nil.is__null | nil.isTRUE (as in include_engine)" do
+    it "does not raise and unboxed_get(0) is true" do
+      result = (nil.is__null | nil.isTRUE).unboxed_get(0)
+      expect(result).to eq true
+    end
+  end
+end

data/specs/object_build_phase2_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Phase 2 (performance): Object.build prefers wrapper_tag / r_class; class() probe only as fallback.
+
+require 'galaaz'
+
+describe 'R::Object.build (Phase 2 — envelope metadata vs class probe)' do
+  describe '.build_class_probe_count' do
+    it 'does not probe when r_class and wrapper_tag come from eval_r_with_result envelope' do
+      vn = R::Support.generate_var_name
+      env = R.bridge.eval_r_with_result("#{vn} <- c(1L, 2L, 3L)")
+      expect(env[:type]).to eq(:handle)
+      expect(env[:wrapper_tag]).to eq('vector')
+
+      R::Object.reset_build_counters!
+      obj = R::Object.build(env[:handle], nil, r_class: env[:r_class], wrapper_tag: env[:wrapper_tag])
+      expect(obj).to be_a(R::Vector)
+      expect(R::Object.build_class_probe_count).to eq(0)
+    end
+
+    it 'does not probe when only r_class is set (legacy envelope)' do
+      vn = R::Support.generate_var_name
+      env = R.bridge.eval_r_with_result("#{vn} <- list(a = 1L)")
+      expect(env[:type]).to eq(:handle)
+
+      R::Object.reset_build_counters!
+      obj = R::Object.build(env[:handle], nil, r_class: env[:r_class], wrapper_tag: nil)
+      expect(obj).to be_a(R::List)
+      expect(R::Object.build_class_probe_count).to eq(0)
+    end
+
+    it 'probes once when neither r_class nor a non-other wrapper_tag is given' do
+      vn = R::Support.generate_var_name
+      R.bridge.eval_r("#{vn} <- c(10L, 20L)")
+
+      R::Object.reset_build_counters!
+      obj = R::Object.build(vn)
+      expect(obj).to be_a(R::Vector)
+      expect(R::Object.build_class_probe_count).to eq(1)
+    end
+
+    it 'uses r_class for wrapper_tag other without probing (e.g. expression)' do
+      vn = R::Support.generate_var_name
+      env = R.bridge.eval_r_with_result("#{vn} <- expression(1 + 2)")
+      expect(env[:wrapper_tag]).to eq('other')
+
+      R::Object.reset_build_counters!
+      obj = R::Object.build(vn, nil, r_class: env[:r_class], wrapper_tag: env[:wrapper_tag])
+      expect(obj).to be_a(R::RExpression)
+      expect(R::Object.build_class_probe_count).to eq(0)
+    end
+  end
+end

data/specs/phase1_callback_bridge_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Phase 1 (plan): NewBridge callback argument transport + semantic return via galaaz_bridge_env.
+# Fast suite — keep coverage here, not in new_bridge_specs.
+
+require 'galaaz'
+
+describe 'Phase 1 NewBridge callbacks (adapter proc stub)' do
+  def global_callback_handles
+    names = R::Support.eval("ls(envir = .GlobalEnv, pattern = '^g2_v[0-9]+$')")
+    ruby = names.respond_to?(:to_ruby) ? names.to_ruby : []
+    ruby.is_a?(Array) ? ruby : Array(ruby).compact
+  end
+
+  before(:all) do
+    R.bridge.eval_r('call_with_arg <- function(f, x) { f(x) }')
+    R.bridge.eval_r('call_twice <- function(f, a, b) { f(a); f(b) }')
+  end
+
+  it 'passes numeric scalar and returns semantic value from R' do
+    result = R.call_with_arg(proc { |x| (x >> 0) + 1 }, 41)
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(42.0)
+  end
+
+  it 'passes character scalar' do
+    result = R.call_with_arg(proc { |x| x.to_ruby.to_s.upcase == 'ABC' ? 1 : 0 }, 'abc')
+    expect(result.to_ruby).to eq(1.0)
+  end
+
+  it 'passes logical scalar' do
+    result = R.call_with_arg(proc { |x| x.to_ruby == true ? 7 : 0 }, true)
+    expect(result.to_ruby).to eq(7.0)
+  end
+
+  it 'passes logical NA (R NA may appear as Ruby nil at the callback boundary)' do
+    na1 = R::Support.eval('NA')
+    result = R.call_with_arg(proc { |x|
+      (x.nil? || (x.respond_to?(:to_ruby) && x.to_ruby.nil?)) ? 1 : 0
+    }, na1)
+    expect(result.to_ruby).to eq(1.0)
+  end
+
+  it 'passes non-scalar argument as boxed R object' do
+    result = R.call_with_arg(proc { |x| (x.length >> 0) == 3 ? 1 : 0 }, R.c(1, 2, 3))
+    expect(result.to_ruby).to eq(1.0)
+  end
+
+  it 'reuses the same callback for two invocations' do
+    result = R.call_twice(proc { |x| (x >> 0) + 100 }, 1, 2)
+    expect(result).to be_a(R::Object)
+    # Last invocation wins as return value of call_twice (f(b) with b=2 -> 102)
+    expect(result.to_ruby).to eq(102.0)
+  end
+
+  it 'isolates two different callback procs' do
+    r1 = R.call_with_arg(proc { |x| (x >> 0) + 1 }, 10)
+    r2 = R.call_with_arg(proc { |x| (x >> 0) + 2 }, 10)
+    expect(r1.to_ruby).to eq(11.0)
+    expect(r2.to_ruby).to eq(12.0)
+  end
+
+  it 'does not leak temporary g2_v callback handles in .GlobalEnv' do
+    before = global_callback_handles
+
+    10.times do |i|
+      out = R.call_with_arg(proc { |x| (x >> 0) + 1 }, i)
+      expect(out.to_ruby).to eq((i + 1).to_f)
+    end
+
+    after = global_callback_handles
+    expect(after).to eq(before)
+  end
+
+  it 'does not create legacy galaaz_bridge_env for callback semantic returns' do
+    R::Support.eval("if (exists('galaaz_bridge_env', envir = .GlobalEnv, inherits = FALSE)) rm('galaaz_bridge_env', envir = .GlobalEnv)")
+
+    out = R.call_with_arg(proc { |x| (x >> 0) + 1 }, 9)
+    expect(out.to_ruby).to eq(10.0)
+
+    exists_legacy = R::Support.eval("exists('galaaz_bridge_env', envir = .GlobalEnv, inherits = FALSE)")
+    expect(exists_legacy).to eq(false)
+  end
+end