shrimp 0.0.1

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,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2

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,159 @@
+# Shrimp
+
+Creates PDFs from URLs using phantomjs
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shrimp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shrimp
+
+
+### pantomjs
+
+    See http://phantomjs.org/download.html on how to install phatomjs
+
+## Usage
+
+```
+url     = 'http://www.google.com'
+options = { :margin => "1cm"}
+Phantomjs::Phantomjs.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 timeout for phantomjs rendering process
+  # rendering_timeout       = 90000
+
+  # the default rendering time
+  # config.rendering_time   = 1000
+end
+```
+
+## 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 PDFKit::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 on seconds
+
+    config.middleware.use Shrimp::Middleware, :cache_ttl => 3600 # one hour
+
+
+### 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 beeing 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/configuration.rb

@@ -0,0 +1,49 @@
+module Shrimp
+  class Configuration
+    attr_accessor :default_options
+    attr_writer :phantomjs
+
+    [:format, :margin, :zoom, :orientation, :tmpdir, :rendering_timeout, :rendering_time].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
+      }
+    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>Prepareing 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,93 @@
+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 Phantom
+    attr_accessor :source, :configuration, :outfile
+    attr_reader :options, :cookies
+    SCRIPT_FILE = File.expand_path('../rasterize.js', __FILE__)
+
+    # Public: Runs the phantomjs binary
+    #
+    # Returns the stdout output of phantomjs
+    def run
+      @result = `#{cmd}`
+    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]
+      @outfile                          ||= "#{options[:tmpdir]}/#{Digest::MD5.hexdigest((Time.now.to_i + rand(9001)).to_s)}.pdf"
+
+      [Shrimp.configuration.phantomjs, SCRIPT_FILE, @source.to_s, @outfile, format, zoom, margin, orientation, cookie_file, rendering_time, timeout].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
+    # 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 = 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 = 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)
+      self.to_pdf(path)
+      File.open(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,73 @@
+var page = require('webpage').create(),
+  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 ,
+  cookies = {},
+  address, output, size, statusCode;
+
+window.setTimeout(function () {
+  console.log("Shit's being weird no result within: " + time_out + "ms");
+  phantom.exit(1);
+}, time_out);
+
+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 > 10) {
+  console.log('Usage: rasterize.js URL filename [paperwidth*paperheight|paperformat] [zoom] [margin] [orientation] [cookie_file] [render_time] [time_out]');
+  console.log('  paper (pdf output) examples: "5in*7.5in", "10cm*20cm", "A4", "Letter"');
+  phantom.exit(1);
+} else {
+  address = system.args[1];
+  output = system.args[2];
+  page.viewportSize = { width:600, height:600 };
+  if (system.args.length > 3 && system.args[2].substr(-4) === ".pdf") {
+    size = system.args[3].split('*');
+    page.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.zoomFactor = system.args[4];
+  }
+
+  // determine the statusCode
+  page.onResourceReceived = function (resource) {
+    if (resource.url == address) {
+      statusCode = resource.status;
+    }
+  };
+
+  page.open(address, function (status) {
+    if (status !== 'success' || (statusCode != 200 && statusCode != null)) {
+      console.log(statusCode, 'Unable to load the address!');
+      if (fs.exists(output)) {
+        fs.remove(output);
+      }
+      fs.touch(output);
+      phantom.exit();
+    } else {
+      window.setTimeout(function () {
+        page.render(output + '_tmp.pdf');
+
+        if (fs.exists(output)) {
+          fs.remove(output);
+        }
+
+        fs.move(output + '_tmp.pdf', output);
+        console.log('rendered to: ' + output, new Date().getTime());
+        phantom.exit();
+      }, render_time);
+    }
+  });
+}

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.1"
+end

data/shrimp.gemspec

@@ -0,0 +1,25 @@
+# -*- 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"
+  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.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"])
+end

data/spec/shrimp/middleware_spec.rb

@@ -0,0 +1,124 @@
+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')
+  @middleware.should_receive(:fire_phantom).any_number_of_times
+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 = mock(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,102 @@
+#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
+
+def testfile
+  File.expand_path('../test_file.html', __FILE__)
+end
+
+Shrimp.configure do |config|
+  config.rendering_time = 1000
+end
+
+describe Shrimp::Phantom do
+  before do
+    Shrimp.configure do |config|
+      config.rendering_time = 1000
+    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" }, { }, "#{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"
+  end
+
+  context "rendering to a file" do
+    before(:all) 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(:all) 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(:all) 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
+end

data/spec/shrimp/source_spec.rb

@@ -0,0 +1,15 @@
+#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,11 @@
+require 'URI'
+require 'json'
+require 'rack'
+require 'rack/test'
+require 'shrimp'
+
+
+RSpec.configure do |config|
+  include Rack::Test::Methods
+end
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: shrimp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Manuel Kniep
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70106322524180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70106322524180
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70106322523660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *70106322523660
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70106322523140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: *70106322523140
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70106322522660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :development
+  prerelease: false
+  version_requirements: *70106322522660
+description: html to pdf with phantomjs
+email:
+- manuel@adeven.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shrimp.rb
+- 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: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- phantomjs, v1.6 or greater
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+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