adzap-wicked_pdf 2.0.0.beta1

data/lib/wicked_pdf/middleware.rb

@@ -0,0 +1,101 @@
+module WickedPdf
+  class Middleware
+    def initialize(app, options = {}, conditions = {})
+      @app = app
+      @options = (WickedPdf.config || {}).merge(options)
+      @conditions = conditions
+      @command = command(options[:wkhtmltopdf])
+    end
+
+    def call(env)
+      @request = Rack::Request.new(env)
+      @render_pdf = false
+
+      set_request_to_render_as_pdf(env) if render_as_pdf?
+      status, headers, response = @app.call(env)
+
+      if rendering_pdf? && headers['Content-Type'] =~ /text\/html|application\/xhtml\+xml/
+        body = response.respond_to?(:body) ? response.body : response.join
+        body = body.join if body.is_a?(Array)
+
+        body = WickedPdf::Document.new(@command).pdf_from_string(translate_paths(body, env), @options)
+
+        response = [body]
+
+        # Do not cache PDFs
+        headers.delete('ETag')
+        headers.delete('Cache-Control')
+
+        headers['Content-Length'] = (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+        headers['Content-Type'] = 'application/pdf'
+        if @options.fetch(:disposition, '') == 'attachment'
+          headers['Content-Disposition'] = 'attachment'
+          headers['Content-Transfer-Encoding'] = 'binary'
+        end
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    # Change relative paths to absolute
+    def translate_paths(body, env)
+      # Host with protocol
+      root = WickedPdf.config[:root_url] || "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}/"
+
+      body.gsub(/(href|src)=(['"])\/([^\"']*|[^"']*)['"]/, '\1=\2' + root + '\3\2')
+    end
+
+    def rendering_pdf?
+      @render_pdf
+    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.fullpath =~ 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.fullpath =~ pattern
+          elsif @request.path[0, pattern.length] == pattern
+            return false
+          end
+        end
+
+        return true
+      else
+        request_path_is_pdf
+      end
+    end
+
+    def set_request_to_render_as_pdf(env)
+      @render_pdf = true
+      %w[PATH_INFO REQUEST_URI].each { |e| env[e] = env[e].sub(%r{\.pdf\b}, '') }
+      env['HTTP_ACCEPT'] = concat(env['HTTP_ACCEPT'], Rack::Mime.mime_type('.html'))
+      env['Rack-Middleware-WickedPdf'] = 'true'
+    end
+
+    def concat(accepts, type)
+      (accepts || '').split(',').unshift(type).compact.join(',')
+    end
+
+    def command(binary_path)
+      if binary_path
+        WickedPdf::Command.new
+      else
+        WickedPdf::Command.new(binary: WickedPdf::Binary.new(binary_path))
+      end
+    end
+  end
+end

data/lib/wicked_pdf/option_parser.rb

@@ -0,0 +1,220 @@
+module WickedPdf
+  class OptionParser
+    BINARY_VERSION_WITHOUT_DASHES = Gem::Version.new('0.12.0')
+
+    attr_reader :binary_version
+
+    def initialize(binary_version = WickedPdf::Binary::DEFAULT_BINARY_VERSION)
+      @binary_version = binary_version
+    end
+
+    def parse(options)
+      [
+        parse_extra(options),
+        parse_others(options),
+        parse_global(options),
+        parse_outline(options.delete(:outline)),
+        parse_header_footer(:header => options.delete(:header),
+                            :footer => options.delete(:footer),
+                            :layout => options[:layout]),
+        parse_cover(options.delete(:cover)),
+        parse_toc(options.delete(:toc)),
+        parse_basic_auth(options)
+      ].flatten
+    end
+
+    def format_option(name)
+      if binary_version < BINARY_VERSION_WITHOUT_DASHES
+        "--#{name}"
+      else
+        name
+      end
+    end
+
+    private
+
+    def parse_extra(options)
+      return [] if options[:extra].nil?
+      return options[:extra].split if options[:extra].respond_to?(:split)
+      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 parse_header_footer(options)
+      r = []
+      unless options.blank?
+        [:header, :footer].collect do |hf|
+          next if 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 = [] unless defined?(@hf_tempfiles)
+            @hf_tempfiles.push(tf = WickedPdf::Tempfile.new("wicked_#{hf}_pdf.html"))
+            tf.write options[hf][:content]
+            tf.flush
+            options[hf][:html] = {}
+            options[hf][:html][:url] = "file:///#{tf.path}"
+          end
+          unless opt_hf[:html].blank?
+            r += make_option("#{hf}-html", opt_hf[:html][:url]) unless opt_hf[:html][:url].blank?
+          end
+        end
+      end
+      r
+    end
+
+    def parse_cover(argument)
+      arg = argument.to_s
+      return [] if arg.blank?
+      # Filesystem path or URL - hand off to wkhtmltopdf
+      if argument.is_a?(Pathname) || (arg[0, 4] == 'http')
+        [format_option('cover'), arg]
+      else # HTML content
+        @hf_tempfiles ||= []
+        @hf_tempfiles << tf = WickedPdf::Tempfile.new('wicked_cover_pdf.html')
+        tf.write arg
+        tf.flush
+        [format_option('cover'), tf.path]
+      end
+    end
+
+    def parse_toc(options)
+      return [] if options.nil?
+      r = [format_option('toc')]
+      unless options.blank?
+        r += make_options(options, [:font_name, :header_text], 'toc')
+        r += make_options(options, [:xsl_style_sheet])
+        r += make_options(options, [:depth,
+                                    :header_fs,
+                                    :text_size_shrink,
+                                    :l1_font_size,
+                                    :l2_font_size,
+                                    :l3_font_size,
+                                    :l4_font_size,
+                                    :l5_font_size,
+                                    :l6_font_size,
+                                    :l7_font_size,
+                                    :level_indentation,
+                                    :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)
+        r += make_options(options, [:disable_dotted_lines,
+                                    :disable_toc_links], nil, :boolean)
+      end
+      r
+    end
+
+    def parse_outline(options)
+      r = []
+      unless options.blank?
+        r = make_options(options, [:outline], '', :boolean)
+        r += make_options(options, [:outline_depth], '', :numeric)
+      end
+      r
+    end
+
+    def parse_margins(options)
+      make_options(options, [:top, :bottom, :left, :right], 'margin', :numeric)
+    end
+
+    def parse_global(options)
+      r = []
+      unless options.blank?
+        r += make_options(options, [:orientation,
+                                    :dpi,
+                                    :page_size,
+                                    :page_width,
+                                    :title])
+        r += make_options(options, [:lowquality,
+                                    :grayscale,
+                                    :no_pdf_compression], '', :boolean)
+        r += make_options(options, [:image_dpi,
+                                    :image_quality,
+                                    :page_height], '', :numeric)
+        r += parse_margins(options.delete(:margin))
+      end
+      r
+    end
+
+    def parse_others(options)
+      r = []
+      unless options.blank?
+        r += make_options(options, [:proxy,
+                                    :username,
+                                    :password,
+                                    :encoding,
+                                    :user_style_sheet,
+                                    :viewport_size,
+                                    :window_status])
+        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,
+                                    :enable_plugins,
+                                    :disable_internal_links,
+                                    :disable_external_links,
+                                    :print_media_type,
+                                    :disable_smart_shrinking,
+                                    :use_xserver,
+                                    :no_background,
+                                    :images,
+                                    :no_images,
+                                    :no_stop_slow_scripts], '', :boolean)
+      end
+      r
+    end
+
+    def make_options(options, names, prefix = '', type = :string)
+      return [] if options.nil?
+      names.collect do |o|
+        if options[o].blank?
+          []
+        else
+          make_option("#{prefix.blank? ? '' : prefix + '-'}#{o}",
+                      options[o],
+                      type)
+        end
+      end
+    end
+
+    def make_option(name, value, type = :string)
+      if value.is_a?(Array)
+        return value.collect { |v| make_option(name, v, type) }
+      end
+      if type == :name_value
+        parts = value.to_s.split(' ')
+        ["--#{name.tr('_', '-')}", *parts]
+      elsif type == :boolean
+        if value
+          ["--#{name.tr('_', '-')}"]
+        else
+          []
+        end
+      else
+        ["--#{name.tr('_', '-')}", value.to_s]
+      end
+    end
+  end
+end

data/lib/wicked_pdf/pdf_helper.rb

@@ -0,0 +1,17 @@
+module WickedPdf
+  module PdfHelper
+    def self.prepended(base)
+      # Protect from trying to augment modules that appear
+      # as the result of adding other gems.
+      return if base != ActionController::Base
+    end
+
+    def render_to_string(options = nil, *args, &block)
+      if options.is_a?(Hash) && options.key?(:pdf)
+        WickedPdf::Renderer.new(self).render(options)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/wicked_pdf/progress.rb

@@ -0,0 +1,33 @@
+module WickedPdf
+  class Progress
+    require 'pty' # no support for windows
+    require 'English'
+
+    def initialize(callback = nil)
+      @callback = callback
+    end
+
+    def execute(command)
+      output = []
+      begin
+        PTY.spawn(command.join(' ')) do |stdout, _stdin, pid|
+          begin
+            stdout.sync
+            stdout.each_line("\r") do |line|
+              output << line.chomp
+              @callback.call(line) if @callback
+            end
+          rescue Errno::EIO # rubocop:disable Lint/HandleExceptions
+            # child process is terminated, this is expected behaviour
+          ensure
+            ::Process.wait pid
+          end
+        end
+      rescue PTY::ChildExited
+        puts 'The child process exited!'
+      end
+      err = output.join('\n')
+      raise "#{command} failed (exitstatus 0). Output was: #{err}" unless $CHILD_STATUS && $CHILD_STATUS.exitstatus.zero?
+    end
+  end
+end

data/lib/wicked_pdf/railtie.rb

@@ -0,0 +1,19 @@
+require 'wicked_pdf/pdf_helper'
+require 'wicked_pdf/renderer'
+require 'wicked_pdf/asset_helper'
+
+module WickedPdf
+  class Railtie < Rails::Railtie
+    initializer 'wicked_pdf.register' do |_app|
+      ActionController::Base.send :prepend, PdfHelper
+      ActionController::Renderers.add :pdf do |template, options|
+        WickedPdf::Renderer.new(self).render(options.merge(:pdf => template))
+      end
+      ActionView::Base.send :include, WickedPdf::AssetHelper
+    end
+  end
+end
+
+if Mime::Type.lookup_by_extension(:pdf).nil?
+  Mime::Type.register('application/pdf', :pdf)
+end

data/lib/wicked_pdf/renderer.rb

@@ -0,0 +1,121 @@
+module WickedPdf
+  class Renderer
+    attr_reader :controller
+
+    delegate :request, :send_data, :controller_path, :action_name, :to => :controller
+
+    def initialize(controller)
+      @controller = controller
+      @hf_tempfiles = []
+    end
+
+    def render(options)
+      options[:basic_auth] = set_basic_auth(options)
+      make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
+    end
+
+    def render_to_string(options)
+      options[:basic_auth] = set_basic_auth(options)
+      options.delete :pdf
+      make_pdf((WickedPdf.config || {}).merge(options))
+    end
+
+    private
+
+    def set_basic_auth(options = {})
+      options[:basic_auth] ||= WickedPdf.config.fetch(:basic_auth) { false }
+      return unless options[:basic_auth] && request.env['HTTP_AUTHORIZATION']
+      request.env['HTTP_AUTHORIZATION'].split(' ').last
+    end
+
+    def make_pdf(options = {})
+      render_opts = {
+        :template => options[:template],
+        :prefixes => options[:prefixes],
+        :layout => options[:layout],
+        :formats => options[:formats],
+        :handlers => options[:handlers],
+        :assigns => options[:assigns]
+      }
+      render_opts[:inline] = options[:inline] if options[:inline]
+      render_opts[:locals] = options[:locals] if options[:locals]
+      render_opts[:file]   = options[:file] if options[:file]
+
+      html_string = controller.render_to_string(render_opts)
+      options = prerender_header_and_footer(options)
+
+      document = WickedPdf::Document.new(command(options[:wkhtmltopdf]))
+      document.pdf_from_string(html_string, options)
+    ensure
+      clean_temp_files
+    end
+
+    def make_and_send_pdf(pdf_name, options = {})
+      options[:layout] ||= false
+      options[:template] ||= File.join(controller_path, action_name)
+      options[:disposition] ||= 'inline'
+      if options[:show_as_html]
+        render_opts = {
+          :template => options[:template],
+          :prefixes => options[:prefixes],
+          :layout => options[:layout],
+          :formats => options[:formats],
+          :handlers => options[:handlers],
+          :assigns => options[:assigns],
+          :content_type => 'text/html'
+        }
+        render_opts[:inline] = options[:inline] if options[:inline]
+        render_opts[:locals] = options[:locals] if options[:locals]
+        render_opts[:file] = options[:file] if options[:file]
+        render(render_opts)
+      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|
+        next unless options[hf] && options[hf][:html] && options[hf][:html][:template]
+
+        options[hf][:html][:layout] ||= options[:layout]
+        render_opts = {
+          :template => options[hf][:html][:template],
+          :layout => options[hf][:html][:layout],
+          :formats => options[hf][:html][:formats],
+          :handlers => options[hf][:html][:handlers],
+          :assigns => options[hf][:html][:assigns]
+        }
+        render_opts[:locals] = options[hf][:html][:locals] if options[hf][:html][:locals]
+        render_opts[:file] = options[hf][:html][:file] if options[:file]
+
+        path = render_to_tempfile("wicked_#{hf}_pdf.html", render_opts)
+        options[hf][:html][:url] = "file:///#{path}"
+      end
+      options
+    end
+
+    def render_to_tempfile(filename, options)
+      tf = WickedPdf::Tempfile.new(filename)
+      @hf_tempfiles.push(tf)
+      tf.write controller.render_to_string(options)
+      tf.flush
+      tf.path
+    end
+
+    def command(binary_path)
+      if binary_path
+        WickedPdf::Command.new binary: WickedPdf::Binary.new(binary_path)
+      else
+        WickedPdf::Command.new
+      end
+    end
+
+    def clean_temp_files
+      @hf_tempfiles.each(&:close!)
+    end
+  end
+end