rack-r 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*~
+.#*
+\#*

data/.rvmrc

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.8.7-p357@rack-r"
+
+#
+# Uncomment the following lines if you want to verify rvm version per project
+#
+# rvmrc_rvm_version="1.10.2" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+#
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+#
+# The variable PROJECT_JRUBY_OPTS requires the following to be run in shell:
+#
+#    chmod +x ${rvm_path}/hooks/after_use_jruby_opts
+#
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create use  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && ! command -v bundle >/dev/null
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && command -v bundle
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Phil Hofmann
+
+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.md

@@ -0,0 +1,106 @@
+RackR - Use R in your Rack stack
+================================
+
+RackR is a Rack middleware which integrates R into a Rack based web
+application (like Rails). With RackR in place displaying graphs is as
+simple as rendering R code into your output. E.g.
+
+    <script type='text/r'>
+      png('sinus.png')
+      plot(sin)
+    </script>
+
+RackR will pick this up on its way out and replace it with an empty
+container and some JavaScript code to perform an immediate async
+request for processing the R code.
+
+RackR will answer to this reqyest with processing the R code in a temp
+directory, then searching this directory for displayable content and
+finally return the html code for display. So the example above will
+eventually turn into something like this.
+
+    <div>
+     <img src='/path/to/sinus.png' />
+     <pre>
+       content of Rout file (stdout of R)
+     </pre>
+    </div>
+
+Almost everything can conveniently be configured in a YAML file. RackR
+will create a sample config file in `config/rack-r.yml` or any other
+path given.
+
+
+Install in Rails
+----------------
+
+Put the following in your Gemfile and run `bundle install` or let
+[Guard](https://github.com/guard/guard-bundler) kick in.
+
+    gem 'rack-r', :require => 'rack_r'
+
+In Rails 3.2 you will have to put this somewhere
+
+    require 'rack_r/railtie'
+
+
+Using RackR outside of Rails
+----------------------------
+
+    require 'rack_r/middleware'
+    use RackR::Middleware, :config => 'path/to/config/rack-r.yml'
+
+
+Dependencies
+------------
+
+These instructions are for Debian Squeeze. Install R.
+
+    apt-get install r-base r-cran-dbi
+
+Alternatively you can use the `rodbc` package.
+
+    apt-get install r-cran-rodbc 
+
+The RackR-Header is a pice of R code that gets prepended to every R
+script which is processed by RackR. Idealy it will read you database
+config and provide a seperate connection to your database via a DBI
+compatible `con` object.
+
+If you want RackR to automatically connect R script to yoyr Rails
+database it is a good idea to install Jeremy Stephens' YAML for R.
+
+    wget http://cran.r-project.org/src/contrib/yaml_2.1.4.tar.gz
+    R CMD INSTALL yaml_2.1.4.tar.gz
+
+### SQLite
+
+    wget http://cran.r-project.org/src/contrib/RSQLite_0.11.1.tar.gz
+    R CMD INSTALL RSQLite_0.11.1.tar.gz
+
+### MySQL
+
+    apt-get install r-cran-rmysql
+
+The whole RackR-Header is a work in progress, if you have to adjust it
+to your database config, please consider to contribute your addition.
+
+
+Trouble shooting
+----------------
+
+Browse to /rack-r/ (including the trailing slash!) to see if RackR is
+working. If so it should respond with "RackR OK."
+
+
+Patches and the like
+--------------------
+
+If you run into bugs, have suggestions or patches feel free to drop me
+a line.
+
+
+License
+-------
+
+RackR is released under MIT License, see LICENSE.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/rack_r.rb

@@ -0,0 +1,2 @@
+require "rack_r/railtie" if defined? Rails
+

data/lib/rack_r/middleware.rb

@@ -0,0 +1,224 @@
+require 'ostruct'
+require 'yaml'
+require 'erb'
+
+require 'csv'
+
+module RackR
+  class Middleware < Struct.new :app, :options
+
+    def call(env)
+      @env = env
+      return call_app unless config.enabled
+      if get? and md = match_path
+        key = md.to_a.last
+        return [200, {}, ['RackR OK.']] if key.empty?
+        process key
+      else
+        extract
+      end
+    end
+
+    def call_app
+      app.call(@env)
+    end
+
+    def extract
+      status, headers, response = call_app
+      if headers["Content-Type"] =~ /text\/html|application\/xhtml\+xml/
+        # TODO if contains <script type="text/r">
+        body = ""
+        response.each { |part| body << part }
+        while md = body.match(node_regex)
+          tempdir = temp_dir
+          key = File.basename(tempdir)
+          r_script = ERB.new(config.r_header).result(binding) + md.to_a.last
+          write_file(File.join(tempdir, config.r_file), r_script)
+          body.sub!(node_regex, ajaxer(key))
+        end
+        headers["Content-Length"] = body.length.to_s
+        response = [ body ]
+      end
+      [ status, headers, response ]
+    end
+
+    def process(key)
+      path = temp_dir(key)
+      return call_app unless File.directory?(path) # TODO render error msg
+      time = exec_r_script(config.r_file, path)
+      files = Dir.entries(path).sort
+      # build body
+      body = [ config.html.prefix ]
+      files.each do |file|
+        config.templates.each do |template|
+          if file =~ Regexp.new(template['pattern'], Regexp::IGNORECASE)
+            src = File.join(path, file)
+            eval(template['process']) unless template['process'].nil?
+            body << ERB.new(template['template']).result(binding)
+          end
+        end
+      end
+      # TODO remove temp dir
+      body << config.html.suffix
+      [ 200, { "Content-Type" => "text/html" }, body ]
+    end
+
+    # return true if request method is GET
+    def get?
+      @env["REQUEST_METHOD"] == "GET"
+    end
+
+    def path_regex
+      Regexp.new "^#{config.url_scope}/(.*)"
+    end
+
+    def node_regex
+      opts = Regexp::IGNORECASE + Regexp::MULTILINE
+      Regexp.new config.node_regex, opts
+    end
+
+    def path_info
+      @env["PATH_INFO"]
+    end
+
+    def match_path
+      path_info.match(path_regex)
+    end
+
+    def exec_r_script(file, path=nil)
+      cmd = path.nil? ? "R CMD BATCH #{file}" :
+        "(cd #{path} && R CMD BATCH #{file})"
+      %x[#{cmd}]
+    end
+
+    def temp_dir(key=nil)
+      return Dir.mktmpdir(config.temp.prefix, config.temp.dir) if key.nil?
+      File.join config.temp.dir, key
+    end
+
+    def write_file(path, content)
+      ::File.open(path, 'w') { |f| f.puts content }
+    end
+
+    def public_path
+      config.public_path.tap do |path|
+        FileUtils.mkdir_p(path) unless File.directory?(path)
+      end
+    end
+
+    def ajaxer(key)
+      ERB.new(config.ajaxer).result(binding)
+    end
+
+    def default_config
+      ::File.read(__FILE__).gsub(/.*__END__\n/m, '')
+    end
+
+    def config_path
+      options[:config].tap do |path|
+        raise "no config path given" unless path
+      end
+    end
+
+    def config
+      return @config unless @config.nil?
+      write_file(config_path, default_config) unless ::File.exist?(config_path)
+      @config = deep_ostruct(::File.open(config_path) { |yf| YAML::load(yf) })
+    end
+
+    private
+
+    def deep_ostruct(hash)
+      OpenStruct.new(hash).tap do |ostruct|
+        hash.keys.each do |key|
+          if ostruct.send(key).is_a?(Hash)
+            ostruct.send("#{key}=", deep_ostruct(hash[key]))
+          end
+        end
+      end
+    end
+
+  end
+end
+
+__END__
+# RackR -- process R on the fly
+# RackR depends on jQuery >= 1.4.4
+#
+# changes to this file will not be picked up
+# without a restart of your app
+#
+enabled:     true
+url_scope:   /rack-r
+public_path: public/system/rack-r
+public_url:  /system/rack-r
+temp:
+  dir:       /tmp
+  prefix:    rr_
+r_file:      script.R
+r_header: |
+  # modify this header in rack-r config file
+  library(yaml)
+  library(DBI)
+  library(RSQLite)
+  root <- '<%= Rails.root %>'
+  dbconf <- yaml.load_file(paste(root, '/config/database.yml', sep=''))
+  dbfile <- paste(root, '/', dbconf$development$database, sep='')
+  drv <- dbDriver("SQLite")
+  con <- dbConnect(drv, dbname=dbfile)
+ajaxer: |
+  <div class='rack_r' id='<%= key %>'>Processing R...</div>
+  <script type='text/javascript'>
+    var url = '<%= config.url_scope %>/<%= key %>';
+    $.ajax(url, { success: function(data) { $('#<%= key %>').html(data); } });
+  </script>
+html:
+  prefix:    <div class='rack_r_out'>
+  suffix:    </div>
+templates:
+  - pattern: .svg$
+    process: |
+      svg = File.read(src)
+    template: |
+      <%= svg %>
+  - pattern: .(jpg|jpeg|png)$
+    process: |
+      # TODO build dst with key, otherwise may lead to undesired results
+      dst = File.join(public_path, file)
+      FileUtils.cp(src, dst)
+      url = "#{config.public_url}/#{file}"
+    template: |
+      <img src='<%= url %>' />
+  - pattern: .csv$
+    process: |
+      table = CSV.read(src)
+      # TODO build dst with key, otherwise may lead to undesired results
+      dst = File.join(public_path, file)
+      FileUtils.cp(src, dst)
+      url = "#{config.public_url}/#{file}"
+    template: |
+      <a href='<%= url %>'><%= file %></a>
+      <table>
+        <% table.each do |row| %>
+          <tr>
+            <% row.each do |col| %>
+              <td><%= col %></td>
+            <% end %>
+          </tr>
+        <% end %>
+      </table>
+  - pattern: .Rout$
+    process: |
+      rout = File.read(src)
+    template: |
+      <pre><%= rout %></pre>
+node_regex:  <script\s+type=['"]text/r['"]\s*>(.*?)</script>
+#
+# uncomment the following two lines, if your project
+# doesn't use jquery already
+# javascripts:
+#   - http://code.jquery.com/jquery-1.5.1.min.js
+# or this line if you want to ship it yourself
+#   - /javascripts/jquery-1.5.1.min.js
+# uncomment the following line, in case your project uses prototype
+# jquery_noconflict: true

data/lib/rack_r/railtie.rb

@@ -0,0 +1,25 @@
+require 'rack_r/middleware'
+
+module RackR
+  
+  major, minor, patch = Rails.version.split('.').map { |s| s.to_i }
+
+  case major
+  when 2
+    Rails.configuration.middleware.use RackR::Middleware,
+      :config => File.expand_path('config/rack-r.yml', RAILS_ROOT)
+
+  when 3
+    class Railtie < Rails::Railtie
+      initializer "rack_r.insert_middleware" do |app|
+        app.config.middleware.use "RackR::Middleware",
+          :config => File.expand_path('config/rack-r.yml', Rails.root)
+      end
+    end
+
+  else
+    raise "Unknown Rails version #{Rails.version}"
+  end
+
+end
+

data/lib/rack_r/version.rb

@@ -0,0 +1,3 @@
+module RackR
+  VERSION = "0.1.0"
+end

data/rack-r.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "rack_r/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rack-r"
+  s.version     = RackR::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Phil Hofmann"]
+  s.email       = ["phil@branch14.org"]
+  s.homepage    = "http://branch14.org/rack-r"
+  s.summary     = %q{Use R in your Rack stack}
+  s.description = %q{Use R in your Rack stack}
+
+  # s.rubyforge_project = "rack-r"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "rails"]
+end

data/test/example.r

@@ -0,0 +1,38 @@
+# y mntl. Rate
+# f Franchise
+# s Selbstbehalt
+# m Selbstbehalt max.
+
+png('insurance.png')
+
+costf <- function(y, f, s=0.1, m=700) {
+  return(function(x) {
+    (y * 12) + min(f, x) + max(0, min(m - f, s * (max(f, x) - f)))
+  })
+}
+
+f0 <- costf( 95.70, 0 )
+f1 <- costf( 90.00, 100 )
+f2 <- costf( 84.10, 200 )
+f4 <- costf( 72.40, 400 )
+f6 <- costf( 60.70, 600 )
+
+x_max <- 7250
+x <- seq(0, x_max, by=10)
+plot(x, x, type='l', lty=3,
+         xlim=range(0, x_max),
+         ylim=range(500, 2000),
+         xlab='Kosten Verursacht',
+         ylab='Kosten Gezahlt')
+
+lines(x, apply(array(x), 1, f0), col='green')
+lines(x, apply(array(x), 1, f1))
+lines(x, apply(array(x), 1, f2))
+lines(x, apply(array(x), 1, f4))
+lines(x, apply(array(x), 1, f6), col='red')
+
+f <- function(x) { return(f0(x) - f6(x)) }
+lower <- uniroot(f, c(400, 600))
+upper <- uniroot(f, c(2500, 3000))
+abline(v=lower$root, lty=2)
+abline(v=upper$root, lty=2)

data/test/helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rack_r'
+require 'rack_r/middleware'
+
+class Test::Unit::TestCase
+end

data/test/test_rack_r.rb

@@ -0,0 +1,153 @@
+require File.expand_path('../helper', __FILE__)
+require 'rack/mock'
+
+class TestRackR < Test::Unit::TestCase
+
+  CONFIGFILE = '/tmp/test_rack_r'
+  File.unlink(CONFIGFILE) if File.exist?(CONFIGFILE)
+
+  EXPECTED_CODE = /class='rack_r'/
+
+  context "Util" do
+    should "create proper temp dir" do
+      td = app.temp_dir
+      assert File.directory?(td)
+
+      base = File.basename(td)
+      assert_equal td, app.temp_dir(base)
+
+      assert FileUtils.rm_rf(td)
+      assert !File.exist?(td)
+    end
+  end
+
+  context "Proper regexs" do
+    should "detect r code if present" do
+      assert_match app.node_regex, HTML_POSITIVE
+    end
+
+    should "not detect r code if none is present" do
+      assert_no_match app.node_regex, HTML_NEGATIVE
+    end
+  end
+
+  context "Embedding payload" do
+    should "place the payload in body of an HTML request" do
+      assert_match EXPECTED_CODE, request.body
+    end
+
+    should "place the payload in body of an XHTML request" do
+      response = request(:content_type => 'application/xhtml+xml')
+      assert_match EXPECTED_CODE, response.body
+    end
+  
+    should "not place the payload in a non HTML request" do
+      response = request(:content_type => 'application/xml', :body => [XML])
+      assert_no_match EXPECTED_CODE, response.body
+    end
+    
+    should "not place the playload in a document not containing r code" do
+      response = request(:body => HTML_NEGATIVE)
+      assert_no_match EXPECTED_CODE, response.body
+    end
+  end
+
+  context "Processing R" do
+    should 'detect get request' do
+      request(:path => "/rack-r/rr-some-random-key")
+      assert @app.get?
+    end
+
+    should 'detect path' do
+      request(:path => "/rack-r/rr-some-random-key")
+      assert @app.match_path
+    end
+
+    should 'properly respond to rack_r request' do
+      key = 'rr-some-key'
+      path = app.temp_dir(key)
+      FileUtils.rm_rf(path) if File.exist?(path)
+      Dir.mkdir(path)
+      src = File.expand_path('../example.r', __FILE__)
+      dst = File.join(path, app.config.r_file)
+      FileUtils.cp(src, dst)
+      response = request(:path => "/rack-r/#{key}")
+      assert Dir.entries(path).include?('insurance.png')
+      regex = Regexp.new("src='#{@app.config.public_url}/insurance.png'")
+      assert_match regex, response.body
+      FileUtils.rm_rf(path)
+    end
+  end
+
+  # context "Deliver payload" do
+  #   setup do
+  #     @expected_file = File.expand_path(File.join(%w(.. .. public) << PAYLOAD), __FILE__)
+  #     @response = request({}, "/#{PAYLOAD}")
+  #   end
+  # 
+  #   should "deliver #{PAYLOAD}" do
+  #     expected = File.read(@expected_file)
+  #     assert expected, @response.body
+  #   end
+  # 
+  #   should "set the content-type correctly" do
+  #     assert 'text/javascript', @response.body
+  #   end
+  # end
+
+  private
+
+  HTML_POSITIVE = <<-EOHTML
+   <html>
+     <head>
+       <title>Sample Page</title>
+     </head>
+     <body>
+       <h2>Here goes some R</h2>
+       <script type='text/r'>
+         some invalid r code
+       </script>
+     </body>
+   </html>
+  EOHTML
+
+  HTML_NEGATIVE = <<-EOHTML
+   <html>
+     <head>
+       <title>Sample page with no matching node</title>
+     </head>
+     <body>
+       <p>Empty page.</p>
+     </body>
+   </html>
+  EOHTML
+
+  XML = <<-EOXML
+   <?xml version="1.0" encoding="ISO-8859-1"?>
+   <user>
+     <name>Some Name</name>
+     <age>Some Age</age>
+   </user>
+  EOXML
+  
+  def request(options={})
+    path = options.delete(:path) || '/'
+    @app = app(options)
+    request = Rack::MockRequest.new(@app).get(path)
+    yield(@app, request) if block_given?
+    request
+  end
+  
+  def app(options={})
+    options = options.clone
+    options[:content_type] ||= "text/html"
+    options[:body]         ||= [ HTML_POSITIVE ]
+    rack_app = lambda do |env|
+      [ 200,
+        { 'Content-Type' => options.delete(:content_type) },
+        options.delete(:body) ]
+    end
+    RackR::Middleware.new(rack_app, :config => CONFIGFILE)
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: rack-r
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Phil Hofmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-23 00:00:00 Z
+dependencies: []
+
+description: Use R in your Rack stack
+email: 
+- phil@branch14.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- lib/rack_r.rb
+- lib/rack_r/middleware.rb
+- lib/rack_r/railtie.rb
+- lib/rack_r/version.rb
+- rack-r.gemspec
+- test/example.r
+- test/helper.rb
+- test/test_rack_r.rb
+homepage: http://branch14.org/rack-r
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- rails
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Use R in your Rack stack
+test_files: []
+