alexgutteridge-rsruby 0.5

data/lib/rsruby/dataframe.rb

@@ -0,0 +1,107 @@
+require 'rsruby'
+require 'rsruby/erobj'
+
+#== Synopsis
+#
+#This is an extended ERObj class inspired by the example given in the RPy
+#manual used for R data frames. 
+#As with ERObj, methods caught by method_missing are converted into attribute 
+#calls on the R dataframe it represents. The rows and columns methods give
+#access to the column and row names.
+#
+#== Usage
+#
+#See examples/dataframe.rb[link:files/examples/dataframe_rb.html] for 
+#examples of usage.
+#
+#--
+#== Author
+#Alex Gutteridge
+#
+#== Copyright
+#Copyright (C) 2006 Alex Gutteridge
+#
+# The Original Code is the RPy python module.
+#
+# The Initial Developer of the Original Code is Walter Moreira.
+# Portions created by the Initial Developer are Copyright (C) 2002
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#    Gregory R. Warnes <greg@warnes.net> (RPy Maintainer)
+#
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+#
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#Lesser General Public License for more details.
+#
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+class DataFrame < ERObj
+
+  #Returns an array of the row names used in the R data frame.
+  def rows
+    return @r.attr(@robj, 'row.names')
+  end
+
+  #Returns an array of the column names used in the R data frame.
+  def columns
+    cols = @r.colnames(@robj)
+    cols = [cols] unless cols.kind_of?(Array)
+    return cols
+  end
+
+  #def[](col)
+  #  return @r['$'].call(@robj,col.to_s)
+  #end
+
+  #Needs to work for named and numbered columns
+  def[](row,col)
+    if col.kind_of?(Integer) and !(columns.include?(col))
+      col = columns[col]
+    end
+    return @r['$'].call(@robj,col.to_s)[row]
+  end
+
+  def[]=(row,col,val)
+    #How to set a value in this dataframe?
+    @r.assign("rsrubytemp",@robj)
+    
+    ### VERY HACKY - This relies on val having the same
+    #string representation in R and Ruby. An assign based
+    #solution with proper conversion of val would be much 
+    #better
+    @r.eval_R("rsrubytemp[#{row+1},#{col+1}] <- #{val}")
+    #
+    #@r.assign("rsrubytemp[#{row+1},#{col+1}]",val)
+
+    @robj = @r.eval_R('get("rsrubytemp")')
+
+    return @r['$'].call(@robj,columns[col].to_s)[row]
+  end
+
+  def method_missing(attr)
+    attr = attr.to_s
+    mode = RSRuby.get_default_mode
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    column_names = @r.colnames(@robj)
+    if attr == column_names or column_names.include?(attr)
+      RSRuby.set_default_mode(mode)
+      return @r['$'].call(@robj,attr.to_s)
+    end
+
+    #? Not sure what here...
+    RSRuby.set_default_mode(mode)
+    return super(attr)
+
+  end
+
+end

data/lib/rsruby/erobj.rb

@@ -0,0 +1,105 @@
+require 'rsruby'
+
+#== Synopsis
+#
+#This is an extended RObj class inspired by the example given in the RPy
+#manual. Methods caught by method_missing are converted into attribute calls
+#on the R object it represents. Also to_s is redefined to print exactly the
+#representation used in R.
+#
+#== Usage
+#
+#See examples/erobj.rb[link:files/examples/erobj_rb.html] for examples of 
+#usage.
+#
+#--
+# == Author
+# Alex Gutteridge
+#
+# == Copyright
+#Copyright (C) 2006 Alex Gutteridge
+#
+# The Original Code is the RPy python module.
+#
+# The Initial Developer of the Original Code is Walter Moreira.
+# Portions created by the Initial Developer are Copyright (C) 2002
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#    Gregory R. Warnes <greg@warnes.net> (RPy Maintainer)
+#
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+#
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#Lesser General Public License for more details.
+#
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+class ERObj
+
+  @@x = 1
+
+  #The ERObj is intialised by passing it an RObj instance which it then stores
+  def initialize(robj)
+    @robj = robj
+    @r    = RSRuby.instance
+  end
+
+  #Returns the storred RObj.
+  def as_r
+    @robj.as_r
+  end
+
+  #Returns the Ruby representation of the object according to the basic
+  #conversion mode.
+  def to_ruby
+    @robj.to_ruby(RSRuby::BASIC_CONVERSION)
+  end
+
+  #Calls the storred RObj.
+  def lcall(args)
+    @robj.lcall(args)
+  end
+
+  #Outputs the string representation provided by R.
+  def to_s
+
+    @@x += 1
+
+    mode = RSRuby.get_default_mode
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    a = @r.textConnection("tmpobj#{@@x}",'w')
+
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
+    @r.sink(:file => a, :type => 'output')
+    @r.print_(@robj)
+    @r.sink.call()
+    @r.close_connection(a)
+
+    str = @r["tmpobj#{@@x}"].join("\n")
+
+    RSRuby.set_default_mode(mode)
+
+    return str
+
+  end
+
+  #Methods caught by method_missing are converted into attribute calls on 
+  #the R object it represents.
+  def method_missing(attr)
+    mode = RSRuby.get_default_mode
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    e = @r['$'].call(@robj,attr.to_s)
+    RSRuby.set_default_mode(mode)
+    return e
+  end
+
+end

data/lib/rsruby/robj.rb

@@ -0,0 +1,67 @@
+#== Synopsis
+#
+#This class represents a reference to an object in the R interpreter. It 
+#also holds a conversion mode used if the RObj represents a callable function.
+#RObj objects can be passed to R functions called from Ruby and are the 
+#default return type if RSRuby cannot convert the returned results of an R 
+#function.
+#
+#--
+# == Author
+# Alex Gutteridge
+#
+# == Copyright
+#Copyright (C) 2006 Alex Gutteridge
+#
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+#
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#Lesser General Public License for more details.
+#
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+class RObj
+
+  attr_accessor :conversion, :wrap
+
+  def as_r
+    self
+  end
+
+  #Attempts to call the RObj with the arguments given. Returns the result
+  #of calling the R object. Only use this method if the RObj represents an
+  #R function.
+  def call(*args)
+    if @wrap
+      e = RSRuby.get_default_mode
+      RSRuby.set_default_mode(@wrap)
+      ret = self.lcall(RSRuby.convert_args_to_lcall(args))
+      RSRuby.set_default_mode(e)
+    else
+      ret = self.lcall(RSRuby.convert_args_to_lcall(args))
+    end
+    return ret
+  end
+
+  #Sets the conversion mode for this RObj (only relevant if the RObj
+  #represents a function). See the constants in RSRuby for valid modes.
+  #Returns the current conversion mode if called with no argument.
+  def autoconvert(m=false)
+    if m
+      raise ArgumentError if m < -1 or m > RSRuby::TOP_CONVERSION
+      @conversion = m
+    end
+    @conversion      
+  end
+
+end
+
+

data/test/table.txt

@@ -0,0 +1,4 @@
+A	B	C	D
+'X1'	4.0	5	'6'
+'X2'	7.0	8	'9'
+'X3'	6.0	2	'Foo'

data/test/tc_array.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestArray < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+    #@r.gctorture(:on => false)
+    @ruby_AoA = [[[0,6,12,18],[2,8,14,20],[4,10,16,22]],
+                 [[1,7,13,19],[3,9,15,21],[5,11,17,23]]]
+
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    @r.array.autoconvert(RSRuby::NO_CONVERSION)
+    @r_array  = @r.array({ :data => (0..24).to_a,
+                           :dim  => [2,3,4]})
+    @r.array.autoconvert(RSRuby::BASIC_CONVERSION)
+  end
+
+  def test_boolean
+    assert_equal [true,false], @r.c(true,false)
+  end
+
+  def test_convert_to_ruby
+    assert_equal(@ruby_AoA,@r_array.to_ruby)
+  end
+
+  #I suspect this only works in RPy with Numeric?
+  def test_convert_to_R
+    @r.list.autoconvert(RSRuby::NO_CONVERSION)
+    @r['[['].autoconvert(RSRuby::NO_CONVERSION)
+    o = @r['[['].call(@r.list(@ruby_AoA),1)
+    @r['[['].autoconvert(RSRuby::BASIC_CONVERSION)
+    #assert_equal(@r.all_equal(o,@r_array),true)
+  end
+
+  def test_dimensions
+    assert_equal(@r.dim(@r_array),[@ruby_AoA.length,
+                                   @ruby_AoA[0].length,
+                                   @ruby_AoA[0][0].length])
+  end
+
+  def test_elements
+    assert_equal(@ruby_AoA[0][0][0],@r['[['].call(@r_array, 1,1,1))
+    assert_equal(@ruby_AoA[1][1][1],@r['[['].call(@r_array, 2,2,2))
+  end
+
+  def test_ruby_out_of_bounds
+    assert_raise NoMethodError do
+      @ruby_AoA[5][5][5]
+    end
+  end
+
+  def test_R_out_of_bounds
+    assert_raise RException do
+      @r['[['].call(@r_array, 5,5,5)
+    end
+  end
+
+end

data/test/tc_boolean.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestBoolean < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    @r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+  end
+
+  def test_true
+    assert_block "r.TRUE not working" do 
+      (@r.typeof(@r.FALSE) == 'logical' and 
+       @r.as_logical(@r.TRUE))
+    end
+  end
+  
+  def test_false
+    assert_block "r.FALSE not working" do
+      (@r.typeof(@r.FALSE) == 'logical' and not
+       @r.as_logical(@r.FALSE))
+    end
+  end
+
+  def test_boolean_array
+    assert_equal([true,false,true,false],@r.c(true,false,true,false))
+  end
+
+end

data/test/tc_cleanup.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'rsruby'
+         
+class TestCleanup < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+  end
+
+  def test_shutdown
+    #@r.eval_R("shutdown_test=10")
+    #@r.shutdown
+    #assert_raise(RException){ @r.eval_R("shutdown_test") }
+  end 
+  
+  def test_crash
+    #Signal.trap('BUS','EXIT')
+    #Signal.trap('BUS',proc{ puts 'hi there'; exit!})
+    #@r.crash    
+  end
+
+end

data/test/tc_eval.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestEval < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+    @r.proc_table = {}
+    @r.class_table = {}
+  end
+
+  def test_eval_R
+    #Test integer, Float, String and Boolean return values
+    assert_equal(@r.eval_R("sum(1,2,3)"),6)
+    assert_equal(@r.eval_R("sum(1.5,2.5,3.5)"),7.5)
+    assert_equal(@r.eval_R("eval('R')"),"R")
+    assert_equal(@r.eval_R("is(1,'numeric')"),true)
+    assert_equal(@r.eval_R("is(1,'madeup')"),false)  
+  end
+
+end

data/test/tc_extensions.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestNewCases < Test::Unit::TestCase
+  @@test_dir = File.expand_path File.dirname(__FILE__) 
+  
+  def test_erobj
+    
+    require 'rsruby/erobj'
+    r = RSRuby.instance
+    r.proc_table[lambda{|x| true}] = lambda{|x| ERObj.new(x)}
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+
+    f = r.c(1,2,3)
+    assert_equal('[1] 1 2 3',f.to_s)
+    assert_equal([1,2,3],f.to_ruby)
+    assert_instance_of(RObj,f.as_r)
+
+  end
+
+  def test_dataframe
+
+    require 'rsruby/dataframe'
+    r = RSRuby.instance
+    r.class_table['data.frame'] = lambda{|x| DataFrame.new(x)}
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    table = r.read_table(@@test_dir+"/table.txt",:header=>true)
+    assert_instance_of(DataFrame,table)
+    
+    assert_equal(['A','B','C','D'],table.columns)
+    assert_equal([1,2,3],table.rows)
+
+    #assert_equal(['X1','X2','X3'],table['A'])
+    assert_equal('X2',table[1,'A'])
+    assert_equal('X2',table[1,0])
+
+    assert_equal(7,table[1,1])
+    table[1,1] = 5
+    assert_equal(5,table[1,1])
+
+  end
+
+end