rsruby 0.4.0

data/test/tc_robj.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestRObj < Test::Unit::TestCase
+
+  def setup
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    $r.class_table.clear
+    $r.proc_table.clear
+  end
+
+  def test_type
+    assert_equal($r.array.class, RObj)
+  end
+
+  def test_call
+    #TODO
+  end
+
+  def test_keyword_parameters
+    #TODO - In RPy keyword parameters are converted like the method calls
+    #In ruby this isn't such a problem because you can use quoted strings
+    #but we will implement it anyway.
+    $r.list.autoconvert(RSRuby::BASIC_CONVERSION)
+    d = $r.list(:foo => 'foo', :bar_foo => 'bar.foo', :print_ => 'print', :as_data_frame => 'as.data.frame')
+    d.each do |k,v|
+      assert_equal(k, d[k])
+    end
+  end
+
+  def test_bad_keyword_parameters
+    #TODO?
+    #assert_raises(ArgumentError){$r.list(:none => 1)}
+  end
+
+  def test_name_conversions
+    assert_equal($r.array, $r['array'])
+    assert_equal($r.print_,$r['print'])
+    assert_equal($r.as_data_frame, $r['as.data.frame'])
+    assert_equal($r.attr__, $r['attr<-'])
+  end
+
+  def test_not_found
+    assert_raises(RException){$r.foo}
+  end
+
+  def test_name_length_one
+    assert_nothing_raised{$r.T}
+  end
+
+  def test_autoconvert
+    $r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.seq(10), (1..10).to_a)
+    $r.seq.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.seq(10).class, RObj)
+  end
+
+  def test_bad_autoconvert
+    assert_raises(ArgumentError){$r.seq.autoconvert(RSRuby::TOP_CONVERSION+1)}
+  end
+
+  def test_get_autoconvert
+    $r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
+    mode = $r.seq.autoconvert
+    assert_equal(mode, RSRuby::BASIC_CONVERSION)
+  end
+
+  def test_r_gc
+    #TODO - How can this work?
+    $r.seq.autoconvert(RSRuby::NO_CONVERSION)
+    arr = $r.seq(100000)
+    $r.gc
+    assert($r['['].call(arr,10))
+  end
+
+  def test_lcall
+    RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    arr = $r.c.lcall([['',0],['a',1],['b',2],['c',3]])
+    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.names(arr), ['','a','b','c'])
+  end
+
+end

data/test/tc_sigint.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestSigint < Test::Unit::TestCase
+
+  def test_sigint
+    assert_raises(SystemExit){Process.kill('SIGINT',0)}
+  end
+
+end

data/test/tc_to_r.rb

@@ -0,0 +1,146 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class Foo
+end
+
+class Bar
+  def initialize(x)
+    @x = x
+  end
+  def as_r
+    @x
+  end
+end
+
+class TestToR < Test::Unit::TestCase
+
+  def setup
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+  end
+
+  def test_robj_to_r
+
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+
+    r1 = $r.c(4)
+    r2 = $r.c('foo')
+    r3 = $r.c(['a','b'])
+
+    assert($r['=='].call(r1,4))
+    assert($r['=='].call(r2,'foo'))
+    assert($r['=='].call(r3,['a','b']))
+
+    assert_equal($r.typeof($r.eval),'closure')
+    assert_equal($r.typeof($r.eval($r.eval)), 'closure')
+    assert_equal($r.typeof($r.eval([$r.eval,$r.eval])), 'list')
+
+    #Same tests as above in basic mode - should be identical
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+
+    r1 = $r.c(4)
+    r2 = $r.c('foo')
+    r3 = $r.c(['a','b'])
+
+    assert($r['=='].call(r1,4))
+    assert($r['=='].call(r2,'foo'))
+    assert($r['=='].call(r3,['a','b']))
+
+    assert_equal($r.typeof($r.eval),'closure')
+    assert_equal($r.typeof($r.eval($r.eval)), 'closure')
+    assert_equal($r.typeof($r.eval([$r.eval,$r.eval])), 'list')
+
+  end
+
+  def test_empty_array_to_null
+    assert($r.is_null([]))
+  end
+
+  def test_boolean_to_logical
+    assert_equal($r.c(true),true)
+    assert_equal($r.c(true).class,true.class)
+    assert_equal($r.c(false),false)
+    assert_equal($r.c(false).class,false.class)
+  end
+
+  def test_int_to_int
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.typeof($r.c(4)), 'integer')
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.typeof($r.c(4)), 'integer')
+  end
+
+  def test_float_to_float
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.typeof($r.c(4.5)), 'double')
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.typeof($r.c(4.5)), 'double')
+  end
+
+  def test_char_to_char
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.typeof($r.c('foo')), 'character')
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.typeof($r.c('foo')), 'character')
+  end
+
+  def test_hash_to_named_vector
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)    
+    assert_equal($r.typeof($r.c(:foo => 5, :bar => 7)),'integer')
+    assert($r.attributes($r.c(:foo => 5, :bar => 7))['names'].include?('foo'))
+    assert($r.attributes($r.c(:foo => 5, :bar => 7))['names'].include?('bar'))
+    #TODO - these fail because of the different calling semantics in
+    #RSRuby
+    #$r.c.autoconvert(RSRuby::BASIC_CONVERSION)    
+    #assert_equal($r.typeof($r.c(:foo => 5, :bar => 7)),'integer')
+    #assert($r.attributes($r.c(:foo => 5, :bar => 7))['names'].include?('foo'))
+    #assert($r.attributes($r.c(:foo => 5, :bar => 7))['names'].include?('bar'))      
+  end
+
+  def test_array_to_vector
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)    
+    assert_equal($r.length($r.c(1,2,3,4)),4)
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)    
+    assert_equal($r.length($r.c(1,2,3,4)),4)
+  end
+
+  def test_not_convertible
+    #TODO - range?
+    assert_raises(ArgumentError){$r.c(1..10)}
+  end
+
+  def test_instances_not_convertible
+    foo = Foo.new
+    assert_raises(ArgumentError){$r.c(foo)}
+  end
+
+  def test_as_r_method
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+
+    a = Bar.new(3)
+    b = Bar.new('foo')
+    d = Bar.new($r.seq)
+
+    assert_equal($r.c(a),3)
+    assert_equal($r.c(b),'foo')
+    assert_equal($r.c(d).call(1,3),[1,2,3])
+
+  end
+
+  def test_max_int_to_r
+    #TODO
+  end
+
+  def test_inf_to_r
+    #TODO
+  end
+
+  def test_NaN_to_r
+    #TODO
+  end
+
+end

data/test/tc_to_ruby.rb

@@ -0,0 +1,155 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestToRuby < Test::Unit::TestCase
+
+  def setup
+    RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    $r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+  end
+
+  def test_null_to_nil
+    assert($r.attributes($r.seq).nil?)
+  end
+
+  def test_factor_to_list
+    assert_equal($r.factor([1,2,3,4]), ['1','2','3','4'])
+    assert_equal($r.factor([1,1,1,2]), ['1','1','1','2'])
+    assert_equal($r.factor(['a','b','c']), ['a','b','c'])
+  end
+
+  def test_NA_int
+    #The formula on right should equal smallest Fixnum
+    #in current Ruby build (can vary)
+    assert_equal($r.NA, (-1)*(2**((1.size*8)-1)))
+    assert($r.is_na($r.NA))
+  end
+
+  def test_NA_string
+    assert_equal($r.eval_R('as.character(NA)'), 'NA')
+    assert_equal($r.as_character($r.NA), 'NA')
+    assert_equal($r.as_character($r.NaN), 'NaN')
+  end
+
+  def test_factor_NA
+    assert_equal($r.factor($r.NA) , 'NA')
+    assert_equal($r.factor($r.NaN), 'NaN')
+    assert_equal($r.factor($r.as_character('NA')), 'NA')
+
+    xi = [1,2,$r.NA,$r.NaN,4]
+    assert_equal($r.factor(xi), ['1','2','NA','NaN','4'])
+
+    xd = [1.01,2.02,$r.NA,$r.NaN,4.04]
+    assert_equal($r.factor(xd), ['1.01','2.02','NA','NaN','4.04'])
+
+  end
+
+  def test_NA_list
+
+    #TODO - RPy has commented out these tests as well. 
+    #The conversion between NA/NaN and Ruby seems a little confused 
+    #at the moment
+
+    xi = [1,2,$r.NA,$r.NaN,4]
+    assert_equal($r.as_character(xi), ['1','2','NA','NaN','4'])
+    #assert_equal($r.as_numeric(xi)  , [1.0,2.0,$r.NA,$r.NaN,4.0])
+    #assert_equal($r.as_integer(xi)  , [1,2,$r.NA,$r.NaN,4])
+    assert_equal($r.factor(xi)      , ['1','2','NA','NaN','4'])
+    assert_equal($r.is_na(xi)       , [false, false, true, true, false])
+
+    xd = [1.01,2.02,$r.NA,$r.NaN,4.04]
+    assert_equal($r.as_character(xd), ['1.01','2.02','NA','NaN','4.04'])
+    #assert_equal($r.as_numeric(xi)  , [1.01,2.01,$r.NA,$r.NaN,4.01])
+    assert_equal($r.as_integer(xd)  , [1,2,$r.NA,$r.NA,4])
+    assert_equal($r.factor(xd)      , ['1.01','2.02','NA','NaN','4.04'])
+    assert_equal($r.is_na(xd)       , [false, false, true, true, false])    
+  end
+
+  #TODO - table.txt?????????
+  def test_dataframe_to_list
+    $r.read_table.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.read_table('test/table.txt', {:header => 1}), 
+      {
+        'A' => ['X1','X2','X3'], 
+        'C' => [5,8,2], 
+        'B' => [4.0,7.0,6.0],
+        'D' => ['6','9','Foo']
+      })
+  end
+  
+  def test_logical_to_boolean
+    assert_equal($r.TRUE,  true)
+    assert_equal($r.T,     true)
+    assert_equal($r.FALSE, false)
+    assert_equal($r.F,     false)
+  end
+
+  def test_int_to_int
+    assert_equal($r.as_integer(5),5)
+    assert_equal($r.as_integer(-3),-3)
+  end
+
+  def test_float_to_float
+    assert_equal($r.as_real(5),5.0)
+    assert_equal($r.as_real(3.1),3.1)
+    assert_equal($r.as_real(-3.1), -3.1)
+  end
+
+  def test_complex_to_complex
+    #TODO - Think about Complex support
+    assert_equal($r.as_complex(Complex(1,2)), Complex(1,2))
+    assert_equal($r.as_complex(Complex(1.5,-3.4)), Complex(1.5,-3.4))
+  end
+
+  def test_str_to_str
+    $r.as_data_frame.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.class_($r.as_data_frame([1,2,3])), 'data.frame')
+  end
+
+  def test_vector_length_one
+    assert_equal($r.c(1),1)
+    assert_equal($r.c('foo'),'foo')
+  end
+
+  def test_int_vector_to_array
+    assert_equal($r.seq(10),[1,2,3,4,5,6,7,8,9,10])
+  end
+
+  def test_float_vector_to_array
+    assert_equal($r.seq(1,2,{:by => 0.5}), [1.0,1.5,2.0])
+  end
+
+  def test_complex_vector_to_array
+    assert_equal($r.c(Complex(1,2),Complex(2,-3)),[Complex(1,2),Complex(2,-3)])
+  end
+
+  def test_str_vector_to_array
+    assert_equal($r.c('Foo','Bar'),['Foo','Bar'])
+  end
+
+  def test_list_to_array
+    $r.list.autoconvert(RSRuby::BASIC_CONVERSION)
+    assert_equal($r.list(1,2.0,'foo'),[1,2.0,'foo'])
+  end
+
+  def test_named_vector_to_hash
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    a = $r.attr__($r.c(1,2,3), 'names', ['foo','bar','baz'])
+    assert_equal(a,{'foo'=>1,'bar'=>2,'baz'=>3})
+    assert_equal($r.list(:foo => 1, :bar => 2, :baz => 3),{'foo'=>1,'bar'=>2,'baz'=>3})
+  end
+
+  def test_vector_coercion
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    assert_equal($r.typeof($r.c(1,2,3)), 'integer')
+    assert_equal($r.typeof($r.c(1,2.0,3)), 'double')
+    assert_equal($r.typeof($r.c(1,Complex(2,3),3)), 'complex')
+    assert_equal($r.typeof($r.c(1,'foo',3)), 'character')    
+  end
+
+end

data/test/tc_util.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestUtil < Test::Unit::TestCase
+
+  def test_as_list
+    #TODO
+    #assert_equal($r.as_lis
+  end
+
+  def test_with_mode
+    #TODO
+  end
+
+  def test_r_code
+    #TODO - Not sure about this. I use r.eval_R('')
+    #Not really a util
+  end
+end

data/test/tc_vars.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'rsruby'
+
+unless $r
+  $r = RSRuby.instance
+end
+
+class TestVars < Test::Unit::TestCase
+
+  def test_get_vars
+    $r.eval_R("f<-function(x) x+1")
+    $r.assign('x',100)
+    $r.assign('v',(1..10).to_a)
+    #There is a difference here between RPy and us
+    #a final hash argument is treated as named arguments
+    #to the original function call (assign) not as a list
+    #to be given to the function
+    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    $r.assign('d',$r.c({'a' => 1, 'b' => 2}))
+    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+
+    assert_equal($r.x, 100)
+    assert_equal($r.v, (1..10).to_a)
+    assert_equal($r.d, $r.c({'a' => 1, 'b' => 2}))
+    assert_equal($r.f.class, $r.c.class)
+  end
+
+end