galaaz 0.5.0 → 2.0.0

data/lib/R_interface/rsupport_scope.rb

@@ -30,7 +30,8 @@ module R
       dataframe = args[0]
       
       args.each_with_index do |arg, index|
-        arg.names.each { |n| attrs << n.to_sym }
+        # Galaaz 2.0: Unbox names into a Ruby array to avoid method_missing recursion
+        (arg.names.unboxed_get).each { |n| attrs << n.to_sym }
       end
 
       Class.new do

data/lib/R_interface/rsymbol.rb

@@ -31,8 +31,58 @@ module R
     include BinaryOperators
     include ExecBinOp
     include LogicalOperators
+
+    def class
+      ::R::RSymbol
+    end
+
+    def rclass
+      res = ::R::Support.exec_function("class", ::R::Support.exec_function("eval", self))
+      val = res.respond_to?(:>>) ? (res >> nil) : res
+      val.is_a?(::Array) ? val[0] : val
+    end
+
+    def typeof
+      res = ::R::Support.exec_function("typeof", ::R::Support.exec_function("eval", self))
+      val = res.respond_to?(:>>) ? (res >> nil) : res
+      val.is_a?(::Array) ? val[0] : val
+    end
+
+    # Symbol name as string (e.g. "read.table") for call[[1]].to_s.
+    def to_s
+      return super unless ::R.bridge.ready?
+      raw = ::R.bridge.eval_r("as.character(#{@r_interop})").to_s
+      m = raw.match(/\[1\]\s*"([^"]*)"/)
+      m ? m[1] : raw.strip
+    end
+
+    def exec_bin_oper(operator, other_object)
+      # Use infix notation: lhs operator rhs, but evaluate self
+      op = operator.delete("`")
+      
+      var_name = ::R::Support.generate_var_name
+      lhs = "eval(#{@r_interop})"
+      
+      # If other object is a symbol, evaluate it too
+      rhs = if other_object.is_a?(::R::RSymbol)
+              "eval(#{other_object.r_interop})"
+            else
+              ::R::Support.parse_arg(other_object)
+            end
+      
+      ::R.bridge.eval_r("#{var_name} <- #{lhs} #{op} #{rhs}")
+      ::R::Object.build(var_name)
+    end
+    
+    def exec_uni_oper(operator)
+      op = operator.delete("`").strip
+      var_name = ::R::Support.generate_var_name
+      ::R.bridge.eval_r("#{var_name} <- #{op}(eval(#{@r_interop}))")
+      ::R::Object.build(var_name)
+    end
     
 =begin    
+    #--------------------------------------------------------------------------------------
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------

data/lib/R_interface/ruby_callback.rb

@@ -48,9 +48,8 @@ module R
     def initialize(object)
       @object = object
       
-      # ruby_callback_method is a method that returns an R function that returns an R
-      # function that calls back this object callback method (look at callback bellow)
-      @r_function = R::Support.ruby_callback_method.call(method(:callback))
+      # Use parse_arg to generate the R function that calls back this object's callback method
+      @r_function = R::Support.parse_arg(method(:callback))
     end
     
     #--------------------------------------------------------------------------------------

data/lib/R_interface/ruby_extensions.rb

@@ -1,206 +1,256 @@
-# -*- coding: utf-8 -*-
-
-##########################################################################################
-# @author Rodrigo Botafogo
-#
-# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
-# and distribute this software and its documentation, without fee and without a signed 
-# licensing agreement, is hereby granted, provided that the above copyright notice, this 
-# paragraph and the following two paragraphs appear in all copies, modifications, and 
-# distributions.
-#
-# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
-# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
-# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
-# POSSIBILITY OF SUCH DAMAGE.
-#
-# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
-# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
-# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
-# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
-# OR MODIFICATIONS.
-##########################################################################################
-
-#==========================================================================================
-#
-#==========================================================================================
+# ruby_extensions.rb
 
-module R
+# Ruby-only expression string builder: :a + :b => "a + b", chaining :a + :b + :c => "a + b + c".
+# No R calls; used so R.expr(:e1 + :e2 + :e3) receives a string after Ruby evaluation.
+class SymbolExprString
+  def initialize(part)
+    @str = part.to_s.gsub(/__/, ".")
+  end
 
-  module ExpBinOp
+  def +(other)
+    other_str = other.respond_to?(:to_expr_str) ? other.to_expr_str : other.to_s.gsub(/__/, ".")
+    SymbolExprString.new("#{@str} + #{other_str}")
+  end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
+  def to_s
+    @str
+  end
+  alias to_expr_str to_s
+end
 
+module R
+  module ExpBinOp
     def exec_bin_oper(operator, other_object)
-      R::Support.exec_function(R::Support.create_bin_expr(operator), self,
-                               other_object)
+      R::Language.build(operator, self, other_object)
     end
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def coerce(numeric)
-      [R::RubyExpression.build_bin_exp(numeric), self]
+      [R::Language.new(numeric.to_s), self]
+    end
+    def inter(other_object)
+      exec_bin_oper("`:`", other_object)
+    end
+    def assign(other_object)
+      exec_bin_oper("`<-`", other_object)
     end
-
-  end
-  
-end
-
-#==========================================================================================
-#
-#==========================================================================================
-
-module E
-
-  #----------------------------------------------------------------------------------------
-  # @param symbol [Symbol]
-  # @param args [Array] arguments to the missing method
-  #----------------------------------------------------------------------------------------
-  
-  def self.method_missing(symbol, *args)
-    name = R::Support.convert_symbol2r(symbol)
-    rargs = R.exprs(name.to_sym, *args)    
-    R.as__call(rargs)
-  end
-  
-end
-
-#==========================================================================================
-#
-#==========================================================================================
-
-class Range
-
-  #----------------------------------------------------------------------------------------
-  # Defines unary minus operation for ranges
-  #----------------------------------------------------------------------------------------
-  
-  def -@
-    final_value = (exclude_end?)?
-                    (first > last)?
-                      (last + 1) : (last - 1)
-                  : last
-    NegRange.new(self.begin, final_value)
   end
-
 end
 
-#==========================================================================================
-# Class NegRange exists to represent a negative range, e.g., -(1...10).  Such a range is
-# used to index vectors and means all elements but the ones in the given range.  Class
-# NegRange is parsed to become "-(1:10)" in R.
-#==========================================================================================
+module R
+  class SymbolRef
+    include R::BinaryOperators
+    include R::ExpBinOp
+    include R::LogicalOperators
 
-class NegRange < Range
+    REF_RUBY_RESERVED = %i[
+      to_str to_path to_ary to_int to_f to_r to_proc to_hash to_h to_a call
+    ].freeze
 
-end
+    def initialize(name)
+      @name = name
+    end
 
-#==========================================================================================
-#
-#==========================================================================================
-
-class Symbol
-  include R::BinaryOperators
-  include R::ExpBinOp
-  include R::LogicalOperators
-  
-  #--------------------------------------------------------------------------------------
-  # Unary '+' converts a Ruby Symbol into an R Symbol
-  #--------------------------------------------------------------------------------------
-
-  def +@
-    R.expr(self)
-  end
+    def to_r_symbol
+      @name.to_s.gsub(/__/, ".")
+    end
 
-  #--------------------------------------------------------------------------------------
-  # Unary '~' retrieves the values of the R symbol
-  #--------------------------------------------------------------------------------------
+    def +@
+      var_name = R::Support.generate_var_name
+      R.bridge.eval_r("#{var_name} <- as.name('#{to_r_symbol}')")
+      R::Object.build(var_name)
+    end
 
-  def ~@
-    R::Object.build(R::Support.eval(to_s))
-  end
+    def ~@
+      expr = to_r_symbol
+      var_name = R::Support.generate_var_name
+      R.bridge.eval_r("#{var_name} <- #{expr}")
+      R::Object.build(var_name)
+    end
 
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
+    def up_to(other_object)
+      R::Language.build("`:`", self, other_object)
+    end
 
-  def succ
-    self.to_s.succ.to_sym
-  end
-  
-  #----------------------------------------------------------------------------------------
-  # We use the following notation to access binary R functions such as %in%:
-  # R.vec_ "in", list.
-  # @param args [Array] The first element of the array is an R infix function, the other
-  # arguments are the list of arguments for the function.
-  #----------------------------------------------------------------------------------------
-  
-  def _(*args)
-    name = "%#{args.shift.to_s}%"
-    args.unshift(self)
-    rargs = R.exprs(name, *args)
-    R.as__call(rargs)
-  end
-  
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
+    def method_missing(method_name, *args)
+      super if REF_RUBY_RESERVED.include?(method_name)
+      name = R::Support.convert_symbol2r(method_name)
+      r_args = [self, *args].map { |arg| R::Support.parse_arg(arg) }
+      expr = "#{name}(#{r_args.join(", ")})"
+      res = R::Language.allocate
+      res.instance_variable_set(:@r_interop, expr)
+      res.expression = expr
+      res
+    end
 
-  def assign(expression)
-    exec_bin_oper("`<-`", expression)
+    def respond_to_missing?(method_name, include_private = false)
+      return false if method_name == :r_interop || method_name == :expression
+      return false if REF_RUBY_RESERVED.include?(method_name)
+      true
+    end
   end
+end
 
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
-
-  def assign2(expression)
-    exec_bin_oper("`=`", expression)
+module E
+  def self.method_missing(symbol, *args)
+    name = R::Support.convert_symbol2r(symbol)
+    r_args = args.map { |arg| R::Support.parse_arg(arg) }
+    expr = "#{name}(#{r_args.join(", ")})"
+    
+    res = R::Language.allocate
+    res.instance_variable_set(:@r_interop, expr)
+    res.expression = expr
+    res
   end
-  
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
+end
 
-  def method_missing(symbol, *args, &block)
+module Galaaz
+  module SymbolDSL
+    SYMBOL_RUBY_RESERVED = %i[
+      to_str to_path to_ary to_int to_f to_r to_proc to_hash to_h to_a call
+    ].freeze
 
-    E.send(symbol.to_s, self, *args)
-    
+    refine Symbol do
+      def __galaaz_ref
+        R::SymbolRef.new(self)
+      end
+
+      def +(other_object)
+        __galaaz_ref + other_object
+      end
+
+      def -(other_object)
+        __galaaz_ref - other_object
+      end
+
+      def *(other_object)
+        __galaaz_ref * other_object
+      end
+
+      def /(other_object)
+        __galaaz_ref / other_object
+      end
+
+      def **(other_object)
+        __galaaz_ref ** other_object
+      end
+
+      def %(other_object)
+        __galaaz_ref % other_object
+      end
+
+      def int_div(other_object)
+        __galaaz_ref.int_div(other_object)
+      end
+
+      def eq(other_object)
+        __galaaz_ref.eq(other_object)
+      end
+
+      def eql(other_object)
+        __galaaz_ref.eql(other_object)
+      end
+
+      def <(other_object)
+        __galaaz_ref < other_object
+      end
+
+      def <=(other_object)
+        __galaaz_ref <= other_object
+      end
+
+      def >(other_object)
+        __galaaz_ref > other_object
+      end
+
+      def >=(other_object)
+        __galaaz_ref >= other_object
+      end
+
+      def !=(other_object)
+        __galaaz_ref != other_object
+      end
+
+      def ne(other_object)
+        __galaaz_ref.ne(other_object)
+      end
+
+      def til(other_object)
+        __galaaz_ref.til(other_object)
+      end
+
+      def inter(other_object)
+        __galaaz_ref.inter(other_object)
+      end
+
+      def assign(other_object)
+        __galaaz_ref.assign(other_object)
+      end
+
+      def _(op, other_object)
+        __galaaz_ref._(op, other_object)
+      end
+
+      def &(other_object)
+        __galaaz_ref.&(other_object)
+      end
+
+      def |(other_object)
+        __galaaz_ref.|(other_object)
+      end
+
+      def +@
+        __galaaz_ref.+@
+      end
+
+      def ~@
+        __galaaz_ref.~@
+      end
+
+      def up_to(other_object)
+        __galaaz_ref.up_to(other_object)
+      end
+
+      def method_missing(method_name, *args)
+        return super if Galaaz::SymbolDSL::SYMBOL_RUBY_RESERVED.include?(method_name)
+        __galaaz_ref.public_send(method_name, *args)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        return false if Galaaz::SymbolDSL::SYMBOL_RUBY_RESERVED.include?(method_name)
+        __galaaz_ref.respond_to?(method_name, include_private) || super
+      end
+    end
   end
+end
 
-  #--------------------------------------------------------------------------------------
-  # Used when selecting column in a data frame, from the first column to the var2
-  # column
-  #--------------------------------------------------------------------------------------
-  
-  def up_to(var2)
-    R::Support.exec_function(R::Support.range, self, var2)
+#--------------------------------------------------------------------------------------
+# NilClass: R NULL is converted to Ruby nil. So nil must respond to is__null / isTRUE
+# so that code like obj.is__null.unboxed_get(0) does not raise when obj is nil.
+#--------------------------------------------------------------------------------------
+module R
+  # Result object for nil.is__null so that nil.is__null.unboxed_get(0) => true.
+  class NullCheckResult
+    def initialize(bool)
+      @bool = bool
+    end
+    def unboxed_get(_index = nil)
+      @bool
+    end
+    # For (nil.is__null | x).unboxed_get(0): true | x => true; false | x => x
+    def |(other)
+      @bool ? self : other
+    end
   end
+  NULL_IS_NULL = NullCheckResult.new(true).freeze
+  NULL_IS_FALSE = NullCheckResult.new(false).freeze
+end
 
-  
-  #--------------------------------------------------------------------------------------
-  # Create an interaction between two variables in formulas
-  #--------------------------------------------------------------------------------------
-  
-  def inter(var2)
-    R::Support.exec_function(R::Support.range, self, var2)
+class NilClass
+  # R NULL becomes Ruby nil; treat nil as null so .is__null.unboxed_get(0) works.
+  def is__null
+    R::NULL_IS_NULL
   end
-  
-  #--------------------------------------------------------------------------------------
-  # If method_missing is implemented, then we also need to implement method 'to_ary'.
-  # This is because starting from ruby 1.9 the code for Array#flatten has changed,
-  # calling 'to_ary' blindly (even if the method is not implemented).  This causes
-  # the method to be caught by 'method_missing' and here sending a 'to_ary' no found
-  # error.  If we create to_ary, then no error is issued.
-  # @TODO: make sure that implementing 'to_ary' as bellow will not create problems
-  #--------------------------------------------------------------------------------------
-
-  def to_ary
-    # [self.to_s]
+  # R's isTRUE(NULL) is FALSE; so nil.isTRUE.unboxed_get(0) => false.
+  def isTRUE
+    R::NULL_IS_FALSE
   end
-
 end