rinruby 1.1.1 → 1.2.0

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby
+# -*- ruby -*-
+# -*- coding: utf-8 -*-
+$:.unshift(File.dirname(__FILE__)+'/lib/')
+require 'rubygems'
+require 'hoe'
+require './lib/rinruby'
+
+Hoe.plugin :git
+
+Hoe.spec 'rinruby' do
+  self.testlib=:rspec
+  self.version=RinRuby::VERSION
+  # self.rubyforge_name = 'rinruby' # if different than 'rinruby2'
+  self.developer('David Dahl', 'rinruby_AT_ddahl.org')
+  self.developer('Claudio Bustos', 'clbustos_AT_gmail.com')
+  self.url = "http://rinruby.ddahl.org/"
+
+end
+
+# vim: syntax=ruby

data/lib/rinruby.rb

@@ -56,16 +56,23 @@
 #
 #
 #The files "java" and "readline" are used when available to add functionality.
-
+require 'matrix'
 class RinRuby
+  
+  require 'socket'
 
-  VERSION = '1.1.1'
+  
+  VERSION = '1.2.0'
 
-  require 'socket'
 
   attr_reader :interactive
   attr_reader :readline
-
+  # Exception for closed engine
+  EngineClosed=Class.new(Exception)
+  # Parse error
+  ParseError=Class.new(Exception)
+  
+  
 #RinRuby is invoked within a Ruby script (or the interactive "irb" prompt denoted >>) using:
 #
 #      >> require "rinruby"
@@ -96,20 +103,20 @@ class RinRuby
     while true
       begin
         @port_number = port_number + rand(port_width)
-        @server_socket = TCPServer::new("127.0.0.1",@port_number)
+        @server_socket = TCPServer::new("127.0.0.1", @port_number)
         break
       rescue Errno::EADDRINUSE
-        sleep 1 if port_width == 1
+        sleep 0.5 if port_width == 1
       end
     end
     @echo_enabled = echo
     @echo_stderr = false
     @interactive = interactive
     @platform = case RUBY_PLATFORM
-      when /mswin/: 'windows'
-      when /mingw/: 'windows'
-      when /bccwin/: 'windows'
-      when /cygwin/: 'windows-cygwin'
+      when /mswin/ then 'windows'
+      when /mingw/ then 'windows'
+      when /bccwin/ then 'windows'
+      when /cygwin/ then 'windows-cygwin'
       when /java/
         require 'java' #:nodoc:
         if java.lang.System.getProperty("os.name") =~ /[Ww]indows/
@@ -137,10 +144,11 @@ class RinRuby
     @engine = IO.popen(cmd,"w+")
     @reader = @engine
     @writer = @engine
+    raise "Engine closed" if @engine.closed?
     @writer.puts <<-EOF
       #{RinRuby_KeepTrying_Variable} <- TRUE
       while ( #{RinRuby_KeepTrying_Variable} ) {
-        #{RinRuby_Socket} <- try(suppressWarnings(socketConnection("127.0.0.1",#{@port_number},blocking=TRUE,open="rb")),TRUE)
+        #{RinRuby_Socket} <- try(suppressWarnings(socketConnection("127.0.0.1", #{@port_number}, blocking=TRUE, open="rb")),TRUE)
         if ( inherits(#{RinRuby_Socket},"try-error") ) {
           Sys.sleep(0.1)
         } else {
@@ -149,6 +157,9 @@ class RinRuby
       }
       rm(#{RinRuby_KeepTrying_Variable})
     EOF
+    r_rinruby_get_value
+    r_rinruby_pull
+    r_rinruby_parseable
     @socket = @server_socket.accept
     echo(nil,true) if @platform =~ /.*-java/      # Redirect error messages on the Java platform
   end
@@ -156,13 +167,21 @@ class RinRuby
 #The quit method will properly close the bridge between Ruby and R, freeing up system resources. This method does not need to be run when a Ruby script ends.
 
   def quit
-    @writer.puts "q(save='no')"
-    @socket.close rescue true
-    @server_socket::close rescue true
-    @reader.close rescue true
-    @writer.close rescue true
-    @engine.close rescue true
-    true
+    begin 
+      @writer.puts "q(save='no')"
+      @socket.read()
+      #@socket.close 
+      @engine.close 
+  
+      
+      @server_socket.close 
+      #@reader.close 
+      #@writer.close
+      true
+    ensure
+      @engine.close unless @engine.closed?
+      @server_socket.close unless @server_socket.closed?
+    end
   end
 
 
@@ -198,13 +217,14 @@ class RinRuby
 #* echo_override: This argument allows one to set the echo behavior for this call only. The default for echo_override is nil, which does not override the current echo behavior.
 
   def eval(string, echo_override=nil)
+    raise EngineClosed if @engine.closed?
     echo_enabled = ( echo_override != nil ) ? echo_override : @echo_enabled
     if complete?(string)
       @writer.puts string
       @writer.puts "warning('#{RinRuby_Stderr_Flag}',immediate.=TRUE)" if @echo_stderr
       @writer.puts "print('#{RinRuby_Eval_Flag}')"
     else
-      raise "Parse error"
+      raise ParseError, "Parse error on eval"
     end
     Signal.trap('INT') do
       @writer.print ''
@@ -313,10 +333,11 @@ class RinRuby
   def method_missing(symbol, *args)
     name = symbol.id2name
     if name =~ /(.*)=$/
-      raise "Unsupported method" if args.length != 1
+      raise ArgumentError, "You shouldn't assign nil" if args==[nil]
+      super if args.length != 1
       assign($1,args[0])
     else
-      raise "Unsupported method" if args.length != 0
+      super if args.length != 0
       pull(name)
     end
   end
@@ -358,10 +379,11 @@ class RinRuby
 #When assigning an array containing differing types of variables, RinRuby will follow R’s conversion conventions. An array that contains any Strings will result in a character vector in R. If the array does not contain any Strings, but it does contain a Float or a large integer (in absolute value), then the result will be a numeric vector of Doubles in R. If there are only integers that are suffciently small (in absolute value), then the result will be a numeric vector of integers in R.
 
   def assign(name, value)
+     raise EngineClosed if @engine.closed?
     if assignable?(name)
       assign_engine(name,value)
     else
-      raise "Parse error"
+      raise ParseError, "Parse error"
     end
   end
 
@@ -419,6 +441,7 @@ class RinRuby
 #      >> puts R.pull("test")
 
   def pull(string, singletons=false)
+    raise EngineClosed if @engine.closed?
     if complete?(string)
       result = pull_engine(string)
       if ( ! singletons ) && ( result.length == 1 ) && ( result.class != String )
@@ -426,7 +449,7 @@ class RinRuby
       end
       result
     else
-      raise "Parse error"
+      raise ParseError, "Parse error"
     end
   end
 
@@ -466,6 +489,8 @@ class RinRuby
   RinRuby_Type_Integer = 1
   RinRuby_Type_String = 2
   RinRuby_Type_String_Array = 3
+  RinRuby_Type_Matrix = 4
+
   RinRuby_KeepTrying_Variable = ".RINRUBY.KEEPTRYING.VARIABLE"
   RinRuby_Length_Variable = ".RINRUBY.PULL.LENGTH.VARIABLE"
   RinRuby_Type_Variable = ".RINRUBY.PULL.TYPE.VARIABLE"
@@ -481,7 +506,77 @@ class RinRuby
   RinRuby_Max_R_Integer = 2**31-1
   RinRuby_Min_R_Integer = -2**31+1
   #:startdoc:
-
+  
+  
+  def r_rinruby_parseable
+    @writer.puts <<-EOF
+    rinruby_parseable<-function(var) {
+      result=try(parse(text=var),TRUE)
+      if(inherits(result, "try-error")) {
+        writeBin(as.integer(-1),#{RinRuby_Socket}, endian="big")
+      } else {
+        writeBin(as.integer(1),#{RinRuby_Socket}, endian="big")
+      }
+    }
+    EOF
+  end
+  # Create function on ruby to get values
+  def r_rinruby_get_value
+    @writer.puts <<-EOF
+    rinruby_get_value <-function() {
+      value <- NULL
+      type <- readBin(#{RinRuby_Socket}, integer(), 1, endian="big")
+      length <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
+      if ( type == #{RinRuby_Type_Double} ) {
+        value <- readBin(#{RinRuby_Socket},numeric(), length,endian="big")
+        } else if ( type == #{RinRuby_Type_Integer} ) {
+        value <- readBin(#{RinRuby_Socket},integer(), length, endian="big")
+        } else if ( type == #{RinRuby_Type_String} ) {
+        value <- readBin(#{RinRuby_Socket},character(),1,endian="big")
+        } else {
+          value <-NULL
+        }
+      value
+      }
+    EOF
+  end
+  
+  def r_rinruby_pull
+ @writer.puts <<-EOF
+ rinruby_pull <-function(var)
+{
+  if ( inherits(var ,"try-error") ) {
+     writeBin(as.integer(#{RinRuby_Type_NotFound}),#{RinRuby_Socket},endian="big")
+  } else {
+    if (is.matrix(var)) {
+      writeBin(as.integer(#{RinRuby_Type_Matrix}),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(dim(var)[1]),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(dim(var)[2]),#{RinRuby_Socket},endian="big")
+      
+    }  else if ( is.double(var) ) {
+      writeBin(as.integer(#{RinRuby_Type_Double}),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(length(var)),#{RinRuby_Socket},endian="big")
+      writeBin(var,#{RinRuby_Socket},endian="big")
+    } else if ( is.integer(var) ) {
+      writeBin(as.integer(#{RinRuby_Type_Integer}),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(length(var)),#{RinRuby_Socket},endian="big")
+      writeBin(var,#{RinRuby_Socket},endian="big")
+    } else if ( is.character(var) && ( length(var) == 1 ) ) {
+      writeBin(as.integer(#{RinRuby_Type_String}),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(nchar(var)),#{RinRuby_Socket},endian="big")
+      writeBin(var,#{RinRuby_Socket},endian="big")
+    } else if ( is.character(var) && ( length(var) > 1 ) ) {
+      writeBin(as.integer(#{RinRuby_Type_String_Array}),#{RinRuby_Socket},endian="big")
+      writeBin(as.integer(length(var)),#{RinRuby_Socket},endian="big")
+    } else {
+      writeBin(as.integer(#{RinRuby_Type_Unknown}),#{RinRuby_Socket},endian="big")
+    }
+  }
+}
+    EOF
+    
+    
+  end
   def to_signed_int(y)
     if y.kind_of?(Integer)
       ( y > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-y) : ( y == RinRuby_NA_R_Integer ? nil : y )
@@ -492,6 +587,13 @@ class RinRuby
 
   def assign_engine(name, value)
     original_value = value
+    # Special assign for matrixes
+    if value.kind_of?(::Matrix)
+      values=value.row_size.times.collect {|i| value.column_size.times.collect {|j| value[i,j]}}.flatten
+      eval "#{name}=matrix(c(#{values.join(',')}), #{value.row_size}, #{value.column_size}, TRUE)"
+      return original_value
+    end
+    
     if value.kind_of?(String)
       type = RinRuby_Type_String
       length = 1
@@ -536,18 +638,8 @@ class RinRuby
     else
       raise "Unsupported data type on Ruby's end"
     end
-    @writer.puts <<-EOF
-      #{RinRuby_Type_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
-      #{RinRuby_Length_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
-      if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Double} ) {
-        #{name} <- readBin(#{RinRuby_Socket},numeric(),#{RinRuby_Length_Variable},endian="big")
-      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Integer} ) {
-        #{name} <- readBin(#{RinRuby_Socket},integer(),#{RinRuby_Length_Variable},endian="big")
-      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_String} ) {
-        #{name} <- readBin(#{RinRuby_Socket},character(),1,endian="big")
-      } else { }
-      rm(#{RinRuby_Type_Variable},#{RinRuby_Length_Variable})
-    EOF
+    @writer.puts "#{name} <- rinruby_get_value()"
+
     @socket.write([type,length].pack('NN'))
     if ( type == RinRuby_Type_String )
       @socket.write(value)
@@ -560,31 +652,9 @@ class RinRuby
 
   def pull_engine(string)
     @writer.puts <<-EOF
-      #{RinRuby_Variable} <- try(#{string})
-      if ( inherits(#{RinRuby_Variable},"try-error") ) {
-        writeBin(as.integer(#{RinRuby_Type_NotFound}),#{RinRuby_Socket},endian="big")
-      } else {
-        if ( is.double(#{RinRuby_Variable}) ) {
-          writeBin(as.integer(#{RinRuby_Type_Double}),#{RinRuby_Socket},endian="big")
-          writeBin(as.integer(length(#{RinRuby_Variable})),#{RinRuby_Socket},endian="big")
-          writeBin(#{RinRuby_Variable},#{RinRuby_Socket},endian="big")
-        } else if ( is.integer(#{RinRuby_Variable}) ) {
-          writeBin(as.integer(#{RinRuby_Type_Integer}),#{RinRuby_Socket},endian="big")
-          writeBin(as.integer(length(#{RinRuby_Variable})),#{RinRuby_Socket},endian="big")
-          writeBin(#{RinRuby_Variable},#{RinRuby_Socket},endian="big")
-        } else if ( is.character(#{RinRuby_Variable}) && ( length(#{RinRuby_Variable}) == 1 ) ) {
-          writeBin(as.integer(#{RinRuby_Type_String}),#{RinRuby_Socket},endian="big")
-          writeBin(as.integer(nchar(#{RinRuby_Variable})),#{RinRuby_Socket},endian="big")
-          writeBin(#{RinRuby_Variable},#{RinRuby_Socket},endian="big")
-        } else if ( is.character(#{RinRuby_Variable}) && ( length(#{RinRuby_Variable}) > 1 ) ) {
-          writeBin(as.integer(#{RinRuby_Type_String_Array}),#{RinRuby_Socket},endian="big")
-          writeBin(as.integer(length(#{RinRuby_Variable})),#{RinRuby_Socket},endian="big")
-        } else {
-          writeBin(as.integer(#{RinRuby_Type_Unknown}),#{RinRuby_Socket},endian="big")
-        }
-      }
-      rm(#{RinRuby_Variable})
+      rinruby_pull(try(#{string}))
     EOF
+
     buffer = ""
     @socket.read(4,buffer)
     type = to_signed_int(buffer.unpack('N')[0].to_i)
@@ -596,6 +666,7 @@ class RinRuby
     end
     @socket.read(4,buffer)
     length = to_signed_int(buffer.unpack('N')[0].to_i)
+    
     if ( type == RinRuby_Type_Double )
       @socket.read(8*length,buffer)
       result = buffer.unpack('G'*length)
@@ -612,6 +683,18 @@ class RinRuby
       for index in 0...length
         result[index] = pull "#{string}[#{index+1}]"
       end
+    elsif (type == RinRuby_Type_Matrix)
+      rows=length
+      @socket.read(4,buffer)
+      cols = to_signed_int(buffer.unpack('N')[0].to_i)
+      elements=pull "as.vector(#{string})"
+      index=0
+      result=Matrix.rows(rows.times.collect {|i|
+        cols.times.collect {|j|
+          elements[(j*rows)+i]
+        }
+      })
+      def result.length; 2;end
     else
       raise "Unsupported data type on Ruby's end"
     end
@@ -619,22 +702,32 @@ class RinRuby
   end
 
   def complete?(string)
-    assign_engine(RinRuby_Parse_String,string)
+    assign_engine(RinRuby_Parse_String, string)
+    @writer.puts "rinruby_parseable(#{RinRuby_Parse_String})"
+    buffer=""
+    @socket.read(4,buffer)
+    @writer.puts "rm(#{RinRuby_Parse_String})"
+    result = to_signed_int(buffer.unpack('N')[0].to_i)
+    return result==-1 ? false : true
+    
+=begin    
+    
     result = pull_engine("unlist(lapply(c('.*','^Error in parse.*','^Error in parse.*unexpected end of input.*'),
       grep,try({parse(text=#{RinRuby_Parse_String}); 1}, silent=TRUE)))")
-    @writer.puts "rm(#{RinRuby_Parse_String})"
+    
     return true if result.length == 1
     return false if result.length == 3
-    raise "Parse error"
+    raise ParseError, "Parse error"
+=end
   end
-
+  public :complete?
   def assignable?(string)
-    raise "Parse error" if ! complete?(string)
+    raise ParseError, "Parse error" if ! complete?(string)
     assign_engine(RinRuby_Parse_String,string)
     result = pull_engine("as.integer(ifelse(inherits(try({eval(parse(text=paste(#{RinRuby_Parse_String},'<- 1')))}, silent=TRUE),'try-error'),1,0))")
     @writer.puts "rm(#{RinRuby_Parse_String})"
     return true if result == [0]
-    raise "Parse error"
+    raise ParseError, "Parse error"
   end
 
   def find_R_on_windows(cygwin)

data/spec/rinruby_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RinRuby do
+  before do
+    R.echo(false)
+  end
+  subject {R}
+  context "basic methods" do 
+    it {should respond_to :eval}
+    it {should respond_to :quit}
+    it {should respond_to :assign}
+    it {should respond_to :pull}
+    it {should respond_to :quit}
+    it {should respond_to :echo}
+    it "return correct values for complete?" do
+      R.eval("x<-1").should be_true
+    end
+    it "return false for complete? for incorrect expressions" do
+      R.complete?("x<-").should be_false
+    end
+    it "correct eval should return true" do 
+      R.complete?("x<-1").should be_true
+    end
+    it "incorrect eval should raise an ParseError" do
+      lambda {R.eval("x<-")}.should raise_error(RinRuby::ParseError)
+    end
+  end
+  context "on assing" do 
+    it "should assign correctly" do
+      x=rand
+      R.assign("x",x)
+      R.pull("x").should==x
+    end
+    it "should be the same using assign than R#= methods" do
+      x=rand
+      R.assign("x1",x)
+      R.x2=x
+      R.pull("x1").should==x
+      R.pull("x2").should==x
+    end
+    it "should raise an ArgumentError error on setter with 0 parameters" do
+      lambda {R.unknown_method=() }.should raise_error(ArgumentError)
+    end
+    
+  end
+  context "on pull" do
+    it "should be the same using pull than R# methods" do
+      x=rand
+      R.x=x
+      R.pull("x").should==x
+      R.x.should==x
+    end
+    it "should raise an NoMethod error on getter with 1 or more parameters" do
+      lambda {R.unknown_method(1) }.should raise_error(NoMethodError)
+    end
+    
+    it "should pull a String" do
+      R.eval("x<-'Value'")
+      R.pull('x').should=='Value'
+    end
+    it "should pull an Integer" do
+      R.eval("x<-1")
+      R.pull('x').should==1
+    end
+    it "should pull a Float" do
+      R.eval("x<-1.5")
+      R.pull('x').should==1.5
+    end
+    it "should pull an Array of Numeric" do
+      R.eval("x<-c(1,2.5,3)")
+      R.pull('x').should==[1,2.5,3]
+    end
+    it "should pull an Array of strings" do
+      R.eval("x<-c('a','b')")
+      R.pull('x').should==['a','b']
+    end
+
+    it "should push a Matrix" do
+      matrix=Matrix[[rand,rand,rand],[rand,rand,rand]]
+      lambda {R.assign('x',matrix)}.should_not raise_error
+      rx=R.x
+      matrix.row_size.times {|i|
+        matrix.column_size.times {|j|
+          matrix[i,j].should be_close(rx[i,j],1e-10)
+        }
+      }
+    end
+    
+  end
+
+  context "on quit" do
+    before(:each) do
+      @r=RinRuby.new(false)
+    end
+    it "return true" do
+      @r.quit.should be_true
+    end
+    it "returns an error if used again" do
+      @r.quit
+      lambda {@r.eval("x=1")}.should raise_error(RinRuby::EngineClosed)
+    end
+  end
+  
+
+end