rinruby 2.0.3 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e778d372d5d1595f97fe69f2986f96fa9a56bf86
+  data.tar.gz: a767fb4e5e793719268c3a561a6bb3a7201a9a65
+SHA512:
+  metadata.gz: f87a7359c4fd94d9a100ecf3ddfe40d2e7016a1e1f5d6144ad799feed1f8d3dc07272f9c4ceae8945cd926b011dc7320d6760b3281b6d38f25ad7d8fbc0d9b31
+  data.tar.gz: 6fb9adbe15972112b5a5a28cb4ccd783495ddbdc8c3a10e85fc95dbdfdcb6955fb2a56bdbcf6af4d4f366e60b5d0dc943220541df35bb439e0f3652ba5bd91fe

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+pkg
+doc
+*~

data/.travis.yml

@@ -0,0 +1,24 @@
+language:
+  ruby
+
+rvm:
+  - '2.1.1'
+  - '2.4.4'
+  - '2.5.1'
+  - jruby-head
+#  - rbx-2.1.1
+cache: bundler
+script:
+  bundle exec rspec 
+  
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y r-base r-base-dev
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
+env:
+  TEST_TRAVIS=1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rinruby.gemspec
+gemspec

data/History.txt

@@ -1,8 +1,51 @@
+=== 2.1.0 / 2018-08-19
+
+638df01 Ruby 2.0.0 deprecated
+86d2370 Omit to_signed_int() with signed pack for speed optimization
+7c182ec Use native endian on Ruby side for speed optimization
+ca8c9a1 Add corner case tests
+555e7d2 Add logical value pull tests
+312b9c9 Add logical value assign/pull
+350ce77 Change type from String to String_Array when assign based on procedure
+e2ce0e1 Optimize pull engine
+c22f821 Separate numeric pull test into integer and float tests
+1ba51e1 Add after{r.quit} to each example because of socket reusability
+7f59977 Revive echo and interactive tests, and add comment of test cache
+a034124 Fix to use a cached RinRuby instance
+a8f4cf1 Update README.md
+17baae9 Update matrix assignment test to use a large matrix
+1a147fd Optimize assign_engine()
+8418a65 Change string assignment scheme to accept array in a same session
+8c6fd6a Add cleanup for socket when connection is persistent
+0ddab52 Add persistent mode to reuse connection, which is now default.
+aa7c90e Optimize performing singleton of pull returned value
+1a29474 Move R socket manipulation procedure into socket_seession() on Ruby
+e1b96ba Refactoring; move socket.close from each procedure to socket_session
+de954ed Reduce namespace contamination by using ".RinRuby" environment
+9519355 Move socketConnection() and close() to session()
+59ffe63 Move rinruby R function assignment from global to base environment
+13056c4 Change socket connection scheme for GC resistance
+97cf371 Perform communication via #{RinRuby_Socket}.write and read functions
+0a2b411 Remove duplication by using dummy R constant temporary
+964d0ae Improve possibility to find R by using regtool on cygwin
+89b7304 Add the R wrapper class without R constant
+bba176b Add a safety net when Windows R is not registered in registry
+67afbe1 Internationalization; workaround for "invalid byte sequence in UTF-8"
+61d0817 Change registry search query because of structure change of R3.4.3
+9433299 Change strategy to find R executable for cygwin-windows
+2515984 Error in README.md example code
+8ff82c1 Markdownify README.md
+e09cc95 Rename README.txt to README.md
+1b05f3e added support for bundler and gemspec
+
 === 2.0.3 / 2012-07-31
-  * 64-bit version is in x64
-  * Adapt to different Rterm.exe locations. On Windows at least, Rterm.exe has moved under an i386/ folder
-  * Update README.txt
-  * Updated spec to rspec 2.0
+* Update README.txt
+
+=== 2.0.2 / 2011-02-03
+
+* Updated RSpec to 2.0. Should work on Windows [clbustos]
+* 64-bit version is in x64 [Rob Heittman]
+* Adapt to different Rterm.exe locations [Rob Heittman]
 
 === 2.0.1 / 2010-05-01
 * Reimplemented Rinruby.new with ordered parameters, for complete backwards compatibility

data/Manifest.txt

@@ -4,6 +4,8 @@ Manifest.txt
 README.txt
 Rakefile
 lib/rinruby.rb
+lib/rinruby_without_r_constant.rb
 spec/rinruby_spec.rb
+spec/rinruby_without_r_constant_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/{README.txt → README.md}

@@ -1,29 +1,38 @@
-= rinruby
-
+# rinruby
 * http://rinruby.ddahl.org/
 
-== DESCRIPTION:
 
-RinRuby is a Ruby library that integrates the R interpreter in Ruby, making R's statistical routines and graphics available within Ruby.  The library consists of a single Ruby script that is simple to install and does not require any special compilation or installation of R.  Since the library is 100% pure Ruby, it works on a variety of operating systems, Ruby implementations, and versions of R.  RinRuby's methods are simple, making for readable code.  The {website [rinruby.ddahl.org]}[http://rinruby.ddahl.org] describes RinRuby usage, provides comprehensive documentation, gives several examples, and discusses RinRuby's implementation.
+[![Build Status](https://travis-ci.org/clbustos/rinruby.svg?branch=master)](https://travis-ci.org/clbustos/rinruby)
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/d6cdb002c01f4a696ff3/maintainability)](https://codeclimate.com/github/clbustos/rinruby/maintainability)
+
+### DESCRIPTION
+
+RinRuby is a Ruby library that integrates the R interpreter in Ruby, making R's statistical routines and graphics available within Ruby.  The library consists of a single Ruby script that is simple to install and does not require any special compilation or installation of R.  Since the library is 100% pure Ruby, it works on a variety of operating systems, Ruby implementations, and versions of R.  RinRuby's methods are simple, making for readable code.  The [website *rinruby.ddahl.org*](http://rinruby.ddahl.org) describes RinRuby usage, provides comprehensive documentation, gives several examples, and discusses RinRuby's implementation.
 
 
 Copyright 2005-2008 David B. Dahl
 
-Developed by David B. Dahl
-Documented by David B. Dahl and Scott Crawford
+Developed by David B. Dahl. Documented by David B. Dahl and Scott Crawford
+
 Homepage: http://rinruby.ddahl.org
 
-Contributors: Claudio Bustos
+*Maintainer*: Claudio Bustos
+
+*Contributors*:
+ 
+- [fenrir-naru](https://fenrir.naruoka.org) 
 
-== FEATURES/PROBLEMS:
+### FEATURES/PROBLEMS
 
-* Pure Ruby. Works on Ruby 1.8.7, 1.9 and JRuby 1.4
+* Pure Ruby. Works on Ruby 2.1, 2.2, 2.4 and JRuby-head (2018/03/29). There isn't any specific code that impides to use Ruby < 2.0, but is deprecated.
 * Slower than RSRuby, but more robust
 
-== SYNOPSIS:
+### SYNOPSIS
+
 Below is a simple example of RinRuby usage for simple linear regression. The simulation parameters are defined in Ruby, computations are performed in R, and Ruby reports the results. In a more elaborate application, the simulation parameter might come from input from a graphical user interface, the statistical analysis might be more involved, and the results might be an HTML page or PDF report. 
 
-<b>Code</b>:
+#### Code
 
       require "rinruby"
       n = 10
@@ -33,34 +42,34 @@ Below is a simple example of RinRuby usage for simple linear regression. The sim
       seed = 23423
       R.x = (1..n).entries
       R.eval <<EOF
-          set.seed({seed})
-          y <- {beta_0} + {beta_1}*x + rnorm({n})
+          set.seed(#{seed})
+          y <- #{beta_0} + #{beta_1}*x + rnorm(#{n})
           fit <- lm( y ~ x )
           est <- round(coef(fit),3)
           pvalue <- summary(fit)$coefficients[2,4]
       EOF
-      puts "E(y|x) ~= {R.est[0]} + {R.est[1]} * x"
+      puts "E(y|x) ~= #{R.est[0]} + #{R.est[1]} * x"
       if R.pvalue < alpha
         puts "Reject the null hypothesis and conclude that x and y are related."
       else
         puts "There is insufficient evidence to conclude that x and y are related."
       end
 
-<b>Output</b>:
+#### Output
 
       E(y|x) ~= 1.264 + 0.273 * x
       Reject the null hypothesis and conclude that x and y are related.
 
-== REQUIREMENTS:
+### REQUIREMENTS
 
 * R
 
-== INSTALL:
+### INSTALL
 
 * sudo gem install rinruby
 
 
-== LICENSE:
+### LICENSE
 
 GPL-3. See LICENSE.txt for more information.
 

data/Rakefile

@@ -14,8 +14,7 @@ Hoe.spec 'rinruby' do
   # 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/"
-
+  self.urls = ["http://rinruby.ddahl.org/"]
 end
 
 # vim: syntax=ruby

data/lib/rinruby.rb

@@ -2,7 +2,7 @@
 #
 #RinRuby is a Ruby library that integrates the R interpreter in Ruby, making R's statistical routines and graphics available within Ruby.  The library consists of a single Ruby script that is simple to install and does not require any special compilation or installation of R.  Since the library is 100% pure Ruby, it works on a variety of operating systems, Ruby implementations, and versions of R.  RinRuby's methods are simple, making for readable code.  The {website [rinruby.ddahl.org]}[http://rinruby.ddahl.org] describes RinRuby usage, provides comprehensive documentation, gives several examples, and discusses RinRuby's implementation.
 #
-#Below is a simple example of RinRuby usage for simple linear regression. The simulation parameters are defined in Ruby, computations are performed in R, and Ruby reports the results. In a more elaborate application, the simulation parameter might come from input from a graphical user interface, the statistical analysis might be more involved, and the results might be an HTML page or PDF report. 
+#Below is a simple example of RinRuby usage for simple linear regression. The simulation parameters are defined in Ruby, computations are performed in R, and Ruby reports the results. In a more elaborate application, the simulation parameter might come from input from a graphical user interface, the statistical analysis might be more involved, and the results might be an HTML page or PDF report.
 #
 #<b>Code</b>:
 #
@@ -34,6 +34,7 @@
 #
 #Coded by:: David B. Dahl
 #Documented by:: David B. Dahl & Scott Crawford
+#Maintained by:: Claudio Bustos
 #Copyright:: 2005-2009
 #Web page:: http://rinruby.ddahl.org
 #E-mail::   mailto:rinruby@ddahl.org
@@ -58,20 +59,20 @@
 #The files "java" and "readline" are used when available to add functionality.
 require 'matrix'
 class RinRuby
-  
+
   require 'socket'
 
-  
   VERSION = '2.0.3'
 
-
   attr_reader :interactive
   attr_reader :readline
   # Exception for closed engine
   EngineClosed=Class.new(Exception)
   # Parse error
   ParseError=Class.new(Exception)
-  
+
+  RinRuby_Env = ".RinRuby"
+  RinRuby_Endian = ([1].pack("L").unpack("C*")[0] == 1) ? (:little) : (:big)
   
 #RinRuby is invoked within a Ruby script (or the interactive "irb" prompt denoted >>) using:
 #
@@ -98,7 +99,7 @@ class RinRuby
 #      >> require "rinruby"
 #      >> R.quit
 #      >> R = RinRuby.new(false)
-attr_reader :echo_enabled
+attr_accessor :echo_enabled
 attr_reader :executable
 attr_reader :port_number
 attr_reader :port_width
@@ -114,8 +115,8 @@ def initialize(*args)
     opts[:port_number]=args.shift unless args.size==0
     opts[:port_width]=args.shift unless args.size==0
   end
-  default_opts= {:echo=>true, :interactive=>true, :executable=>nil, :port_number=>38442, :port_width=>1000, :hostname=>'127.0.0.1'}
-  
+  default_opts= {:echo=>true, :interactive=>true, :executable=>nil, :port_number=>38442, :port_width=>1000, :hostname=>'127.0.0.1', :persistent => true}
+
     @opts=default_opts.merge(opts)
     @port_width=@opts[:port_width]
     @executable=@opts[:executable]
@@ -166,37 +167,26 @@ def initialize(*args)
     @writer = @engine
     raise "Engine closed" if @engine.closed?
     @writer.puts <<-EOF
-      #{RinRuby_KeepTrying_Variable} <- TRUE
-      while ( #{RinRuby_KeepTrying_Variable} ) {
-        #{RinRuby_Socket} <- try(suppressWarnings(socketConnection("#{@hostname}", #{@port_number}, blocking=TRUE, open="rb")),TRUE)
-        if ( inherits(#{RinRuby_Socket},"try-error") ) {
-          Sys.sleep(0.1)
-        } else {
-          #{RinRuby_KeepTrying_Variable} <- FALSE
-        }
-      }
-      rm(#{RinRuby_KeepTrying_Variable})
+      assign("#{RinRuby_Env}", new.env(), baseenv())
     EOF
+    @socket = nil
+    r_rinruby_socket_io
     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
 
 #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
-    begin 
+    begin
       @writer.puts "q(save='no')"
-      # TODO: Verify if read is needed
-      @socket.read()
-      #@socket.close 
-      @engine.close 
-  
-      
-      @server_socket.close 
-      #@reader.close 
+      @engine.close
+
+
+      @server_socket.close
+      #@reader.close
       #@writer.close
       true
     ensure
@@ -464,11 +454,7 @@ def initialize(*args)
   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 )
-        result = result[0]
-      end
-      result
+      pull_engine(string, singletons)
     else
       raise ParseError, "Parse error"
     end
@@ -511,231 +497,259 @@ def initialize(*args)
   RinRuby_Type_String = 2
   RinRuby_Type_String_Array = 3
   RinRuby_Type_Matrix = 4
+  RinRuby_Type_Boolean = 5
 
-  RinRuby_KeepTrying_Variable = ".RINRUBY.KEEPTRYING.VARIABLE"
-  RinRuby_Length_Variable = ".RINRUBY.PULL.LENGTH.VARIABLE"
-  RinRuby_Type_Variable = ".RINRUBY.PULL.TYPE.VARIABLE"
-  RinRuby_Socket = ".RINRUBY.PULL.SOCKET"
-  RinRuby_Variable = ".RINRUBY.PULL.VARIABLE"
-  RinRuby_Parse_String = ".RINRUBY.PARSE.STRING"
+  RinRuby_Socket = "#{RinRuby_Env}$socket"
+  RinRuby_Parse_String = "#{RinRuby_Env}$parse.string"
+  
   RinRuby_Eval_Flag = "RINRUBY.EVAL.FLAG"
   RinRuby_Stderr_Flag = "RINRUBY.STDERR.FLAG"
   RinRuby_Exit_Flag = "RINRUBY.EXIT.FLAG"
+  
   RinRuby_Max_Unsigned_Integer = 2**32
   RinRuby_Half_Max_Unsigned_Integer = 2**31
   RinRuby_NA_R_Integer = 2**31
   RinRuby_Max_R_Integer = 2**31-1
   RinRuby_Min_R_Integer = -2**31+1
   #:startdoc:
-  
+
+  def r_rinruby_socket_io
+    @writer.puts <<-EOF
+      #{RinRuby_Socket} <- NULL
+      #{RinRuby_Env}$session <- function(f){
+        invisible(f(#{RinRuby_Socket}))
+      }
+      #{RinRuby_Env}$write <- function(con, v, ...){
+        invisible(lapply(list(v, ...), function(v2){
+            writeBin(v2, con, endian="#{RinRuby_Endian}")}))
+      }
+      #{RinRuby_Env}$read <- function(con, vtype, len){
+        invisible(readBin(con, vtype(), len, endian="#{RinRuby_Endian}"))
+      }
+    EOF
+  end
   
   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")
-      }
+    #{RinRuby_Env}$parseable <- function(var) {
+      #{RinRuby_Env}$session(function(con){
+        result=try(parse(text=var),TRUE)
+        if(inherits(result, "try-error")) {
+          #{RinRuby_Env}$write(con, as.integer(-1))
+        } else {
+          #{RinRuby_Env}$write(con, as.integer(1))
+        }
+      })
     }
     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")
+    #{RinRuby_Env}$get_value <- function() {
+      #{RinRuby_Env}$session(function(con){
+        value <- NULL
+        type <- #{RinRuby_Env}$read(con, integer, 1)
+        length <- #{RinRuby_Env}$read(con, integer, 1)
+        if ( type == #{RinRuby_Type_Double} ) {
+          value <- #{RinRuby_Env}$read(con, numeric, length)
         } 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")
+          value <- #{RinRuby_Env}$read(con, integer, length)
+        } else if ( type == #{RinRuby_Type_Boolean} ) {
+          value <- #{RinRuby_Env}$read(con, logical, length)
+        } else if ( type == #{RinRuby_Type_String_Array} ) {
+          value <- character(length)
+          for(i in 1:length){
+            value[i] <- #{RinRuby_Env}$read(con, character, 1)
+          }
         } else {
           value <-NULL
         }
-      value
-      }
+        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")
+    @writer.puts <<-EOF
+#{RinRuby_Env}$pull <- function(var){
+  #{RinRuby_Env}$session(function(con){
+    if ( inherits(var ,"try-error") ) {
+      #{RinRuby_Env}$write(con, as.integer(#{RinRuby_Type_NotFound}))
     } else {
-      writeBin(as.integer(#{RinRuby_Type_Unknown}),#{RinRuby_Socket},endian="big")
+      if (is.matrix(var)) {
+        #{RinRuby_Env}$write(con,
+            as.integer(#{RinRuby_Type_Matrix}),
+            as.integer(dim(var)[1]))
+      } else if ( is.double(var) ) {
+        #{RinRuby_Env}$write(con,
+            as.integer(#{RinRuby_Type_Double}),
+            as.integer(length(var)),
+            var)
+      } else if ( is.integer(var) ) {
+        #{RinRuby_Env}$write(con, 
+            as.integer(#{RinRuby_Type_Integer}),
+            as.integer(length(var)),
+            var)
+      } else if ( is.character(var) && ( length(var) == 1 ) ) {
+        #{RinRuby_Env}$write(con, 
+            as.integer(#{RinRuby_Type_String}),
+            as.integer(nchar(var)),
+            var)
+      } else if ( is.character(var) && ( length(var) > 1 ) ) {
+        #{RinRuby_Env}$write(con, 
+            as.integer(#{RinRuby_Type_String_Array}),
+            as.integer(length(var)))
+      } else if ( is.logical(var) ) {
+        #{RinRuby_Env}$write(con, 
+            as.integer(#{RinRuby_Type_Boolean}),
+            as.integer(length(var)),
+            var)
+      } else {
+        #{RinRuby_Env}$write(con, as.integer(#{RinRuby_Type_Unknown}))
+      }
     }
-  }
+  })
 }
     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 )
+  
+  def socket_session(&b)
+    socket = @socket
+    # TODO check still available connection?
+    unless socket then
+      t = Thread::new{socket = @server_socket.accept}
+      @writer.puts <<-EOF
+        #{RinRuby_Socket} <- socketConnection(
+            "#{@hostname}", #{@port_number}, blocking=TRUE, open="rb")
+        #{"on.exit(close(#{RinRuby_Socket}, add = T))" if @opts[:persistent]}
+      EOF
+      t.join
+    end
+    res = b.call(socket)
+    if @opts[:persistent]
+      @socket = socket
     else
-      y.collect { |x| ( x > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-x) : ( x == RinRuby_NA_R_Integer ? nil : x ) }
+      @writer.puts <<-EOF
+        close(#{RinRuby_Socket})
+        #{RinRuby_Socket} <- NULL
+      EOF
+      socket.close
     end
+    res
   end
 
   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
+    
+    r_exp = "#{name} <- #{RinRuby_Env}$get_value()"
+    
+    if value.kind_of?(::Matrix) # assignment for matrices
+      r_exp = "#{name} <- matrix(#{RinRuby_Env}$get_value(), nrow=#{value.row_size}, ncol=#{value.column_size}, byrow=T)"
+      value = value.row_vectors.collect{|row| row.to_a}.flatten
+    elsif !value.kind_of?(Array) then # check Array
+      value = [value]
     end
     
-    if value.kind_of?(String)
-      type = RinRuby_Type_String
-      length = 1
-    elsif value.kind_of?(Integer)
-      if ( value >= RinRuby_Min_R_Integer ) && ( value <= RinRuby_Max_R_Integer )
-        value = [ value.to_i ]
-        type = RinRuby_Type_Integer
-      else
-        value = [ value.to_f ]
-        type = RinRuby_Type_Double
-      end
-      length = 1
-    elsif value.kind_of?(Float)
-      value = [ value.to_f ]
-      type = RinRuby_Type_Double
-      length = 1
-    elsif value.kind_of?(Array)
-      begin
-        if value.any? { |x| x.kind_of?(String) }
-          eval "#{name} <- character(#{value.length})"
-          for index in 0...value.length
-            assign_engine("#{name}[#{index}+1]",value[index])
-          end
-          return original_value
-        elsif value.any? { |x| x.kind_of?(Float) }
-          type = RinRuby_Type_Double
-          value = value.collect { |x| x.to_f }
-        elsif value.all? { |x| x.kind_of?(Integer) }
-          if value.all? { |x| ( x >= RinRuby_Min_R_Integer ) && ( x <= RinRuby_Max_R_Integer ) }
-            type = RinRuby_Type_Integer
-          else
-            value = value.collect { |x| x.to_f }
-            type = RinRuby_Type_Double
+    type = (if value.any?{|x| x.kind_of?(String)}
+      value = value.collect{|v| v.to_s}
+      RinRuby_Type_String_Array
+    elsif value_b = value.collect{|v|
+          case v
+          when true; 1
+          when false; 0
+          else; break false
           end
-        else
-          raise "Unsupported data type on Ruby's end"
-        end
+        }
+      value = value_b
+      RinRuby_Type_Boolean
+    elsif value.all?{|x|
+          x.kind_of?(Integer) && (x >= RinRuby_Min_R_Integer) && (x <= RinRuby_Max_R_Integer)
+        }
+      RinRuby_Type_Integer
+    else
+      begin
+        value = value.collect{|x| Float(x)}
       rescue
         raise "Unsupported data type on Ruby's end"
       end
-      length = value.length
-    else
-      raise "Unsupported data type on Ruby's end"
-    end
-    @writer.puts "#{name} <- rinruby_get_value()"
-
-    @socket.write([type,length].pack('NN'))
-    if ( type == RinRuby_Type_String )
-      @socket.write(value)
-      @socket.write([0].pack('C'))   # zero-terminated strings
-    else
-      @socket.write(value.pack( ( type==RinRuby_Type_Double ? 'G' : 'N' )*length ))
-    end
+      RinRuby_Type_Double
+    end)
+    
+    socket_session{|socket|
+      @writer.puts(r_exp)
+      socket.write([type, value.size].pack('LL'))
+      case type
+      when RinRuby_Type_String_Array
+        value.each{|v|
+          socket.write(v)
+          socket.write([0].pack('C')) # zero-terminated strings
+        }
+      else
+        socket.write(value.pack("#{(type == RinRuby_Type_Double) ? 'D' : 'l'}#{value.size}"))
+      end
+    }
+    
     original_value
   end
 
-  def pull_engine(string)
-    @writer.puts <<-EOF
-      rinruby_pull(try(#{string}))
-    EOF
-
-    buffer = ""
-    @socket.read(4,buffer)
-    type = to_signed_int(buffer.unpack('N')[0].to_i)
-    if ( type == RinRuby_Type_Unknown )
-      raise "Unsupported data type on R's end"
-    end
-    if ( type == RinRuby_Type_NotFound )
-      return nil
-    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)
-    elsif ( type == RinRuby_Type_Integer )
-      @socket.read(4*length,buffer)
-      result = to_signed_int(buffer.unpack('N'*length))
-    elsif ( type == RinRuby_Type_String )
-      @socket.read(length,buffer)
-      result = buffer.dup
-      @socket.read(1,buffer)    # zero-terminated string
-      result
-    elsif ( type == RinRuby_Type_String_Array )
-      result = Array.new(length,'')
-      for index in 0...length
-        result[index] = pull "#{string}[#{index+1}]"
+  def pull_engine(string, singletons = true)
+    pull_proc = proc{|var, socket|
+      @writer.puts "#{RinRuby_Env}$pull(try(#{var}))"  
+      type = socket.read(4).unpack('l').first
+      case type
+      when RinRuby_Type_Unknown
+        raise "Unsupported data type on R's end"
+      when RinRuby_Type_NotFound
+        return nil
       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]
+      length = socket.read(4).unpack('l').first
+  
+      case type
+      when RinRuby_Type_Double
+        result = socket.read(8 * length).unpack("D#{length}")
+        (!singletons) && (length == 1) ? result[0] : result 
+      when RinRuby_Type_Integer
+        result = socket.read(4 * length).unpack("l#{length}")
+        (!singletons) && (length == 1) ? result[0] : result
+      when RinRuby_Type_String
+        result = socket.read(length)
+        socket.read(1) # zero-terminated string
+        result
+      when RinRuby_Type_String_Array
+        Array.new(length){|i|
+          pull_proc.call("#{var}[#{i+1}]", socket)
         }
-      })
-      def result.length; 2;end
-    else
-      raise "Unsupported data type on Ruby's end"
-    end
-    result
+      when RinRuby_Type_Matrix
+        Matrix.rows(length.times.collect{|i|
+          pull_proc.call("#{var}[#{i+1},]", socket)
+        })
+      when RinRuby_Type_Boolean
+        result = socket.read(4 * length).unpack("l#{length}").collect{|v| v > 0}
+        (!singletons) && (length == 1) ? result[0] : result
+      else
+        raise "Unsupported data type on Ruby's end"
+      end
+    }
+    socket_session{|socket|
+      pull_proc.call(string, socket)
+    }
   end
 
   def complete?(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)
+    result = socket_session{|socket|
+      @writer.puts "#{RinRuby_Env}$parseable(#{RinRuby_Parse_String})"
+      socket.read(4).unpack('l').first
+    }
     return result==-1 ? false : true
-    
-=begin    
-    
+
+=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)))")
-    
+
     return true if result.length == 1
     return false if result.length == 3
     raise ParseError, "Parse error"
@@ -746,7 +760,6 @@ def initialize(*args)
     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 ParseError, "Parse error"
   end
@@ -754,29 +767,70 @@ def initialize(*args)
   def find_R_on_windows(cygwin)
     path = '?'
     for root in [ 'HKEY_LOCAL_MACHINE', 'HKEY_CURRENT_USER' ]
-      `reg query "#{root}\\Software\\R-core\\R" /v "InstallPath"`.split("\n").each do |line|
-        next if line !~ /^\s+InstallPath\s+REG_SZ\s+(.*)/
-        path = $1
-        while path.chomp!
+      if cygwin then
+        [:w, :W].collect{|opt| # [64bit, then 32bit registry]
+          [:R64, :R].collect{|mode|
+            `regtool list -#{opt} /#{root}/Software/R-core/#{mode} 2>/dev/null`.lines.collect{|v|
+              v =~ /^\d\.\d\.\d/ ? $& : nil
+            }.compact.sort{|a, b| # latest version has higher priority
+              b <=> a
+            }.collect{|ver|
+              ["-#{opt}", "/#{root}/Software/R-core/#{mode}/#{ver}/InstallPath"]
+            }
+          }
+        }.flatten(2).each{|args|
+          v = `regtool get #{args.join(' ')}`.chomp
+          unless v.empty? then
+            path = v
+            break
+          end
+        }
+      else
+        proc{|str| # Remove invalid byte sequence
+          if RUBY_VERSION >= "2.1.0" then
+            str.scrub
+          elsif RUBY_VERSION >= "1.9.0" then
+            str.chars.collect{|c| (c.valid_encoding?) ? c : '*'}.join
+          else
+            str
+          end
+        }.call(`reg query "#{root}\\Software\\R-core" /v "InstallPath" /s`).each_line do |line|
+          next if line !~ /^\s+InstallPath\s+REG_SZ\s+(.*)/
+          path = $1
+          while path.chomp!
+          end
+          break
         end
-        break
       end
       break if path != '?'
     end
-    raise "Cannot locate R executable" if path == '?'
+    if path == '?'
+      # search at default install path
+      path = [
+        "Program Files",
+        "Program Files (x86)"
+      ].collect{|prog_dir|
+        Dir::glob(File::join(
+            cygwin ? "/cygdrive/c" : "C:",
+            prog_dir, "R", "*"))
+      }.flatten[0]
+      raise "Cannot locate R executable" unless path
+    end
     if cygwin
       path = `cygpath '#{path}'`
       while path.chomp!
       end
-      path.gsub!(' ','\ ')
+      path = [path.gsub(' ','\ '), path]
     else
-      path.gsub!('\\','/')
+      path = [path.gsub('\\','/')]
     end
-    for hierarchy in [ 'bin', 'bin/i386', 'bin/x64' ]
-      target = "#{path}/#{hierarchy}/Rterm.exe"
-      if File.exists? target
-        return %Q<"#{target}">
-      end
+    for hierarchy in [ 'bin', 'bin/x64', 'bin/i386']
+      path.each{|item|
+        target = "#{item}/#{hierarchy}/Rterm.exe"
+        if File.exists? target
+          return %Q<"#{target}">
+        end
+      }
     end
     raise "Cannot locate R executable"
   end