rsruby 0.4.0 → 0.4.2

data/test/tc_robj.rb

@@ -1,20 +1,17 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class TestRObj < Test::Unit::TestCase
 
   def setup
+    @r = RSRuby.instance
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
-    $r.class_table.clear
-    $r.proc_table.clear
+    @r.class_table.clear
+    @r.proc_table.clear
   end
 
   def test_type
-    assert_equal($r.array.class, RObj)
+    assert_equal(@r.array.class, RObj)
   end
 
   def test_call
@@ -25,8 +22,8 @@ class TestRObj < Test::Unit::TestCase
     #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')
+    @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
@@ -34,54 +31,54 @@ class TestRObj < Test::Unit::TestCase
 
   def test_bad_keyword_parameters
     #TODO?
-    #assert_raises(ArgumentError){$r.list(:none => 1)}
+    #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<-'])
+    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}
+    assert_raises(RException){@r.foo}
   end
 
   def test_name_length_one
-    assert_nothing_raised{$r.T}
+    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)
+    @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)}
+    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
+    @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))
+    @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]])
+    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'])
+    assert_equal(@r.names(arr), ['','a','b','c'])
   end
 
 end

data/test/tc_sigint.rb

@@ -4,7 +4,7 @@ require 'rsruby'
 class TestSigint < Test::Unit::TestCase
 
   def test_sigint
-    assert_raises(SystemExit){Process.kill('SIGINT',0)}
+    assert_raises(KeyboardInterrupt){Process.kill('SIGINT',0)}
   end
 
 end

data/test/tc_to_r.rb

@@ -1,10 +1,6 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class Foo
 end
 
@@ -20,114 +16,115 @@ end
 class TestToR < Test::Unit::TestCase
 
   def setup
+    @r = RSRuby.instance
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
   end
 
   def test_robj_to_r
 
-    $r.c.autoconvert(RSRuby::NO_CONVERSION)
+    @r.c.autoconvert(RSRuby::NO_CONVERSION)
 
-    r1 = $r.c(4)
-    r2 = $r.c('foo')
-    r3 = $r.c(['a','b'])
+    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(@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')
+    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)
+    @r.c.autoconvert(RSRuby::BASIC_CONVERSION)
 
-    r1 = $r.c(4)
-    r2 = $r.c('foo')
-    r3 = $r.c(['a','b'])
+    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(@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')
+    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([]))
+    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)
+    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')
+    @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')
+    @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')
+    @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'))
+    @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'))      
+    #@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)
+    @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)}
+    assert_raises(ArgumentError){@r.c(1..10)}
   end
 
   def test_instances_not_convertible
     foo = Foo.new
-    assert_raises(ArgumentError){$r.c(foo)}
+    assert_raises(ArgumentError){@r.c(foo)}
   end
 
   def test_as_r_method
-    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    @r.c.autoconvert(RSRuby::BASIC_CONVERSION)
 
     a = Bar.new(3)
     b = Bar.new('foo')
-    d = Bar.new($r.seq)
+    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])
+    assert_equal(@r.c(a),3)
+    assert_equal(@r.c(b),'foo')
+    assert_equal(@r.c(d).call(1,3),[1,2,3])
 
   end
 

data/test/tc_to_ruby.rb

@@ -1,51 +1,48 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class TestToRuby < Test::Unit::TestCase
 
   def setup
+    @r = RSRuby.instance
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
-    $r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
-    $r.c.autoconvert(RSRuby::BASIC_CONVERSION)
+    @r.seq.autoconvert(RSRuby::BASIC_CONVERSION)
+    @r.c.autoconvert(RSRuby::BASIC_CONVERSION)
   end
 
   def test_null_to_nil
-    assert($r.attributes($r.seq).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'])
+    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))
+    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')
+    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')
+    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'])
+    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'])
+    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
 
@@ -55,25 +52,25 @@ class TestToRuby < Test::Unit::TestCase
     #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])
+    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])    
+    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}), 
+    @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], 
@@ -83,73 +80,73 @@ class TestToRuby < Test::Unit::TestCase
   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)
+    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)
+    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)
+    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))
+    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')
+    @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')
+    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])
+    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])
+    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)])
+    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'])
+    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'])
+    @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'])
+    @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})
+    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')    
+    @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