galaaz 0.5.0 → 2.1.0

data/lib/R_interface/r.rb

@@ -21,14 +21,46 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
+require 'fileutils'
+require 'msgpack'
+
 # Load required R libraries
 dir = File.dirname(File.expand_path('.', __FILE__))
-Polyglot.eval_file('R', "#{dir}/r_libs.R")
+# Polyglot.eval_file('R', "#{dir}/r_libs.R")
 
-require_relative 'robject'
+# Bridge and Support first
 require_relative 'rsupport'
 
+# Operator modules next (so R::Object can include them)
+require_relative 'rbinary_operators'
+require_relative 'runary_operators'
+require_relative 'rlogical_operators'
+require_relative 'rindexed_object'
+require_relative 'rmd_indexed_object'
+
+# Now R::Object
+require_relative 'robject'
+
 module R
+  def self.[](name)
+    R::SymbolRef.new(name)
+  end
+
+  # Raised when R.batch hits an R error mid-batch (later ops are not executed).
+  class BatchEvaluationError < StandardError
+    attr_reader :failed_index
+
+    def initialize(message, failed_index = nil)
+      super(message)
+      @failed_index = failed_index
+    end
+  end
+
+  # R↔Ruby bridge: NewBridge only.
+  def self.bridge
+    require_relative 'new_bridge_adapter'
+    R::NewBridgeAdapter.instance
+  end
 
   RCONSTANTS = ["LETTERS", "letters", "month.abb", "month.name", "pi"]
 
@@ -56,51 +88,166 @@ module R
     R::Support.process_missing(symbol, true, *args)
   end
 
+  # Queue several eval_r_with_result assignments and send them in one bridge round-trip.
+  # Fail-fast: on the first R error, remaining queued ops are not run (+R::BatchEvaluationError+,
+  # +#failed_index+ is 0-based). Same outcomes as sequential +eval_r_with_result+ when all succeed.
+  def self.batch
+    col = R::Support::BatchCollector.new
+    yield col
+    raise ArgumentError, 'R.batch requires at least one eval_with_result assignment' if col.ops.empty?
+
+    R::Support.batch_eval_with_result(col.ops)
+  end
+
+  # Async string eval against R; +block+ receives +NewBridge::EvalResult+ (+#value+ matches +eval_r+ on success).
+  def self.eval_r_async(code, timeout: nil, &block)
+    R.bridge.eval_r_async(code, timeout: timeout, &block)
+  end
+
+  # Async R function calls without blocking the caller. Requires a block; completion receives +NewBridge::EvalResult+.
+  # (+R.foo { ... }+ is reserved for dplyr-style scopes; use +R::Async.foo(...)+ for async completion.)
+  module Async
+    def self.method_missing(symbol, *args, **kwargs, &block)
+      raise ArgumentError, 'R::Async method calls require a block' unless block
+
+      timeout = kwargs.delete(:timeout)
+      name = R::Support.convert_symbol2r(symbol)
+      R::Support.exec_function_async(name, *args, timeout: timeout, **kwargs, &block)
+    end
+  end
+
   #----------------------------------------------------------------------------------------
   # Checks to see if the given libs are installed in R and if not, install them
   # @param libs [Array] Array of strings with the names of the libraries to check and
   # install
   #----------------------------------------------------------------------------------------
 
-  def self.install_rlibs(*libs)
+  def self.with_callback_timeout_ms(callback_timeout_ms)
+    return yield if callback_timeout_ms.nil?
+
+    old = ENV['GALAAZ_CALLBACK_TIMEOUT_MS']
+    ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = Integer(callback_timeout_ms).to_s
+    yield
+  ensure
+    ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = old unless callback_timeout_ms.nil?
+  end
 
-    packages = R.c(*libs)
+  def self.install_rlibs(*libs, install_timeout_sec: nil, callback_timeout_ms: nil, bridge_timeout_sec: nil)
+    with_callback_timeout_ms(callback_timeout_ms) do
 
-    new_packages = packages[!(packages._ :in, R.installed__packages[:all, "Package"])]
-    
-    if(new_packages.size > 0)
+      # Use a fixed local library directory and ensure R can see it
+      lib_dir = File.expand_path("~/R/x86_64-pc-linux-gnu-library/galaaz")
+      FileUtils.mkdir_p(lib_dir) unless Dir.exist?(lib_dir)
+      R.bridge.eval_r(".libPaths(c('#{lib_dir.gsub("'", "\\\\'")}', .libPaths()))", timeout: bridge_timeout_sec)
+
+      packages = R.c(*libs)
+
+    # installed.packages() returns a matrix; package names are in the row names.
+    # Using [:all, "Package"] on this matrix ends up calling [[ with a missing
+    # row subscript in R, which raises "missing subscript". Instead, rely on
+    # the row names vector for the list of installed packages.
+    installed_mat   = R.installed__packages(nil)
+    installed_names = R.rownames(installed_mat)
+
+    new_packages = packages[!(packages._ :in, installed_names)]
+    new_packages_str = new_packages.to_s
+
+      if(new_packages.length > 0 && new_packages_str != "character(0)")
+      $stderr.puts "[RUBY] The following packages are missing and will be installed: #{new_packages_str}"
+      $stderr.puts "[RUBY] Installing to: #{lib_dir}"
+      
+      # Get packages as Ruby array using :native mode
+      pkg_list = []
+      new_packages.each(:native) { |pkg| pkg_list << pkg }
+      $stderr.puts "[RUBY] Package list: #{pkg_list.inspect}"
       
-      # package 'data_table' cannot be installed by install.packages.  FastR implements
-      # install.fastr.packages for installing 'data_table'
-      if ((R.c('data.table')._ :in, new_packages) >> 0)
-        new_packages = new_packages[!'data_table']
-        R.install__fastr__packages('data_table')
+      # Install each package
+      pkg_list.each do |pkg|
+        $stderr.puts "[RUBY] Installing #{pkg}..."
+        if install_timeout_sec
+          timeout_i = Integer(install_timeout_sec)
+          R.bridge.eval_r("options(timeout=#{timeout_i})", timeout: bridge_timeout_sec)
+        end
+        r_cmd = "install.packages('#{pkg.gsub("'", "\\\\'")}', repos='https://cloud.r-project.org', lib='#{lib_dir.gsub("'", "\\\\'")}', dependencies=NA)"
+        $stderr.puts "[RUBY] R command: #{r_cmd}"
+        result = R.bridge.eval_r(r_cmd, timeout: bridge_timeout_sec)
+        $stderr.puts "[RUBY] Install output: #{result.inspect}"
+        if result.to_s.include?("ANTICONF") || result.to_s.include?("Configuration failed")
+          $stderr.puts "[RUBY] WARNING: Package #{pkg} failed to install due to missing system libraries."
+          $stderr.puts "[RUBY] For kableExtra, you may need: libfontconfig1-dev libxml2-dev libfreetype6-dev"
+        end
+      ensure
+        begin
+          R.bridge.eval_r("options(timeout=60)", timeout: bridge_timeout_sec)
+        rescue StandardError
+          nil
+        end
       end
       
-      puts "The following packages are missing and will be installed:\n #{new_packages}"
-      R.install__packages(new_packages)
+      # Re-check installed packages after install attempt
+      installed_mat = R.installed__packages(nil)
+      installed_names = R.rownames(installed_mat)
+      still_missing = packages[!(packages._ :in, installed_names)]
+      if still_missing.length > 0
+        raise "Failed to install packages: #{still_missing.to_s}. Check stderr output above for [RUBY] debug messages."
+      end
+      end
+
     end
-    
   end
 
   #----------------------------------------------------------------------------------------
   #
   #----------------------------------------------------------------------------------------
 
-  def self.install_and_loads(*libs)
-    R.install_rlibs(*libs)
-    libs.each { |lib| R.require lib }
+  def self.install_and_loads(*libs, install_timeout_sec: nil, callback_timeout_ms: nil, bridge_timeout_sec: nil)
+    R.install_rlibs(*libs, install_timeout_sec: install_timeout_sec, callback_timeout_ms: callback_timeout_ms, bridge_timeout_sec: bridge_timeout_sec)
+    # Use library() so load failures throw immediately with a clear R error
+    libs.each { |lib| R.library(lib) }
+  end
+
+  #--------------------------------------------------------------------------
+  # rlang helpers (reintroduced legacy API surface)
+  #--------------------------------------------------------------------------
+
+  def self.ensure_rlang!
+    ok = R::Support.eval("requireNamespace('rlang', quietly=TRUE)")
+    return if ok == true
+
+    raise "R package 'rlang' is required for this API. Install with: Rscript -e \"install.packages('rlang', repos='https://cloud.r-project.org/')\""
+  end
+
+  # Build an R expression/symbol using rlang::expr().
+  def self.expr(arg)
+    ensure_rlang!
+    var_name = R::Support.generate_var_name
+    parsed = R::Support.parse_arg(arg)
+    R.bridge.eval_r("#{var_name} <- rlang::expr(#{parsed})")
+    R::Object.build(var_name)
+  end
+
+  # Build a call object with rlang::call2().
+  def self.call2(fn, *args, **kwargs)
+    ensure_rlang!
+    var_name = R::Support.generate_var_name
+    parts = [R::Support.parse_arg(fn)]
+    parts.concat(args.map { |a| R::Support.parse_arg(a) }) unless args.empty?
+    unless kwargs.empty?
+      kw = kwargs.map { |k, v| "#{k.to_s.gsub(/__/, ".")} = #{R::Support.parse_arg(v)}" }
+      parts.concat(kw)
+    end
+    R.bridge.eval_r("#{var_name} <- rlang::call2(#{parts.join(', ')})")
+    R::Object.build(var_name)
+  end
+
+  # Execute a function call with dynamic args via rlang::exec().
+  def self.exec(fn, *args, **kwargs)
+    ensure_rlang!
+    R.rlang___exec(fn, *args, **kwargs)
   end
   
 end
 
-# Binary operators: '+', '-', etc
-require_relative 'rbinary_operators'
-# Unary operators: '!', '@-', etc
-require_relative 'runary_operators'
-# Logical operators
-require_relative 'rlogical_operators'
-
 # Ruby class extensions.  Extends Symbol to allow the creation of
 # expressions using Symbol: (:x > 10)
 require_relative 'ruby_extensions'
@@ -128,8 +275,13 @@ require_relative 'renvironment'
 require_relative 'rlanguage'
 # Definition of R Symbol
 require_relative 'rsymbol'
+# Device for ggplot (png/svg, plot_snapshot, save_plot)
+require_relative 'rdevice'
 # Access to package symbols
 require_relative 'rpkg'
 
+# Arrow helpers (tables, datasets, Feather/Parquet IO)
+require_relative 'r_arrow'
+
 # Class to allow R calling back into Ruby
 require_relative 'ruby_callback'

data/lib/R_interface/r_arrow.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Arrow helpers for Galaaz
+# 
+# These methods provide a small, Ruby-friendly surface over common R Arrow
+# operations (tables, datasets, Feather/Parquet IO). They are thin wrappers
+# around the R Arrow package and keep all Arrow data resident in the R process.
+##########################################################################################
+
+module R
+  module Arrow
+
+    # Build an Arrow table in R from Ruby-produced batches.
+    #
+    # Input shapes:
+    # - Array<Hash>: each hash is a row
+    # - Array<Array<Hash>>: each inner array is a row batch
+    # - Any Enumerable yielding Hash rows or Array<Hash> batches
+    #
+    # This keeps batch construction on the Ruby side and creates one R data.frame
+    # from the merged column vectors, then converts it to Arrow Table.
+    #
+    # @param enum_or_array [Enumerable]
+    # @return [R::Object] Arrow Table handle in R
+    def self.from_ruby_batches(enum_or_array)
+      rows = []
+      enum_or_array.each do |batch|
+        if batch.is_a?(Hash)
+          rows << batch
+        elsif batch.respond_to?(:each)
+          batch.each do |row|
+            unless row.is_a?(Hash)
+              raise ArgumentError, 'each row must be a Hash'
+            end
+            rows << row
+          end
+        else
+          raise ArgumentError, 'batches must yield Hash rows or arrays of Hash rows'
+        end
+      end
+
+      raise ArgumentError, 'from_ruby_batches requires at least one row' if rows.empty?
+
+      keys = rows.flat_map(&:keys).map(&:to_s).uniq
+      columns = keys.each_with_object({}) { |k, h| h[k.to_sym] = [] }
+
+      rows.each do |row|
+        key_map = row.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+        keys.each { |k| columns[k.to_sym] << key_map[k] }
+      end
+
+      df = R::Support.exec_function('data.frame', columns)
+      table_from(df)
+    end
+
+    # Create an Arrow Table from an R data.frame (or tibble) handle.
+    # Uses arrow::as_arrow_table() on the R side.
+    #
+    # @param r_df [R::DataFrame, R::Object] an R-side data.frame/tibble handle
+    # @return [R::Object] handle to an Arrow Table in R
+    def self.table_from(r_df)
+      R.arrow___as_arrow_table(r_df)
+    end
+
+    # Open a Parquet/Feather directory or file as an Arrow Dataset
+    # using arrow::open_dataset().
+    #
+    # @param path [String] file or directory path visible to R
+    # @return [R::Object] handle to an Arrow Dataset in R
+    def self.dataset(path)
+      R.arrow___open_dataset(path)
+    end
+
+    # Read a Feather file into an R data.frame/tibble using read_feather().
+    #
+    # @param path [String]
+    # @return [R::DataFrame] Arrow-backed data.frame/tibble in R
+    def self.read_feather(path)
+      R.arrow___read_feather(path)
+    end
+
+    # Write an R data.frame/tibble to a Feather file using write_feather().
+    #
+    # @param r_df [R::DataFrame, R::Object]
+    # @param path [String]
+    # @return [nil]
+    def self.write_feather(r_df, path)
+      R.arrow___write_feather(r_df, path)
+      nil
+    end
+
+    # Read a Parquet file into an R data.frame/tibble using read_parquet().
+    #
+    # @param path [String]
+    # @return [R::DataFrame] Arrow-backed data.frame/tibble in R
+    def self.read_parquet(path)
+      R.arrow___read_parquet(path)
+    end
+
+    # Write an R data.frame/tibble to a Parquet file using write_parquet().
+    #
+    # @param r_df [R::DataFrame, R::Object]
+    # @param path [String]
+    # @return [nil]
+    def self.write_parquet(r_df, path)
+      R.arrow___write_parquet(r_df, path)
+      nil
+    end
+
+  end
+end
+

data/lib/R_interface/r_libs.R

@@ -8,7 +8,7 @@ if (!('data.table' %in% installed.packages()[, "Package"])) {
 }
 
 library('formula.tools')
-library('lobstr')
-library('rlang')
-library('purrr')
+# library('lobstr')
+# library('rlang')
+# library('purrr')
 

data/lib/R_interface/r_methods.rb

@@ -25,162 +25,49 @@ module R
 
   module Support
 
-    #--------------------------------------------------------------------------------------
-    # Captures the R output to a variable and returns it. 
-    #--------------------------------------------------------------------------------------
-    
+    # Galaaz 2.0: In the Shadow Bridge, these methods return 
+    # the name of the R function as a string handle.
+
     def self.capture
-      Polyglot.eval("R", <<-R)
-        function(obj, ...) {
-          sink(tt <- textConnection("results","w"), split=FALSE, type = c("output", "message"));
-          print(obj, ...);
-          sink();
-          close(tt);
-          results
-        }
-      R
+      "capture" # Requires capture to be defined in R
     end
 
     def self.capture2
-      Polyglot.eval("R", <<-R)
-        function(obj, ...) {
-          tryCatch({
-            sink(tt <- textConnection("results","w"), split=FALSE, type = c("output", "message"));
-            print(obj, ...);
-            sink();
-            results
-          }, finally = {
-            close(tt);
-          })
-        }
-      R
+      "capture2"
     end
     
     def self.start_capture
-      Polyglot.eval("R", <<-R)
-        function(cap_variable) {
-          sink(con <- textConnection(cap_variable,"w"), split=FALSE, type = c("output"));
-          con
-        }
-      R
+      "start_capture"
     end
 
     def self.stop_capture
-      Polyglot.eval("R", <<-R)
-        function(con) {
-          sink();
-          close(con);
-        }
-      R
+      "stop_capture"
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def self.dbk_index
-      Polyglot.eval("R", <<-R)
-        function(obj, ...) {
-          obj[[...]]
-        }
-      R
+      "`[[`"
     end
     
-    #--------------------------------------------------------------------------------------
-    # multi-dimensional indexing
-    #--------------------------------------------------------------------------------------
-    
     def self.md_index
-      Polyglot.eval("R", <<-R)
-        function(mdobject, ...) { 
-          mdobject[...];
-        }
-      R
+      "`[`"
     end
 
-    #--------------------------------------------------------------------------------------
-    # R function that returns another R function that calls back a Ruby Method or Proc
-    # Some R functions that receive a function as argument will test to see if their
-    # parameters is a function or a symbol, so the Ruby method needs to be wrapped inside
-    # an R function in order for it to pass this test.
-    #--------------------------------------------------------------------------------------
-
     def self.ruby_callback_method
-      Polyglot.eval("R", <<-R)
-        function(rb_method) {
-          function(...) {
-          rb_method(...)
-          }
-        }
-      R
+      "ruby_callback_method"
     end
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
     
     def self.enquo
-      Polyglot.eval("R", <<-R)
-        function(x, ...) {
-          enquo(x)          
-        } 
-      R
+      "enquo"
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def self.range
-      Polyglot.eval("R", <<-R)
-        function(x, y, neg = FALSE) {
-          e1 = enexpr(x)
-          e2 = enexpr(y)
-          if (neg) {
-            expr(-(!!e1:!!e2))
-          } else {
-            expr(!!e1:!!e2)
-          }
-        }
-      R
+      "range_helper"
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def self.create_bin_expr(operator)
-      is_formula = (operator == "`~`")? 'TRUE' : 'FALSE'
-      Polyglot.eval("R", <<-R)
-        function(op1, op2) {
-          o1 = enexpr(op1)
-          o2 = enexpr(op2)
-          if (typeof(o1) == 'symbol' && o1 == expr(`__`)) {
-            o1 = expr(.)
-          }
-          if (typeof(o2) == 'symbol' && o2 == expr(`__`)) {
-            o2 = expr(.)
-          }
-          exp = expr(#{operator}(!!o1, !!o2))
-          if (#{is_formula}) {
-            as.formula(exp)
-          } else {
-            exp
-          }
-        }
-        R
+      "function(op1, op2) { #{operator}(op1, op2) }"
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    Polyglot.eval("R", <<-R)
-      plot = function(...) {
-        print("Function 'plot' is not implemented in fastR.  Please, use ggplot instead")
-      }
-    R
-
   end
   
 end

data/lib/R_interface/rbinary_operators.rb

@@ -34,7 +34,15 @@ module R
     #--------------------------------------------------------------------------------------  
 
     def exec_bin_oper(operator, other_object)
-      R::Support.exec_function_name(operator, @r_interop, other_object)
+      # Use infix notation: lhs operator rhs
+      # We need to strip backticks from operator if present
+      op = operator.delete("`")
+      
+      var_name = R::Support.generate_var_name
+      rhs = R::Support.parse_arg(other_object)
+      
+      R.bridge.eval_r("#{var_name} <- #{@r_interop} #{op} #{rhs}")
+      R::Object.build(var_name)
     end
        
     #--------------------------------------------------------------------------------------
@@ -135,6 +143,8 @@ module R
       exec_bin_oper("`==`", other_object)
     end
 
+    alias_method :eql, :eq
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
@@ -191,10 +201,18 @@ module R
 
     def til(other_object)
       return R::Support.exec_function_name("`~`", other_object) if
-        ((self.is_a? Symbol) && (self == :all))
+        ((self.is_a?(Symbol) && (self == :all)) ||
+         (self.is_a?(R::SymbolRef) && self.to_r_symbol == "all"))
       exec_bin_oper("`~`", other_object)
     end
 
+    def _(op, other_object)
+      operator = op.to_s.gsub(/__/,".")
+      # If it's a standard letter-based operator like 'in', wrap in %
+      operator = "%#{operator}%" if operator =~ /^[a-zA-Z.]+$/
+      exec_bin_oper(operator, other_object)
+    end
+
   end
 
 end

data/lib/R_interface/rclosure.rb

@@ -25,12 +25,16 @@ module R
 
   class Closure < Object
 
+    def class
+      ::R::Closure
+    end
+
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------
     
     def call(*args)
-      R::Support.exec_function(@r_interop, *args)
+      ::R::Support.exec_function(@r_interop, *args)
     end
 
   end