rsruby 0.4.0 → 0.4.2

data/lib/rsruby/dataframe.rb

@@ -1,14 +1,18 @@
+require 'rsruby'
+require 'rsruby/erobj'
+
 #== Synopsis
 #
-#This is an extended #ERObj class inspired by the example given in the RPy
+#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 
+#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 for examples of usage.
+#See examples/dataframe.rb[link:files/examples/dataframe_rb.html] for 
+#examples of usage.
 #
 #--
 #== Author
@@ -41,9 +45,6 @@
 #Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #++
 
-require 'rsruby'
-require 'rsruby/erobj'
-
 class DataFrame < ERObj
 
   #Returns an array of the row names used in the R data frame.
@@ -58,6 +59,10 @@ class DataFrame < ERObj
     return cols
   end
 
+  def[](col)
+    return @r['$'].call(@robj,col.to_s)
+  end
+
   def method_missing(attr)
     attr = attr.to_s
     mode = RSRuby.get_default_mode

data/lib/rsruby/erobj.rb

@@ -1,13 +1,16 @@
+require 'rsruby'
+
 #== Synopsis
 #
-#This is an extended #RObj class inspired by the example given in the RPy
+#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
+#representation used in R.
 #
 #== Usage
 #
-#See examples/erobj.rb for examples of usage.
+#See examples/erobj.rb[link:files/examples/erobj_rb.html] for examples of 
+#usage.
 #
 #--
 # == Author
@@ -40,25 +43,28 @@
 #Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #++
 
-require 'rsruby'
-
 class ERObj
 
   @@x = 1
 
-  #Requires an RObj for intialization.
+  #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 wrapped RObj when RSRuby attempts to convert it to
-  #R.
+  #Returns the storred RObj.
   def as_r
     @robj.as_r
   end
 
-  #Calls the wrapped RObj.
+  #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
@@ -72,7 +78,7 @@ class ERObj
     RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
     a = @r.textConnection("tmpobj#{@@x}",'w')
 
-    RSRuby.set_default_mode(RSRuby::BASIC_CONVERSION)
+    RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
     @r.sink(:file => a, :type => 'output')
     @r.print_(@robj)
     @r.sink.call()
@@ -86,6 +92,8 @@ class ERObj
 
   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)

data/lib/rsruby/robj.rb

@@ -3,7 +3,7 @@
 #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 
+#default return type if RSRuby cannot convert the returned results of an R 
 #function.
 #
 #--
@@ -32,7 +32,9 @@ class RObj
 
   attr_accessor :conversion, :wrap
 
-  :private
+  #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
@@ -45,6 +47,9 @@ class RObj
     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

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

@@ -1,22 +1,19 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class TestArray < Test::Unit::TestCase
 
   def setup
 
+    @r = RSRuby.instance
     @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,
+    @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)
+    @r.array.autoconvert(RSRuby::BASIC_CONVERSION)
   end
 
   def test_convert_to_ruby
@@ -25,22 +22,22 @@ class TestArray < Test::Unit::TestCase
 
   #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)
+    @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,
+    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))
+    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
@@ -51,7 +48,7 @@ class TestArray < Test::Unit::TestCase
 
   def test_R_out_of_bounds
     assert_raise RException do
-      $r['[['].call(@r_array, 5,5,5)
+      @r['[['].call(@r_array, 5,5,5)
     end
   end
 

data/test/tc_boolean.rb

@@ -1,27 +1,24 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class TestBoolean < Test::Unit::TestCase
 
   def setup
+    @r = RSRuby.instance
     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))
+      (@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))
+      (@r.typeof(@r.FALSE) == 'logical' and not
+       @r.as_logical(@r.FALSE))
     end
   end
 end

data/test/tc_cleanup.rb

@@ -1,22 +1,20 @@
 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()
+  def setup
+    @r = RSRuby.instance
   end
 
-  def test_restart
-    $r.shutdown
-    $r = RSRuby.instance()
-    assert $r
+  def test_shutdown
+    tempdir = @r.tempdir.call
+    @r.postscript(tempdir+"/foo.ps")
+    @r.plot(1,1)
+    @r.dev_off.call
+    assert(File.exists?(tempdir))
+    @r.shutdown
+    assert(!File.exists?(tempdir))
   end
+
 end

data/test/tc_eval.rb

@@ -3,13 +3,17 @@ require 'rsruby'
 
 class TestEval < Test::Unit::TestCase
 
+  def setup
+    @r = RSRuby.instance
+  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)  
+    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,26 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestNewCases < Test::Unit::TestCase
+
+  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)
+
+  end
+
+  def test_dataframe
+
+    r = RSRuby.instance
+    r.as_data_frame({'x' => [1,2,3], 'row.names' => ['a','b','c']})
+
+  end
+
+end

data/test/tc_io.rb

@@ -1,10 +1,6 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class DummyIO
   def write
   end
@@ -13,6 +9,7 @@ end
 class TestIO < Test::Unit::TestCase
 
   def setup
+    @r = RSRuby.instance
     $stdout = $stderr = DummyIO.new
   end
 
@@ -23,15 +20,15 @@ class TestIO < Test::Unit::TestCase
 
   def test_io_stdin
     dummy = lambda{|prompt,n| prompt+'\n'}
-    $r.set_rsruby_input(dummy)
-    assert $r.readline('foo') == 'foo'
+    @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)
+    @r.set_rsruby_output(dummy)
+    @r.print(5)
     assert out == ['[1]','5','\n']
   end
 
@@ -40,8 +37,8 @@ class TestIO < Test::Unit::TestCase
     dummy = lambda{|files,headers,title,delete|
       out.push('foo')
     }
-    $r.set_rsruby_showfiles(dummy)
-    $r.help()
+    @r.set_rsruby_showfiles(dummy)
+    @r.help()
     assert out == ['foo']
   end
      

data/test/tc_library.rb

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

data/test/tc_modes.rb

@@ -1,38 +1,35 @@
 require 'test/unit'
 require 'rsruby'
 
-unless $r
-  $r = RSRuby.instance
-end
-
 class TestModes < 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_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')}
+    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)
+    @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))
+    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])
+    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)
@@ -43,11 +40,11 @@ class TestModes < Test::Unit::TestCase
     RSRuby.set_default_mode(RSRuby::VECTOR_CONVERSION)
     assert_equal(sequence.to_ruby, [1,2,3])
 
-    $r.class_table['htest'] = lambda{5}
+    @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}
+    @r.proc_table[lambda{true}] = lambda{return 6}
     RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
     assert_equal(t_test.to_ruby, 6)
   end
@@ -73,50 +70,50 @@ class TestModes < Test::Unit::TestCase
   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)
+    @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.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)
+    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)
+    @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)
+    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])
+    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)
+    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])
+    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
 
@@ -124,67 +121,67 @@ class TestModes < Test::Unit::TestCase
     
     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(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), 
+    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)
+    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(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), 
+    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)
+    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
+    @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')
+    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'])
+    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}
+    @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'])
+    @r.class_table.delete(['bar','foo'])
     assert_equal(g.to_ruby, 'bar')
     
-    $r.class_table.delete('bar')
+    @r.class_table.delete('bar')
     assert_equal(g.to_ruby, 'foo')
     
   end
@@ -192,7 +189,7 @@ class TestModes < Test::Unit::TestCase
   def test_proc_table
 
     t = lambda{|x|
-      e = $r.attr(x,'names')
+      e = @r.attr(x,'names')
       return false if e.nil?
       if e == 'alternative' or e.include?('alternative')
         return true
@@ -200,12 +197,67 @@ class TestModes < Test::Unit::TestCase
         return false
       end
     }
-    f = lambda{|x| $r['$'].call(x,'alternative')}
+    f = lambda{|x| @r['$'].call(x,'alternative')}
 
-    $r.proc_table[t] = f
+    @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')
+    @r.t_test.autoconvert(RSRuby::PROC_CONVERSION)
+    assert_equal(@r.t_test([1,2,3]), 'two.sided')
+
+  end
+
+  def test_proc_convert
+
+    r = RSRuby.instance
+
+    check_str = lambda{|x| RSRuby.instance.is_character(x)}
+    f = lambda{|x|
+      x = x.to_ruby(RSRuby::BASIC_CONVERSION)
+      return "Cannot return 'foo'" if x == 'foo'
+      return x
+    }
+    
+    r.proc_table[check_str] = f
+
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+
+    assert_equal('bar',r.c('bar'))
+    assert_equal("Cannot return 'foo'",r.c('foo'))
+    assert_equal(['bar','foo'],r.c('bar','foo'))
+
+  end
+
+  def test_restore_mode_after_exception_in_proc
+
+    r = RSRuby.instance
+    
+    check_str = lambda{|x| RSRuby.instance.is_character(x)}
+    f = lambda{|x|
+      x.reverse
+    }
+    
+    r.proc_table[check_str] = f
+
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+
+    assert_equal(6,r.sum(1,2,3))
+    assert_equal(RSRuby::PROC_CONVERSION,RSRuby.get_default_mode)
+    assert_raise(NoMethodError){r.paste("foo","bar")}
+    assert_raise(NoMethodError){r.paste("foo","bar")}
+    assert_equal(RSRuby::PROC_CONVERSION,RSRuby.get_default_mode)
+
+  end
+
+  def test_restore_mode_after_exception_in_class
+
+    r = RSRuby.instance
+    r.class_table['htest'] = lambda{|x| x.foo}
+
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    assert_equal(RSRuby::CLASS_CONVERSION,RSRuby.get_default_mode)
+    assert_raise(NoMethodError){r.t_test([1,2,3])}
+    assert_raise(NoMethodError){r.t_test([1,2,3])}
+    assert_equal(RSRuby::CLASS_CONVERSION,RSRuby.get_default_mode)
 
   end