alexgutteridge-rsruby 0.5

data/test/tc_sigint.rb

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

data/test/tc_to_r.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+require 'rsruby'
+
+class Foo
+end
+
+class Bar
+  def initialize(x)
+    @x = x
+  end
+  def as_r
+    @x
+  end
+end
+
+class TestToR < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+    #@r.gctorture(:on => true)
+    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,153 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestToRuby < Test::Unit::TestCase
+  @@test_dir = File.expand_path File.dirname(__FILE__) 
+  
+  def setup
+    @r = RSRuby.instance
+    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_dir+"/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'
+
+class TestVars < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+  end
+
+  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

data/test/test_all.rb

@@ -0,0 +1,22 @@
+#Tests all test cases for rsruby
+
+require 'test/unit'
+
+require 'tc_array'
+require 'tc_boolean'
+require 'tc_cleanup'
+require 'tc_eval'
+require 'tc_extensions'
+require 'tc_init'
+#require 'tc_io'
+require 'tc_library'
+require 'tc_matrix'
+require 'tc_modes'
+require 'tc_robj'
+#require 'tc_sigint'
+require 'tc_to_ruby'
+require 'tc_to_r'
+require 'tc_util'
+require 'tc_vars'
+
+

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: alexgutteridge-rsruby
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Alex Gutteridge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
+email: ag357@cam.ac.uk
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.txt
+- History.txt
+- License.txt
+- examples/bioc.rb
+- examples/dataframe.rb
+- examples/arrayfields.rb
+- examples/erobj.rb
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile.rb
+- examples/arrayfields.rb
+- examples/bioc.rb
+- examples/dataframe.rb
+- examples/erobj.rb
+- ext/Converters.c
+- ext/Converters.h
+- ext/R_eval.c
+- ext/R_eval.h
+- ext/extconf.rb
+- ext/robj.c
+- ext/rsruby.c
+- ext/rsruby.h
+- lib/rsruby.rb
+- lib/rsruby/dataframe.rb
+- lib/rsruby/erobj.rb
+- lib/rsruby/robj.rb
+- test/table.txt
+- test/tc_array.rb
+- test/tc_boolean.rb
+- test/tc_cleanup.rb
+- test/tc_eval.rb
+- test/tc_extensions.rb
+- test/tc_init.rb
+- test/tc_io.rb
+- test/tc_library.rb
+- test/tc_matrix.rb
+- test/tc_modes.rb
+- test/tc_robj.rb
+- test/tc_sigint.rb
+- test/tc_to_r.rb
+- test/tc_to_ruby.rb
+- test/tc_util.rb
+- test/tc_vars.rb
+- test/test_all.rb
+has_rdoc: true
+homepage: http://web.kuicr.kyoto-u.ac.jp/~alexg/rsruby/
+post_install_message: 
+rdoc_options: 
+- --exclude
+- test/*
+- --main
+- README.txt
+- --inline-source
+require_paths: 
+- lib
+- test
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rsruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
+test_files: 
+- test/test_all.rb