galaaz 0.4.10 → 2.0.0

data/specs/tmp.rb

@@ -22,35 +22,56 @@
 ##########################################################################################
 
 require 'galaaz'
+# require 'gknit'
 
-puts RChunk
-puts RCbinding
-
-eval("a = 10", RCbinding)
-eval("puts a", RCbinding)
-
-code = <<-EOC
-     def test
-       puts "hello from test"
-     end
-EOC
-
-eval(code, RCbinding)
-eval("test", RCbinding)
+describe "error" do
+# describe R::DataFrame do
 
+  context "Bootsraping" do
 
+    it "should error with R" do
+      vec = R.c(2)
+      puts vec
+      # expect(vec[1]).to eq 2
+    end
 
 =begin
-code6 = <<-EOC
-  test
-EOC
+    it "should error with Ruby" do
+      expect(1).to eq 2
+    end
+    
+    before(:each) do
+      R.len = 10
+      R.sd = 20
+      R.vec = R.c(1, 2, 3, 4)
+    end
+
+    it "should inline r objects in 'expressions'" do
+      e1 = :len + :sd + 5 + R.c(1, 2, 3, 4)
+      expect(e1.rclass).to eq "integer"
+      expect(e1.eval).to eq R.c(36, 37, 38, 39)
+      # expect(e1.eval).not_to eq R.c(35, 37, 38, 39)
+    end
+=end
+    
+  end
+  
+end
 
-puts code2
 
-eval(code2, RubyChunk.binding)
+=begin
+Polyglot.eval("R", <<-R)
+library(plotly)
+m <- highlight_key(mpg)
+p <- ggplot(m, aes(displ, hwy)) + geom_point()
+gg <- highlight(ggplotly(p), "plotly_selected")
+crosstalk::bscols(gg, DT::datatable(m))
+R
 =end
 
-
+# GKnit.draft(file: "rmd_test.Rmd", template: 'acm_article'))
+# GKnit.draft(file: "rmd_test.Rmd", template: 'acm_article2', package: 'rticles')
+# GKnit.draft(file: "rmd_test", template: 'acm_article', package: 'rticles')
 
 ## Renaming columns
 

data/specs/unboxing_recursion_regression_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'galaaz'
+require 'tmpdir'
+
+describe 'Unboxing recursion regression' do
+  it 'unboxes Arrow/dplyr collected scalar views without stack overflow' do
+    ok = R::Support.eval("requireNamespace('arrow', quietly=TRUE) && requireNamespace('dplyr', quietly=TRUE)")
+    skip 'arrow/dplyr not available' unless ok == true
+
+    path = File.join(Dir.tmpdir, 'galaaz_unboxing_recursion.parquet')
+    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)
+
+    # These are scalar views represented as one-column data.frame handles in this path.
+    total_cell = collected[[1, 'total']]
+    group_cell = collected[[1, 'group']]
+    expect(total_cell).to be_a(R::DataFrame)
+    expect(group_cell).to be_a(R::DataFrame)
+
+    # Regression target: this used to recurse until stack overflow.
+    expect(total_cell >> 0).to eq 3
+    expect(group_cell >> 0).to eq 'a'
+  end
+end

data/specs/unboxing_spec.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# Specs for unboxing semantics: recurse until only Ruby values; single list → [x];
+# depth limit raises UnboxDepthError. Run with: bin/run_rspec specs/unboxing_spec.rb
+
+require 'galaaz'
+
+describe "Unboxing (>> nil / to_ruby / unboxed_get(nil))" do
+
+  context "single scalar (length-1 vector)" do
+    it "unboxes to Ruby scalar" do
+      expect(R.c(42) >> nil).to eq 42
+      expect(R.c(3.14) >> nil).to eq 3.14
+      expect(R.c(true) >> nil).to eq true
+      expect(R.c("hello") >> nil).to eq "hello"
+    end
+  end
+
+  context "single list (list of one element)" do
+    it "unboxes to Array with one element" do
+      lst = R.list(42)
+      expect(lst >> nil).to eq [42]
+    end
+
+    it "unboxes single list with vector to [array]" do
+      lst = R.list(R.c(1, 2, 3))
+      expect(lst >> nil).to eq [[1, 2, 3]]
+    end
+  end
+
+  context "nested list" do
+    it "unboxes to nested Ruby arrays" do
+      lst = R.list(R.list(1, 2), R.list(3, 4))
+      expect(lst >> nil).to eq [[1, 2], [3, 4]]
+    end
+
+    it "unboxes list of list of scalar" do
+      lst = R.list(R.list(10))
+      expect(lst >> nil).to eq [[10]]
+    end
+  end
+
+  context "list too deep" do
+    it "raises R::UnboxDepthError when depth exceeds MAX_UNBOX_DEPTH" do
+      deep = R.list(1)
+      (R::Support::MAX_UNBOX_DEPTH - 1).times { deep = R.list(deep) }
+      expect { deep >> nil }.to raise_error(R::UnboxDepthError, /list too deep/)
+    end
+  end
+end

data/specs/verify_callbacks.rb

@@ -0,0 +1,42 @@
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'galaaz'
+
+puts "Testing Galaaz 2.0 Callbacks..."
+
+# Define a Ruby callback
+my_ruby_proc = Proc.new do
+  puts "JRuby: Callback reached!"
+  42.0
+end
+
+# In R, we'll use 'lapply' or a simple call to trigger the callback
+# parse_arg will wrap my_ruby_proc in an R function
+begin
+  # A better way: define a helper in R that calls its argument
+  puts "Defining R helper function 'call_me'..."
+  R.bridge.eval_r("call_me <- function(f) { f() }")
+  
+  puts "Calling R 'call_me' with Ruby Proc..."
+  # R.call_me will trigger method_missing -> process_missing -> exec_function
+  # which will then call call_me(wrapper_function)
+  result = R.call_me(my_ruby_proc)
+  
+  puts "Handle from R: #{result.r_interop}"
+  puts "String representation from R: #{result.to_s}"
+  
+  unboxed = result >> nil
+  puts "Unboxed result from R: #{unboxed.inspect}"
+  
+  if unboxed == 42.0 || unboxed == 42
+    puts "SUCCESS: Callback worked!"
+  else
+    puts "FAILURE: Unexpected unboxed result: #{unboxed.inspect}"
+  end
+
+rescue => e
+  puts "Error during callback test: #{e.message}"
+  puts e.backtrace.join("\n")
+ensure
+  R.bridge.close
+end

data/version.rb

@@ -1,2 +1,2 @@
 $gem_name = "galaaz"
-$version="0.4.10"
+$version="2.0.0"