rinruby 2.0.3 → 2.1.0

data/lib/rinruby_without_r_constant.rb

@@ -0,0 +1,24 @@
+#=RinRuby: Accessing the R[http://www.r-project.org] interpreter from pure Ruby
+#
+#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.
+#
+
+if defined?(R)
+  require 'rinruby'
+else
+  R = :dummy
+  require 'rinruby'
+  Object::send(:remove_const, :R)
+end
+
+class RinRubyWithoutRConstant < RinRuby
+  DEFAULT_PORT_NUMBER = 38542
+  def initialize(*args)
+    if args.size == 1 and args[0].kind_of?(Hash) then
+      args[0][:port_number] ||= DEFAULT_PORT_NUMBER
+    else
+      args[3] ||= DEFAULT_PORT_NUMBER
+    end
+    super(*args)
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Rinruby
+  VERSION = "2.1.0"
+end

data/rinruby.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rinruby"
+  spec.version       = Rinruby::VERSION
+  spec.authors       = ["David Dahl", "Scott Crawford", "Claudio Bustos"]
+  spec.email         = ["rinruby@ddahl.org", "scott@ddahl.org", "clbustos@gmail.com"]
+  spec.summary       = %q{RinRuby is a Ruby library that integrates the R interpreter in Ruby}
+  spec.description   = %q{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.}
+  spec.homepage      = "http://rinruby.ddahl.org"
+  spec.license       = "Copyright 2005-2008 David B. Dahl"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 2.11"
+  spec.add_development_dependency "hoe"
+end

data/spec/rinruby_spec.rb

@@ -1,148 +1,235 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rinruby'
 puts "RinRuby #{RinRuby::VERSION} specification"
 
-describe RinRuby do
+shared_examples 'RinRubyCore' do
+  let(:params){
+    {
+      :echo_enabled => false, 
+      :interactive => false, 
+      :executable => nil, 
+      :port_number => 38500,
+      :port_width => 1000,
+    }
+  }
   describe "on init" do
+    after{(r.quit rescue nil) if defined?(r)}
     it "should accept parameters as specified on Dahl & Crawford(2009)" do
-      
-      platform = case RUBY_PLATFORM
-      when /mswin/ then 'windows'
-      when /mingw/ then 'windows'
-      when /bccwin/ then 'windows'
-      else 
-        "other"
-      end
-      if platform=='windows'
-        pending("Difficult to test without specific location of R executable on Windows")
-      else      
-      
-      r=RinRuby.new(false, false, "R", 38500, 1)
-      r.echo_enabled.should_not be_true
-      r.interactive.should_not be_true
-      r.executable.should=="R"
-      r.port_number.should==38500
-      r.port_width.should==1      
-      end
+      expect(r.echo_enabled).to be_falsy
+      expect(r.interactive).to be_falsy
+      case r.instance_variable_get(:@platform)
+      when /^windows/ then
+        expect(r.executable).to match(/Rterm\.exe["']?$/)
+      else
+        expect(r.executable).to eq("R")
+      end      
     end
     it "should accept :echo and :interactive parameters" do
-      r=RinRuby.new(:echo=>false, :interactive=>false)
-      r.echo_enabled.should_not be_true
-      r.interactive.should_not be_true
-      
-    end
-    it "should accept :port_number" do
-      port=38442+rand(3)
-      r=RinRuby.new(:port_number=>port,:port_width=>1)
-      r.port_number.should==port
-      r.quit
-    end
-    it "should accept :port_width" do
-      port=38442
-      port_width=rand(10)
-      r=RinRuby.new(:port=>port, :port_width=>port_width)
-      r.port_width.should==port_width
-      r.port_number.should satisfy {|v| v>=port and v < port+port_width}
-    end
-  end
-  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)
+      params.merge!(:echo_enabled => true, :interactive => true)
+      expect(r.echo_enabled).to be_truthy
+      expect(r.interactive).to be_truthy
+    end
+    it "should accept custom :port_number" do
+      params.merge!(:port_number => 38442+rand(3), :port_width => 1)
+      expect(r.port_number).to eq(params[:port_number])
+    end
+    it "should accept custom :port_width" do
+      params.merge!(:port_number => 38442, :port_width => rand(10)+1)
+      expect(r.port_width).to eq(params[:port_width])
+      expect(r.port_number).to satisfy {|v| 
+        ((params[:port_number])...(params[:port_number] + params[:port_width])).include?(v)
+      }
     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)
+  
+  describe "R interface" do
+    # In before(:each) or let(including subject) blocks, Assignment to instance variable 
+    # having a same name defined in before(:all) will not work intentionally, 
+    # because a new instance variable will be created for the following examples.
+    # For workaround, two-step indirect assignment to a hash created in before(:all) is applied. 
+    before(:all){@cached_env = {:r => nil}} # make placeholder
+    subject{@cached_env[:r] ||= r}
+    after(:all){@cached_env[:r].quit rescue nil}
+    describe "basic methods" do 
+      it {is_expected.to respond_to(:eval)}
+      it {is_expected.to respond_to(:assign)}
+      it {is_expected.to respond_to(:pull)}
+      it {is_expected.to respond_to(:quit)}
+      it {is_expected.to respond_to(:echo)}
+      it "return correct values for complete?" do
+        expect(subject.eval("x<-1")).to be_truthy
+      end
+      it "return false for complete? for incorrect expressions" do
+        expect(subject.complete?("x<-")).to be_falsy
+      end
+      it "correct eval should return true" do 
+        expect(subject.complete?("x<-1")).to be_truthy
+      end
+      it "incorrect eval should raise an ParseError" do
+        expect{subject.eval("x<-")}.to raise_error(RinRuby::ParseError)
+      end
     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
+    context "on pull" do
+      it "should pull a String" do
+        subject.eval("x<-'Value'")
+        expect(subject.pull('x')).to eql('Value')
+      end
+      it "should pull an Integer" do
+        [0x12345678, -0x12345678].each{|v| # for check endian, and range
+          subject.eval("x<-#{v}L")
+          expect(subject.pull('x')).to eql(v)
+        }
+      end
+      it "should pull a Float" do
+        [1.5, 1.0].each{|v|
+          subject.eval("x<-#{v}e0")
+          expect(subject.pull('x')).to eql(v)
+        }
+        [1 << 32, -(1 << 32)].each{|v| # big integer will be treated as float
+          subject.eval("x<-#{v}")
+          expect(subject.pull('x')).to eql(v.to_f)
+        }
+      end
+      it "should pull a Logical" do
+        {:T => true, :F => false}.each{|k, v|
+          subject.eval("x<-#{k}")
+          expect(subject.pull('x')).to eql(v)
+        }
+      end
+      it "should pull an Array of String" do
+        subject.eval("x<-c('a','b')")
+        expect(subject.pull('x')).to eql(['a','b'])
+      end
+      it "should pull an Array of Integer" do
+        subject.eval("x<-c(1L,2L,-5L,-3L)")
+        expect(subject.pull('x')).to eql([1,2,-5,-3])
+      end
+      it "should pull an Array of Float" do
+        subject.eval("x<-c(1.1,2.2,5,3)")
+        expect(subject.pull('x')).to eql([1.1,2.2,5.0,3.0])
+        subject.eval("x<-c(1L,2L,5L,3.0)") # numeric vector 
+        expect(subject.pull('x')).to eql([1.0,2.0,5.0,3.0])
+      end
+      it "should pull an Array of Logical" do
+        subject.eval("x<-c(T, F)")
+        expect(subject.pull('x')).to eql([true, false])
+      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_within(1e-10).of(rx[i,j])
+      it "should pull a Matrix" do
+        [
+          proc{ # integer matrix
+            v = rand(100000000) # get 8 digits
+            [v, "#{v}L"]
+          },
+          proc{ # float matrix
+            v = rand(100000000) # get 8 digits
+            [Float("0.#{v}"), "0.#{v}"]
+          },
+        ].each{|gen_proc|
+          nrow, ncol = [10, 10] # 10 x 10 small matrix
+          subject.eval("x<-matrix(nrow=#{nrow}, ncol=#{ncol})")
+          rx = Matrix[*((1..nrow).collect{|i|
+            (1..ncol).collect{|j|
+              v_rb, v_R = gen_proc.call
+              subject.eval("x[#{i},#{j}]<-#{v_R}")
+              v_rb
+            }
+          })]
+          expect(subject.pull('x')).to eql(rx)
         }
-      }
+      end
+      
+      it "should be the same using pull than R# methods" do
+        subject.eval("x <- #{rand(100000000)}")
+        expect(subject.pull("x")).to eql(subject.x)
+      end
+      it "should raise an NoMethod error on getter with 1 or more parameters" do
+        expect{subject.unknown_method(1)}.to raise_error(NoMethodError)
+      end
     end
     
-  end
+    context "on assign (PREREQUISITE: all pull tests are passed)" do
+      it "should assign a String" do
+        x = 'Value'
+        subject.assign("x", x)
+        expect(subject.pull('x')).to eql(x)
+      end
+      it "should assign an Integer" do
+        [0x12345678, -0x12345678].each{|x|
+          subject.assign("x", x)
+          expect(subject.pull('x')).to eql(x)
+        }
+      end
+      it "should assign a Float" do
+        [rand, 1 << 32, -(1 << 32)].each{|x|
+          subject.assign("x", x)
+          expect(subject.pull('x')).to eql(x.to_f)
+        }
+      end
+      it "should assign a Logical" do
+        [true, false].each{|x|
+          subject.assign("x", x)
+          expect(subject.pull('x')).to eql(x)
+        }
+      end
+      it "should assign an Array of String" do
+        x = ['a', 'b']
+        subject.assign("x", x)
+        expect(subject.pull('x')).to eql(x)
+      end
+      it "should assign an Array of Integer" do
+        x = [1, 2, -5, -3]
+        subject.assign("x", x)
+        expect(subject.pull('x')).to eql(x)
+      end
+      it "should assign an Array of Float" do
+        subject.assign("x", [1.1, 2.2, 5, 3])
+        expect(subject.pull('x')).to eql([1.1,2.2,5.0,3.0])
+      end
+      it "should assign an Array of Logical" do
+        x = [true, false]
+        subject.assign("x", x)
+        expect(subject.pull('x')).to eql(x)
+      end
 
+      it "should assign a Matrix" do
+        [
+          proc{rand(100000000)}, # integer matrix
+          proc{rand}, # float matrix
+        ].each{|gen_proc|
+          x = Matrix::build(100, 200){|i, j| gen_proc.call} # 100 x 200 matrix
+          subject.assign("x", x)
+          expect(subject.pull('x')).to eql(x)
+        }
+      end
+      
+      it "should be the same using assign than R#= methods" do
+        x = rand(100000000)
+        subject.assign("x1", x)
+        subject.x2 = x
+        expect(subject.pull("x1")).to eql(subject.pull("x2"))
+      end
+      it "should raise an ArgumentError error on setter with 0 parameters" do
+        expect{subject.unknown_method=() }.to raise_error(ArgumentError)
+      end
+    end 
+  end
+  
   context "on quit" do
-    before(:each) do
-      @r=RinRuby.new(:echo=>false)
-    end
     it "return true" do
-      @r.quit.should be_true
+      expect(r.quit).to be_truthy
     end
     it "returns an error if used again" do
-      @r.quit
-      lambda {@r.eval("x=1")}.should raise_error(RinRuby::EngineClosed)
+      r.quit
+      expect{r.eval("x=1")}.to raise_error(RinRuby::EngineClosed)
     end
   end
-  
-
 end
+
+describe RinRuby do
+  let(:r){
+    RinRuby.new(*([:echo_enabled, :interactive, :executable, :port_number, :port_width].collect{|k| params[k]}))
+  }
+  include_examples 'RinRubyCore'
+end

data/spec/rinruby_without_r_constant_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rinruby_without_r_constant'
+
+describe RinRubyWithoutRConstant do
+  let(:r){
+    RinRubyWithoutRConstant.new(*([:echo_enabled, :interactive, :executable, :port_number, :port_width].collect{|k| params[k]}))
+  }
+  include_examples 'RinRubyCore'
+end

data/spec/spec_helper.rb

@@ -1,16 +1,28 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
 $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
-require 'rinruby'
 require 'rspec'
-
 require 'matrix'
 
 RSpec.configure do |config|
-  
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  # Use color in STDOUT
+  config.color = true
+
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # Use the specified formatter
+  config.formatter = :documentation # :progress, :html, :textmate
 end
 
+
 class String
   def deindent
-    gsub /^[ \t]*/, ''
+    gsub /^[ \t]*/, '' 
   end
 end
+
+