rserve-simpler 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# right now, using initialize code, so it is very version specific
+gem "rserve-client", "~>0.2.5"  
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "spec-more", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bacon (1.1.0)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rserve-client (0.2.5)
+    spec-more (0.0.3)
+      bacon
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  rserve-client (~> 0.2.5)
+  spec-more

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Brigham Young University
+Authored by John T. Prince
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,139 @@
+= rserve-simpler
+
+rserve-simpler is a simple interface on top of
+{rserve-client}[https://github.com/clbustos/Rserve-Ruby-client], a fantastic
+gem that lets a user communicate with R in a straighforward, efficient way.
+
+{rserve-client}[https://github.com/clbustos/Rserve-Ruby-client] is doing all
+the heavy lifting and should be consulted for background.
+
+== Synposis
+
+
+    require 'rserve/simpler'
+    r = Rserve::Simpler.new
+
+    # or can initialize a connection held in the 'R' constant:
+    require 'rserve/simpler/R'
+    R.do_something_fantastic ...  # ** not a real method
+
+=== converse, convert, command
+
+These commands specify ways of talking to your Rserve connection.  All three
+allow passing names through to R in a hash.  They differ chiefly in the type
+of output you'll receive back from R.  
+
+    # converse: to_ruby the result
+    r.converse "mean(c(1,2,3))"  # -> 2.0
+
+    # convert: Rserve::REXP result
+    rexp = r.convert "mean(c(1,2,3))"  # -> #<Rserve::REXP::Double:0x00000002296498 @payload=[2.0], @attr=nil>
+    rexp.as_doubles   # -> [2.0]
+    rexp.to_ruby      # -> 2.0
+
+    # command: boolean reply if things went well
+    r.command "z <- mean(c(1,2,3))"  # -> true
+    # can retrieve variables with converse
+    r.converse "z"  # -> 2.0
+
+converse/convert/command let you name variables in a hash as a shortcut to
+'assign'.  [These examples use Ruby 1.9 hash syntax, but they should work on
+1.8 if the hashes are keyed old-style {:key => val}]
+    
+    r.converse(a: [1,2,3], b: [4,5,6]) { "cor(a,b)" } # -> 1.0
+    # another form doing the same thing
+    r.converse("cor(a,b)", a: [1,2,3], b: [4,5,6])
+
+==== prompt-like syntax '>>'
+
+'>>' is an alias for converse, so you can write code like this:
+
+    r >> "mean(c(1,2,3))"  # -> 2.0
+    # note: use '.' to get proper behavior with multiple args or blocks
+    r.>> "cor(a,b)", a: [1,2,3], b: [1,2,3]
+
+=== simple DataFrame
+
+==== with a hash
+
+Column names are derived from hash keys (#keys).  Ruby 1.9 hashes keep track
+of insertion order.  Use an OrderedHash (gem install orderedhash) for ruby
+1.8, or set colnames.
+     
+    hash = {
+      var1: [1,2,3,4], 
+      fac1: [3,4,5,6], 
+      res1: [4,5,6,7]
+    }
+    # convert with hash.to_dataframe or Rserve::DataFrame.new(hash)
+    r.command( df: hash.to_dataframe ) do 
+      %Q{ 
+        pdf("out.pdf")
+        plot(df)
+        dev.off()
+      }
+    end
+
+==== with an array of Structs
+
+    DataRow = Struct.new(:var1, :fac1, :res1)
+    structs = [
+      DataRow.new(1,3,4),
+      DataRow.new(2,4,5),
+      DataRow.new(3,5,6),
+      DataRow.new(4,6,7)
+    ]
+    datafr = Rserve::DataFrame.from_structs(structs)
+    reply = r.converse("summary(df)", df: datafr).each_cons(6).to_a
+    datafr.colnames.zip(reply) {|name,data| puts [name].+(data).join("\n ") }
+
+    ## outputs -> :
+    var1
+     Min.   :1.00  
+     1st Qu.:1.75  
+     Median :2.50  
+     Mean   :2.50  
+     3rd Qu.:3.25  
+     Max.   :4.00  
+    fac1
+     Min.   :3.00  
+     1st Qu.:3.75  
+     ...
+
+=== Notes on plotting
+
+Rserve is great for graphical output.  Here are some pointers when getting started with plotting:
+
+==== plot to screen
+
+    r.command "plot(c(1,2,3), c(3,4,5))"
+    # if you resize a window (at least on Ubuntu) you may need to re-issue the call
+    r.command "plot(c(1,2,3), c(3,4,5))"
+    # return a list of currently used devices (device 2 is the only one being used)
+    # to_ruby returns an array of 1 value as a number
+    r.converse "dev.list()" # -> 2
+    # shut off graphics device 2
+    r.command "dev.off(2)"
+    r.command "graphics.off()"  # shut off all graphics
+
+==== plot to file
+
+Files are written below the workdir specified when the Rserve connection was
+made (see {Rserve configuration}[http://www.rforge.net/Rserve/doc.html#conf]
+for background) and this is "/tmp/Rserve" on my system.
+
+    r.>> "pdf('output.pdf')", "plot(c(1,2,3),c(4,5,6))", "dev.off()"
+    # outputs file /tmp/Rserv/conn156/output.pdf
+    # note the connection number dir!
+    # (I haven't figured out how to predict this number)
+
+== TODO
+
+* simple option to use pwd as default directory
+* quiet the startup of Rserve by default
+* wrap graphic output commands
+
+== Copyright
+
+see LICENSE.txt
+

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rserve-simpler"
+  gem.homepage = "http://github.com/jtprince/rserve-simpler"
+  gem.license = "MIT"
+  gem.summary = %Q{simple interface for interacting with R through Rserve}
+  gem.description = %Q{interface layered on top of rserve-client gem for interacting with R}
+  gem.email = "jtprince@gmail.com"
+  gem.authors = ["John Prince"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |spec|
+  spec.libs << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rserve-simpler #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rserve/data_frame.rb

@@ -0,0 +1,49 @@
+
+module Rserve
+  # An R-centric container for storing data frame-ish data
+  class DataFrame
+    attr_accessor :rownames
+    attr_accessor :hash
+
+    # takes an array of structs and returns a data frame object
+    def self.from_structs(array)
+      names = array.first.members
+      lengthwise_arrays = names.map { Array.new(names.size) }
+      array.each_with_index do |struct,m|
+        struct.values.each_with_index do |val,n|
+          lengthwise_arrays[n][m] = val
+        end
+      end
+      hash = {}
+      names.zip(lengthwise_arrays) do |name, lengthwise_array|
+        hash[name] = lengthwise_array
+      end
+      self.new(hash)
+    end
+
+    def colnames() @hash.keys end
+
+    # takes an ordered hash, where the col_name is the key and the data rows
+    # are an array of values.  The default ordering of the hash keys will be
+    # used as the colnames.  This works great for ruby 1.9 (which remembers
+    # ordering).  Use an OrderedHash for ruby 1.8.  The rownames can be used
+    # to specify the names of the rows (remains nil if no values specified)
+    def initialize(ordered_hash, rownames=nil)
+      @hash = ordered_hash
+      @rownames = rownames
+    end
+
+    def ==(other)
+      (self.hash == other.hash) && (self.rownames == other.rownames)
+    end
+  end
+
+end
+
+class Hash
+  def to_dataframe(rownames=nil)
+    obj = Rserve::DataFrame.new(self)
+    obj.rownames = rownames if rownames
+    obj
+  end
+end

data/lib/rserve/simpler.rb

@@ -0,0 +1,77 @@
+
+require 'rserve'
+require 'rserve/rexp'
+require 'rserve/data_frame'
+
+class Rserve::Simpler < Rserve::Connection
+
+  # assigns variables and returns an array of commands to be evaluated
+  def with(*args, &block)
+    if args.last.is_a? Hash
+      hash = args.pop  # remove the hash
+      hash.each do |sym, obj|
+        rserve_compat_obj = 
+          case obj
+          when Rserve::DataFrame
+            wrapped_lists = obj.hash.values.map {|v| Rserve::REXP::Wrapper.wrap(v) }
+            z = Rserve::Rlist.new(wrapped_lists, obj.hash.keys.map(&:to_s))
+            Rserve::REXP.create_data_frame(z)
+          else
+            obj
+          end
+
+        assign sym.to_s, rserve_compat_obj
+
+        # this is super hackish but I tried "correct" methods to do this
+        # and they do not want to work.
+        # TODO: roll creation of row.names into create_data_frame method
+        if obj.is_a?(Rserve::DataFrame) && obj.rownames
+          tmp_var = "#{sym}__rownames__tmp__"
+          # all rownames become string arrays:
+          assign tmp_var, Rserve::REXP::String.new(obj.rownames)
+          void_eval( ["row.names(#{sym}) <- #{tmp_var}", "rm(#{tmp_var})"].join("\n") )
+        end
+
+      end
+    end
+    to_eval = args
+    unless block.nil?
+      to_eval.push(*block.call)
+    end
+    to_eval
+  end
+
+  # eval and cast reply .to_ruby
+  #
+  # typically, a single string is passed in either as the first argument or
+  # with the block.  The results of .to_ruby are passed back to the caller.
+  # However, if multiple strings are passed in (either as multiple string
+  # arguments or as multiple strings in the block, or one of each, etc.) the
+  # reply will be given as an array, one reply for each string.
+  def converse(*args, &block)
+    reply = with(*args, &block).map do |str|
+      response = self.eval(str)
+      reply = nil
+      begin ; reply = response.to_ruby 
+      rescue ; reply = response
+      end
+      reply
+    end
+    (reply.size == 1) ?  reply.first : reply
+  end
+
+  alias_method '>>'.to_sym, :converse
+
+  # void_eval
+  def command(*args, &block)
+    self.void_eval with(*args, &block).join("\n")
+  end
+
+  def convert(*args, &block)
+    reply = with(*args, &block).map do |str|
+      self.eval(str)
+    end
+    (reply.size == 1) ?  reply.first : reply
+  end
+
+end

data/lib/rserve/simpler/R.rb

@@ -0,0 +1,3 @@
+
+require 'rserve/simpler'
+R = Rserve::Simpler.new

data/rserve-simpler.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rserve-simpler}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Prince"]
+  s.date = %q{2011-02-14}
+  s.description = %q{TODO: longer description of your gem}
+  s.email = %q{jtprince@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/rserve-simpler.rb",
+    "lib/rserve/data_frame.rb",
+    "lib/rserve/simpler.rb",
+    "lib/rserve/simpler/R.rb",
+    "spec/rserve/simpler_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/jtprince/rserve-simpler}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{TODO: one-line summary of your gem}
+  s.test_files = [
+    "spec/rserve/simpler_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rserve-client>, ["~> 0.2.5"])
+      s.add_development_dependency(%q<spec-more>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rserve-client>, ["~> 0.2.5"])
+      s.add_dependency(%q<spec-more>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rserve-client>, ["~> 0.2.5"])
+    s.add_dependency(%q<spec-more>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/rserve/simpler_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+require 'rserve/simpler'
+
+describe "initializing a connection held in 'R'" do
+  it 'require "rserve/simpler/R" # loads a connection into R' do
+    require 'rserve/simpler/R'
+    R.converse("mean(c(1,2,3))").is 2.0
+    R.close
+  end
+end
+
+describe 'rserve connection with simpler' do
+  xit 'is quiet on startup' do
+    @r = Rserve::Simpler.new
+  end
+end
+
+describe 'rserve connection with simpler additions' do
+
+  before do
+    @r = Rserve::Simpler.new 
+  end
+
+  after do
+    @r.close
+  end
+
+  it 'converses with R using strings' do
+  # both sides speak native
+    ok @r.connected?
+    reply = @r.converse "mean(c(1,2,3))"
+    @r.converse("mean(c(1,2,3))").is 2.0
+  end
+
+  it 'converses with R using arrays and numbers' do
+    @r.converse("cor(a,b)", :a => [1,2,3], :b => [4,5,6]).is 1.0
+    @r.converse(:a => [1,2,3], :b => [4,5,6]) { "cor(a,b)" }.is 1.0
+    @r.converse(:a => 3) { "mean(a)" }.is 3.0
+  end
+
+  it 'can converse in sentences' do
+    (mean, cor) = @r.converse("mean(a)", "cor(a,b)", :a => [1,2,3], :b => [4,5,6])
+    mean.is 2.0
+    cor.is 1.0
+    # not sure why you'd want to do this, but this is okay
+    (mean, cor) = @r.converse("mean(a)") { "cor(a,b)" } 
+    # also okay
+    (mean, cor) = @r.converse "mean(a)", "cor(a,b)"
+  end
+
+  it 'has a prompt-like syntax' do
+    reply = @r >> "mean(c(1,2,3))"
+    reply.is 2.0
+    reply = @r.>> "cor(a,b)", a: [1,2,3], b: [1,2,3]
+    reply.is 1.0
+  end
+
+  it "commands R (giving no response but 'true')" do
+    @r.command(:a => [1,2,3], :b => [4,5,6]) { "z = cor(a,b)" }.is true
+    @r.converse("z").is 1.0
+  end
+
+  it "convert to REXP" do
+    reply =  @r.convert(:a => [1,2,3], :b => [4,5,6]) { "cor(a,b)" }
+    ok reply.is_a?(Rserve::REXP::Double)
+    reply.as_doubles.is [1.0]
+    reply.to_ruby .is 1.0
+  end
+
+  xit "returns the REXP if to_ruby raises an error" do
+    # still need to test this
+    flunk
+  end
+
+end
+
+if RUBY_VERSION > '1.9'
+
+  # TODO: write these compatible for 1.8
+
+  describe 'rserve with DataFrame convenience functions' do
+
+    Row = Struct.new(:fac1, :var1, :res1)
+
+    before do
+      @r = Rserve::Simpler.new 
+      @hash = {:fac1 => [1,2,3,4], :var1 => [4,5,6,7], :res1 => [8,9,10,11]}
+      @colnames = %w(fac1 var1 res1).map(&:to_sym)
+      @ar_of_structs = [Row.new(1,4,8), Row.new(2,5,9), Row.new(3,6,10), Row.new(4,7,11)]
+    end
+
+    after do
+      @r.close
+    end
+
+    it 'gives hashes a .to_dataframe method' do
+      # only need to set the colnames with Ruby 1.8 (unless using OrderedHash)
+      df1 = Rserve::DataFrame.new(@hash) 
+      df2 = @hash.to_dataframe
+      df2.colnames.is @colnames
+      df1.is df2
+      df2.colnames.is @colnames
+      df2.rownames.is nil
+      df2.rownames = [1,2,3,4]
+      df2.rownames.is [1,2,3,4]
+    end
+
+    it 'converts an array of parallel structs into a dataframe' do
+      df = Rserve::DataFrame.from_structs( @ar_of_structs )
+      df.is @hash.to_dataframe
+    end
+
+    it 'accepts simple dataframes when conversing with R' do
+      @r.converse(:df => @hash.to_dataframe) { "names(df)" }.is %w(fac1 var1 res1)
+    end
+
+    it 'accepts dataframes with rownames when conversing with R' do
+      rownames = [11,12,13,14]
+      @r.converse(:df => @hash.to_dataframe(rownames)) { "row.names(df)" }.is rownames.map(&:to_s)
+      rownames = %w(row1 row2 row3 row4)
+      @r.converse(:df => @hash.to_dataframe(rownames)) { "row.names(df)" }.is rownames
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'spec/more'
+
+Bacon.summary_on_exit

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: rserve-simpler
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- John Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rserve-client
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 5
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: spec-more
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: interface layered on top of rserve-client gem for interacting with R
+email: jtprince@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rserve-simpler.rb
+- lib/rserve/data_frame.rb
+- lib/rserve/simpler.rb
+- lib/rserve/simpler/R.rb
+- rserve-simpler.gemspec
+- spec/rserve/simpler_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jtprince/rserve-simpler
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3232687242390354005
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: simple interface for interacting with R through Rserve
+test_files: 
+- spec/rserve/simpler_spec.rb
+- spec/spec_helper.rb