wisepdf 1.0.0

data/lib/wisepdf/render.rb

@@ -0,0 +1,92 @@
+require 'tempfile'
+
+module Wisepdf
+  module Render
+    def self.included(base)
+      base.class_eval do
+        after_filter :clean_temp_files
+      end
+    end
+
+    def render(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), Wisepdf::Configuration.options.merge(options))
+      else
+        super
+      end
+    end
+
+    def render_to_string(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(Wisepdf::Configuration.options.merge(options))
+      else
+        super
+      end
+    end
+
+    private
+
+      def log_pdf_creation
+        logger.info '*'*15 + 'PDF' + '*'*15
+      end
+
+      def set_basic_auth(options={})
+        options[:basic_auth] ||= Wisepdf::Configuration.options.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])
+        options = prerender_header_and_footer(options)
+        w = Wisepdf::Writer.new(options[:wkhtmltopdf])
+        w.to_pdf(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], :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]
+        
+          pdf_name += '.pdf' unless pdf_name =~ /.pdf\z|.PDF\Z/
+          send_data(pdf_content, :filename => pdf_name, :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 = Wisepdf::Tempfile.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])
+            tf.flush
+            options[hf][:html].delete(:template)
+            options[hf][:html][:url] = "file://#{tf.path}"
+          end
+        end
+        options
+      end
+  end
+end

data/lib/wisepdf/tempfile.rb

@@ -0,0 +1,11 @@
+require 'tempfile'
+
+module Wisepdf
+  class Tempfile < 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
+end

data/lib/wisepdf/writer.rb

@@ -0,0 +1,177 @@
+# 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'
+require 'active_support/core_ext/object/blank'
+
+# require 'wicked_pdf_railtie'
+require 'tempfile'
+
+module Wisepdf
+  class Writer        
+    def initialize(path=nil)
+      self.wkhtmltopdf = path unless path.nil?
+    end
+
+    def to_pdf(string, options={})
+      command = "\"#{self.wkhtmltopdf}\" #{parse_options(options)} #{'-q ' unless Wisepdf::Configuration.windows?}- - " # -q for no errors on stdout
+      print_command(command) if Wisepdf::Configuration.development?
+      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 Wisepdf::WriteError if pdf && pdf.rstrip.length == 0
+      
+      return pdf
+    end
+    
+    def wkhtmltopdf
+      return @wkhtmltopdf if @wkhtmltopdf.present?
+
+      @wkhtmltopdf = Wisepdf::Configuration.wkhtmltopdf
+      raise Wisepdf::NoExecutableError.new(@wkhtmltopdf) if @wkhtmltopdf.nil? || !File.exists?(@wkhtmltopdf)
+      
+      return @wkhtmltopdf
+    end
+    
+    def wkhtmltopdf=(value)
+      @wkhtmltopdf = value
+      raise Wisepdf::NoExecutableError.new(@wkhtmltopdf) if @wkhtmltopdf.nil? || !File.exists?(@wkhtmltopdf)      
+    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)
+        puts "*"*15 
+        puts cmd
+        puts "*"*15
+      end
+
+      def parse_options(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_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)
+            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, [ :level_indentation, :header_text], "toc")
+          r += make_options(options, [ :text_size_shrink], "toc", :numeric)
+          r += make_options(options, [ :disable_toc_links, :disable_dotted_lines], "", :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,
+                                      :greyscale,
+                                      :lowquality,
+                                      :enable_plugins,
+                                      :disable_internal_links,
+                                      :disable_external_links,
+                                      :print_media_type,
+                                      :disable_smart_shrinking,
+                                      :use_xserver,
+                                      :no_background], "", :boolean)
+        end
+      end
+
+  end
+end

data/lib/wisepdf.rb

@@ -0,0 +1,10 @@
+require 'wisepdf/tempfile'
+require 'wisepdf/errors'
+require 'wisepdf/configuration'
+require 'wisepdf/writer'
+require 'wisepdf/helper'
+require 'wisepdf/render'
+require 'wisepdf/rails' if defined?(Rails)
+
+module Pdf
+end

data/pdf.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "pdf"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Igor Alexandrov"]
+  s.date = "2012-03-09"
+  s.description = "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 pdf take care of the hard stuff."
+  s.email = "igor.alexandrov@gmail.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "generators/pdf/pdf_generator.rb",
+    "generators/pdf/templates/configure_pdf.rb",
+    "lib/generators/pdf_generator.rb",
+    "lib/pdf.rb",
+    "lib/pdf/configuration.rb",
+    "lib/pdf/errors.rb",
+    "lib/pdf/helper.rb",
+    "lib/pdf/rails.rb",
+    "lib/pdf/rails/engine.rb",
+    "lib/pdf/rails/legacy.rb",
+    "lib/pdf/rails/railtie.rb",
+    "lib/pdf/render.rb",
+    "lib/pdf/tempfile.rb",
+    "lib/pdf/writer.rb",
+    "test/fixtures/wicked.css",
+    "test/helper_test.rb",
+    "test/test_helper.rb",
+    "test/wicked_pdf_helper_test.rb",
+    "test/writer_test.rb"
+  ]
+  s.homepage = "http://github.com/igor-alexandrov/pdf"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "PDF generator for Ruby on Rails"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/test/application_controller_test.rb

@@ -0,0 +1,27 @@
+require 'helper'
+ 
+class ApplicationControllerTest < ActionController::TestCase
+  tests ApplicationController
+ 
+  context "The controller" do
+    setup do
+      module Wisepdf::Render
+        public :make_pdf
+        public :make_and_send_pdf
+        public :prerender_header_and_footer
+      end
+    end
+    
+    should "respond to #make_pdf" do
+      assert_respond_to @controller, :make_pdf
+    end
+    
+    should "respond to #make_and_send_pdf" do
+      assert_respond_to @controller, :make_and_send_pdf
+    end    
+    
+    should "respond to #prerender_header_and_footer" do
+      assert_respond_to @controller, :prerender_header_and_footer
+    end        
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/test/dummy/app/assets/javascripts/wisepdf.js

@@ -0,0 +1 @@
+// Wisepdf javascript

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+*/