wicked_pdf_rails_2 0.7.9.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Miles Z. Sterret
+ 
+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,245 @@
+# Wicked PDF
+
+## A PDF generation plugin for Ruby on Rails
+
+Wicked PDF uses the shell utility [wkhtmltopdf](http://code.google.com/p/wkhtmltopdf/) to serve a PDF file to a user from HTML.  In other words, rather than dealing with a PDF generation DSL of some sort, you simply write an HTML view as you would normally, then let Wicked take care of the hard stuff.
+
+_Wicked PDF has been verified to work on Ruby 1.8.7 and 1.9.2; Rails 2 and Rails 3_
+
+### Installation
+
+First, be sure to install [wkhtmltopdf](http://code.google.com/p/wkhtmltopdf/).
+Note that versions before 0.9.0 [have problems](http://code.google.com/p/wkhtmltopdf/issues/detail?id=82&q=vodnik) on some machines with reading/writing to streams.
+This plugin relies on streams to communicate with wkhtmltopdf.
+
+More information about [wkhtmltopdf](http://code.google.com/p/wkhtmltopdf/) could be found [here](http://madalgo.au.dk/~jakobt/wkhtmltoxdoc/wkhtmltopdf-0.9.9-doc.html).
+
+Next:
+
+    script/plugin install git://github.com/mileszs/wicked_pdf.git
+    script/generate wicked_pdf
+
+or add this to your Gemfile:
+
+    gem 'wicked_pdf'
+
+### Basic Usage
+
+    class ThingsController < ApplicationController
+      def show
+        respond_to do |format|
+          format.html
+          format.pdf do
+            render :pdf => "file_name"
+          end
+        end
+      end
+    end
+
+### Advanced Usage with all available options
+
+    class ThingsController < ApplicationController
+      def show
+        respond_to do |format|
+          format.html
+          format.pdf do
+            render :pdf                            => 'file_name',
+                   :disposition	                   => 'attachment',                 # default 'inline'                   
+                   :template                       => 'things/show.pdf.erb',
+                   :layout                         => 'pdf.html',                   # use 'pdf.html' for a pdf.html.erb file
+                   :wkhtmltopdf                    => '/usr/local/bin/wkhtmltopdf', # path to binary
+                   :show_as_html                   => params[:debug].present?,      # allow debuging based on url param
+                   :orientation                    => 'Landscape',                  # default Portrait
+                   :page_size                      => 'A4, Letter, ...',            # default A4
+                   :save_to_file                   => Rails.root.join('pdfs', "#{filename}.pdf"),
+                   :save_only                      => false,                        # depends on :save_to_file being set first
+                   :proxy                          => 'TEXT',
+                   :basic_auth                     => false                         # when true username & password are automatically sent from session
+                   :username                       => 'TEXT',
+                   :password                       => 'TEXT',
+                   :cover                          => 'URL',
+                   :dpi                            => 'dpi',
+                   :encoding                       => 'TEXT',
+                   :user_style_sheet               => 'URL',
+                   :cookie                         => ['_session_id SESSION_ID'], # could be an array or a single string in a 'name value' format
+                   :post                           => ['query QUERY_PARAM'],      # could be an array or a single string in a 'name value' format
+                   :redirect_delay                 => NUMBER,
+                   :zoom                           => FLOAT,
+                   :page_offset                    => NUMBER,
+                   :book                           => true,
+                   :default_header                 => true,
+                   :disable_javascript             => false,
+                   :grayscale                      => true,
+                   :lowquality                     => true,
+                   :enable_plugins                 => true,
+                   :disable_internal_links         => true,
+                   :disable_external_links         => true,
+                   :print_media_type               => true,
+                   :disable_smart_shrinking        => true,
+                   :use_xserver                    => true,
+                   :no_background                  => true,
+                   :extra                          => ''                        # directly inserted into the command to wkhtmltopdf
+                   :margin => {:top                => SIZE,                     # default 10 (mm)
+                               :bottom             => SIZE,
+                               :left               => SIZE,
+                               :right              => SIZE},
+                   :header => {:html => { :template => 'users/header.pdf.erb',  # use :template OR :url
+                                          :layout   => 'pdf_plain.html',        # optional, use 'pdf_plain.html' for a pdf_plain.html.erb file, defaults to main layout
+                                          :url      => 'www.example.com',
+                                          :locals   => { :foo => @bar }},
+                               :center             => 'TEXT',
+                               :font_name          => 'NAME',
+                               :font_size          => SIZE,
+                               :left               => 'TEXT',
+                               :right              => 'TEXT',
+                               :spacing            => REAL,
+                               :line               => true,
+                               :content            => 'HTML CONTENT ALREADY RENDERED'}, # optionally you can pass plain html already rendered (useful if using pdf_from_string)
+                   :footer => {:html => { :template => 'shared/footer.pdf.erb', # use :template OR :url
+                                          :layout   => 'pdf_plain.html',        # optional, use 'pdf_plain.html' for a pdf_plain.html.erb file, defaults to main layout
+                                          :url      => 'www.example.com',
+                                          :locals   => { :foo => @bar }},
+                               :center             => 'TEXT',
+                               :font_name          => 'NAME',
+                               :font_size          => SIZE,
+                               :left               => 'TEXT',
+                               :right              => 'TEXT',
+                               :spacing            => REAL,
+                               :line               => true,
+                               :content            => 'HTML CONTENT ALREADY RENDERED'}, # optionally you can pass plain html already rendered (useful if using pdf_from_string)
+                   :toc    => {:font_name          => "NAME",
+                               :depth              => LEVEL,
+                               :header_text        => "TEXT",
+                               :header_fs          => SIZE,
+                               :l1_font_size       => SIZE,
+                               :l2_font_size       => SIZE,
+                               :l3_font_size       => SIZE,
+                               :l4_font_size       => SIZE,
+                               :l5_font_size       => SIZE,
+                               :l6_font_size       => SIZE,
+                               :l7_font_size       => SIZE,
+                               :l1_indentation     => NUM,
+                               :l2_indentation     => NUM,
+                               :l3_indentation     => NUM,
+                               :l4_indentation     => NUM,
+                               :l5_indentation     => NUM,
+                               :l6_indentation     => NUM,
+                               :l7_indentation     => NUM,
+                               :no_dots            => true,
+                               :disable_links      => true,
+                               :disable_back_links => true},
+                   :outline => {:outline           => true,
+                                :outline_depth     => LEVEL}
+          end
+        end
+      end
+    end
+
+By default, it will render without a layout (:layout => false) and the template for the current controller and action.
+
+### Super Advanced Usage ###
+
+If you need to just create a pdf and not display it:
+
+    # create a pdf from a string
+    pdf = WickedPdf.new.pdf_from_string('<h1>Hello There!</h1>')
+
+    # create a pdf from string using templates, layouts and content option for header or footer
+    WickedPdf.new.pdf_from_string(
+        render_to_string(:pdf => "pdf_file.pdf", :template => 'templates/pdf.html.erb', :layout => 'pdfs/layout_pdf'), 
+        :footer => {:content => render_to_string({:template => 'templates/pdf_footer.html.erb', :layout => 'pdfs/layout_pdf'})}
+		
+    # or from your controller, using views & templates and all wicked_pdf options as normal
+    pdf = render_to_string :pdf => "some_file_name"
+		
+    # then save to a file
+    save_path = Rails.root.join('pdfs','filename.pdf')
+    File.open(save_path, 'wb') do |file|
+      file << pdf
+    end
+
+If you need to display utf encoded characters, add this to your pdf views or layouts:
+
+    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+
+### Styles
+
+You must define absolute paths to CSS files, images, and javascripts; the best option is to use the *wicked_pdf_stylesheet_link_tag*, *wicked_pdf_image_tag*, and *wicked_pdf_javascript_include_tag* helpers.
+
+    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+      <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+        <%= wicked_pdf_stylesheet_link_tag "pdf" -%>
+        <%= wicked_pdf_javascript_include_tag "number_pages" %>
+      </head>
+      <body onload='number_pages'>
+        <div id="header">
+          <%= wicked_pdf_image_tag 'mysite.jpg' %>
+        </div>
+        <div id="content">
+          <%= yield %>
+        </div>
+      </body>
+    </html>
+
+### Page Numbering
+
+A bit of javascript can help you number your pages. Create a template or header/footer file with this:
+
+    <html>
+      <head>
+        <script>
+          function number_pages() {
+            var vars={};
+            var x=document.location.search.substring(1).split('&');
+            for(var i in x) {var z=x[i].split('=',2);vars[z[0]] = unescape(z[1]);}
+            var x=['frompage','topage','page','webpage','section','subsection','subsubsection'];
+            for(var i in x) {
+              var y = document.getElementsByClassName(x[i]);
+              for(var j=0; j<y.length; ++j) y[j].textContent = vars[x[i]];
+            }
+          }
+        </script>
+      </head>
+      <body onload="number_pages()">
+        Page <span class="page"></span> of <span class="topage"></span>
+      </body>
+    </html>
+
+Anything with a class listed in "var x" above will be auto-filled at render time.
+
+If you do not have explicit page breaks (and therefore do not have any "page" class), you can also use wkhtmltopdf's built in page number generation by setting one of the headers to "[page]":
+
+    render :pdf => 'filename', :header => { :right => '[page] of [topage]' }
+
+### Configuration
+
+You can put your default configuration, applied to all pdf's at "wicked_pdf.rb" initializer.
+
+### Further Reading
+
+Andreas Happe's post [Generating PDFs from Ruby on Rails](http://snikt.net/rails/2012/04/26/wicked-pdf/)
+
+StackOverflow [questions with the tag "wicked-pdf"](http://stackoverflow.com/questions/tagged/wicked-pdf)
+
+### Debugging
+
+Now you can use a debug param on the URL that shows you the content of the pdf in plain html to design it faster.
+
+First of all you must configure the render parameter ":show_as_html => params[:debug]" and then just use it like normally but adding "debug=1" as a param:
+
+http://localhost:3001/CONTROLLER/X.pdf?debug=1
+
+However, the wicked_pdf_* helpers will use file:// paths for assets when using :show_as_html, and your browser's cross-domain safety feature will kick in, and not render them. To get around this, you can load your assets like so in your templates:
+
+    <%= params[:debug].present? ? image_tag('foo') : wicked_pdf_image_tag('foo') %>
+
+### Inspiration
+
+You may have noticed: this plugin is heavily inspired by the PrinceXML plugin [princely](http://github.com/mbleigh/princely/tree/master).  PrinceXML's cost was prohibitive for me. So, with a little help from some friends (thanks [jqr](http://github.com/jqr)), I tracked down wkhtmltopdf, and here we are.
+
+### Awesome Peoples
+
+Also, thanks to [unixmonkey](https://github.com/Unixmonkey), [galdomedia](http://github.com/galdomedia), [jcrisp](http://github.com/jcrisp), [lleirborras](http://github.com/lleirborras), [tiennou](http://github.com/tiennou), and everyone else for all their hard work and patience with my delays in merging in their enhancements.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the wicked_pdf plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the wicked_pdf plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WickedPdf'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/generators/wicked_pdf_generator.rb

@@ -0,0 +1,11 @@
+if defined?(Rails) && Rails::VERSION::MAJOR != 2
+
+  # Rails3 generator invoked with 'rails generate wicked_pdf'
+  class WickedPdfGenerator < Rails::Generators::Base
+    source_root(File.expand_path(File.dirname(__FILE__) + "/../../generators/wicked_pdf/templates"))
+    def copy_initializer
+      copy_file 'wicked_pdf.rb', 'config/initializers/wicked_pdf.rb'
+    end
+  end
+
+end

data/lib/pdf_helper.rb

@@ -0,0 +1,90 @@
+module PdfHelper
+  require 'wicked_pdf'
+  require 'wicked_pdf_tempfile'
+
+  def self.included(base)
+    base.class_eval do
+      alias_method_chain :render, :wicked_pdf
+      alias_method_chain :render_to_string, :wicked_pdf
+      after_filter :clean_temp_files
+    end
+  end
+
+  def render_with_wicked_pdf(options = nil, *args, &block)
+    if options.is_a?(Hash) && options.has_key?(:pdf)
+      log_pdf_creation
+      options[:basic_auth] = set_basic_auth(options)
+      make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
+    else
+      render_without_wicked_pdf(options, *args, &block)
+    end
+  end
+
+  def render_to_string_with_wicked_pdf(options = nil, *args, &block)
+    if options.is_a?(Hash) && options.has_key?(:pdf)
+      log_pdf_creation
+      options[:basic_auth] = set_basic_auth(options)
+      options.delete :pdf
+      make_pdf((WickedPdf.config || {}).merge(options))
+    else
+      render_to_string_without_wicked_pdf(options, *args, &block)
+    end
+  end
+
+  private
+
+    def log_pdf_creation
+      logger.info '*'*15 + 'WICKED' + '*'*15
+    end
+
+    def set_basic_auth(options={})
+      options[:basic_auth] ||= WickedPdf.config.fetch(:basic_auth){ false }
+      if options[:basic_auth] && request.env["HTTP_AUTHORIZATION"]
+        request.env["HTTP_AUTHORIZATION"].split(" ").last
+      end
+    end
+
+    def clean_temp_files
+      if defined?(@hf_tempfiles)
+        @hf_tempfiles.each { |tf| tf.close! }
+      end
+    end
+
+    def make_pdf(options = {})
+      html_string = render_to_string(:template => options[:template], :layout => options[:layout], :formats => options[:formats], :handlers => options[:handlers])
+      options = prerender_header_and_footer(options)
+      w = WickedPdf.new(options[:wkhtmltopdf])
+      w.pdf_from_string(html_string, options)
+    end
+
+    def make_and_send_pdf(pdf_name, options={})
+      options[:wkhtmltopdf] ||= nil
+      options[:layout]      ||= false
+      options[:template]    ||= File.join(controller_path, action_name)
+      options[:disposition] ||= "inline"
+      if options[:show_as_html]
+        render :template => options[:template], :layout => options[:layout], :formats => options[:formats], :handlers => options[:handlers], :content_type => "text/html"
+      else
+        pdf_content = make_pdf(options)
+        File.open(options[:save_to_file], 'wb') {|file| file << pdf_content } if options[:save_to_file]
+        send_data(pdf_content, :filename => pdf_name + '.pdf', :type => 'application/pdf', :disposition => options[:disposition]) unless options[:save_only]
+      end
+    end
+
+    # Given an options hash, prerenders content for the header and footer sections
+    # to temp files and return a new options hash including the URLs to these files.
+    def prerender_header_and_footer(options)
+      [:header, :footer].each do |hf|
+        if options[hf] && options[hf][:html] && options[hf][:html][:template]
+          @hf_tempfiles = [] if ! defined?(@hf_tempfiles)
+          @hf_tempfiles.push( tf=WickedPdfTempfile.new("wicked_#{hf}_pdf.html") )
+          options[hf][:html][:layout] ||=  options[:layout]
+          tf.write render_to_string(:template => options[hf][:html][:template], :layout => options[hf][:html][:layout], :locals => options[hf][:html][:locals], :formats => options[hf][:html][:formats], :handlers => options[hf][:html][:handlers])
+          tf.flush
+          options[hf][:html].delete(:template)
+          options[hf][:html][:url] = "file://#{tf.path}"
+        end
+      end
+      options
+    end
+end

data/lib/wicked_pdf.rb

@@ -0,0 +1,214 @@
+# wkhtml2pdf Ruby interface
+# http://code.google.com/p/wkhtmltopdf/
+
+require 'logger'
+require 'digest/md5'
+require 'rbconfig'
+require RbConfig::CONFIG['target_os'] == 'mingw32' && !(RUBY_VERSION =~ /1.9/) ? 'win32/open3' : 'open3'
+require 'active_support/core_ext/class/attribute_accessors'
+
+begin
+  require 'active_support/core_ext/object/blank'
+rescue LoadError
+  require 'active_support/core_ext/blank'
+end
+
+require 'wicked_pdf_railtie'
+require 'wicked_pdf_tempfile'
+
+class WickedPdf
+  EXE_NAME = "wkhtmltopdf"
+  @@config = {}
+  cattr_accessor :config
+
+  def initialize(wkhtmltopdf_binary_path = nil)
+    @exe_path = wkhtmltopdf_binary_path || find_wkhtmltopdf_binary_path
+    raise "Location of #{EXE_NAME} unknown" if @exe_path.empty?
+    raise "Bad #{EXE_NAME}'s path" unless File.exists?(@exe_path)
+    raise "#{EXE_NAME} is not executable" unless File.executable?(@exe_path)
+  end
+
+  def pdf_from_string(string, options={})
+    command = "\"#{@exe_path}\" #{'-q ' unless on_windows?}#{parse_options(options)} - - " # -q for no errors on stdout
+    print_command(command) if in_development_mode?
+    pdf, err = Open3.popen3(command) do |stdin, stdout, stderr|
+      stdin.binmode
+      stdout.binmode
+      stderr.binmode
+      stdin.write(string)
+      stdin.close
+      [stdout.read, stderr.read]
+    end
+    raise "PDF could not be generated!" if pdf and pdf.rstrip.length == 0
+    pdf
+  rescue Exception => e
+    raise "Failed to execute:\n#{command}\nError: #{e}"
+  end
+
+  private
+
+    def in_development_mode?
+      (defined?(Rails) && Rails.env == 'development') ||
+        (defined?(RAILS_ENV) && RAILS_ENV == 'development')
+    end
+
+    def on_windows?
+      RbConfig::CONFIG['target_os'] == 'mingw32'
+    end
+
+    def print_command(cmd)
+      p "*"*15 + cmd + "*"*15
+    end
+
+    def parse_options(options)
+      [
+        parse_extra(options),
+        parse_header_footer(:header => options.delete(:header),
+                            :footer => options.delete(:footer),
+                            :layout => options[:layout]),
+        parse_toc(options.delete(:toc)),
+        parse_outline(options.delete(:outline)),
+        parse_margins(options.delete(:margin)),
+        parse_others(options),
+        parse_basic_auth(options)
+      ].join(' ')
+    end
+
+    def parse_extra(options)
+      options[:extra].nil? ? '' : options[:extra]
+    end
+
+    def parse_basic_auth(options)
+      if options[:basic_auth]
+        user, passwd = Base64.decode64(options[:basic_auth]).split(":")
+        "--username '#{user}' --password '#{passwd}'"
+      else
+        ""
+      end
+    end
+
+    def make_option(name, value, type=:string)
+      if value.is_a?(Array)
+        return value.collect { |v| make_option(name, v, type) }.join('')
+      end
+      "--#{name.gsub('_', '-')} " + case type
+        when :boolean then ""
+        when :numeric then value.to_s
+        when :name_value then value.to_s
+        else "\"#{value}\""
+      end + " "
+    end
+
+    def make_options(options, names, prefix="", type=:string)
+      names.collect {|o| make_option("#{prefix.blank? ? "" : prefix + "-"}#{o.to_s}", options[o], type) unless options[o].blank?}.join
+    end
+
+    def parse_header_footer(options)
+      r=""
+      [:header, :footer].collect do |hf|
+        unless options[hf].blank?
+          opt_hf = options[hf]
+          r += make_options(opt_hf, [:center, :font_name, :left, :right], "#{hf.to_s}")
+          r += make_options(opt_hf, [:font_size, :spacing], "#{hf.to_s}", :numeric)
+          r += make_options(opt_hf, [:line], "#{hf.to_s}", :boolean)
+          if options[hf] && options[hf][:content]
+            @hf_tempfiles = [] if ! defined?(@hf_tempfiles)
+            @hf_tempfiles.push( tf=WickedPdfTempfile.new("wicked_#{hf}_pdf.html") )
+            tf.write options[hf][:content]
+            tf.flush
+            options[hf].delete(:content)
+            options[hf][:html] = {}
+            options[hf][:html][:url] = "file://#{tf.path}"
+          end
+          unless opt_hf[:html].blank?
+            r += make_option("#{hf.to_s}-html", opt_hf[:html][:url]) unless opt_hf[:html][:url].blank?
+          end
+        end
+      end unless options.blank?
+      r
+    end
+
+    def parse_toc(options)
+      r = '--toc ' unless options.nil?
+      unless options.blank?
+        r += make_options(options, [ :font_name, :header_text], "toc")
+        r +=make_options(options, [ :depth,
+                                    :header_fs,
+                                    :l1_font_size,
+                                    :l2_font_size,
+                                    :l3_font_size,
+                                    :l4_font_size,
+                                    :l5_font_size,
+                                    :l6_font_size,
+                                    :l7_font_size,
+                                    :l1_indentation,
+                                    :l2_indentation,
+                                    :l3_indentation,
+                                    :l4_indentation,
+                                    :l5_indentation,
+                                    :l6_indentation,
+                                    :l7_indentation], "toc", :numeric)
+        r +=make_options(options, [ :no_dots,
+                                    :disable_links,
+                                    :disable_back_links], "toc", :boolean)
+      end
+      return r
+    end
+
+    def parse_outline(options)
+      unless options.blank?
+        r = make_options(options, [:outline], "", :boolean)
+        r +=make_options(options, [:outline_depth], "", :numeric)
+      end
+    end
+
+    def parse_margins(options)
+      make_options(options, [:top, :bottom, :left, :right], "margin", :numeric) unless options.blank?
+    end
+
+    def parse_others(options)
+      unless options.blank?
+        r = make_options(options, [ :orientation,
+                                    :page_size,
+                                    :page_width,
+                                    :page_height,
+                                    :proxy,
+                                    :username,
+                                    :password,
+                                    :cover,
+                                    :dpi,
+                                    :encoding,
+                                    :user_style_sheet])
+        r +=make_options(options, [ :cookie,
+                                    :post], "", :name_value)
+        r +=make_options(options, [ :redirect_delay,
+                                    :zoom,
+                                    :page_offset,
+                                    :javascript_delay], "", :numeric)
+        r +=make_options(options, [ :book,
+                                    :default_header,
+                                    :disable_javascript,
+                                    :grayscale,
+                                    :lowquality,
+                                    :enable_plugins,
+                                    :disable_internal_links,
+                                    :disable_external_links,
+                                    :print_media_type,
+                                    :disable_smart_shrinking,
+                                    :use_xserver,
+                                    :no_background], "", :boolean)
+      end
+    end
+
+    def find_wkhtmltopdf_binary_path
+      possible_locations = (ENV['PATH'].split(':')+%w[/usr/bin /usr/local/bin ~/bin]).uniq
+      exe_path ||= WickedPdf.config[:exe_path] unless WickedPdf.config.empty?
+      exe_path ||= begin
+        (defined?(Bundler) ? `bundle exec which wkhtmltopdf` : `which wkhtmltopdf`).chomp
+      rescue Exception => e
+        nil
+      end
+      exe_path ||= possible_locations.map{|l| File.expand_path("#{l}/#{EXE_NAME}") }.find{|location| File.exists? location}
+      exe_path || ''
+    end
+end

data/lib/wicked_pdf_helper.rb

@@ -0,0 +1,78 @@
+module WickedPdfHelper
+  def wicked_pdf_stylesheet_link_tag(*sources)
+    
+    if Rails.root.kind_of?(Pathname)
+      root_pathname = Rails.root
+    elsif Rails.root.kind_of?(String)
+      root_obj = Pathname(Rails.root)
+    end
+
+    css_dir = root_obj.join('public','stylesheets')
+    
+    begin
+      sources.collect { |source|
+        "<style type='text/css'>#{File.read(css_dir.join(source+'.css'))}</style>"
+      }.join("\n").html_safe
+    rescue NoMethodError
+      sources.collect { |source|
+        "<style type='text/css'>#{File.read(css_dir.join(source+'.css'))}</style>"
+      }.join("\n")
+    end
+  end
+
+  def wicked_pdf_image_tag(img, options={})
+    image_tag "file:///#{root_obj.join('public', 'images', img)}", options
+  end
+
+  def wicked_pdf_javascript_src_tag(jsfile, options={})
+    javascript_src_tag "file:///#{root_obj.join('public','javascripts',jsfile)}", options
+  end
+
+  def wicked_pdf_javascript_include_tag(*sources)
+    begin
+      sources.collect{ |source| wicked_pdf_javascript_src_tag(source, {}) }.join("\n").html_safe
+    rescue NoMethodError
+      sources.collect{ |source| wicked_pdf_javascript_src_tag(source, {}) }.join("\n")
+    end
+  end
+
+  module Assets
+    def wicked_pdf_stylesheet_link_tag(*sources)
+      sources.collect { |source|
+        "<style type='text/css'>#{read_asset(source+".css")}</style>"
+      }.join("\n").html_safe
+    end
+
+    def wicked_pdf_image_tag(img, options={})
+      image_tag "file://#{asset_pathname(img).to_s}", options
+    end
+
+    def wicked_pdf_javascript_src_tag(jsfile, options={})
+      javascript_include_tag "file://#{asset_pathname(jsfile).to_s}", options
+    end
+
+    def wicked_pdf_javascript_include_tag(*sources)
+      sources.collect { |source|
+        "<script type='text/javascript'>#{read_asset(source+".js")}</script>"
+      }.join("\n").html_safe
+    end
+
+    private
+
+    def asset_pathname(source)
+      if Rails.configuration.assets.compile == false
+        File.join(Rails.public_path, asset_path(source))
+      else
+        Rails.application.assets.find_asset(source).pathname
+      end
+    end
+
+    def read_asset(source)
+      if Rails.configuration.assets.compile == false
+        IO.read(asset_pathname(source))
+      else
+        Rails.application.assets.find_asset(source).to_s
+      end
+    end
+  end
+end

data/lib/wicked_pdf_railtie.rb

@@ -0,0 +1,34 @@
+require 'pdf_helper'
+require 'wicked_pdf_helper'
+
+if defined?(Rails)
+
+  if Rails::VERSION::MAJOR == 2
+
+    unless ActionController::Base.instance_methods.include? "render_with_wicked_pdf"
+      ActionController::Base.send :include, PdfHelper
+    end
+    unless ActionView::Base.instance_methods.include? "wicked_pdf_stylesheet_link_tag"
+      ActionView::Base.send :include, WickedPdfHelper
+    end
+    
+  else
+
+    class WickedRailtie < Rails::Railtie
+      initializer "wicked_pdf.register" do |app|
+        ActionController::Base.send :include, PdfHelper
+        if Rails::VERSION::MINOR > 0
+          ActionView::Base.send :include, WickedPdfHelper::Assets
+        else
+          ActionView::Base.send :include, WickedPdfHelper
+        end
+      end
+    end
+
+  end
+  
+  if Mime::Type.lookup_by_extension(:pdf).nil?
+    Mime::Type.register('application/pdf', :pdf)
+  end
+  
+end

data/lib/wicked_pdf_tempfile.rb

@@ -0,0 +1,10 @@
+require 'tempfile'
+
+class WickedPdfTempfile < Tempfile
+  # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+  def make_tmpname(basename, n)
+    extension = File.extname(basename)
+    sprintf("%s_%d_%d%s", File.basename(basename, extension), $$, n.to_i, extension)
+  end
+end
+

data/test/fixtures/wicked.css

@@ -0,0 +1 @@
+/* Wicked styles */

data/test/pdf_helper_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module ActionController
+  class Base
+    def render_to_string opts={}
+      opts.to_s
+    end
+  end
+end
+
+class PdfHelperTest < ActionController::TestCase
+  def setup
+    @ac = ActionController::Base.new
+  end
+
+  def teardown
+    @ac=nil
+  end
+
+  test "should prerender header and footer :template options" do
+    options = @ac.send( :prerender_header_and_footer,
+                        :header => {:html => { :template => 'hf.html.erb'}});
+    assert !options[:header][:html].has_key?(:template)
+    assert_match /^file:\/\/.*wicked_header_pdf.*\.html/, options[:header][:html][:url]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+require 'rails'
+require 'action_controller/test_case'
+require 'wicked_pdf'

data/test/wicked_pdf_helper_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'action_view/test_case'
+
+class WickedPdfHelperTest < ActionView::TestCase
+  test 'wicked_pdf_stylesheet_link_tag should inline the stylesheets passed in' do
+    assert_equal "<style type='text/css'>/* Wicked styles */\n</style>",
+                 wicked_pdf_stylesheet_link_tag('../../vendor/plugins/wicked_pdf/test/fixtures/wicked')
+  end
+
+  test 'wicked_pdf_image_tag should return the same as image_tag when passed a full path' do
+    assert_equal image_tag("file://#{Rails.root.join('public','images','pdf')}"),
+                 wicked_pdf_image_tag('pdf')
+  end
+
+  test 'wicked_pdf_javascript_src_tag should return the same as javascript_src_tag when passed a full path' do
+    assert_equal javascript_src_tag("file://#{Rails.root.join('public','javascripts','pdf')}", {}),
+                 wicked_pdf_javascript_src_tag('pdf')
+  end
+
+  test 'wicked_pdf_include_tag should return many wicked_pdf_javascript_src_tags' do
+    assert_equal [wicked_pdf_javascript_src_tag('foo'), wicked_pdf_javascript_src_tag('bar')].join("\n"),
+                 wicked_pdf_javascript_include_tag('foo', 'bar')
+  end
+end

data/test/wicked_pdf_test.rb

@@ -0,0 +1,147 @@
+require 'test_helper'
+
+WickedPdf.config = { :exe_path => '/usr/local/bin/wkhtmltopdf' }
+HTML_DOCUMENT = "<html><body>Hello World</body></html>"
+
+# Provide a public accessor to the normally-private parse_options function
+class WickedPdf
+  def get_parsed_options(opts)
+    parse_options(opts)
+  end
+end
+
+class WickedPdfTest < ActiveSupport::TestCase
+
+  test "should generate PDF from html document" do
+    wp = WickedPdf.new
+    pdf = wp.pdf_from_string HTML_DOCUMENT
+    assert pdf.start_with?("%PDF-1.4")
+    assert pdf.rstrip.end_with?("%%EOF")
+    assert pdf.length > 100
+  end
+
+  test "should raise exception when no path to wkhtmltopdf" do
+    assert_raise RuntimeError do
+      WickedPdf.new " "
+    end
+  end
+
+  test "should raise exception when wkhtmltopdf path is wrong" do
+    assert_raise RuntimeError do
+      WickedPdf.new "/i/do/not/exist/notwkhtmltopdf"
+    end
+  end
+
+  test "should raise exception when wkhtmltopdf is not executable" do
+    begin
+      tmp = Tempfile.new('wkhtmltopdf')
+      fp = tmp.path
+      File.chmod 0000, fp
+      assert_raise RuntimeError do
+        WickedPdf.new fp
+      end
+    ensure
+      tmp.delete
+    end
+  end
+
+  test "should raise exception when pdf generation fails" do
+    begin
+      tmp = Tempfile.new('wkhtmltopdf')
+      fp = tmp.path
+      File.chmod 0777, fp
+      wp = WickedPdf.new fp
+      assert_raise RuntimeError do
+        wp.pdf_from_string HTML_DOCUMENT
+      end
+    ensure
+      tmp.delete
+    end
+  end
+
+  test "should parse header and footer options" do
+    wp = WickedPdf.new
+
+    [:header, :footer].each do |hf|
+      [:center, :font_name, :left, :right].each do |o|
+        assert_equal  "--#{hf.to_s}-#{o.to_s.gsub('_', '-')} \"header_footer\"",
+                      wp.get_parsed_options(hf => {o => "header_footer"}).strip
+      end
+
+      [:font_size, :spacing].each do |o|
+        assert_equal  "--#{hf.to_s}-#{o.to_s.gsub('_', '-')} 12",
+                      wp.get_parsed_options(hf => {o => "12"}).strip
+      end
+
+      assert_equal  "--#{hf.to_s}-line",
+                    wp.get_parsed_options(hf => {:line => true}).strip
+      assert_equal  "--#{hf.to_s}-html \"http://www.abc.com\"",
+                    wp.get_parsed_options(hf => {:html => {:url => 'http://www.abc.com'}}).strip
+    end
+  end
+
+  test "should parse toc options" do
+    wp = WickedPdf.new
+
+    [:font_name, :header_text].each do |o|
+      assert_equal  "--toc-#{o.to_s.gsub('_', '-')} \"toc\"",
+                    wp.get_parsed_options(:toc => {o => "toc"}).strip
+    end
+
+    [ :depth, :header_fs, :l1_font_size, :l2_font_size, :l3_font_size, :l4_font_size,
+      :l5_font_size, :l6_font_size, :l7_font_size, :l1_indentation, :l2_indentation,
+      :l3_indentation, :l4_indentation, :l5_indentation, :l6_indentation, :l7_indentation
+    ].each do |o|
+      assert_equal  "--toc-#{o.to_s.gsub('_', '-')} 5",
+                    wp.get_parsed_options(:toc => {o => 5}).strip
+    end
+
+    [:no_dots, :disable_links, :disable_back_links].each do |o|
+      assert_equal  "--toc-#{o.to_s.gsub('_', '-')}",
+                    wp.get_parsed_options(:toc => {o => true}).strip
+    end
+  end
+
+  test "should parse outline options" do
+    wp = WickedPdf.new
+
+    assert_equal "--outline", wp.get_parsed_options(:outline => {:outline => true}).strip
+    assert_equal "--outline-depth 5", wp.get_parsed_options(:outline => {:outline_depth => 5}).strip
+  end
+
+  test "should parse margins options" do
+    wp = WickedPdf.new
+
+    [:top, :bottom, :left, :right].each do |o|
+      assert_equal "--margin-#{o.to_s} 12", wp.get_parsed_options(:margin => {o => "12"}).strip
+    end
+  end
+
+  test "should parse other options" do
+    wp = WickedPdf.new
+
+    [ :orientation, :page_size, :proxy, :username, :password, :cover, :dpi,
+      :encoding, :user_style_sheet
+    ].each do |o|
+      assert_equal "--#{o.to_s.gsub('_', '-')} \"opts\"", wp.get_parsed_options(o => "opts").strip
+    end
+
+    [:cookie, :post].each do |o|
+      assert_equal "--#{o.to_s.gsub('_', '-')} name value", wp.get_parsed_options(o => "name value").strip
+
+      nv_formatter = ->(number){ "--#{o.to_s.gsub('_', '-')} par#{number} val#{number}" }
+      assert_equal "#{nv_formatter.call(1)} #{nv_formatter.call(2)}", wp.get_parsed_options(o => ['par1 val1', 'par2 val2']).strip
+    end
+
+    [:redirect_delay, :zoom, :page_offset].each do |o|
+      assert_equal "--#{o.to_s.gsub('_', '-')} 5", wp.get_parsed_options(o => 5).strip
+    end
+
+    [ :book, :default_header, :disable_javascript, :grayscale, :lowquality,
+      :enable_plugins, :disable_internal_links, :disable_external_links,
+      :print_media_type, :disable_smart_shrinking, :use_xserver, :no_background
+    ].each do |o|
+      assert_equal "--#{o.to_s.gsub('_', '-')}", wp.get_parsed_options(o => true).strip
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: wicked_pdf_rails_2
+version: !ruby/object:Gem::Version 
+  hash: 81
+  prerelease: 
+  segments: 
+  - 0
+  - 7
+  - 9
+  - 1
+  version: 0.7.9.1
+platform: ruby
+authors: 
+- Miles Z. Sterret
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-12 00:00:00 Z
+dependencies: []
+
+description: |
+  This is a fork of the wicked_pdf gem which allows Rails < 2.3.4 to run. Basically no really big
+  changes, so I am leaving most of this the same, and hopefully it will be pulled into the master.
+  
+  Wicked PDF uses the shell utility wkhtmltopdf to serve a PDF file to a user from HTML.
+  In other words, rather than dealing with a PDF generation DSL of some sort,
+  you simply write an HTML view as you would normally, and let Wicked take care of the hard stuff.
+
+email: miles.sterrett@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- MIT-LICENSE
+- lib/wicked_pdf_railtie.rb
+- lib/wicked_pdf_helper.rb
+- lib/pdf_helper.rb
+- lib/generators/wicked_pdf_generator.rb
+- lib/wicked_pdf_tempfile.rb
+- lib/wicked_pdf.rb
+- test/pdf_helper_test.rb
+- test/test_helper.rb
+- test/fixtures/wicked.css
+- test/wicked_pdf_helper_test.rb
+- test/wicked_pdf_test.rb
+homepage: https://github.com/d3vkit/wicked_pdf
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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.24
+signing_key: 
+specification_version: 3
+summary: PDF generator (from HTML) plugin for Ruby on Rails
+test_files: []
+