adzap-wicked_pdf 2.0.0.beta5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0e3c7a80eafff7408d840f346daf69875aa08ddf4732dcce26b8d41a293df84
-  data.tar.gz: 04fe3eb6fbe869899c46faa88eec83ec4abbf2aa7c3dbbb904cda40415a434e3
+  metadata.gz: df55b441686f92b7087e24ccc0311fdb2c2653a6a07ee8a661f5168ba403462c
+  data.tar.gz: c9016439d082b975e932d1912f84434375897d06a17905065b5cbbf18e1f2354
 SHA512:
-  metadata.gz: a1f3607db97564707b60ff9427de9c24aa5112144665d53ace67fa667216bea616ddbe78e91a94abaebbee85086b8118d8f36722f00d32532b3a4f7963fa6e7a
-  data.tar.gz: 62dba9bf7aa036f6f5c4f249190ccee3f4879914a163f22c42e4c2b6fcb33c2b096b6d858a38e10881d9d39262f2af1a7dd2d715fc05a636b3d3561863897a9c
+  metadata.gz: 7a7568160aadb93576e342cb0185b44854658029c3f46a4fe50c5a3b69b9ef36d06692679760353f535981c2f603637af705e458cc887dce331506763d341b59
+  data.tar.gz: 739be6b379f0834f488c6db9aad4ecc5561838a981b11f5589f54ad6d1d4c7b5b202373518cdce66c68f69a78e6d9b40e5f153e31f94e68d22c7d9d8301551d5

data/.rubocop.yml

@@ -1,9 +1,14 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 3.4
+  NewCops: disable
+  SuggestExtensions: false
   Exclude:
     - 'test/dummy/**/*'
+    - 'spike/**/*'
+    - 'gemfiles/**/*'
+    - 'vendor/**/*'
 
 Metrics/BlockLength:
   Exclude:
@@ -19,4 +24,4 @@ Style/SymbolArray:
   EnforcedStyle: brackets
 
 Style/SafeNavigation:
-  Enabled: false
+  Enabled: false

data/.rubocop_todo.yml

@@ -28,7 +28,7 @@ Metrics/CyclomaticComplexity:
 
 # Offense count: 92
 # Configuration parameters: AllowURI, URISchemes.
-Metrics/LineLength:
+Layout/LineLength:
   Max: 563
 
 # Offense count: 14
@@ -38,7 +38,7 @@ Metrics/MethodLength:
 
 # Offense count: 4
 Metrics/PerceivedComplexity:
-  Max: 12
+  Max: 14
 
 # Offense count: 2
 Naming/AccessorMethodName:

data/lib/generators/wicked_pdf_generator.rb

@@ -1,5 +1,5 @@
 class WickedPdfGenerator < Rails::Generators::Base
-  source_root(File.expand_path(File.dirname(__FILE__) + '/../../generators/wicked_pdf/templates'))
+  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

data/lib/wicked_pdf/asset_helper.rb

@@ -15,6 +15,7 @@ module WickedPdf
     def wicked_pdf_asset_base64(path)
       asset = find_asset(path)
       raise "Could not find asset '#{path}'" if asset.nil?
+
       base64 = Base64.encode64(asset.to_s).gsub(/\s+/, '')
       "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
     end
@@ -95,7 +96,7 @@ module WickedPdf
     # will prepend a http or default_protocol to a protocol relative URL
     # or when no protcol is set.
     def prepend_protocol(source)
-      protocol = WickedPdf.config[:default_protocol] || 'http'
+      protocol = WickedPdf.config.default_protocol || 'http'
       if source[0, 2] == '//'
         source = [protocol, ':', source].join
       elsif source[0] != '/' && !source[0, 8].include?('://')
@@ -107,7 +108,7 @@ module WickedPdf
     def precompiled_or_absolute_asset?(source)
       Rails.configuration.assets.compile == false ||
         source.to_s[0] == '/' ||
-        source.to_s.match(/\Ahttps?\:\/\//)
+        source.to_s.match(/\Ahttps?:\/\//)
     end
 
     def read_asset(source)
@@ -125,7 +126,7 @@ module WickedPdf
 
     def read_from_uri(uri)
       asset = Net::HTTP.get(URI(uri))
-      asset = gzip(asset) if WickedPdf.config[:expect_gzipped_remote_assets]
+      asset = gzip(asset) if WickedPdf.config.expect_gzipped_remote_assets
       asset
     end
 

data/lib/wicked_pdf/binary.rb

@@ -5,6 +5,21 @@ module WickedPdf
 
     attr_reader :path, :version
 
+    # Shared instance, so the version check (`wkhtmltopdf -V` subprocess) runs
+    # once instead of once per render. Re-resolved whenever config.exe_path
+    # changes — including back to nil (automatic path detection).
+    def self.default
+      configured_path = WickedPdf.config.exe_path
+      @default = nil if @default && @default_configured_path != configured_path
+      @default_configured_path = configured_path
+      @default ||= new
+    end
+
+    def self.reset_default!
+      @default = nil
+      @default_configured_path = nil
+    end
+
     def initialize(binary_path = nil)
       @path = binary_path || find_binary_path
       @version = retrieve_binary_version
@@ -27,14 +42,15 @@ module WickedPdf
     private
 
     def retrieve_binary_version
-      _stdin, stdout, _stderr = Open3.popen3(@path + ' -V')
-      parse_version_string(stdout.gets(nil))
+      # argv form: no shell parsing, so paths with spaces work.
+      stdout, = Open3.capture3(@path, '-V')
+      parse_version_string(stdout)
     rescue StandardError
       MINIMUM_BINARY_VERSION
     end
 
     def find_binary_path
-      return WickedPdf.config[:exe_path] if WickedPdf.config[:exe_path]
+      return WickedPdf.config.exe_path if WickedPdf.config.exe_path
 
       begin
         detected_path = (defined?(Bundler) ? Bundler.which('wkhtmltopdf') : `which wkhtmltopdf`).chomp

data/lib/wicked_pdf/command.rb

@@ -2,14 +2,14 @@ module WickedPdf
   class Command
     attr_reader :binary, :option_parser
 
-    def initialize(binary: Binary.new, option_parser: OptionParser.new)
+    def initialize(binary: Binary.default, option_parser: OptionParser.new)
       @binary = binary
       @option_parser = option_parser
     end
 
     def execute(options, *args)
       command = [binary.path]
-      command << '--enable-local-file-access' # FIXME should be set as config
+      command += global_argv
       command += option_parser.parse(options)
       command += args
 
@@ -18,28 +18,168 @@ module WickedPdf
       if track_progress?(options)
         Progress.new(options[:progress]).execute(command)
       else
-        begin
-          err = Open3.popen3(*command) do |_stdin, _stdout, stderr|
-            stderr.read
-          end
+        err = run_process(command)
+
+        raise GenerationError, "Error generating PDF\n Command Error: #{err}" if options[:raise_on_all_errors] && !err.empty?
+
+        err
+      end
+    end
+
+    # Runs several conversions through shared wkhtmltopdf processes using
+    # --read-args-from-stdin, avoiding one process boot per document.
+    #
+    # Each job is a Hash with:
+    #   options:     wkhtmltopdf options for this conversion only
+    #   url:         input URL (file:///... for local files)
+    #   output_path: file the PDF is written to
+    #
+    # Jobs are split into `concurrency` contiguous slices, each processed by
+    # its own wkhtmltopdf process. wkhtmltopdf aborts a batch at the first
+    # failing conversion, so the failed job is retried as a normal single
+    # invocation (for a proper error) and the batch resumed with the rest.
+    # Raises WickedPdf::GenerationError if a job cannot be rendered.
+    #
+    # All argv compilation happens here on the calling thread: OptionParser
+    # is not thread-safe (it accumulates tempfile state for inline
+    # header/footer content), so worker threads only ever see frozen strings.
+    def execute_batch(jobs, concurrency: 1)
+      return if jobs.empty?
+
+      compiled = jobs.map { |job| BatchJob.new(job, batch_argv(job)) }
+
+      slices = compiled.each_slice(batch_slice_size(jobs.size, concurrency)).to_a
+      errors = Array.new(slices.size)
+
+      slices.each_with_index.map do |slice, index|
+        Thread.new do
+          process_batch_slice(slice)
         rescue StandardError => e
-          raise "Failed to execute:\n#{command}\nError: #{e}"
+          errors[index] = e
         end
+      end.each(&:join)
 
-        raise "Error generating PDF\n Command Error: #{err}" if options[:raise_on_all_errors] && !err.empty?
-        err
+      error = errors.compact.first
+      raise error if error
+    end
+
+    # A batch job with its argv compiled up front (thread-safe to run).
+    BatchJob = Struct.new(:job, :argv) do
+      def output_path
+        job[:output_path]
+      end
+
+      def line
+        @line ||= argv.join(' ')
       end
     end
 
     private
 
+    def batch_slice_size(job_count, concurrency)
+      concurrency = concurrency.clamp(1, job_count)
+      (job_count.to_f / concurrency).ceil
+    end
+
+    def process_batch_slice(batch_jobs)
+      pending = batch_jobs
+      until pending.empty?
+        run_batch_process(pending.map(&:line))
+        pending = pending.drop_while { |batch_job| batch_output_complete?(batch_job) }
+        break if pending.empty?
+
+        retry_batch_job(pending.shift)
+      end
+    end
+
+    # A failed conversion aborts its batch process, leaving this job and all
+    # jobs after it unrendered. Retrying it individually either renders it
+    # (transient failure) or produces a proper single-invocation error.
+    def retry_batch_job(batch_job)
+      command = [binary.path] + batch_job.argv.map { |token| unquote_batch_token(token) }
+      print_command(command.inspect) if in_development_mode?
+
+      err = run_process(command)
+      return if batch_output_complete?(batch_job)
+
+      raise GenerationError, "Error generating PDF for #{batch_job.output_path}\n Command Error: #{err}"
+    end
+
+    # wkhtmltopdf aborts a failing batch conversion partway, which can leave
+    # a non-empty but truncated file behind. Only a well-formed PDF (header
+    # and end-of-file marker) counts as done; anything else is retried.
+    def batch_output_complete?(batch_job)
+      size = File.size?(batch_job.output_path)
+      return false unless size
+
+      File.open(batch_job.output_path, 'rb') do |file|
+        return false unless file.read(5) == '%PDF-'
+
+        file.seek([size - 64, 0].max)
+        file.read.include?('%%EOF')
+      end
+    end
+
+    def batch_argv(job)
+      argv = global_argv
+      argv += option_parser.parse(job[:options].dup)
+      argv += [job[:url], job[:output_path]]
+      argv.map { |arg| batch_token(arg.to_s) }
+    end
+
+    # Flags controlled by gem configuration rather than per-render options.
+    def global_argv
+      WickedPdf.config.enable_local_file_access ? ['--enable-local-file-access'] : []
+    end
+
+    # wkhtmltopdf tokenises each stdin line itself: spaces separate arguments
+    # unless quoted. Only quoted-space handling is verified, so reject
+    # characters with unknown escaping semantics rather than corrupt a line.
+    def batch_token(arg)
+      raise ArgumentError, "Unsupported character in wkhtmltopdf batch argument: #{arg.inspect}" if arg.match?(/["\n\r]/)
+
+      arg.include?(' ') ? %("#{arg}") : arg
+    end
+
+    # Reverses batch_token quoting when a compiled token is passed directly
+    # as a process argument instead of through the stdin line protocol.
+    def unquote_batch_token(token)
+      token.start_with?('"') && token.end_with?('"') ? token[1..-2] : token
+    end
+
+    def run_process(command)
+      Open3.popen3(*command) do |_stdin, _stdout, stderr|
+        stderr.read
+      end
+    rescue StandardError => e
+      raise Error, "Failed to execute:\n#{command}\nError: #{e}"
+    end
+
+    def run_batch_process(lines)
+      print_command(lines.inspect) if in_development_mode?
+
+      err = nil
+      Open3.popen3(binary.path, '--read-args-from-stdin') do |stdin, stdout, stderr, wait_thr|
+        stdout_reader = Thread.new { stdout.read }
+        stderr_reader = Thread.new { stderr.read }
+        lines.each { |line| stdin.puts(line) }
+        stdin.close
+        stdout_reader.value
+        err = stderr_reader.value
+        wait_thr.value
+      end
+      err
+    rescue StandardError => e
+      raise Error, "Failed to execute wkhtmltopdf batch:\n#{lines.inspect}\nError: #{e}"
+    end
+
     def in_development_mode?
       defined?(Rails.env) && Rails.env.development?
     end
 
     def print_command(cmd)
       # TODO: if no Rails what then?
-      Rails.logger.debug '[wicked_pdf]: ' + cmd
+      Rails.logger.debug "[wicked_pdf]: #{cmd}"
     end
 
     def track_progress?(options)

data/lib/wicked_pdf/configuration.rb

@@ -0,0 +1,60 @@
+module WickedPdf
+  # Global gem configuration, set via WickedPdf.configure or by assigning a
+  # Hash to WickedPdf.config (kept for backward compatibility).
+  #
+  # Two kinds of values live here:
+  #
+  # * Typed settings, declared as accessors below, which control the gem
+  #   itself (binary location, middleware URLs, asset handling).
+  # * default_options, a Hash of wkhtmltopdf render options (:footer,
+  #   :orientation, :dpi, ...) merged under every render's own options.
+  #   Unknown keys assigned through a Hash or #[]= land here.
+  class Configuration
+    SETTINGS = [
+      :exe_path,
+      :basic_auth,
+      :root_url,
+      :default_protocol,
+      :expect_gzipped_remote_assets,
+      :enable_local_file_access
+    ].freeze
+
+    attr_accessor(*SETTINGS)
+    attr_reader :default_options
+
+    def self.from_hash(hash)
+      new.tap do |config|
+        (hash || {}).each { |key, value| config[key] = value }
+      end
+    end
+
+    def initialize
+      @basic_auth = false
+      @enable_local_file_access = true
+      @default_options = {}
+    end
+
+    def []=(key, value)
+      if setting?(key)
+        public_send("#{key}=", value)
+      else
+        default_options[key.to_sym] = value
+      end
+    end
+
+    def [](key)
+      setting?(key) ? public_send(key) : default_options[key.to_sym]
+    end
+
+    def to_h
+      settings = SETTINGS.to_h { |key| [key, public_send(key)] }
+      settings.compact.merge(default_options)
+    end
+
+    private
+
+    def setting?(key)
+      SETTINGS.include?(key.to_sym)
+    end
+  end
+end

data/lib/wicked_pdf/document.rb

@@ -10,7 +10,7 @@ module WickedPdf
 
     def pdf_from_string(string, options = {})
       options = options.dup
-      options.merge!(WickedPdf.config) { |_key, option, _config| option }
+      options.merge!(WickedPdf.config.default_options) { |_key, option, _config| option }
       string_file = WickedPdf::Tempfile.new('wicked_pdf.html', options[:temp_path])
       string_file.write_in_chunks(string)
 
@@ -22,21 +22,52 @@ module WickedPdf
       string_file.close! if string_file
     end
 
+    # Renders many HTML strings via Command#execute_batch (shared wkhtmltopdf
+    # processes instead of one boot per document). Items are Hashes of
+    # { html: String, options: Hash }; each item's options apply to that
+    # conversion only. Returns the PDF strings in item order.
+    def pdfs_from_strings(items, concurrency: 1)
+      tempfiles = []
+
+      jobs = items.map do |item|
+        options = (item[:options] || {}).dup
+        options.merge!(WickedPdf.config.default_options) { |_key, option, _config| option }
+
+        input = WickedPdf::Tempfile.new('wicked_pdf_batch.html', options[:temp_path])
+        tempfiles << input
+        input.write_in_chunks(item.fetch(:html))
+
+        output = WickedPdf::Tempfile.new('wicked_pdf_batch.pdf', options[:temp_path])
+        tempfiles << output
+
+        { options: options, url: "file:///#{input.path}", output_path: output.path, output_file: output }
+      end
+
+      @command.execute_batch(jobs, concurrency: concurrency)
+
+      jobs.map do |job|
+        pdf = job[:output_file].read_in_chunks
+        raise GenerationError, "PDF could not be generated!\n Output: #{job[:output_path]}" if pdf.rstrip.empty?
+
+        pdf
+      end
+    ensure
+      tempfiles.each(&:close!)
+    end
+
     def pdf_from_url(url, options = {})
       # merge in global config options
-      options.merge!(WickedPdf.config) { |_key, option, _config| option }
+      options.merge!(WickedPdf.config.default_options) { |_key, option, _config| option }
       generated_pdf_file = WickedPdf::Tempfile.new('wicked_pdf_generated_file.pdf', options[:temp_path])
       return_file = options.delete(:return_file)
 
       err = @command.execute(options, url, generated_pdf_file.path.to_s)
 
-      if return_file
-        return generated_pdf_file
-      end
+      return generated_pdf_file if return_file
 
       pdf = generated_pdf_file.read_in_chunks
 
-      raise "PDF could not be generated!\n Command Error: #{err}" if pdf && pdf.rstrip.empty?
+      raise GenerationError, "PDF could not be generated!\n Command Error: #{err}" if pdf && pdf.rstrip.empty?
 
       pdf
     rescue Errno::EINVAL => e

data/lib/wicked_pdf/middleware.rb

@@ -2,7 +2,7 @@ module WickedPdf
   class Middleware
     def initialize(app, options = {}, conditions = {})
       @app = app
-      @options = (WickedPdf.config || {}).merge(options)
+      @options = WickedPdf.config.default_options.merge(options)
       @conditions = conditions
       @command = command(options[:wkhtmltopdf])
     end
@@ -42,9 +42,9 @@ module WickedPdf
     # 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']}/"
+      root = WickedPdf.config.root_url || "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}/"
 
-      body.gsub(/(href|src)=(['"])\/([^\"']*|[^"']*)['"]/, '\1=\2' + root + '\3\2')
+      body.gsub(/(href|src)=(['"])\/([^"']*|[^"']*)['"]/, "\\1=\\2#{root}\\3\\2")
     end
 
     def rendering_pdf?
@@ -73,7 +73,7 @@ module WickedPdf
           end
         end
 
-        return true
+        true
       else
         request_path_is_pdf
       end

data/lib/wicked_pdf/option_parser.rb

@@ -20,6 +20,7 @@ module WickedPdf
     def parse_extra(options)
       return [] if options[:extra].nil?
       return options[:extra].split if options[:extra].respond_to?(:split)
+
       options[:extra]
     end
 
@@ -37,6 +38,7 @@ module WickedPdf
       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)
@@ -49,9 +51,7 @@ module WickedPdf
             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
+          r += make_option("#{hf}-html", opt_hf[:html][:url]) if !opt_hf[:html].blank? && !opt_hf[:html][:url].blank?
         end
       end
       r
@@ -60,6 +60,7 @@ module WickedPdf
     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')
         ['cover', arg]
@@ -74,6 +75,7 @@ module WickedPdf
 
     def parse_toc(options)
       return [] if options.nil?
+
       r = ['toc']
       unless options.blank?
         r += make_options(options, [:font_name, :header_text], 'toc')
@@ -172,11 +174,12 @@ module WickedPdf
 
     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}",
+          make_option("#{prefix.blank? ? '' : "#{prefix}-"}#{o}",
                       options[o],
                       type)
         end
@@ -184,9 +187,8 @@ module WickedPdf
     end
 
     def make_option(name, value, type = :string)
-      if value.is_a?(Array)
-        return value.collect { |v| make_option(name, v, type) }
-      end
+      return value.collect { |v| make_option(name, v, type) } if value.is_a?(Array)
+
       if type == :name_value
         parts = value.to_s.split(' ')
         ["--#{name.tr('_', '-')}", *parts]

data/lib/wicked_pdf/pdf_helper.rb

@@ -3,7 +3,7 @@ module WickedPdf
     def self.prepended(base)
       # Protect from trying to augment modules that appear
       # as the result of adding other gems.
-      return if base != ActionController::Base
+      nil if base != ActionController::Base
     end
 
     def render_to_string(options = nil, *args, &block)

data/lib/wicked_pdf/progress.rb

@@ -11,17 +11,15 @@ module WickedPdf
       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
+          stdout.sync
+          stdout.each_line("\r") do |line|
+            output << line.chomp
+            @callback.call(line) if @callback
           end
+        rescue Errno::EIO
+          # child process is terminated, this is expected behaviour
+        ensure
+          ::Process.wait pid
         end
       rescue PTY::ChildExited
         puts 'The child process exited!'

data/lib/wicked_pdf/railtie.rb

@@ -5,17 +5,15 @@ require 'wicked_pdf/asset_helper'
 module WickedPdf
   class Railtie < Rails::Railtie
     initializer 'wicked_pdf.register' do |_app|
-      ActiveSupport.on_load(:action_controller) {
-        ActionController::Base.send :prepend, PdfHelper
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.prepend PdfHelper
         ActionController::Renderers.add :pdf do |template, options|
           WickedPdf::Renderer.new(self).render(options.merge(pdf: template))
         end
-      }
+      end
       ActiveSupport.on_load(:action_view) { include WickedPdf::AssetHelper }
     end
   end
 end
 
-if Mime::Type.lookup_by_extension(:pdf).nil?
-  Mime::Type.register('application/pdf', :pdf)
-end
+Mime::Type.register('application/pdf', :pdf) if Mime::Type.lookup_by_extension(:pdf).nil?

data/lib/wicked_pdf/renderer.rb

@@ -9,20 +9,46 @@ module WickedPdf
 
     def render(options)
       options[:basic_auth] = set_basic_auth(options)
-      make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
+      make_and_send_pdf(options.delete(:pdf), WickedPdf.config.default_options.merge(options))
     end
 
     def render_to_string(options)
       options[:basic_auth] = set_basic_auth(options)
       options.delete :pdf
-      make_pdf((WickedPdf.config || {}).merge(options))
+      make_pdf(WickedPdf.config.default_options.merge(options))
+    end
+
+    # Renders the template and any header/footer templates WITHOUT invoking
+    # wkhtmltopdf, returning { html:, options: } suitable for
+    # Document#pdfs_from_strings. Header/footer tempfiles referenced by the
+    # returned options stay alive until #cleanup is called, which must happen
+    # after the PDFs have been generated.
+    #
+    # Defaults (layout, template) match #render's `render :pdf` path, so a
+    # prepared document converts identically to a single render.
+    def prepare(options)
+      options = WickedPdf.config.default_options.merge(options)
+      options[:basic_auth] = set_basic_auth(options)
+      options.delete(:pdf)
+      options[:layout] ||= false
+      options[:template] ||= File.join(controller.controller_path, controller.action_name)
+
+      {
+        html: controller.render_to_string(render_options(options)),
+        options: prerender_header_and_footer(options)
+      }
+    end
+
+    def cleanup
+      clean_temp_files
     end
 
     private
 
     def set_basic_auth(options = {})
-      options[:basic_auth] ||= WickedPdf.config.fetch(:basic_auth, false)
+      options[:basic_auth] ||= WickedPdf.config.basic_auth
       return unless options[:basic_auth] && controller.request.env['HTTP_AUTHORIZATION']
+
       controller.request.env['HTTP_AUTHORIZATION'].split(' ').last
     end
 
@@ -45,7 +71,7 @@ module WickedPdf
       else
         pdf_content = make_pdf(options)
         File.open(options[:save_to_file], 'wb') { |file| file << pdf_content } if options[:save_to_file]
-        controller.send_data(pdf_content, :filename => pdf_name + '.pdf', :type => 'application/pdf', :disposition => options[:disposition]) unless options[:save_only]
+        controller.send_data(pdf_content, :filename => "#{pdf_name}.pdf", :type => 'application/pdf', :disposition => options[:disposition]) unless options[:save_only]
       end
     end