galaaz 0.5.0 → 2.1.0

data/specs/r_instance_manager_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'galaaz'
+require_relative '../lib/new_bridge/r_instance_manager'
+
+module NewBridge
+  class StubSessionClient
+    attr_reader :source_path, :host, :bridge_host, :r_cmd, :runtime_source_path, :start_calls
+    attr_accessor :eval_proc, :stopped
+
+    @@instances = []
+    @@start_errors = []
+
+    def self.instances
+      @@instances
+    end
+
+    def self.reset!
+      @@instances = []
+      @@start_errors = []
+    end
+
+    def self.enqueue_start_error(error)
+      @@start_errors << error
+    end
+
+    def initialize(source_path:, host:, r_cmd:, runtime_source_path: nil, bridge_host: nil)
+      @source_path = source_path
+      @host = host
+      @bridge_host = bridge_host
+      @r_cmd = r_cmd
+      @runtime_source_path = runtime_source_path
+      @start_calls = []
+      @stopped = false
+      @eval_proc = ->(_code, _kwargs) { 'ok' }
+      @@instances << self
+    end
+
+    def start(accept_timeout: nil)
+      @start_calls << accept_timeout
+      raise @@start_errors.shift unless @@start_errors.empty?
+      true
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def eval_r(code = nil, **kwargs)
+      @eval_proc.call(code, kwargs)
+    end
+  end
+end
+
+describe NewBridge::RInstanceManager do
+  let(:out) { StringIO.new }
+  let(:mgr) do
+    described_class.new(
+      source_path: File.expand_path('../ext/new_bridge/gatekeeper.cpp', __dir__),
+      session_client_class: NewBridge::StubSessionClient,
+      out: out,
+      docker_access_checker: -> { [true, nil] }
+    )
+  end
+
+  before do
+    NewBridge::StubSessionClient.reset!
+  end
+
+  it 'spawns local instances and tracks metadata/default' do
+    mgr.spawn_local(instance_id: 'a', r_cmd: 'R', version: 'v1')
+    mgr.spawn_local(instance_id: 'b', r_cmd: '/usr/bin/R', version: 'v2')
+
+    expect(mgr.default_instance_id).to eq('a')
+    ids = mgr.instance_ids
+    expect(ids).to include('a', 'b')
+
+    info = mgr.instances
+    expect(info.size).to eq(2)
+    expect(info.find { |h| h[:id] == 'a' }[:default]).to eq(true)
+    expect(info.find { |h| h[:id] == 'b' }[:runtime]).to eq('local')
+  end
+
+  it 'raises on duplicate local instance id' do
+    mgr.spawn_local(instance_id: 'a', version: 'v1')
+    expect { mgr.spawn_local(instance_id: 'a', version: 'v1') }.to raise_error(ArgumentError, /already exists/)
+  end
+
+  it 'supports spawn runtime dispatch and container metadata' do
+    mgr.spawn(instance_id: 'c1', runtime: 'container', version: 'v-current', image: 'r-image', bridge_hosts: ['host.docker.internal'])
+
+    item = mgr.instances.find { |h| h[:id] == 'c1' }
+    expect(item[:runtime]).to eq('container')
+    expect(item[:provider]).to eq('docker')
+    expect(item[:image]).to eq('r-image')
+    expect(item[:container_name]).to include('galaaz-c1')
+  end
+
+  it 'supports local runtime via unified spawn API' do
+    mgr.spawn(instance_id: 'l1', runtime: 'local', version: 'v-local', r_cmd: 'R')
+    expect(mgr.instance_ids).to include('l1')
+  end
+
+  it 'rejects invalid runtime values and missing container image' do
+    expect do
+      mgr.spawn(instance_id: 'x', runtime: 'unknown', version: 'v')
+    end.to raise_error(ArgumentError, /unsupported runtime/)
+
+    expect do
+      mgr.spawn(instance_id: 'x', runtime: 'container', version: 'v', image: '')
+    end.to raise_error(ArgumentError, /image is required/)
+  end
+
+  it 'retries once on infrastructure timeout by restarting instance' do
+    mgr.spawn_local(instance_id: 'a', version: 'v1')
+    first = NewBridge::StubSessionClient.instances.first
+    first.eval_proc = ->(_code, _kwargs) { raise Timeout::Error, 'timeout' }
+
+    result = mgr.eval_r('1+1', session_id: 's1', instance_id: 'a')
+    expect(result).to eq('ok')
+    expect(NewBridge::StubSessionClient.instances.size).to eq(2)
+    expect(first.stopped).to eq(true)
+  end
+
+  it 'routes by version and evaluates once per version' do
+    mgr.spawn_local(instance_id: 'a', version: 'v1')
+    mgr.spawn_local(instance_id: 'b', version: 'v1')
+    mgr.spawn_local(instance_id: 'c', version: 'v2')
+
+    expect(mgr.eval_with_version('2+2', version: 'v2')).to eq('ok')
+    expect { mgr.eval_with_version('2+2', version: 'missing') }.to raise_error(KeyError)
+
+    out = mgr.eval_all_versions('2+2')
+    expect(out.keys.sort).to eq(%w[v1 v2])
+  end
+
+  it 'supports default switching and stop variants' do
+    mgr.spawn_local(instance_id: 'a', version: 'v1')
+    mgr.spawn_local(instance_id: 'b', version: 'v2')
+    mgr.set_default_instance('b')
+    expect(mgr.default_instance_id).to eq('b')
+    expect { mgr.set_default_instance('missing') }.to raise_error(KeyError)
+
+    mgr.stop_all(keep_default: true)
+    expect(mgr.instance_ids).to eq(['b'])
+
+    mgr.stop('b')
+    expect(mgr.instance_ids).to eq([])
+    expect(mgr.default_instance_id).to eq(nil)
+  end
+
+  it 'supports force killing container instances' do
+    mgr.spawn(instance_id: 'c1', runtime: 'container', version: 'v-current', image: 'r-image', bridge_hosts: ['host.docker.internal'])
+    expect { mgr.kill_container('c1') }.not_to raise_error
+
+    mgr.spawn_local(instance_id: 'a', version: 'v1')
+    expect { mgr.kill_container('a') }.to raise_error(ArgumentError, /not container runtime/)
+  end
+
+  it 'fails container spawn when docker checker reports inaccessible daemon' do
+    bad_mgr = described_class.new(
+      source_path: File.expand_path('../ext/new_bridge/gatekeeper.cpp', __dir__),
+      session_client_class: NewBridge::StubSessionClient,
+      out: out,
+      docker_access_checker: -> { [false, 'permission denied'] }
+    )
+
+    expect do
+      bad_mgr.spawn(instance_id: 'c2', runtime: 'container', version: 'v', image: 'img')
+    end.to raise_error(NewBridge::RInstanceManager::Error, /docker daemon is not accessible: permission denied/)
+  end
+
+  it 'tries multiple bridge hosts and logs failures before succeeding' do
+    NewBridge::StubSessionClient.enqueue_start_error(StandardError.new('accept failed'))
+    mgr.spawn(
+      instance_id: 'c-fallback',
+      runtime: 'container',
+      version: 'v',
+      image: 'img',
+      bridge_hosts: %w[bad.host good.host]
+    )
+
+    text = out.string
+    expect(text).to include('trying bridge host bad.host')
+    expect(text).to include('trying bridge host good.host')
+    expect(text).to include('bridge host bad.host failed')
+  end
+
+  it 'raises when all bridge host candidates fail' do
+    NewBridge::StubSessionClient.enqueue_start_error(StandardError.new('fail 1'))
+    NewBridge::StubSessionClient.enqueue_start_error(StandardError.new('fail 2'))
+
+    expect do
+      mgr.spawn(
+        instance_id: 'c-fail',
+        runtime: 'container',
+        version: 'v',
+        image: 'img',
+        bridge_hosts: %w[h1 h2]
+      )
+    end.to raise_error(NewBridge::RInstanceManager::Error, /container runtime start failed/)
+  end
+
+  it 'classifies retryable infrastructure errors conservatively' do
+    expect(mgr.send(:infrastructure_retryable_error?, Timeout::Error.new('t'))).to eq(true)
+    expect(mgr.send(:infrastructure_retryable_error?, IOError.new('io'))).to eq(true)
+    expect(mgr.send(:infrastructure_retryable_error?, NewBridge::SessionClient::TimeoutError.new('timeout'))).to eq(true)
+    expect(mgr.send(:infrastructure_retryable_error?, NewBridge::SessionClient::RProcessError.new('connection closed by peer'))).to eq(true)
+    expect(mgr.send(:infrastructure_retryable_error?, NewBridge::SessionClient::RProcessError.new('evaluation error: bad call'))).to eq(false)
+    expect(mgr.send(:infrastructure_retryable_error?, StandardError.new('other'))).to eq(false)
+  end
+
+  it 'builds bridge host candidates honoring preferred host cache' do
+    mgr.instance_variable_set(:@preferred_bridge_host, 'cached.host')
+    allow(mgr).to receive(:running_in_wsl?).and_return(false)
+    allow(mgr).to receive(:local_wsl_ip).and_return('172.22.0.5')
+
+    with_cache = mgr.send(:bridge_host_candidates, relearn: false)
+    relearn = mgr.send(:bridge_host_candidates, relearn: true)
+
+    expect(with_cache.first).to eq('cached.host')
+    expect(with_cache).to include('host.docker.internal', '172.22.0.5')
+    expect(relearn).to eq(%w[host.docker.internal 172.22.0.5])
+  end
+
+  it 'prefers WSL IP before host.docker.internal when running in WSL' do
+    allow(mgr).to receive(:running_in_wsl?).and_return(true)
+    allow(mgr).to receive(:local_wsl_ip).and_return('172.22.0.5')
+
+    expect(mgr.send(:bridge_host_candidates, relearn: true)).to eq(%w[172.22.0.5 host.docker.internal])
+
+    mgr.instance_variable_set(:@preferred_bridge_host, 'cached.host')
+    with_cache = mgr.send(:bridge_host_candidates, relearn: false)
+    expect(with_cache.first).to eq('cached.host')
+    expect(with_cache).to eq(%w[cached.host 172.22.0.5 host.docker.internal])
+  end
+
+  it 'handles docker log and cleanup helper branches' do
+    allow(Open3).to receive(:capture3).with('docker', 'logs', '--tail', '80', 'cname').and_return(['ok logs', '', instance_double(Process::Status, success?: true)])
+    expect(mgr.send(:docker_logs, 'cname')).to eq('ok logs')
+
+    allow(Open3).to receive(:capture3).with('docker', 'logs', '--tail', '80', 'cname2').and_return(['', 'no logs', instance_double(Process::Status, success?: false)])
+    expect(mgr.send(:docker_logs, 'cname2')).to eq('no logs')
+
+    allow(Open3).to receive(:capture3).with('docker', 'rm', '-f', 'dead-c').and_return(['', '', instance_double(Process::Status, success?: true)])
+    expect { mgr.send(:cleanup_container, { runtime: 'container', container_name: 'dead-c' }, force: true) }.not_to raise_error
+    expect { mgr.send(:cleanup_container, { runtime: 'container', container_name: '' }, force: true) }.not_to raise_error
+    expect { mgr.send(:cleanup_container, { runtime: 'local' }, force: true) }.not_to raise_error
+  end
+
+  it 'reads local wsl ip and handles shell failures' do
+    allow(Open3).to receive(:capture3).with('bash', '-lc', "hostname -I | awk '{print $1}'").and_return(["172.22.0.7\n", '', instance_double(Process::Status, success?: true)])
+    expect(mgr.send(:local_wsl_ip)).to eq('172.22.0.7')
+
+    allow(Open3).to receive(:capture3).with('bash', '-lc', "hostname -I | awk '{print $1}'").and_return(['', 'err', instance_double(Process::Status, success?: false)])
+    expect(mgr.send(:local_wsl_ip)).to eq(nil)
+  end
+
+  it 'checks docker daemon access when checker is not provided' do
+    mgr2 = described_class.new(
+      source_path: File.expand_path('../ext/new_bridge/gatekeeper.cpp', __dir__),
+      session_client_class: NewBridge::StubSessionClient,
+      out: out
+    )
+
+    allow(Open3).to receive(:capture3).with('docker', 'info').and_return(['ok', '', instance_double(Process::Status, success?: true)])
+    expect { mgr2.send(:ensure_docker_daemon_access!) }.not_to raise_error
+
+    allow(Open3).to receive(:capture3).with('docker', 'info').and_return(['', 'permission denied', instance_double(Process::Status, success?: false)])
+    expect { mgr2.send(:ensure_docker_daemon_access!) }.to raise_error(NewBridge::RInstanceManager::Error, /docker daemon is not accessible: permission denied/)
+  end
+
+  it 'handles helper rescues for docker logs, cleanup, and local ip' do
+    allow(Open3).to receive(:capture3).with('docker', 'logs', '--tail', '80', 'boom').and_raise(StandardError, 'x')
+    expect(mgr.send(:docker_logs, 'boom')).to eq('')
+
+    allow(Open3).to receive(:capture3).with('docker', 'rm', '-f', 'boom').and_raise(StandardError, 'x')
+    expect { mgr.send(:cleanup_container, { runtime: 'container', container_name: 'boom' }, force: true) }.not_to raise_error
+
+    allow(Open3).to receive(:capture3).with('bash', '-lc', "hostname -I | awk '{print $1}'").and_raise(StandardError, 'x')
+    expect(mgr.send(:local_wsl_ip)).to eq(nil)
+  end
+end
+

data/specs/r_list_apply.spec.rb

@@ -32,7 +32,7 @@ describe R::List do
       @x = R.list(a: (1..10), beta: R.exp(-3..3), logic: R.c(true, false, false, true))
       R.library("stats")
       # Make @q the function R quantile
-      @q = ~:quantile
+      @q = ~R[:quantile]
     end
     
     it "should work with lapply and mean" do
@@ -49,7 +49,7 @@ describe R::List do
       # and method all__equal is not defined on floats.
       expect(R.all__equal(mean.beta,
                           4.5351252347,
-                          tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
+                          tolerance: (~R[:".Machine"]).double__eps ** 0.5)).to eq true
 
       expect(mean.logic).to eq 0.5
     end
@@ -62,21 +62,21 @@ describe R::List do
       expect(quant.a[1]).to eq R.c('0%': 1.0)
       expect(quant.a[[1]]).to eq 1.0
              
-      expect(quant.a[['50,00000%']]).to eq 5.50
-      expect(quant.a['50,00000%']).to eq R.c('50,00000%': 5.50)
-      expect(R.all__equal(quant.beta['100,0000%'],
-                          R.c('100,0000%': 20.08553692),
-                          tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
+      expect(quant.a[['50%']]).to eq 5.50
+      expect(quant.a['50%']).to eq R.c('50%': 5.50)
+      expect(R.all__equal(quant.beta['100%'],
+                          R.c('100%': 20.08553692),
+                          tolerance: (~R[:".Machine"]).double__eps ** 0.5)).to eq true
       expect(quant.logic[[2]]).to eq 0.0
     end
 
     it "should allow using method lapply with quantile" do
       x = R.lapply(@x, @q, R.c(0.25, 0.50, 0.75))
       expect(x.a[[1]]).to eq 3.25
-      expect(x.a[['50,00000%']]).to eq 5.50
-      expect(R.all__equal(x.beta['75,00000%'],
-                          R.c('75,00000%': 5.0536690),
-                          tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
+      expect(x.a[['50%']]).to eq 5.50
+      expect(R.all__equal(x.beta['75%'],
+                          R.c('75%': 5.0536690),
+                          tolerance: (~R[:".Machine"]).double__eps ** 0.5)).to eq true
       expect(x.logic[[2]]).to eq 0.5
     end
 
@@ -84,9 +84,9 @@ describe R::List do
       # sapply will return a matrix
       quant = R.sapply(@x, @q)
       expect(quant.rclass).to eq 'matrix'
-      expect(quant[:all, 'a']).to eq R.c('0%': 1, '25,00000%': 3.25,
-                                         '50,00000%': 5.50, '75,00000%': 7.75,
-                                         '100,0000%': 10)
+      expect(quant[:all, 'a']).to eq R.c('0%': 1, '25%': 3.25,
+                                         '50%': 5.50, '75%': 7.75,
+                                         '100%': 10)
       
       expect(quant[3, 'beta']).to eq 1.0
     end
@@ -97,7 +97,7 @@ describe R::List do
       i39 = R.sapply((3..9), "seq")
       expect(i39[[1]]).to eq R.c(1, 2, 3)
       expect(i39[[7]]).to eq R.c(1, 2, 3, 4, 5, 6, 7, 8, 9)
-      sap = R.sapply(i39, ~:fivenum)
+      sap = R.sapply(i39, ~R[:fivenum])
       expect(sap[1, 1]).to eq 1.0
       expect(sap[5, 7]).to eq 9.0
     end

data/specs/r_nse.spec.rb

@@ -40,17 +40,17 @@ describe R do
         df[r, :all]  
       end
 
-      puts subset(@sample_df, :a >= 4)
+      puts subset(@sample_df, R[:a] >= 4)
 
       y = 4
       x = 4
       condition = 4
       condition_call = 4
 
-      puts subset(@sample_df, :a == 4)
-      puts subset(@sample_df, :a == y)
-      puts subset(@sample_df, :a == condition)
-      puts subset(@sample_df, :a == condition_call)
+      puts subset(@sample_df, R[:a] == 4)
+      puts subset(@sample_df, R[:a] == y)
+      puts subset(@sample_df, R[:a] == condition)
+      puts subset(@sample_df, R[:a] == condition_call)
     end
     
   end

data/specs/r_object_send_dispatch_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'R::Object send dispatch' do
+  it 'uses Ruby send instead of R send(...) function call' do
+    df = R.data__frame(mpg: R.c(21, 22), cyl: R.c(6, 4))
+    mpg = df.send(:mpg)
+
+    expect(mpg).to be_a(R::Object)
+    expect(mpg.unboxed_get(0)).to eq(21)
+  end
+end

data/specs/r_vector_comparator_spec.rb

@@ -0,0 +1,8 @@
+require 'galaaz'
+
+describe R::Vector do
+  it 'raises NotImplementedError for <=>' do
+    vec = R.c(1, 2, 3)
+    expect { vec <=> vec }.to raise_error(NotImplementedError, /not implemented/)
+  end
+end

data/specs/r_vector_structured_scalar_reads_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'R::Vector structured scalar reads (result protocol)' do
+  it 'unboxes indexed integer element without relying on printed length/typeof' do
+    v = R.c(10, 20, 30)
+    expect(v.unboxed_get(1)).to eq(20)
+  end
+
+  it 'unboxes indexed double element' do
+    v = R.c(1.5, 2.5)
+    expect(v.unboxed_get(0)).to eq(1.5)
+  end
+
+  it 'unboxes logical TRUE, FALSE, and NA via scalar_logical envelope' do
+    v = R.c(true, false, R::NA)
+    expect(v.unboxed_get(0)).to eq(true)
+    expect(v.unboxed_get(1)).to eq(false)
+    expect(v.unboxed_get(2)).to be_nil
+  end
+
+  it 'unboxes indexed character element' do
+    v = R.c('a', 'b')
+    expect(v.unboxed_get(1)).to eq('b')
+  end
+
+  it 'stitch uses protocol-based length' do
+    v = R.c(1.0, 2.0, 3.0)
+    out = v.stitch(halo: 0) { |chunk| chunk.map { |x| x * 2 } }
+    expect(out).to be_a(R::Vector)
+    expect(out.length.unboxed_get(0)).to eq(3)
+    expect((out >> nil)).to eq([2.0, 4.0, 6.0])
+  end
+end

data/specs/range_helper_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'range_helper / up_to DSL' do
+  it 'supports select with symbol range syntax' do
+    ok = R::Support.eval("requireNamespace('dplyr', quietly=TRUE)")
+    skip 'dplyr is not available' unless ok == true
+
+    df = R.data__frame(
+      year: R.c(2020, 2021),
+      month: R.c(1, 2),
+      day: R.c(10, 11),
+      tailnum: R.c('N1', 'N2')
+    )
+
+    out = R.dplyr___select(df, R[:year].up_to(R[:day]))
+    cols = R.names(out) >> nil
+    expect(cols).to eq(%w[year month day])
+  end
+end

data/specs/rsupport_scope_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe R::Support do
+  describe '.new_scope' do
+    it 'evaluates expression-style calls inside dataframe scope' do
+      df = R.data__frame(a: (1..4), b: R.c(10, 20, 30, 40))
+
+      out = R::Support.new_scope(:with, df) do
+        (a > 2).eval(df)
+      end
+
+      expect(out).to eq R.c(false, false, true, true)
+    end
+
+    it 'allows direct column access via generated methods' do
+      df = R.data__frame(a: (1..3), b: R.c(5, 6, 7))
+
+      val = R::Support.new_scope(:with, df) do
+        (a + b).eval(df)
+      end
+
+      expect(val).to eq R.c(6, 8, 10)
+    end
+  end
+end
+

data/specs/rsupport_var_name_thread_safety_spec.rb

@@ -0,0 +1,24 @@
+require 'galaaz'
+
+describe R::Support do
+  it 'generates unique g2_v handles under concurrency' do
+    n_threads = 8
+    per_thread = 200
+    names = []
+    lock = Mutex.new
+
+    threads = n_threads.times.map do
+      Thread.new do
+        local = []
+        per_thread.times { local << R::Support.generate_var_name }
+        lock.synchronize { names.concat(local) }
+      end
+    end
+
+    threads.each(&:join)
+
+    expect(names.length).to eq(n_threads * per_thread)
+    expect(names.uniq.length).to eq(names.length)
+    expect(names).to all(match(/\Ag2_v\d+\z/))
+  end
+end

data/specs/scalar_character_spec.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Scalar character result protocol: when R sends a length-1 character (type 3),
+# the bridge unescapes so Ruby receives real newlines and double quotes
+# (e.g. \n -> newline, \" -> ", \\ -> \). This avoids SyntaxError when chunk
+# code is round-tripped (e.g. gknit exec_ruby).
+# Run with: bin/run_rspec specs/scalar_character_spec.rb
+
+require 'galaaz'
+
+describe "Scalar character (result protocol unescaping)" do
+
+  context "R -> Ruby: literal \\n and \" in string" do
+    # R string "a\\nb" has chars: a, backslash, n, b. Bridge unescapes \n -> newline.
+    it "unescapes \\n to real newline when unboxing length-1 character" do
+      v = R::Support.eval('"a\\\\nb"')
+      expect(v).to be_a(R::Object)
+      s = v >> 0
+      expect(s).to eq "a\nb"
+    end
+
+    # R string "a\\\"b" has chars: a, backslash, double-quote, b. Bridge unescapes \" -> ".
+    it "unescapes \\\" to real double-quote when unboxing length-1 character" do
+      v = R::Support.eval('"a\\\\\\"b"')
+      expect(v).to be_a(R::Object)
+      s = v >> 0
+      expect(s).to eq 'a"b'
+    end
+
+    it "unescapes both \\n and \\\" in one string" do
+      # R string with a, \n, b, \", c -> Ruby "a\nb\"c"
+      v = R::Support.eval('"a\\\\nb\\\\\\"c"')
+      expect(v).to be_a(R::Object)
+      s = v >> 0
+      expect(s).to eq "a\nb\"c"
+    end
+  end
+
+  context "plain strings unchanged" do
+    it "leaves strings without backslash escapes unchanged" do
+      v = R::Support.eval('"hello"')
+      expect((v >> 0)).to eq "hello"
+    end
+  end
+end

data/specs/scoped_symbol_dsl_refinement_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+module ScopedSymbolDslWithUsing
+  using Galaaz::SymbolDSL
+
+  def self.build_expr
+    :a + :b + 5
+  end
+
+  def self.fetch_symbol
+    ~:letters
+  end
+end
+
+module ScopedSymbolDslWithoutUsing
+  def self.build_expr
+    :a + :b + 5
+  end
+end
+
+describe 'Scoped Symbol DSL refinement' do
+  it 'enables symbol expression DSL inside lexical using scope' do
+    expr = ScopedSymbolDslWithUsing.build_expr
+    expect(expr).to be_a(R::Language)
+    expect(expr.to_s).to eq('a + b + 5L')
+  end
+
+  it 'enables unary symbol fetch inside lexical using scope' do
+    vec = ScopedSymbolDslWithUsing.fetch_symbol
+    expect(vec).to be_a(R::Vector)
+    expect(vec[1]).to eq('a')
+  end
+
+  it 'does not enable symbol expression DSL outside using scope' do
+    expect { ScopedSymbolDslWithoutUsing.build_expr }.to raise_error(NoMethodError)
+  end
+end
+

data/specs/session_env_bridge_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'Session env bridge helpers' do
+  it 'ensures, assigns, gets, and removes values in a session-scoped env' do
+    bridge = R.bridge
+    skip 'session env API available only on NewBridge adapter' unless bridge.respond_to?(:ensure_session_env)
+
+    sid = "spec_sid_#{Time.now.to_i}_#{rand(1000)}"
+    key = 'tmp_value'
+
+    expect(bridge.ensure_session_env(sid)).to eq(nil)
+
+    bridge.assign_session(sid, key, '42L')
+    got = bridge.get_session(sid, key)
+    expect(got['kind'].to_s).to eq('integer')
+    expect(got['value']).to eq(42)
+
+    bridge.rm_session(sid, key)
+    expect do
+      bridge.get_session(sid, key)
+    end.to raise_error(NewBridge::SessionClient::RProcessError)
+  end
+end

data/specs/simplecov_bootstrap_spec.rb

@@ -0,0 +1,10 @@
+describe 'SimpleCov bootstrap' do
+  it 'loads SimpleCov when available' do
+    if Gem.loaded_specs.key?('simplecov')
+      expect(defined?(SimpleCov)).to eq('constant')
+      expect(SimpleCov.running).to eq(true)
+    else
+      skip('simplecov gem is not available in this environment')
+    end
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/specs/'
+    add_filter '/new_bridge_specs/'
+  end
+rescue LoadError
+  # Keep spec bootstrap working even if simplecov is unavailable locally.
+end