rri 0.1.0

data/lib/rri/java_gd.rb

@@ -0,0 +1,23 @@
+require 'java'
+
+module Rri
+  module JavaGd
+    
+    def self.jars
+      ["javaGD" ]
+    end
+    
+    JavaGd.jars.each do |jar|
+      raise "You must set RRI_JAVAGD_JAR_PATH!" if ENV['RRI_JAVAGD_JAR_PATH'].nil?
+      begin
+        require File.join(ENV['RRI_JAVAGD_JAR_PATH'], jar)
+      rescue LoadError => e
+        STDERR.puts e.message
+        STDERR.puts "Make sure you have set RRI_JAVAGD_JAR_PATH to the result of the R command: system.file(\"java\", package=\"JavaGD\")"
+        exit -1
+      end
+    end
+    
+    include_package "org.rosuda.javaGD"
+  end
+end

data/lib/rri/jri.rb

@@ -0,0 +1,24 @@
+require 'java'
+
+module Rri
+  module Jri
+    
+    def self.jars
+      ["JRI", "JRIEngine", "REngine" ]
+    end
+    
+    Jri.jars.each do |jar|
+      raise "You must set RRI_JRI_JAR_PATH!" if ENV['RRI_JRI_JAR_PATH'].nil?
+      begin
+        require File.join(ENV['RRI_JRI_JAR_PATH'], jar)
+      rescue LoadError => e
+        STDERR.puts e.message
+        STDERR.puts "Make sure you have set RRI_JRI_JAR_PATH to the result of the R command: system.file(\"jri\",package=\"rJava\")"
+        STDERR.puts "Also, make sure your OS can load dynamic libraries from that directory. E.g. on windows that means it needs to be part of the PATH"
+        exit -1
+      end
+    end
+    
+    include_package "org.rosuda.REngine.JRI"
+  end
+end

data/lib/rri/r_converters.rb

@@ -0,0 +1,4 @@
+require 'rri/r_converters/float_converter'
+require 'rri/r_converters/integer_converter'
+require 'rri/r_converters/string_converter'
+require 'rri/r_converters/array_converter'

data/lib/rri/r_converters/array_converter.rb

@@ -0,0 +1,59 @@
+require 'rri/rexp'
+
+module Rri
+  module RConverters
+    
+    # Converter for ruby Arrays
+    class ArrayConverter
+      
+      # Convert ruby object to R format
+      # 
+      # If the ruby object is an Array, converts it into an R object.
+      #
+      # Does not deal with empty arrays.
+      #
+      # Depending on what type of content the ruby array has, different things happen:
+      # * if all elements are doubles, convert to vector of doubles
+      # * if all elements are integers, convert to vector of integers
+      # * if all elements are strings, convert to vector of strings
+      # 
+      # @param obj object to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(obj)
+        if obj.kind_of? Array and obj.size > 0
+          if is_all_same_type?(obj)
+            o = obj[0]
+            return [true, create_integer_vector(obj)] if o.kind_of? Integer
+            return [true, create_double_vector(obj)] if o.kind_of? Float
+            return [true, create_string_vector(obj)] if o.kind_of? String
+            [false, nil]
+          end
+        else
+          [false, nil]
+        end
+      end
+      
+      ########################## PRIVATE METHODS #########################
+      
+      private
+      
+      def is_all_same_type?(array)
+        array.map {|x| x.class}.uniq.size == 1
+      end
+      
+      def create_integer_vector(array)
+        REXPInteger.new(array.to_java :int)
+      end
+      
+      def create_double_vector(array)
+        REXPDouble.new(array.to_java :double)
+      end
+
+      def create_string_vector(array)
+        REXPString.new(array.to_java :string)
+      end
+    end
+    
+  end
+end

data/lib/rri/r_converters/float_converter.rb

@@ -0,0 +1,28 @@
+require 'rri/rexp'
+
+module Rri
+  module RConverters
+    
+    # Converter for ruby Floats
+    #
+    # Convert ruby Floats to double in R
+    class FloatConverter
+      
+      # Convert ruby object to R format
+      # 
+      # If the ruby object is a Float, converts it into an R double
+      # 
+      # @param obj object to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(obj)
+        if obj.kind_of? Float
+          [true, REXPDouble.new(obj)]
+        else
+          [false, nil]
+        end
+      end
+    end
+    
+  end
+end

data/lib/rri/r_converters/integer_converter.rb

@@ -0,0 +1,28 @@
+require 'rri/rexp'
+
+module Rri
+  module RConverters
+    
+    # Converter for ruby Integers
+    #
+    # Convert ruby Integer to integer in R
+    class IntegerConverter
+      
+      # Convert ruby object to R format
+      # 
+      # If the ruby object is an Integer, converts it into an R integer
+      # 
+      # @param obj object to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(obj)
+        if obj.kind_of? Integer
+          [true, REXPInteger.new(obj)]
+        else
+          [false, nil]
+        end
+      end
+    end
+    
+  end
+end

data/lib/rri/r_converters/string_converter.rb

@@ -0,0 +1,28 @@
+require 'rri/rexp'
+
+module Rri
+  module RConverters
+    
+    # Converter for ruby Strings
+    #
+    # Convert ruby Strings to character vector in R
+    class StringConverter
+      
+      # Convert ruby object to R format
+      # 
+      # If the ruby object is a String, converts it into an R character vector
+      # 
+      # @param obj object to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(obj)
+        if obj.kind_of? String
+          [true, REXPString.new(obj)]
+        else
+          [false, nil]
+        end
+      end
+    end
+    
+  end
+end

data/lib/rri/rexp.rb

@@ -0,0 +1,8 @@
+require 'rri/jri'
+
+module Rri
+  java_import "org.rosuda.REngine.REXP"
+  java_import "org.rosuda.REngine.REXPInteger"
+  java_import "org.rosuda.REngine.REXPDouble"
+  java_import "org.rosuda.REngine.REXPString"
+end

data/lib/rri/rri_exception.rb

@@ -0,0 +1,5 @@
+module Rri
+  # Exception class for all exceptions coming from rri itself
+  class RriException < StandardError
+  end
+end

data/lib/rri/ruby_converters.rb

@@ -0,0 +1,2 @@
+require 'rri/ruby_converters/integer_converter'
+require 'rri/ruby_converters/double_converter'

data/lib/rri/ruby_converters/double_converter.rb

@@ -0,0 +1,28 @@
+require 'rri/rexp'
+
+module Rri
+  module RubyConverters
+    
+    # Converter for R Integers
+    #
+    # Convert R double to ruby Fixnum
+    class DoubleConverter
+      
+      # Convert R object to ruby format
+      # 
+      # If the R object is a double, converts it into a ruby Float
+      # 
+      # @param [REXP] rexp rexp to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(rexp)
+        if rexp.kind_of?(REXP) and rexp.isNumeric and !rexp.isInteger and !rexp.isComplex and rexp.length == 1
+          [true, rexp.asDouble]
+        else
+          [false, nil]
+        end
+      end
+    end
+    
+  end
+end

data/lib/rri/ruby_converters/integer_converter.rb

@@ -0,0 +1,28 @@
+require 'rri/rexp'
+
+module Rri
+  module RubyConverters
+    
+    # Converter for R Integers
+    #
+    # Convert R integer to ruby Fixnum
+    class IntegerConverter
+      
+      # Convert R object to ruby format
+      # 
+      # If the R object is an integer, converts it into a ruby Fixnum
+      # 
+      # @param [REXP] rexp rexp to convert
+      # @return [Array] an array of size 2 where first element is a boolean indicating succes,
+      #   and the second element is the converted object if conversion successful    
+      def convert(rexp)
+        if rexp.kind_of?(REXP) and rexp.isInteger and rexp.length == 1
+          [true, rexp.asInteger]
+        else
+          [false, nil]
+        end
+      end
+    end
+    
+  end
+end

data/lib/rri/version.rb

@@ -0,0 +1,5 @@
+# Module to contain all rri related classes
+module Rri
+  # rri version
+  VERSION = "0.1.0"
+end

data/rri.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+begin
+  Ore::Specification.new do |gemspec|
+    # custom logic here
+  end
+rescue NameError
+  begin
+    require 'ore/specification'
+    retry
+  rescue LoadError
+    STDERR.puts "The '#{__FILE__}' file requires Ore."
+    STDERR.puts "Run `gem install ore-core` to install Ore."
+  end
+end

data/spec/rri/engine_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+require 'rri'
+
+describe Rri::Engine do
+
+  before(:all) do
+    # Note: we can't create a new engine for each test because of bug
+    # in JRI/R. After 12 recreations in same process something in the
+    # C layer gets stuck, not sure if the JRI JNI code or the R lib.
+    # That's true even if we properly close and dispose of the engines.
+    # That wont be much of a limit in practice, just not ideal for testing.
+    @engine = Rri::Engine.new
+  end
+
+  before(:each) do
+    # since we're not recreating engine each time we need to clear caches
+    # between runs
+    Rri::Engine.clear_r_converters
+    Rri::Engine.clear_ruby_converters
+    @engine.clear_r_converters
+    @engine.clear_ruby_converters
+  end
+
+  after(:all) do
+    @engine.close
+    @engine = nil
+  end
+
+  describe "instantiation" do
+    it "should instantiate passing no args to .new" do
+      @engine.should_not be_nil
+    end
+    
+    it "should instantiate passing options to .new" do
+      Rri::Engine.new(:r_arguments => ["--save"], :run_repl => false).should_not be_nil
+    end
+  end
+  
+  describe "when converting ruby objects to R objects" do
+    describe "at the instance level" do
+      it "should be able to add an instance level R converter" do
+          converter = mock('converter')
+          @engine.add_r_converter(converter)
+          @engine.r_converters.size.should == 1
+          @engine.r_converters[0] == converter
+        end
+        
+      it "should be able to add several instance level R converters and return them in reverse order" do
+        converter1 = mock('converter')
+        converter2 = mock('converter')
+        @engine.add_r_converter(converter1)
+        @engine.add_r_converter(converter2)
+        @engine.r_converters.size.should == 2
+        @engine.r_converters[0] == converter2
+        @engine.r_converters[1] == converter1
+      end
+      
+      it "should correctly convert to R objects using instance level custom converters" do
+        ruby_value = 123
+        converter = double('converter')
+        converter.should_receive(:convert).and_return([true, ruby_value.to_s])
+        @engine.add_r_converter(converter)
+        success, rexp = @engine.convert_to_r_object(ruby_value)
+        success.should be_true
+        rexp.should == ruby_value.to_s
+      end
+    end
+
+    describe "at the class level" do
+      it "should be able to add a class level R converter" do
+          converter = mock('converter')
+          Rri::Engine.add_r_converter(converter)
+          Rri::Engine.r_converters.size.should == 1
+          Rri::Engine.r_converters[0] == converter
+        end
+        
+      it "should be able to add several class level R converters and return them in reverse order" do
+        converter1 = mock('converter')
+        converter2 = mock('converter')
+        Rri::Engine.add_r_converter(converter1)
+        Rri::Engine.add_r_converter(converter2)
+        Rri::Engine.r_converters.size.should == 2
+        Rri::Engine.r_converters[0] == converter2
+        Rri::Engine.r_converters[1] == converter1
+      end
+      
+      it "should correctly convert to R objects using class level custom converters" do
+        ruby_value = 123
+        converter = double('converter')
+        converter.should_receive(:convert).and_return([true, ruby_value.to_s])
+        Rri::Engine.add_r_converter(converter)
+        success, rexp = @engine.convert_to_r_object(ruby_value)
+        success.should be_true
+        rexp.should == ruby_value.to_s
+      end
+    end
+    
+    it "should correctly convert to R objects using default converters" do
+      ruby_value = 123
+      success, rexp = @engine.convert_to_r_object(ruby_value)
+      success.should be_true
+      rexp.class.should == REXPInteger
+      rexp.asInteger.should == ruby_value
+    end
+    
+    it "should return failure if no conversion available when converting ruby object to R object" do
+      ruby_value = @engine
+      success, rexp = @engine.convert_to_r_object(ruby_value)
+      success.should be_false
+      rexp.should == @engine
+    end
+  end
+  
+  describe "when converting R objects to ruby objects" do
+    describe "at the instance level" do
+      it "should be able to add an instance level ruby converter" do
+        converter = mock('converter')
+        @engine.add_ruby_converter(converter)
+        @engine.ruby_converters.size.should == 1
+        @engine.ruby_converters[0] == converter
+      end
+        
+        it "should be able to add several instance level converters and return them in reverse order" do
+        converter1 = mock('converter')
+        converter2 = mock('converter')
+        @engine.add_ruby_converter(converter1)
+        @engine.add_ruby_converter(converter2)
+        @engine.ruby_converters.size.should == 2
+        @engine.ruby_converters[0] == converter2
+        @engine.ruby_converters[1] == converter1
+      end
+      
+      it "should correctly convert to R objects using instance level custom converters" do
+        value = 123
+        rexp = REXPInteger.new(value)
+        converter = double('converter')
+        converter.should_receive(:convert).and_return([true, value])
+        @engine.add_ruby_converter(converter)
+        success, obj = @engine.convert_to_ruby_object(rexp)
+        success.should be_true
+        obj.should == value
+      end
+    end
+    
+    describe "at the class level" do
+      it "should be able to add a class level ruby converter" do
+        converter = mock('converter')
+        Rri::Engine.add_ruby_converter(converter)
+        Rri::Engine.ruby_converters.size.should == 1
+        Rri::Engine.ruby_converters[0] == converter
+      end
+        
+      it "should be able to add several instance level ruby converters and return them in reverse order" do
+        converter1 = mock('converter')
+        converter2 = mock('converter')
+        Rri::Engine.add_ruby_converter(converter1)
+        Rri::Engine.add_ruby_converter(converter2)
+        Rri::Engine.ruby_converters.size.should == 2
+        Rri::Engine.ruby_converters[0] == converter2
+        Rri::Engine.ruby_converters[1] == converter1
+      end
+
+      it "should correctly convert to ruby objects using class level custom converters" do
+        value = 123
+        rexp = REXPInteger.new(value)
+        converter = double('converter')
+        converter.should_receive(:convert).and_return([true, value])
+        Rri::Engine.add_ruby_converter(converter)
+        success, obj = @engine.convert_to_ruby_object(rexp)
+        success.should be_true
+        obj.should == value
+      end
+    end
+    
+    it "should correctly convert to ruby objects using default converters" do
+      value = 123
+      rexp = REXPInteger.new(value)
+      success, obj = @engine.convert_to_ruby_object(rexp)
+      success.should be_true
+      obj.should == value
+    end
+    
+    it "should return failure if no conversion available when converting ruby object to R object" do
+      rexp = @engine
+      success, obj = @engine.convert_to_ruby_object(rexp)
+      success.should be_false
+      obj.should == @engine
+    end
+  end
+
+  it "should correctly convert a ruby object and assign it to an R variable" do
+    ruby_value = 1.23
+    @engine.convert_and_assign(ruby_value, :x)
+    rexp = @engine.get("x", nil, true)
+    rexp.class.should == REXPDouble
+    rexp.asDouble.should == ruby_value
+  end
+  
+  it "should raise if it can't correctly convert a ruby object and assign it to an R variable" do
+    expect { @engine.convert_and_assign(@engine, :x) }.to raise_error(Rri::RriException)
+  end
+
+end