galaaz 0.4.10 → 2.0.0

data/specs/arrow_semantics_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+require 'tmpdir'
+
+describe 'Arrow semantics' do
+  before(:all) do
+    ok = R::Support.eval("requireNamespace('arrow', quietly=TRUE)")
+    skip 'R package arrow is not available' unless ok == true
+  end
+
+  it 'creates an Arrow table from a data.frame via Ruby helper' do
+    df = R.data__frame(x: (1..3), y: (3..1))
+    tbl = R::Arrow.table_from(df)
+    expect(tbl.rclass.split(' ')).to include('Table')
+  end
+
+  it 'writes and reads Feather through namespaced Arrow helpers' do
+    path = File.join(Dir.tmpdir, 'galaaz_arrow_semantics.feather')
+    df1 = R.data__frame(x: (1..5), y: (~R[:letters])[(1..5)])
+
+    R::Arrow.write_feather(df1, path)
+    df2 = R::Arrow.read_feather(path)
+
+    expect(df2.names).to eq R.c('x', 'y')
+    expect(df2.nrow >> 0).to eq 5
+    expect(df2.rclass.split(' ')).to include('tbl_df').or include('data.frame')
+    expect(df2[[1]][1]).to eq 1
+    expect(df2[[1]][5]).to eq 5
+    expect(df2[[2]][1]).to eq 'a'
+    expect(df2[[2]][5]).to eq 'e'
+  end
+
+  it 'opens Parquet dataset and runs grouped aggregation with dplyr' do
+    path = File.join(Dir.tmpdir, 'galaaz_arrow_semantics.parquet')
+    R.install_and_loads('dplyr', 'arrow')
+
+    df = R.data__frame(group: R.c('a', 'a', 'b', 'b'), value: R.c(1, 2, 3, 4))
+    R::Arrow.write_parquet(df, path)
+
+    ds = R::Arrow.dataset(path)
+    grouped = R.dplyr___group_by(ds, :group)
+    summarised = R.dplyr___summarise(grouped, total: E.sum(:value))
+    collected = R.dplyr___collect(summarised)
+
+    expect(collected.rclass.split(' ')).to include('tbl_df').or include('data.frame')
+    expect(collected.nrow >> 0).to eq 2
+
+    groups = collected[['group']]
+    totals = collected[['total']]
+    rows = {}
+    (1..(groups.length >> 0)).each do |i|
+      grp = groups[i]
+      tot = totals[i]
+      grp = grp.to_ruby if grp.respond_to?(:to_ruby)
+      tot = tot.to_ruby if tot.respond_to?(:to_ruby)
+      grp = grp.first if grp.is_a?(Array)
+      tot = tot.first if tot.is_a?(Array)
+      rows[grp] = tot
+    end
+    expect(rows['a']).to eq 3
+    expect(rows['b']).to eq 7
+  end
+end

data/specs/bridge_concurrent_spec.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Phase 1: concurrent bridge spec. N threads × M rounds of eval_r_with_result;
+# assert no exceptions, every result correct, and exactly N×M results (no loss/duplicates).
+
+require 'galaaz'
+
+describe "Bridge concurrent access (Phase 1)" do
+
+  it "serializes concurrent eval_r_with_result calls and returns correct results" do
+    bridge = R.bridge
+    n_threads = 5
+    rounds_per_thread = 10
+    results_mutex = Mutex.new
+    results = []   # [ { thread_id:, round:, value: }, ... ]
+    errors = []
+
+    threads = n_threads.times.map do |thread_id|
+      Thread.new do
+        rounds_per_thread.times do |round|
+          expected_value = thread_id * 1000 + round
+          assignment = "g2_v_t#{thread_id}_r#{round} <- #{expected_value}L"
+          env = bridge.eval_r_with_result(assignment)
+          results_mutex.synchronize do
+            if env && env[:type] == :scalar_integer && env[:value] == expected_value
+              results << { thread_id: thread_id, round: round, value: env[:value] }
+            else
+              errors << { thread_id: thread_id, round: round, env: env, expected: expected_value }
+            end
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    expect(errors).to eq([])
+    expect(results.size).to eq(n_threads * rounds_per_thread)
+    seen = {}
+    results.each do |r|
+      key = [r[:thread_id], r[:round]]
+      expect(seen[key]).to be_nil
+      seen[key] = true
+      expect(r[:value]).to eq(r[:thread_id] * 1000 + r[:round])
+    end
+  end
+end

data/specs/bridge_nested_spec.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Phase 4: nested bridge spec. Callback invokes eval_r_with_result; assert inner and outer both get correct results (no cross-talk, no deadlock).
+
+require 'galaaz'
+
+describe "Bridge nested access (Phase 4)" do
+
+  it "allows nested eval_r_with_result from callback and returns correct inner and outer results" do
+    bridge = R.bridge
+    inner_envelope = nil
+
+    # Callback runs inside R's lapply; it calls eval_r_with_result (nested) and we capture the result
+    result = R.lapply(R.c(1), (proc do |_x|
+      inner_envelope = bridge.eval_r_with_result("g2_v_inner <- 200L")
+      33
+    end))
+
+    expect(inner_envelope).not_to be_nil
+    expect(inner_envelope[:type]).to eq(:scalar_integer)
+    expect(inner_envelope[:value]).to eq(200)
+
+    # Outer lapply returns a list (handle); we can at least treat it as an R object
+    expect(result).to be_a(R::Object)
+  end
+end

data/specs/dataframe_semantics_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe R::DataFrame do
+  context 'creation and basic access' do
+    it 'creates a data.frame from a shaped vector' do
+      vec = R.seq(6)
+      vec.dim = R.c(2, 3)
+
+      df = vec.as__data__frame
+      expect(df).to be_a(R::DataFrame)
+      expect(df[1, 'V1']).to eq 1
+      expect(df[1, 'V2']).to eq 3
+      expect(df[1, :all].as__numeric).to eq R.c(1.0, 3, 5)
+    end
+  end
+
+  context "subsetting with '[' and '[['" do
+    before(:each) do
+      @mtcars = ~R[:mtcars]
+    end
+
+    it 'subsets a single column by index' do
+      slice = @mtcars[1]
+      expect(slice).to be_a(R::DataFrame)
+      expect(slice.length).to eq 1
+      expect(slice[[1]][1]).to eq 21.0
+      expect(slice[[1, 1]]).to eq 21.0
+    end
+
+    it 'raises bridge process error for invalid column selection with []' do
+      slice = @mtcars[1]
+      expect { slice['Mazda RX4'] }.to raise_error(NewBridge::SessionClient::RProcessError)
+      expect(slice[['Mazda RX4']]).to eq nil
+    end
+
+    it 'supports row+column by names and indices' do
+      expect(@mtcars[1, 1]).to eq 21.0
+      expect(@mtcars['Merc 450SL', 'drat']).to eq 3.07
+      expect(@mtcars[['Valiant', 'mpg']]).to eq 18.1
+      expect(@mtcars[[6, 5]]).to eq 2.76
+    end
+
+    it 'supports drop parameter for row extraction' do
+      lst = @mtcars[1, :all, drop: true]
+      expect(lst).to be_a(R::List)
+      expect(lst[[1]]).to eq 21.0
+      expect(lst[1]).to eq R.list(mpg: 21.0)
+    end
+  end
+
+  context "assignment with '[<-'" do
+    before(:each) do
+      @mtcars = ~R[:mtcars]
+    end
+
+    it 'adds a column and updates cells by index' do
+      @mtcars['New Column'] = R.c((1..32))
+      expect(@mtcars[[1, 12]]).to eq 1
+      expect(@mtcars[['Mazda RX4', 'New Column']]).to eq 1
+
+      @mtcars[17, 6] = 1000
+      expect(@mtcars[[17, 6]]).to eq 1000.0
+      expect(@mtcars[['Chrysler Imperial', 'wt']]).to eq 1000.0
+    end
+  end
+
+  context 'iteration helpers' do
+    it 'iterates columns with each_column and exposes column names' do
+      mtcars = ~R[:mtcars]
+      seen = {}
+
+      mtcars.each_column do |col, col_name|
+        seen[col_name] = col[1] if %w[mpg cyl disp].include?(col_name)
+      end
+
+      expect(seen['mpg']).to eq 21.0
+      expect(seen['cyl']).to eq 6.0
+      expect(seen['disp']).to eq 160.0
+    end
+
+    it 'iterates rows with each_row and exposes row names' do
+      mtcars = ~R[:mtcars]
+      seen = {}
+
+      mtcars.each_row do |row, row_name|
+        if ['Mazda RX4', 'Merc 240D'].include?(row_name)
+          seen[row_name] = [row[['mpg']], row[['hp']]]
+        end
+      end
+
+      expect(seen['Mazda RX4']).to eq([21.0, 110.0])
+      expect(seen['Merc 240D']).to eq([24.4, 62.0])
+    end
+  end
+
+  context 'bootstrap-style row reordering' do
+    before(:each) do
+      @df = R.data__frame(
+        x: R.rep((1..3), each: 2),
+        y: (6..1),
+        z: R.factor((~R[:letters])[(1..6)])
+      )
+      R.set__seed(10)
+    end
+
+    it 'reorders rows using sampled integer indices' do
+      table = @df[R.sample(@df.nrow), :all]
+      expect(table.x[3]).to eq 1
+      expect(table.y[2]).to eq 6
+      expect(table.z.levels[table.z[4]]).to eq 'f'
+    end
+
+    it 'selects a sampled subset of rows' do
+      table = @df[R.sample(@df.nrow, 3), :all]
+      expect(table.x[3]).to eq 1
+      expect(table.y[1]).to eq 4
+      expect(table.z.levels[table.z[2]]).to eq 'a'
+    end
+  end
+end

data/specs/dataframe_single_index_logical_filter_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'DataFrame single-index logical filtering' do
+  it 'treats df[logical_expression] as row filter with all columns' do
+    df = R.data__frame(
+      origin: R.c('JFK', 'LGA', 'JFK'),
+      month: R.c(6, 6, 7),
+      value: R.c(1, 2, 3)
+    )
+
+    out = df[(R[:origin].eq('JFK')) & (R[:month].eq(6))]
+    n = out.nrow >> 0
+    origins = out.origin >> nil
+    origins = [origins] unless origins.is_a?(Array)
+
+    expect(n).to eq(1)
+    expect(origins).to eq(['JFK'])
+  end
+end

data/specs/dispatch_probe_cache_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'dispatch_probe per-handle cache (Phase 3)' do
+  it 'reuses cached probe for the same object and method name' do
+    df = R.data__frame(a: R.c(1, 2, 3))
+    bridge = R.bridge
+    calls = 0
+    allow(bridge).to receive(:dispatch_probe).and_wrap_original do |m, h, n|
+      calls += 1
+      m.call(h, n)
+    end
+
+    R::Support.reset_dispatch_probe_cache_stats!
+    R::Support.clear_dispatch_probe_handle_cache!
+
+    x1 = df.a
+    x2 = df.a
+    expect(x1.unboxed_get(0)).to eq(1)
+    expect(x2.unboxed_get(0)).to eq(1)
+    expect(calls).to eq(1)
+    expect(R::Support.dispatch_probe_cache_hits).to be >= 1
+    expect(R::Support.dispatch_probe_cache_misses).to eq(1)
+  end
+
+  it 'does not use handle cache for R.foo module calls (no probe)' do
+    bridge = R.bridge
+    allow(bridge).to receive(:dispatch_probe).and_call_original
+
+    R::Support.reset_dispatch_probe_cache_stats!
+    R::Support.clear_dispatch_probe_handle_cache!
+
+    R.c(1, 2)
+    R.c(3, 4)
+    expect(bridge).not_to have_received(:dispatch_probe)
+  end
+end

data/specs/dispatch_probe_error_class_fallback_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'dispatch_probe error-class fallback' do
+  it 'falls back when dispatch_probe raises bridge RProcessError' do
+    ok = R::Support.eval("requireNamespace('dplyr', quietly=TRUE)")
+    skip 'dplyr is not available' unless ok == true
+    R.library('dplyr')
+
+    bridge = R.bridge
+    allow(bridge).to receive(:dispatch_probe).and_raise(
+      NewBridge::SessionClient::RProcessError, 'invalid dispatch_probe params'
+    )
+
+    df = R.data__frame(g1: R.c('x', 'x', 'y'), a: R.c(1, 2, 3))
+    out = df.group_by(:g1).summarise(a: E.mean(:a))
+    expect(out.nrow >> 0).to eq(2)
+  end
+end

data/specs/dispatch_probe_fallback_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe 'dispatch_probe fallback for method names' do
+  it 'falls back to function dispatch when dispatch_probe rejects params' do
+    ok = R::Support.eval("requireNamespace('dplyr', quietly=TRUE)")
+    skip 'dplyr is not available' unless ok == true
+    R.library('dplyr')
+
+    df = R.data__frame(g1: R.c('x', 'x', 'y'), a: R.c(1, 2, 3))
+    group_var = :g1
+
+    out = df.group_by(group_var).summarise(a: E.mean(:a))
+    n = out.nrow >> 0
+    expect(n).to eq(2)
+  end
+end

data/specs/environment_semantics_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+
+describe R::Environment do
+  def new_env
+    R::Support.eval('new.env(parent = emptyenv())')
+  end
+
+  context 'creation and key/value operations' do
+    it 'creates an environment handle from new.env()' do
+      env = new_env
+      expect(env).to be_a(R::Environment)
+      expect(env.typeof).to eq R.c('environment')
+      expect(env.rclass).to eq R.c('environment')
+    end
+
+    it 'supports set/get and dot assignment accessors' do
+      env = new_env
+
+      env.set(:a, 25)
+      expect(env.get(:a)).to eq 25
+
+      env.b = 33
+      expect(env.b).to eq 33
+
+      env.vec = R.c(1, 2, 3, 4)
+      expect(env.vec).to eq R.c(1, 2, 3, 4)
+      expect(R.ls(envir: env).all__equal(R.c('a', 'b', 'vec'))).to eq true
+    end
+
+    it 'supports env_names from environment object and R helper (legacy Galaaz)' do
+      env = new_env
+      expect(env.env_names.length).to eq 0
+      expect(R.env_names(env).length).to eq 0
+
+      env.a = 30
+      env.vec = R.c(1, 2, 3, 4)
+      expect(env.env_names.length).to eq 2
+      expect(R.env_names(env).all__equal(R.c('a', 'vec'))).to eq true
+    end
+
+    it 'supports element lookup with [[]] by name' do
+      env = new_env
+      env.a = 'This is a string'
+      expect(env[['a']]).to eq R.c('This is a string')
+    end
+
+    it 'allows multiple names to reference the same assigned object' do
+      env = new_env
+      env.d = R.c(1, 2, 3)
+      env.a = env.d
+      expect(env.a).to eq R.c(1, 2, 3)
+      expect(env.d).to eq R.c(1, 2, 3)
+    end
+  end
+
+  context 'remove and invalid subsetting semantics' do
+    it 'removes an environment binding with rm()' do
+      env = new_env
+      env.a = false
+      env.b = 'x'
+      expect(env.a).to eq false
+
+      R.rm('a', envir: env)
+      expect { env.a }.to raise_error(NoMethodError)
+      expect(R.ls(envir: env).all__equal(R.c('b'))).to eq true
+    end
+
+    it "raises bridge process error when using [] on environment" do
+      env = new_env
+      env.a = 1
+      expect { env['a'] }.to raise_error(NewBridge::SessionClient::RProcessError)
+    end
+  end
+
+  context 'expression evaluation in environment context' do
+    it 'evaluates expression against environment bindings when parent has base operators' do
+      env = R::Support.eval('new.env(parent = baseenv())')
+      env.e1 = 10
+      env.e2 = 20
+      env.e3 = R.c(1, 2, 3, 4)
+
+      expr = R[:e1] + R[:e2] + R[:e3]
+      expect(expr.to_s).to eq('e1 + e2 + e3')
+      expect(expr.eval(env)).to eq R.c(31, 32, 33, 34)
+    end
+  end
+end

data/specs/field_access_spec.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Specs for field/component access: we use R's [[ (obj[["name"]]) instead of $
+# so that atomic vectors don't trigger "$ operator is invalid for atomic vectors".
+# Run with: bin/run_rspec specs/field_access_spec.rb
+
+require 'galaaz'
+
+describe "Field access (obj.name → R [[, not $)" do
+
+  context "list with named elements" do
+    it "returns element when accessed by method (list.fig__ext)" do
+      lst = R.list(a: 1, b: 2, fig__ext: "png")
+      expect(lst.fig__ext).to be_a(R::Object)
+      expect(lst.fig__ext >> 0).to eq "png"
+    end
+
+    it "returns element for other names (list.a, list.b)" do
+      lst = R.list(a: 10, b: 20)
+      expect(lst.a >> 0).to eq 10
+      expect(lst.b >> 0).to eq 20
+    end
+  end
+
+  context "data frame column access" do
+    it "returns column when accessed by method (df.mpg)" do
+      df = ~R[:mtcars]
+      expect(df.mpg).to be_a(R::Vector)
+      expect(df.mpg.length >> 0).to be >= 1
+    end
+  end
+end