scicom 0.3.0-java → 0.4.0-java

data/lib/JRubyR/attributes.rb

@@ -40,7 +40,11 @@ class Renjin
     end
 
     #----------------------------------------------------------------------------------------
-    #
+    # When accessing an attribute, we need to keep track of the object that holds the
+    # attribute.  This is necessary for the following construct to work:
+    # elmt.attr.name = "name".  In this case, we need to change the attribute of elmt and
+    # in R this is done by elmt.attr <- name. But when parsing Ruby, when we get to
+    # elmt.attr.name, it is to late.
     #----------------------------------------------------------------------------------------
     
     def method_missing(symbol, *args)
@@ -52,7 +56,6 @@ class Renjin
       name.gsub!("rclass", "class")
       
       if name =~ /(.*)=$/
-        super if args.length != 1
         args = R.parse(*args)
         ret = R.eval("attr(#{@rbsexp.r}, \"#{name.delete!('=')}\") = #{args}")
       else

data/lib/JRubyR/callback.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2016 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.
+##########################################################################################
+
+class Renjin
+
+  class Callback
+    include Java::RbScicom.RubyCallbackInterface
+    include Renjin::RBSexp
+    
+    attr_reader :ruby_obj
+    
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def initialize(ruby_obj)
+      @ruby_obj = ruby_obj
+    end
+    
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def run(method, *args)
+      # puts "method #{method} called with args: #{args}"
+      # The returned value from the called method should be packed.
+      Callback.pack(@ruby_obj.send(method, *args))
+    end
+    
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def get_class(class_name)
+      run("const_get", class_name)
+    end
+
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def build(class_name, *args)
+      klass = get_class(class_name)
+      klass.run("new", *args)
+    end
+
+    #----------------------------------------------------------------------------------------
+    # Scope can be:
+    #  * external: only the received object is packed
+    #  * internal: only the internal objects are packed.  In this case, the received object
+    #    must respond to the 'each'.
+    #  * all: packs both internal and external
+    #----------------------------------------------------------------------------------------
+
+    def self.pack(obj, scope: :external)
+
+      # Do not pack basic types Boolean, Numberic or String
+      case obj
+      when TrueClass, FalseClass, Numeric, String
+        return obj
+      end
+      
+      case scope
+      when :internal
+        raise "Cannot rpack object's internals as it does not respond to the :each method." if
+          !obj.respond_to?(:each)
+        obj.map { |pk| Callback.new(pk) }
+      when :external
+        Callback.new(obj)
+      when :all
+        Callback.new(obj.map! { |pk| Callback.new(pk) })
+      else
+        raise "Scope must be :internal, :external or :all.  Unknown #{scope} scope"
+      end
+      
+    end
+    
+  end
+
+end
+
+=begin
+class Hash
+  def deep_traverse(&block)
+    stack = self.map{ |k,v| [ [k], v ] }
+    while not stack.empty?
+      key, value = stack.pop
+      yield(key, value)
+      if value.is_a? Hash
+        value.each{ |k,v| stack.push [ key.dup << k, v ] }
+      end
+    end
+  end
+end
+=end

data/lib/JRubyR/environment.rb

@@ -36,7 +36,6 @@ class Renjin
       if name =~ /(.*)=$/
         # should never reach this point.  Parse error... but check
         raise ArgumentError, "You shouldn't assign nil" if args==[nil]
-        super if args.length != 1
         ret = R.assign($1,args[0])
       else
         name.gsub!(/__/,".")

data/lib/JRubyR/indexed.rb

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2013 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.
+##########################################################################################
+
+require_relative "attributes"
+
+#==========================================================================================
+# Module Index, should be required by classes that can be accessed by an index, such as
+# list and vector
+#==========================================================================================
+
+class Renjin
+
+  module Index
+    
+    #----------------------------------------------------------------------------------------
+    # Access an element of the class by indexing
+    #----------------------------------------------------------------------------------------
+    
+    def [](*index)
+      index = parse(index)
+      R.eval("#{r}[#{index}]")
+    end
+        
+    #----------------------------------------------------------------------------------------
+    # Assign a value to a given index
+    #----------------------------------------------------------------------------------------
+    
+    def []=(*index, value)
+      index = parse(index)
+      value = R.parse(value)
+      R.eval("#{r}[#{index}] = #{value}")
+    end
+
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def parse(index)
+
+      params = Array.new
+
+      index.each do |i|
+        if (i.is_a? Array)
+          params << i
+        else
+          params << R.parse(i)
+        end
+      end
+      
+      ps = String.new
+      params.each_with_index do |p, i|
+        ps << "," if i > 0
+        ps << ((p == "NULL")? "" : p.to_s)
+      end
+
+      ps
+
+    end
+
+    #----------------------------------------------------------------------------------------
+    # Module Index is included in list and vector. We allow access to list/vector elements
+    # by name.  Two underscores are replaced with a '.' in order to be able to call methods
+    # in R that have a '.' such as is.na, becomes R.is__na. 
+    #----------------------------------------------------------------------------------------
+
+    def method_missing(symbol, *args)
+
+      name = symbol.id2name
+      name.gsub!(/__/,".")
+      
+      if name =~ /(.*)=$/
+        # p "#{r}$#{$1} = #{args[0].r}"
+        # ret = R.eval("#{r}[\"#{name}\"] = #{args[0].r}")
+        ret = R.eval("#{r}$#{$1} = #{args[0].r}")
+      elsif (args.length == 0)
+        # treat name as a named item of the list
+        if (R.eval("\"#{name}\" %in% names(#{r})").gt)
+          ret = R.eval("#{r}[[\"#{name}\"]]")
+        else
+          ret = R.eval("#{name}(#{r})") if ret == nil 
+        end
+      elsif (args.length > 0)
+        # p "#{name}(#{r}, #{R.parse(*args)})"
+        ret = R.eval("#{name}(#{r}, #{R.parse(*args)})")
+      else
+        raise "Illegal argument for named list item #{name}"
+      end
+      
+      ret
+      
+    end
+
+    #----------------------------------------------------------------------------------------
+    # We use the following notation to access binary R functions such as %in%:
+    # R.vec_ "in", list.
+    #----------------------------------------------------------------------------------------
+
+    def _(*args)
+      method = "%#{args.shift.to_s}%"
+      arg2 = R.parse(*args)
+      ret = R.eval("#{r} #{method} #{arg2}")
+    end
+    
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+    
+    def each(&block)
+      while (@iterator.hasNext())
+        block.call(@iterator.next())
+      end
+    end
+
+  end
+
+end
+
+require_relative 'vector'
+require_relative 'list'

data/lib/JRubyR/list.rb

@@ -35,22 +35,6 @@ class Renjin
       @iterator = @sexp.iterator()
     end
 
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def names
-      R.names(self)
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def unlist
-      R.unlist(self)
-    end
-
   end
   
 end

data/lib/JRubyR/logical_value.rb

@@ -25,7 +25,6 @@
 #
 #==========================================================================================
 
-require 'java'
 
 class Renjin
 

data/lib/JRubyR/rbsexp.rb

@@ -29,112 +29,8 @@ require_relative "attributes"
 
 class Renjin
 
-  module Index
-    
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-    
-    def [](*index)
-      index = parse(index)
-      R.eval("#{r}[#{index}]")
-    end
-        
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-    
-    def []=(*index, value)
-      index = parse(index)
-      value = R.parse(value)
-      R.eval("#{r}[#{index}] = #{value}")
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def parse(index)
-
-      params = Array.new
-
-      index.each do |i|
-        if (i.is_a? Array)
-          params << i
-        else
-          params << R.parse(i)
-        end
-      end
-      
-      ps = String.new
-      params.each_with_index do |p, i|
-        ps << "," if i > 0
-        ps << ((p == "NULL")? "" : p.to_s)
-      end
-
-      ps
-
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def method_missing(symbol, *args)
-      
-      name = symbol.id2name
-      name.gsub!(/__/,".")
-      
-      # super if args.length != 0
-      if name =~ /(.*)=$/
-        super if args.length != 1
-        # p "#{r}$#{$1} = #{args[0].r}"
-        # ret = R.eval("#{r}[\"#{name}\"] = #{args[0].r}")
-        ret = R.eval("#{r}$#{$1} = #{args[0].r}")
-      elsif (name == "_")
-        method = "%#{args.shift.to_s}%"
-        arg2 = R.parse(*args)
-        ret = R.eval("#{r} #{method} #{arg2}")
-      elsif (args.length == 0)
-        # treat name as a named item of the list
-        if (R.eval("\"#{name}\" %in% names(#{r})").gt)
-          ret = R.eval("#{r}[[\"#{name}\"]]")
-        else
-          ret = R.eval("#{name}(#{r})") if ret == nil 
-        end
-      elsif (args.length > 0)
-        # p "#{name}(#{r}, #{R.parse(*args)})"
-        ret = R.eval("#{name}(#{r}, #{R.parse(*args)})")
-      else
-        raise "Illegal argument for named list item #{name}"
-      end
-      
-      ret
-      
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-    
-    def length
-      R.length(R.eval("#{r}")).gz
-    end
-    
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-    
-    def each(&block)
-      while (@iterator.hasNext())
-        block.call(@iterator.next())
-      end
-    end
-
-  end
-
   #==========================================================================================
-  #
+  # Module to wrapp every Renjin SEXP.
   #==========================================================================================
 
   module RBSexp
@@ -167,18 +63,26 @@ class Renjin
     end
     
     #----------------------------------------------------------------------------------------
-    #
+    # Push the object into the R evaluator.  Check to see if this object already has an R
+    # value (rvar).  The rvar is just a string of the form sc_xxxxxxxx. This string will be
+    # an R variable that holds the SEXP.  
     #----------------------------------------------------------------------------------------
     
     def r
       
       if (@rvar == nil)
+        # create a new variable name to hold this object inside R
         @rvar = "sc_#{SecureRandom.hex(8)}"
+        
+        # if this object already has a sexp value then assign to @rvar the existing sexp,
+        # otherwise, assign itself to @rvar.
         (@sexp == nil)? R.assign(@rvar, self) : R.assign(@rvar, @sexp)
+        
         # Whenever a variable is injected in Renjin, it is also added to the Renjin stack.
         # After eval, every injected variable is removed from Renjin making sure that we
         # do not have memory leak.
         Renjin.stack << self
+        
       end
       
       @rvar
@@ -194,7 +98,7 @@ class Renjin
     end
     
     #----------------------------------------------------------------------------------------
-    # 
+    # Scope is used for accessing attribute values for an R object.
     #----------------------------------------------------------------------------------------
     
     def unbind
@@ -234,22 +138,6 @@ class Renjin
       print
     end
     
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def nrow
-      R.nrow(self)
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def ncol
-      R.ncol(self)
-    end
-
   end
   
 end
@@ -297,13 +185,13 @@ class Renjin
     
     def self.build(sexp)
       
-      if (sexp.instance_of? Java::OrgRenjinSexp::Null)
+      if (sexp.java_kind_of? Java::OrgRenjinSexp::Null)
         res = nil
-      elsif (sexp.instance_of? Java::OrgRenjinSexp::ListVector)
+      elsif (sexp.java_kind_of? Java::OrgRenjinSexp::ListVector)
         res = Renjin::List.new(sexp)
-      elsif (sexp.instance_of? Java::OrgRenjinSexp::LogicalArrayVector)
+      elsif (sexp.java_kind_of? Java::OrgRenjinSexp::LogicalArrayVector)
         res = Renjin::Logical.new(sexp)
-      elsif (sexp.instance_of? Java::OrgRenjinSexp::Environment)
+      elsif (sexp.java_kind_of? Java::OrgRenjinSexp::Environment)
         res = Renjin::Environment.new(sexp)
       elsif (sexp.is_a? Java::OrgRenjinSexp::ComplexVector)
         res = Renjin::ComplexVector.new(sexp)
@@ -311,11 +199,12 @@ class Renjin
         res = Renjin::Vector.new(sexp)
       elsif (sexp.is_a? Java::OrgRenjinSexp::Closure)
         res = Renjin::Closure.new(sexp)
+      elsif (sexp.is_a? Java::OrgRenjinSexp::ExternalPtr)
+        res = Renjin::RubySexp.new(sexp)
       # elsif (sexp.is_a? Java::OrgRenjinPrimitives::R$primitive$sum)
         # res = Renjin::Primitive.new(sexp)
       else
-        p "sexp type needs to be specialized"
-        p sexp
+        puts "rbsexp build: sexp type needs to be specialized: #{sexp}"
         res = Renjin::RubySexp.new(sexp)
       end
       
@@ -328,8 +217,8 @@ class Renjin
 end
 
 require_relative 'ruby_classes'
-require_relative 'vector'
-require_relative 'list'
+require_relative 'indexed'
 require_relative 'function'
 require_relative 'logical_value'
 require_relative 'environment'
+require_relative 'callback'