rsruby 0.4.0

data/lib/rsruby/erobj.rb

@@ -0,0 +1,97 @@
+#== 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 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
+#++
+
+require 'rsruby'
+
+class ERObj
+
+  @@x = 1
+
+  #Requires an RObj for intialization.
+  def initialize(robj)
+    @robj = robj
+    @r    = RSRuby.instance
+  end
+
+  #Returns the wrapped RObj when RSRuby attempts to convert it to
+  #R.
+  def as_r
+    @robj.as_r
+  end
+
+  #Calls the wrapped 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::BASIC_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
+
+  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,58 @@
+#== 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
+
+  :private
+  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
+
+  def autoconvert(m=false)
+    if m
+      raise ArgumentError if m < -1 or m > RSRuby::TOP_CONVERSION
+      @conversion = m
+    end
+    @conversion      
+  end
+
+end
+
+

data/test/tc_array.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestArray < Test::Unit::TestCase
+
+  def setup
+
+    @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_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,27 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestBoolean < Test::Unit::TestCase
+
+  def setup
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+  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
+end

data/test/tc_cleanup.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestCleanup < Test::Unit::TestCase
+
+  def test_shutdown
+    #TODO - shutdown doesn't really seem to do anything???
+    $r.shutdown
+    assert $r.nil?
+    $r = RSRuby.instance()
+  end
+
+  def test_restart
+    $r.shutdown
+    $r = RSRuby.instance()
+    assert $r
+  end
+end

data/test/tc_eval.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestEval < Test::Unit::TestCase
+
+  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_io.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class DummyIO
+  def write
+  end
+end
+
+class TestIO < Test::Unit::TestCase
+
+  def setup
+    $stdout = $stderr = DummyIO.new
+  end
+
+  def teardown
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+
+  def test_io_stdin
+    dummy = lambda{|prompt,n| prompt+'\n'}
+    $r.set_rsruby_input(dummy)
+    assert $r.readline('foo') == 'foo'
+  end
+
+  def test_io_stdout
+    out = []
+    dummy = lambda{|string| out.push(string)}
+    $r.set_rsruby_output(dummy)
+    $r.print(5)
+    assert out == ['[1]','5','\n']
+  end
+
+  def test_io_showfiles
+    out = []
+    dummy = lambda{|files,headers,title,delete|
+      out.push('foo')
+    }
+    $r.set_rsruby_showfiles(dummy)
+    $r.help()
+    assert out == ['foo']
+  end
+     
+  def test_io_stdout_exception
+    #TODO - I can't understand this test in Rpy
+  end
+
+  def test_io_stdin_exception
+    #TODO - I can't understand this test in Rpy
+  end  
+
+  def test_io_stderr_exception
+    #TODO - I can't understand this test in Rpy
+  end
+
+end

data/test/tc_library.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestLibrary < Test::Unit::TestCase
+
+  def test_library
+    #Test success
+    assert_nothing_raised(){$r.library("boot")}
+  end
+
+  def test_library_fail
+    #Test failure
+    assert_raises(RException){$r.library("Missing")}
+  end  
+
+end

data/test/tc_modes.rb

@@ -0,0 +1,212 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestModes < Test::Unit::TestCase
+
+  def setup
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    $r.class_table.clear
+    $r.proc_table.clear
+  end
+
+  def test_to_ruby_args
+    assert_raises(ArgumentError){$r.seq.to_ruby(RSRuby::TOP_CONVERSION+1)}
+    assert_raises(ArgumentError){$r.seq.to_ruby(-2)}
+    assert_raises(TypeError){$r.seq.to_ruby('foo')}
+  end
+
+  def test_to_ruby
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    four = $r.c(4)
+    assert_equal(four.to_ruby, 4)
+    assert_equal(four.to_ruby(RSRuby::PROC_CONVERSION), 4)
+    assert_equal(four.to_ruby(RSRuby::BASIC_CONVERSION), 4)
+    assert_equal(four.to_ruby(RSRuby::VECTOR_CONVERSION), [4])
+    assert($r["=="].call(four.to_ruby(RSRuby::NO_CONVERSION),four))
+  end
+
+  def test_to_ruby_default_arg
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    sequence = $r.seq(1,3)
+    t_test   = $r.t_test([1,2,3])
+
+    assert_equal(sequence.to_ruby.class , RObj)
+    assert_equal(sequence.to_ruby.class, sequence.class)
+
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    assert_equal(sequence.to_ruby, [1,2,3])
+    
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
+    assert_equal(sequence.to_ruby, [1,2,3])
+
+    $r.class_table['htest'] = lambda{5}
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    assert_equal(t_test.to_ruby, 5)
+
+    $r.proc_table[lambda{true}] = lambda{return 6}
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+    assert_equal(t_test.to_ruby, 6)
+  end
+
+  def test_default_modes
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+    assert_equal(RSRuby.get_default_mode, RSRuby::PROC_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    assert_equal(RSRuby.get_default_mode, RSRuby::CLASS_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    assert_equal(RSRuby.get_default_mode, RSRuby::BASIC_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
+    assert_equal(RSRuby.get_default_mode, RSRuby::VECTOR_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    assert_equal(RSRuby.get_default_mode, RSRuby::NO_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    assert_equal(RSRuby.get_default_mode, RSRuby::NO_DEFAULT)
+  end
+
+  def test_bad_modes
+    assert_raises(ArgumentError){RSRuby.set_default_mode(-2)}
+    assert_raises(ArgumentError){RSRuby.set_default_mode(RSRuby::TOP_CONVERSION+1)}
+  end
+
+  def test_no_default_mode
+    $r.t_test.autoconvert(RSRuby::CLASS_CONVERSION)
+    $r.array.autoconvert(RSRuby::NO_CONVERSION)
+    $r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
+
+    assert_equal($r.array(1,3).class, $r.array.class)
+    
+    assert_equal($r.seq(1,3), [1,2,3])
+    $r.class_table['htest'] = lambda{5}
+    assert_equal($r.t_test([1,2,3]), 5)
+  end
+
+  def test_individual_conversions
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    $r.seq.autoconvert(RSRuby::PROC_CONVERSION)
+    $r.min.autoconvert(RSRuby::VECTOR_CONVERSION)
+
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    assert_equal($r.c(4).class, RObj)
+    assert_equal($r.seq(1,3).class, RObj)
+    assert_equal($r.min(1,3).class, RObj)
+
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    assert_equal($r.c.autoconvert, RSRuby::BASIC_CONVERSION)
+    assert_equal($r.seq.autoconvert, RSRuby::PROC_CONVERSION)
+    assert_equal($r.min.autoconvert, RSRuby::VECTOR_CONVERSION)
+    assert_equal($r.c(4), 4)
+    assert_equal($r.seq(1,3), [1,2,3])
+    assert_equal($r.min(1,3), [1])
+    
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.c.autoconvert, RSRuby::BASIC_CONVERSION)
+    assert_equal($r.seq.autoconvert, RSRuby::PROC_CONVERSION)
+    assert_equal($r.min.autoconvert, RSRuby::VECTOR_CONVERSION)
+    assert_equal($r.c(4), 4)
+    assert_equal($r.seq(1,3), [1,2,3])
+    assert_equal($r.min(1,3), 1)
+
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
+    assert_equal($r.c.autoconvert, RSRuby::BASIC_CONVERSION)
+    assert_equal($r.seq.autoconvert, RSRuby::PROC_CONVERSION)
+    assert_equal($r.min.autoconvert, RSRuby::VECTOR_CONVERSION)
+    assert_equal($r.c(4), [4])
+    assert_equal($r.seq(1,3), [1,2,3])
+    assert_equal($r.min(1,3), [1])
+
+  end
+
+  def test_vector_conversion
+    
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
+
+    assert_equal($r.c(true), [true])
+    assert_equal($r.c(4)   , [4])
+    assert_equal($r.c('A') , ['A'])
+
+    assert_equal($r.c(1,'A',2), ['1','A','2'])
+    assert_equal($r.c(:a => 1, :b => 'A', :c => 2), {'a' => '1', 'b' => 'A', 'c' => '2'})
+    assert_equal($r.list(:a => 1, :b => 'A', :c => 2), 
+      {'a' => [1], 'b' => ['A'], 'c' => [2]})
+    assert_equal($r.eval_R("x~y").class, RObj)
+  end
+
+  def test_basic_conversion
+
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.c(true), true)
+    assert_equal($r.c(4), 4)
+    assert_equal($r.c('A') , 'A')
+
+    assert_equal($r.c(1,'A',2), ['1','A','2'])
+    assert_equal($r.c(:a => 1, :b => 'A', :c => 2), {'a' => '1', 'b' => 'A', 'c' => '2'})
+    assert_equal($r.list(:a => 1, :b => 'A', :c => 2), 
+      {'a' => 1, 'b' => 'A', 'c' => 2})
+    assert_equal($r.eval_R("x~y").class, RObj)
+    
+  end
+
+  def test_class_table
+
+    $r.class_table['htest'] = lambda{'htest'}
+    $r.class_table['data.frame'] = lambda{|x| 
+      if $r['[['].call(x,1).length > 2
+        return 5
+      else
+        return 'bar'
+      end
+    }
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    assert_equal($r.t_test([1,2,3]), 'htest')
+    assert_equal($r.as_data_frame([1,2,3]), 5)
+    assert_equal($r.as_data_frame([1,2]), 'bar')
+
+  end
+
+  def test_multiple_class_table
+
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    f = $r.class__($r.c(4),'foo')
+    g = $r.class__($r.c(4), ['bar','foo'])
+
+    $r.class_table['foo'] = lambda{'foo'}
+    $r.class_table['bar'] = lambda{'bar'}
+    $r.class_table[['bar','foo']] = lambda{5}
+
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    assert_equal(f.to_ruby, 'foo')
+    assert_equal(g.to_ruby, 5)
+
+    $r.class_table.delete(['bar','foo'])
+    assert_equal(g.to_ruby, 'bar')
+    
+    $r.class_table.delete('bar')
+    assert_equal(g.to_ruby, 'foo')
+    
+  end
+
+  def test_proc_table
+
+    t = lambda{|x|
+      e = $r.attr(x,'names')
+      return false if e.nil?
+      if e == 'alternative' or e.include?('alternative')
+        return true
+      else
+        return false
+      end
+    }
+    f = lambda{|x| $r['$'].call(x,'alternative')}
+
+    $r.proc_table[t] = f
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    $r.t_test.autoconvert(RSRuby::PROC_CONVERSION)
+    assert_equal($r.t_test([1,2,3]), 'two.sided')
+
+  end
+
+end