shrimp-orangejulius 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcb06ce8ced640f4b8f73bd159d06f784a28faeb
+  data.tar.gz: 33f37c32163be0f438763dbcd6f99e377d410ddb
+SHA512:
+  metadata.gz: f6586310d4c7bf3302b8ef1b36fdd8632cc76fbb6bd0eedaf01d3e116819036b0de8960add26c36de16d836bcff900fa8ad356888fcaad33a3154753bc289819
+  data.tar.gz: 77f7ef5d6fc83dcc5144e0d43cb8d7224da878252606997ce6a3b1e10befd1ecf12bd58757b65c0809070417179226d541bdd1284e87eac210a8c60c4a5d1e00

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - rbx-2
+  - 2.0.0
+  - 2.1.1
+matrix:
+  allow_failures:
+    - rvm: rbx-2

data/ChangeLog.md

@@ -0,0 +1,9 @@
+## ChangeLog
+
+2012-12-18: Version 0.0.2
+    Improved Error handling
+    Improved Readme
+    Minor Bug fixes
+
+2012-12-17: Version 0.0.1
+    Initial launch.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 adeven GmbH Manuel Kniep
+
+MIT License
+
+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,191 @@
+# Shrimp
+[![Build Status](https://travis-ci.org/adjust/shrimp.png?branch=master)](https://travis-ci.org/adjust/shrimp)
+Creates PDFs from URLs using phantomjs
+
+Read our [blogpost](http://big-elephants.com/2012-12/pdf-rendering-with-phantomjs/) about how it works.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shrimp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shrimp
+
+
+### Phantomjs
+
+    See http://phantomjs.org/download.html on how to install phantomjs
+
+## Usage
+
+```
+require 'shrimp'
+url     = 'http://www.google.com'
+options = { :margin => "1cm"}
+Shrimp::Phantom.new(url, options).to_pdf("~/output.pdf")
+```
+## Configuration
+
+```
+Shrimp.configure do |config|
+
+  # The path to the phantomjs executable
+  # defaults to `where phantomjs`
+  # config.phantomjs = '/usr/local/bin/phantomjs'
+
+  # the default pdf output format
+  # e.g. "5in*7.5in", "10cm*20cm", "A4", "Letter"
+  # config.format           = 'A4'
+
+  # the default margin
+  # config.margin           = '1cm'
+
+  # the zoom factor
+  # config.zoom             = 1
+
+  # the page orientation 'portrait' or 'landscape'
+  # config.orientation      = 'portrait'
+
+  # a temporary dir used to store tempfiles
+  # config.tmpdir           = Dir.tmpdir
+
+  # the default rendering time in ms
+  # increase if you need to render very complex pages
+  # config.rendering_time   = 1000
+
+  # change the viewport size.  If you rendering pages that have
+  # flexible page width and height then you may need to set this
+  # to enforce a specific size
+  # config.viewport_width     = 600
+  # config.viewport_height    = 600
+
+  # the timeout for the phantomjs rendering process in ms
+  # this needs always to be higher than rendering_time
+  # config.rendering_timeout  = 90000
+
+  # maximum number of redirects to follow
+  # by default Shrimp does not follow any redirects which means that
+  # if the server responds with non HTTP 200 an error will be returned
+  # config.max_redirect_count = 0
+
+  # the path to a json configuration file for command-line options
+  # config.command_config_file = "#{Rails.root.join('config', 'shrimp', 'config.json')}"
+end
+```
+
+### Command Configuration
+
+```
+{
+    "diskCache": false,
+    "ignoreSslErrors": false,
+    "loadImages": true,
+    "outputEncoding": "utf8",
+    "webSecurity": true
+}
+```
+
+## Middleware
+
+Shrimp comes with a middleware that allows users to get a PDF view of any page on your site by appending .pdf to the URL.
+
+### Middleware Setup
+
+**Non-Rails Rack apps**
+
+    # in config.ru
+    require 'shrimp'
+    use Shrimp::Middleware
+
+**Rails apps**
+
+    # in application.rb(Rails3) or environment.rb(Rails2)
+    require 'shrimp'
+    config.middleware.use Shrimp::Middleware
+
+**With Shrimp options**
+
+    # options will be passed to Shrimp::Phantom.new
+    config.middleware.use Shrimp::Middleware, :margin => '0.5cm', :format => 'Letter'
+
+**With conditions to limit routes that can be generated in pdf**
+
+    # conditions can be regexps (either one or an array)
+    config.middleware.use Shrimp::Middleware, {}, :only => %r[^/public]
+    config.middleware.use Shrimp::Middleware, {}, :only => [%r[^/invoice], %r[^/public]]
+
+    # conditions can be strings (either one or an array)
+    config.middleware.use Shrimp::Middleware, {}, :only => '/public'
+    config.middleware.use Shrimp::Middleware, {}, :only => ['/invoice', '/public']
+
+    # conditions can be regexps (either one or an array)
+    config.middleware.use Shrimp::Middleware, {}, :except => [%r[^/prawn], %r[^/secret]]
+
+    # conditions can be strings (either one or an array)
+    config.middleware.use Shrimp::Middleware, {}, :except => ['/secret']
+
+
+### Polling
+
+To avoid deadlocks Shrimp::Middleware renders the pdf in a separate process retuning a 503 Retry-After response Header.
+you can setup the polling interval and the polling offset in seconds.
+
+    config.middleware.use Shrimp::Middleware, :polling_interval => 1, :polling_offset => 5
+
+### Caching
+
+To avoid rendering the page on each request you can setup some the cache ttl in seconds
+
+    config.middleware.use Shrimp::Middleware, :cache_ttl => 3600, :out_path => "my/pdf/store"
+
+
+### Ajax requests
+
+To include some fancy Ajax stuff with jquery
+
+```js
+
+ var url = '/my_page.pdf'
+ var statusCodes = {
+      200: function() {
+        return window.location.assign(url);
+      },
+      504: function() {
+       console.log("Shit's being wired")
+      },
+      503: function(jqXHR, textStatus, errorThrown) {
+        var wait;
+        wait = parseInt(jqXHR.getResponseHeader('Retry-After'));
+        return setTimeout(function() {
+          return $.ajax({
+            url: url,
+            statusCode: statusCodes
+          });
+        }, wait * 1000);
+      }
+  }
+  $.ajax({
+    url: url,
+    statusCode: statusCodes
+  })
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+Shrimp is Copyright © 2012 adeven (Manuel Kniep). It is free software, and may be redistributed under the terms
+specified in the LICENSE file.

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/shrimp.rb

@@ -0,0 +1,5 @@
+require 'shrimp/version'
+require 'shrimp/source'
+require 'shrimp/phantom'
+require 'shrimp/middleware'
+require 'shrimp/configuration'

data/lib/shrimp/config.json

@@ -0,0 +1,7 @@
+{
+    "diskCache": false,
+    "ignoreSslErrors": false,
+    "loadImages": true,
+    "outputEncoding": "utf8",
+    "webSecurity": true
+}

data/lib/shrimp/configuration.rb

@@ -0,0 +1,55 @@
+require 'tmpdir'
+
+module Shrimp
+  class Configuration
+    attr_accessor :default_options
+    attr_writer :phantomjs
+
+    [:format, :margin, :zoom, :orientation, :tmpdir, :rendering_timeout, :rendering_time, :command_config_file, :viewport_width, :viewport_height, :max_redirect_count].each do |m|
+      define_method("#{m}=") do |val|
+        @default_options[m]=val
+      end
+    end
+
+    def initialize
+      @default_options = {
+          :format               => 'A4',
+          :margin               => '1cm',
+          :zoom                 => 1,
+          :orientation          => 'portrait',
+          :tmpdir               => Dir.tmpdir,
+          :rendering_timeout    => 90000,
+          :rendering_time       => 1000,
+          :command_config_file  => File.expand_path('../config.json', __FILE__),
+          :viewport_width       => 600,
+          :viewport_height      => 600,
+          :max_redirect_count   => 0
+      }
+    end
+
+    def phantomjs
+      @phantomjs ||= (defined?(Bundler::GemfileError) ? `bundle exec which phantomjs` : `which phantomjs`).chomp
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure Phantomjs someplace sensible,
+  # like config/initializers/phantomjs.rb
+  #
+  # @example
+  #   Shrimp.configure do |config|
+  #     config.phantomjs = '/usr/local/bin/phantomjs'
+  #     config.format = 'Letter'
+  #   end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/shrimp/middleware.rb

@@ -0,0 +1,175 @@
+module Shrimp
+  class Middleware
+    def initialize(app, options = { }, conditions = { })
+      @app                        = app
+      @options                    = options
+      @conditions                 = conditions
+      @options[:polling_interval] ||= 1
+      @options[:polling_offset]   ||= 1
+      @options[:cache_ttl]        ||= 1
+      @options[:request_timeout]  ||= @options[:polling_interval] * 10
+    end
+
+    def call(env)
+      @request = Rack::Request.new(env)
+      if render_as_pdf? #&& headers['Content-Type'] =~ /text\/html|application\/xhtml\+xml/
+        if already_rendered? && (up_to_date?(@options[:cache_ttl]) || @options[:cache_ttl] == 0)
+          if File.size(render_to) == 0
+            File.delete(render_to)
+            remove_rendering_flag
+            return error_response
+          end
+          return ready_response if env['HTTP_X_REQUESTED_WITH']
+          file = File.open(render_to, "rb")
+          body = file.read
+          file.close
+          File.delete(render_to) if @options[:cache_ttl] == 0
+          remove_rendering_flag
+          response                  = [body]
+          headers                   = { }
+          headers["Content-Length"] = (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+          headers["Content-Type"]   = "application/pdf"
+          [200, headers, response]
+        else
+          if rendering_in_progress?
+            if rendering_timed_out?
+              remove_rendering_flag
+              error_response
+            else
+              reload_response(@options[:polling_interval])
+            end
+          else
+            File.delete(render_to) if already_rendered?
+            set_rendering_flag
+            fire_phantom
+            reload_response(@options[:polling_offset])
+          end
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    # Private: start phantom rendering in a separate process
+    def fire_phantom
+      Process::detach fork { Phantom.new(@request.url.sub(%r{\.pdf$}, ''), @options, @request.cookies).to_pdf(render_to) }
+    end
+
+    def render_to
+      file_name = Digest::MD5.hexdigest(@request.path) + ".pdf"
+      file_path = @options[:out_path]
+      "#{file_path}/#{file_name}"
+    end
+
+    def already_rendered?
+      File.exists?(render_to)
+    end
+
+    def up_to_date?(ttl = 30)
+      (Time.now - File.new(render_to).mtime) <= ttl
+    end
+
+
+    def remove_rendering_flag
+      @request.session["phantom-rendering"] ||={ }
+      @request.session["phantom-rendering"].delete(render_to)
+    end
+
+    def set_rendering_flag
+      @request.session["phantom-rendering"]            ||={ }
+      @request.session["phantom-rendering"][render_to] = Time.now
+    end
+
+    def rendering_timed_out?
+      Time.now - @request.session["phantom-rendering"][render_to] > @options[:request_timeout]
+    end
+
+    def rendering_in_progress?
+      @request.session["phantom-rendering"]||={ }
+      @request.session["phantom-rendering"][render_to]
+    end
+
+    def render_as_pdf?
+      request_path_is_pdf = !!@request.path.match(%r{\.pdf$})
+
+      if request_path_is_pdf && @conditions[:only]
+        rules = [@conditions[:only]].flatten
+        rules.any? do |pattern|
+          if pattern.is_a?(Regexp)
+            @request.path =~ pattern
+          else
+            @request.path[0, pattern.length] == pattern
+          end
+        end
+      elsif request_path_is_pdf && @conditions[:except]
+        rules = [@conditions[:except]].flatten
+        rules.map do |pattern|
+          if pattern.is_a?(Regexp)
+            return false if @request.path =~ pattern
+          else
+            return false if @request.path[0, pattern.length] == pattern
+          end
+        end
+        return true
+      else
+        request_path_is_pdf
+      end
+    end
+
+    def concat(accepts, type)
+      (accepts || '').split(',').unshift(type).compact.join(',')
+    end
+
+    def reload_response(interval=1)
+      body = <<-HTML.gsub(/[ \n]+/, ' ').strip
+          <html>
+          <head>
+        </head>
+          <body onLoad="setTimeout(function(){ window.location.reload()}, #{interval * 1000});">
+          <h2>Preparing pdf... </h2>
+          </body>
+        </ html>
+      HTML
+      headers                   = { }
+      headers["Content-Length"] = body.size.to_s
+      headers["Content-Type"]   = "text/html"
+      headers["Retry-After"]    = interval.to_s
+
+      [503, headers, [body]]
+    end
+
+    def ready_response
+      body = <<-HTML.gsub(/[ \n]+/, ' ').strip
+        <html>
+        <head>
+        </head>
+        <body>
+        <a href="#{@request.path}">PDF ready here</a>
+        </body>
+      </ html>
+      HTML
+      headers                   = { }
+      headers["Content-Length"] = body.size.to_s
+      headers["Content-Type"]   = "text/html"
+      [200, headers, [body]]
+    end
+
+    def error_response
+      body = <<-HTML.gsub(/[ \n]+/, ' ').strip
+        <html>
+        <head>
+        </head>
+        <body>
+        <h2>Sorry request timed out... </h2>
+        </body>
+      </ html>
+      HTML
+      headers                   = { }
+      headers["Content-Length"] = body.size.to_s
+      headers["Content-Type"]   = "text/html"
+      [504, headers, [body]]
+    end
+  end
+end

data/lib/shrimp/phantom.rb

@@ -0,0 +1,153 @@
+require 'uri'
+require 'json'
+require 'shellwords'
+
+module Shrimp
+  class NoExecutableError < StandardError
+    def initialize
+      msg = "No phantomjs executable found at #{Shrimp.configuration.phantomjs}\n"
+      msg << ">> Please install phantomjs - http://phantomjs.org/download.html"
+      super(msg)
+    end
+  end
+
+  class ImproperSourceError < StandardError
+    def initialize(msg = nil)
+      super("Improper Source: #{msg}")
+    end
+  end
+
+  class RenderingError < StandardError
+    def initialize(msg = nil)
+      super("Rendering Error: #{msg}")
+    end
+  end
+
+  class Phantom
+    attr_accessor :source, :configuration, :outfile
+    attr_reader :options, :cookies, :result, :error
+    SCRIPT_FILE = File.expand_path('../rasterize.js', __FILE__)
+
+    # Public: Runs the phantomjs binary
+    #
+    # Returns the stdout output of phantomjs
+    def run
+      @error  = nil
+      @result = `#{cmd}`
+      unless $?.exitstatus == 0
+        @error  = @result
+        @result = nil
+      end
+      @result
+    end
+
+    def run!
+      @error  = nil
+      @result = `#{cmd}`
+      unless $?.exitstatus == 0
+        @error  = @result
+        @result = nil
+        raise RenderingError.new(@error)
+      end
+      @result
+    end
+
+    # Public: Returns the phantom rasterize command
+    def cmd
+      cookie_file                       = dump_cookies
+      format, zoom, margin, orientation = options[:format], options[:zoom], options[:margin], options[:orientation]
+      rendering_time, timeout           = options[:rendering_time], options[:rendering_timeout]
+      viewport_width, viewport_height   = options[:viewport_width], options[:viewport_height]
+      max_redirect_count                = options[:max_redirect_count]
+      @outfile                          ||= "#{options[:tmpdir]}/#{Digest::MD5.hexdigest((Time.now.to_i + rand(9001)).to_s)}.pdf"
+      command_config_file               = "--config=#{options[:command_config_file]}"
+      [
+        Shrimp.configuration.phantomjs,
+        command_config_file,
+        SCRIPT_FILE,
+        @source.to_s.shellescape,
+        @outfile,
+        format,
+        zoom,
+        margin,
+        orientation,
+        cookie_file,
+        rendering_time,
+        timeout,
+        viewport_width,
+        viewport_height,
+        max_redirect_count
+      ].join(" ")
+    end
+
+    # Public: initializes a new Phantom Object
+    #
+    # url_or_file             - The url of the html document to render
+    # options                 - a hash with options for rendering
+    #   * format              - the paper format for the output eg: "5in*7.5in", "10cm*20cm", "A4", "Letter"
+    #   * zoom                - the viewport zoom factor
+    #   * margin              - the margins for the pdf
+    #   * command_config_file - the path to a json configuration file for command-line options
+    # cookies                 - hash with cookies to use for rendering
+    # outfile                 - optional path for the output file a Tempfile will be created if not given
+    #
+    # Returns self
+    def initialize(url_or_file, options = { }, cookies={ }, outfile = nil)
+      @source  = Source.new(url_or_file)
+      @options = Shrimp.configuration.default_options.merge(options)
+      @cookies = cookies
+      @outfile = File.expand_path(outfile) if outfile
+      raise NoExecutableError.new unless File.exists?(Shrimp.configuration.phantomjs)
+    end
+
+    # Public: renders to pdf
+    # path  - the destination path defaults to outfile
+    #
+    # Returns the path to the pdf file
+    def to_pdf(path=nil)
+      @outfile = File.expand_path(path) if path
+      self.run
+      @outfile
+    end
+
+    # Public: renders to pdf
+    # path  - the destination path defaults to outfile
+    #
+    # Returns a File Handle of the Resulting pdf
+    def to_file(path=nil)
+      self.to_pdf(path)
+      File.new(@outfile)
+    end
+
+    # Public: renders to pdf
+    # path  - the destination path defaults to outfile
+    #
+    # Returns the binary string of the pdf
+    def to_string(path=nil)
+      File.open(self.to_pdf(path)).read
+    end
+
+    def to_pdf!(path=nil)
+      @outfile = File.expand_path(path) if path
+      self.run!
+      @outfile
+    end
+
+    def to_file!(path=nil)
+      self.to_pdf!(path)
+      File.new(@outfile)
+    end
+
+    def to_string!(path=nil)
+      File.open(self.to_pdf!(path)).read
+    end
+
+    private
+
+    def dump_cookies
+      host = @source.url? ? URI::parse(@source.to_s).host : "/"
+      json = @cookies.inject([]) { |a, (k, v)| a.push({ :name => k, :value => v, :domain => host }); a }.to_json
+      File.open("#{options[:tmpdir]}/#{rand}.cookies", 'w') { |f| f.puts json; f }.path
+    end
+  end
+end

data/lib/shrimp/rasterize.js

@@ -0,0 +1,143 @@
+var
+  webpage = require('webpage'),
+  fs      = require('fs'),
+  system  = require('system'),
+  margin          = system.args[5] || '0cm',
+  orientation     = system.args[6] || 'portrait',
+  cookie_file     = system.args[7],
+  render_time     = system.args[8] || 10000 ,
+  time_out        = system.args[9] || 90000 ,
+  viewport_width  = system.args[10] || 600,
+  viewport_height = system.args[11] || 600,
+  redirects_num   = system.args[12] || 0,
+  cookies = {},
+  address, output, size;
+
+function error(msg) {
+  msg = msg || 'Unknown error';
+  console.log(msg);
+  phantom.exit(1);
+  throw msg;
+}
+
+function print_usage() {
+  console.log('Usage: rasterize.js URL filename [paperwidth*paperheight|paperformat] [zoom] [margin] [orientation] [cookie_file] [render_time] [time_out] [viewport_width] [viewport_height] [max_redirects_count]');
+  console.log('  paper (pdf output) examples: "5in*7.5in", "10cm*20cm", "A4", "Letter"');
+}
+
+window.setTimeout(function () {
+  error("Shit's being weird no result within: " + time_out + "ms");
+}, time_out);
+
+function renderUrl(url, output, options) {
+  options = options || {};
+
+  var statusCode,
+      page = webpage.create();
+
+  for (var k in options) {
+    if (options.hasOwnProperty(k)) {
+      page[k] = options[k];
+    }
+  }
+
+  // determine the statusCode
+  page.onResourceReceived = function (resource) {
+    if (resource.url == url) {
+      statusCode = resource.status;
+    }
+  };
+
+  page.onResourceError = function (resourceErrorOrId, errorString) {
+    //phantomjs 1.9.1 and above uses a resourceError object
+    if(typeof resourceErrorOrId == Object) {
+        resourceError = resourceErrorOrId;
+        error(resourceError.errorString + ' (URL: ' + resourceError.url + ')');
+    //phantomjs 1.9.0 and below pass the request id and the error string
+    } else {
+        error(errorString)
+    }
+  };
+
+  page.onNavigationRequested = function (redirect_url, type, willNavigate, main) {
+    if (main) {
+      if (redirect_url !== url) {
+        page.close();
+
+        if (redirects_num-- >= 0) {
+          renderUrl(redirect_url, output, options);
+        } else {
+          error(url + ' redirects to ' + redirect_url + ' after maximum number of redirects reached');
+        }
+      }
+    }
+  };
+
+  page.open(url, function (status) {
+    if (status !== 'success' || (statusCode != 200 && statusCode != null)) {
+      if (fs.exists(output)) {
+        fs.remove(output);
+      }
+      try {
+        fs.touch(output);
+      } catch (e) {
+        console.log(e);
+      }
+
+      error('Unable to load the URL: ' + url + ' (HTTP ' + statusCode + ')');
+    } else {
+      window.setTimeout(function () {
+        page.render(output + '_tmp.pdf');
+
+        if (fs.exists(output)) {
+          fs.remove(output);
+        }
+
+        try {
+          fs.move(output + '_tmp.pdf', output);
+        } catch (e) {
+          error(e);
+        }
+        console.log('Rendered to: ' + output, new Date().getTime());
+        phantom.exit(0);
+      }, render_time);
+    }
+  });
+}
+
+if (cookie_file) {
+  try {
+    f = fs.open(cookie_file, "r");
+    cookies = JSON.parse(f.read());
+    fs.remove(cookie_file);
+  } catch (e) {
+    console.log(e);
+  }
+  phantom.cookiesEnabled = true;
+  phantom.cookies = cookies;
+}
+
+if (system.args.length < 3 || system.args.length > 13) {
+  print_usage() && phantom.exit(2);
+} else {
+  address = system.args[1];
+  output  = system.args[2];
+
+  page_options = {
+    viewportSize: {
+      width:  viewport_width,
+      height: viewport_height
+    }
+  };
+
+  if (system.args.length > 3 && system.args[2].substr(-4) === ".pdf") {
+    size = system.args[3].split('*');
+    page_options.paperSize = size.length === 2 ? { width:size[0], height:size[1], margin:'0px' }
+      : { format:system.args[3], orientation:orientation, margin:margin };
+  }
+  if (system.args.length > 4) {
+    page_options.zoomFactor = system.args[4];
+  }
+
+  renderUrl(address, output, page_options);
+}

data/lib/shrimp/source.rb

@@ -0,0 +1,25 @@
+require 'uri'
+module Shrimp
+  class Source
+    def initialize(url_or_file)
+      @source = url_or_file
+      raise ImproperSourceError.new unless url? || file?
+    end
+
+    def url?
+      @source.is_a?(String) && @source.match(URI::regexp)
+    end
+
+    def file?
+      @source.kind_of?(File)
+    end
+
+    def html?
+      !(url? || file?)
+    end
+
+    def to_s
+      file? ? @source.path : @source
+    end
+  end
+end

data/lib/shrimp/version.rb

@@ -0,0 +1,3 @@
+module Shrimp
+  VERSION = "0.0.5"
+end

data/shrimp.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shrimp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "shrimp-orangejulius"
+  gem.version       = Shrimp::VERSION
+  gem.authors       = ["Manuel Kniep"]
+  gem.email         = %w(manuel@adeven.com)
+  gem.description   = %q{html to pdf with phantomjs}
+  gem.summary       = %q{a phantomjs based pdf renderer}
+  gem.homepage      = "http://github.com/adeven/shrimp"
+  gem.files         = `git ls-files`.split($/)
+  gem.files.reject! { |fn| fn.include? "script" }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = %w(lib)
+  gem.requirements << 'phantomjs, v1.6 or greater'
+  gem.add_runtime_dependency "json"
+
+  # Developmnet Dependencies
+  gem.add_development_dependency(%q<rake>, [">=0.9.2"])
+  gem.add_development_dependency(%q<rspec>, [">= 2.2.0"])
+  gem.add_development_dependency(%q<rack-test>, [">= 0.5.6"])
+  gem.add_development_dependency(%q<rack>, ["= 1.4.1"])
+end

data/spec/shrimp/middleware_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+def app;
+  Rack::Lint.new(@app)
+end
+
+def options
+  { :margin          => "1cm", :out_path => Dir.tmpdir,
+    :polling_offset  => 10, :polling_interval => 1, :cache_ttl => 3600,
+    :request_timeout => 1 }
+end
+
+def mock_app(options = { }, conditions = { })
+  main_app = lambda { |env|
+    headers = { 'Content-Type' => "text/html" }
+    [200, headers, ['Hello world!']]
+  }
+
+  @middleware = Shrimp::Middleware.new(main_app, options, conditions)
+  @app        = Rack::Session::Cookie.new(@middleware, :key => 'rack.session')
+end
+
+
+describe Shrimp::Middleware do
+  before { mock_app(options) }
+
+  context "matching pdf" do
+    it "should render as pdf" do
+      get '/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be true
+    end
+    it "should return 503 the first time" do
+      get '/test.pdf'
+      last_response.status.should eq 503
+      last_response.header["Retry-After"].should eq "10"
+    end
+
+    it "should return 503 the with polling interval the second time" do
+      get '/test.pdf'
+      get '/test.pdf'
+      last_response.status.should eq 503
+      last_response.header["Retry-After"].should eq "1"
+    end
+
+    it "should set render to to outpath" do
+      get '/test.pdf'
+      @middleware.send(:render_to).should match (Regexp.new("^#{options[:out_path]}"))
+    end
+
+    it "should return 504 on timeout" do
+      get '/test.pdf'
+      sleep 1
+      get '/test.pdf'
+      last_response.status.should eq 504
+    end
+
+    it "should retry rendering after timeout" do
+      get '/test.pdf'
+      sleep 1
+      get '/test.pdf'
+      get '/test.pdf'
+      last_response.status.should eq 503
+    end
+
+    it "should return a pdf with 200 after rendering" do
+      mock_file = double(File, :read => "Hello World", :close => true, :mtime => Time.now)
+      File.should_receive(:'exists?').and_return true
+      File.should_receive(:'size').and_return 1000
+      File.should_receive(:'open').and_return mock_file
+      File.should_receive(:'new').and_return mock_file
+      get '/test.pdf'
+      last_response.status.should eq 200
+      last_response.body.should eq "Hello World"
+    end
+
+
+  end
+  context "not matching pdf" do
+    it "should skip pdf rendering" do
+      get 'http://www.example.org/test'
+      last_response.body.should include "Hello world!"
+      @middleware.send(:'render_as_pdf?').should be false
+    end
+  end
+end
+
+describe "Conditions" do
+  context "only" do
+    before { mock_app(options, :only => [%r[^/invoice], %r[^/public]]) }
+    it "render pdf for set only option" do
+      get '/invoice/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be true
+    end
+
+    it "render pdf for set only option" do
+      get '/public/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be true
+    end
+
+    it "not render pdf for any other path" do
+      get '/secret/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be false
+    end
+  end
+
+  context "except" do
+    before { mock_app(options, :except => %w(/secret)) }
+    it "render pdf for set only option" do
+      get '/invoice/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be true
+    end
+
+    it "render pdf for set only option" do
+      get '/public/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be true
+    end
+
+    it "not render pdf for any other path" do
+      get '/secret/test.pdf'
+      @middleware.send(:'render_as_pdf?').should be false
+    end
+  end
+end

data/spec/shrimp/phantom_spec.rb

@@ -0,0 +1,155 @@
+#encoding: UTF-8
+require 'spec_helper'
+
+def valid_pdf(io)
+  case io
+    when File
+      io.read[0...4] == "%PDF"
+    when String
+      io[0...4] == "%PDF" || File.open(io).read[0...4] == "%PDF"
+  end
+end
+
+describe Shrimp::Phantom do
+  let(:testfile) { File.expand_path('../test_file.html', __FILE__) }
+
+  before do
+    Shrimp.configure { |config| config.rendering_time = 1000 }
+  end
+
+  # describe ".quote_arg" do
+  #   subject { described_class }
+
+  #   let(:arg) { "test" }
+
+  #   it "wraps the argument with single quotes" do
+  #     subject.quote_arg(arg).should eq "'test'"
+  #   end
+
+  #   context "when the argument contains single quotes" do
+  #     let(:arg) { "'te''st'" }
+
+  #     it "escapes them" do
+  #       %x(echo #{subject.quote_arg(arg)}).strip.should eq arg
+  #     end
+  #   end
+  # end
+
+  it "should initialize attributes" do
+    phantom = Shrimp::Phantom.new("file://#{testfile}", { :margin => "2cm" }, { }, "#{Dir.tmpdir}/test.pdf")
+    phantom.source.to_s.should eq "file://#{testfile}"
+    phantom.options[:margin].should eq "2cm"
+    phantom.outfile.should eq "#{Dir.tmpdir}/test.pdf"
+  end
+
+  it "should render a pdf file" do
+    #phantom = Shrimp::Phantom.new("file://#{@path}")
+    #phantom.to_pdf("#{Dir.tmpdir}/test.pdf").first should eq "#{Dir.tmpdir}/test.pdf"
+  end
+
+  it "should accept a local file url" do
+    phantom = Shrimp::Phantom.new("file://#{testfile}")
+    phantom.source.should be_url
+  end
+
+  it "should accept a URL as source" do
+    phantom = Shrimp::Phantom.new("http://google.com")
+    phantom.source.should be_url
+  end
+
+  it "should parse options into a cmd line" do
+    phantom = Shrimp::Phantom.new("file://#{testfile}", { :margin => "2cm", :max_redirect_count => 10 }, { }, "#{Dir.tmpdir}/test.pdf")
+    phantom.cmd.should include "test.pdf A4 1 2cm portrait"
+    phantom.cmd.should include "file://#{testfile}"
+    phantom.cmd.should include "lib/shrimp/rasterize.js"
+    phantom.cmd.should end_with " 10"
+  end
+
+  it "should properly escape arguments" do
+    malicious_uri = "file:///hello';shutdown"
+    bogus_phantom = Shrimp::Phantom.new(malicious_uri)
+
+    bogus_phantom.cmd.should_not include malicious_uri
+
+    Shrimp.configuration.stub(:phantomjs).and_return "echo"
+    %x(#{bogus_phantom.cmd}).strip.should include malicious_uri
+  end
+
+  context "rendering to a file" do
+    before do
+      phantom = Shrimp::Phantom.new("file://#{testfile}", { :margin => "2cm" }, { }, "#{Dir.tmpdir}/test.pdf")
+      @result = phantom.to_file
+    end
+
+    it "should return a File" do
+      @result.should be_a File
+    end
+
+    it "should be a valid pdf" do
+      valid_pdf(@result)
+    end
+  end
+
+  context "rendering to a pdf" do
+    before do
+      @phantom = Shrimp::Phantom.new("file://#{testfile}", { :margin => "2cm" }, { })
+      @result  = @phantom.to_pdf("#{Dir.tmpdir}/test.pdf")
+    end
+
+    it "should return a path to pdf" do
+      @result.should be_a String
+      @result.should eq "#{Dir.tmpdir}/test.pdf"
+    end
+
+    it "should be a valid pdf" do
+      valid_pdf(@result)
+    end
+  end
+
+  context "rendering to a String" do
+    before do
+      phantom = Shrimp::Phantom.new("file://#{testfile}", { :margin => "2cm" }, { })
+      @result = phantom.to_string("#{Dir.tmpdir}/test.pdf")
+    end
+
+    it "should return the File IO String" do
+      @result.should be_a String
+    end
+
+    it "should be a valid pdf" do
+      valid_pdf(@result)
+    end
+  end
+
+  context "Error" do
+    it "should return result nil" do
+      phantom = Shrimp::Phantom.new("file://foo/bar")
+      @result = phantom.run
+      @result.should be_nil
+    end
+
+    it "should be unable to load the address" do
+      phantom = Shrimp::Phantom.new("file:///foo/bar")
+      phantom.run
+      phantom.error.should include "Error opening /foo/bar: No such file or directory (URL: file:///foo/bar)"
+    end
+
+    it "should be unable to copy file" do
+      phantom = Shrimp::Phantom.new("file://#{testfile}")
+      phantom.to_pdf("/foo/bar/")
+      phantom.error.should include "Unable to copy file "
+    end
+  end
+
+  context "Error Bang!" do
+    it "should be unable to load the address" do
+      phantom = Shrimp::Phantom.new("file:///foo/bar")
+      expect { phantom.run! }.to raise_error Shrimp::RenderingError
+    end
+
+    it "should be unable to copy file" do
+      phantom = Shrimp::Phantom.new("file://#{testfile}")
+      expect { phantom.to_pdf!("/foo/bar/") }.to raise_error Shrimp::RenderingError
+    end
+  end
+end

data/spec/shrimp/source_spec.rb

@@ -0,0 +1,16 @@
+#encoding: UTF-8
+require 'spec_helper'
+
+describe Shrimp::Source do
+  context "url" do
+    it "should match file urls" do
+      source = Shrimp::Source.new("file:///test/test.html")
+      source.should be_url
+    end
+
+    it "should match http urls" do
+      source = Shrimp::Source.new("http://test/test.html")
+      source.should be_url
+    end
+  end
+end

data/spec/shrimp/test_file.html

@@ -0,0 +1,6 @@
+<html>
+<head></head>
+<body>
+    <h1>Hello World!</h1>
+</body>
+</html>

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rack/test'
+require 'shrimp'
+
+RSpec.configure do |config|
+  include Rack::Test::Methods
+end
+

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: shrimp-orangejulius
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Manuel Kniep
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+description: html to pdf with phantomjs
+email:
+- manuel@adeven.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shrimp.rb
+- lib/shrimp/config.json
+- lib/shrimp/configuration.rb
+- lib/shrimp/middleware.rb
+- lib/shrimp/phantom.rb
+- lib/shrimp/rasterize.js
+- lib/shrimp/source.rb
+- lib/shrimp/version.rb
+- shrimp.gemspec
+- spec/shrimp/middleware_spec.rb
+- spec/shrimp/phantom_spec.rb
+- spec/shrimp/source_spec.rb
+- spec/shrimp/test_file.html
+- spec/spec_helper.rb
+homepage: http://github.com/adeven/shrimp
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- phantomjs, v1.6 or greater
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: a phantomjs based pdf renderer
+test_files:
+- spec/shrimp/middleware_spec.rb
+- spec/shrimp/phantom_spec.rb
+- spec/shrimp/source_spec.rb
+- spec/shrimp/test_file.html
+- spec/spec_helper.rb