adzap-wicked_pdf 2.0.0.beta5 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0e3c7a80eafff7408d840f346daf69875aa08ddf4732dcce26b8d41a293df84
-  data.tar.gz: 04fe3eb6fbe869899c46faa88eec83ec4abbf2aa7c3dbbb904cda40415a434e3
+  metadata.gz: ee59b976a1f8a763eb2a754baf8727f970fe5f06c88194b42735d5c37e3ac6b7
+  data.tar.gz: 543153109daf65bcbe75959aecf5416689fd54481dd31b08bf068322de805551
 SHA512:
-  metadata.gz: a1f3607db97564707b60ff9427de9c24aa5112144665d53ace67fa667216bea616ddbe78e91a94abaebbee85086b8118d8f36722f00d32532b3a4f7963fa6e7a
-  data.tar.gz: 62dba9bf7aa036f6f5c4f249190ccee3f4879914a163f22c42e4c2b6fcb33c2b096b6d858a38e10881d9d39262f2af1a7dd2d715fc05a636b3d3561863897a9c
+  metadata.gz: bc98c1fbb159ec1c228f320d8d79d805d8c9e85927fd3f6b4f96b7d0927c05da270a55d3e87f348a4c7602f350ce855761c3a65f671d133b7bab6e7712cf4296
+  data.tar.gz: 237bef4134c63adb17a206b197888e7a6f8845a7fa4f637454420ab91590c40706766a3d14f1d50f60b3c4df168158751716258b8865ae80c639c4afb75e128c

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_cache.rb

@@ -0,0 +1,33 @@
+module WickedPdf
+  # Process-wide memo for the output of the inlining asset helpers
+  # (wicked_pdf_asset_base64, wicked_pdf_stylesheet_link_tag,
+  # wicked_pdf_javascript_include_tag).
+  #
+  # Reading, concatenating and base64-encoding assets is deterministic for a
+  # given deployment, but the helpers are invoked once per rendered document —
+  # expensive when many documents are rendered in one request (e.g. printing a
+  # batch). Enable with `config.cache_assets = true`; disabled by default so
+  # environments that recompile assets on change (development) stay live.
+  #
+  # Cached values are frozen so a stale reference can't be mutated in place.
+  class AssetCache
+    def initialize
+      @store = {}
+      @mutex = Mutex.new
+    end
+
+    def fetch(key)
+      @mutex.synchronize do
+        @store.fetch(key) { @store[key] = yield.freeze }
+      end
+    end
+
+    def clear
+      @mutex.synchronize { @store.clear }
+    end
+
+    def size
+      @mutex.synchronize { @store.size }
+    end
+  end
+end

data/lib/wicked_pdf/asset_helper.rb

@@ -13,25 +13,30 @@ module WickedPdf
     end
 
     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)}"
+      wicked_pdf_asset_cache(:base64, path) do
+        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
     end
 
     def wicked_pdf_stylesheet_link_tag(*sources)
-      stylesheet_contents = sources.collect do |source|
-        source = WickedPdf::AssetHelper.add_extension(source, 'css')
-        "<style type='text/css'>#{read_asset(source)}</style>"
-      end.join("\n")
-
-      stylesheet_contents.gsub(ASSET_URL_REGEX) do
-        if Regexp.last_match[1].starts_with?('data:')
-          "url(#{Regexp.last_match[1]})"
-        else
-          "url(#{wicked_pdf_asset_path(Regexp.last_match[1])})"
-        end
-      end.html_safe
+      wicked_pdf_asset_cache(:stylesheet, *sources) do
+        stylesheet_contents = sources.collect do |source|
+          source = WickedPdf::AssetHelper.add_extension(source, 'css')
+          "<style type='text/css'>#{read_asset(source)}</style>"
+        end.join("\n")
+
+        stylesheet_contents.gsub(ASSET_URL_REGEX) do
+          if Regexp.last_match[1].starts_with?('data:')
+            "url(#{Regexp.last_match[1]})"
+          else
+            "url(#{wicked_pdf_asset_path(Regexp.last_match[1])})"
+          end
+        end.html_safe
+      end
     end
 
     def wicked_pdf_image_tag(img, options = {})
@@ -44,10 +49,12 @@ module WickedPdf
     end
 
     def wicked_pdf_javascript_include_tag(*sources)
-      sources.collect do |source|
-        source = WickedPdf::AssetHelper.add_extension(source, 'js')
-        "<script type='text/javascript'>#{read_asset(source)}</script>"
-      end.join("\n").html_safe
+      wicked_pdf_asset_cache(:javascript, *sources) do
+        sources.collect do |source|
+          source = WickedPdf::AssetHelper.add_extension(source, 'js')
+          "<script type='text/javascript'>#{read_asset(source)}</script>"
+        end.join("\n").html_safe
+      end
     end
 
     def wicked_pdf_asset_path(asset)
@@ -63,6 +70,11 @@ module WickedPdf
     # borrowed from actionpack/lib/action_view/helpers/asset_url_helper.rb
     URI_REGEXP = %r{^[-a-z]+://|^(?:cid|data):|^//}
 
+    # Inlined asset output is deterministic per deployment; memoized process-wide when config.cache_assets is on.
+    def wicked_pdf_asset_cache(*key, &block)
+      WickedPdf.config.cache_assets ? WickedPdf.asset_cache.fetch(key, &block) : yield
+    end
+
     def asset_pathname(source)
       if precompiled_or_absolute_asset?(source)
         asset = asset_path(source)
@@ -95,7 +107,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 +119,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 +137,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,62 @@
+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,
+      :cache_assets
+    ].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
+      @cache_assets = false
+      @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)