wicked_pdf 0.11.0 → 1.0.0

data/Rakefile

@@ -5,7 +5,7 @@ require 'rails/version'
 require 'bundler/gem_tasks'
 
 desc 'Default: run unit tests.'
-task :default => :test
+task :default => :setup_and_run_tests
 
 desc 'Test the wicked_pdf plugin.'
 Rake::TestTask.new(:test) do |t|
@@ -15,19 +15,31 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
 end
 
-desc "Generate dummy application for test cases"
+desc 'Setup and run all tests'
+task :setup_and_run_tests do
+  unless File.exist?('test/dummy/config/environment.rb')
+    Rake::Task[:dummy_generate].invoke
+  end
+  Rake::Task[:test].invoke
+end
+
+desc 'Generate dummy application for test cases'
 task :dummy_generate do
-	# recursively remove test/dummy directory entity
-	FileUtils.rm_r Dir.glob('test/dummy/*')
+  Rake::Task[:dummy_remove].invoke
+  puts 'Creating dummy application to run tests'
 
-	prefix = ''
-	if Rails::VERSION::MAJOR != 2
-		prefix = 'new '
-	end
+  prefix = ''
+  if Rails::VERSION::MAJOR != 2
+    prefix = 'new '
+  end
+
+  system("rails #{prefix}test/dummy")
+  FileUtils.rm_r Dir.glob('test/dummy/test/*')
+end
 
-	system("rails #{prefix}test/dummy")
-	
-	FileUtils.rm_r Dir.glob('test/dummy/test/*')
+desc 'Remove dummy application'
+task :dummy_remove do
+  FileUtils.rm_r Dir.glob('test/dummy/*')
 end
 
 desc 'Generate documentation for the wicked_pdf plugin.'
@@ -35,6 +47,6 @@ RDoc::Task.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('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/gemfiles/2.3.gemfile

@@ -4,5 +4,7 @@ gem 'rdoc'
 gem 'rails', '~> 2.3.0'
 gem 'rake', '~> 0.9.2'
 gem 'ruby-prof', '~> 0.11.3'
+gem 'test-unit', '= 2.5.2'
+gem 'mocha', '~> 0.12.8'
 gem 'wicked_pdf', :path => '../'
 gemspec :path => '../'

data/gemfiles/3.1.gemfile

@@ -3,5 +3,6 @@ source "https://rubygems.org"
 gem 'rdoc'
 gem 'rails', '~> 3.1.0'
 gem 'sqlite3'
-gem 'wicked_pdf', :path => '../'
-gemspec :path => '../'
+gem 'i18n', '~> 0.6.0'
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/gemfiles/3.2.gemfile

@@ -2,5 +2,6 @@ source "https://rubygems.org"
 
 gem 'rdoc'
 gem 'rails', '~> 3.2.0'
-gem 'wicked_pdf', :path => '../'
-gemspec :path => '../'
+gem 'i18n', '~> 0.6.0'
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/gemfiles/4.0.gemfile

@@ -2,5 +2,5 @@ source "https://rubygems.org"
 
 gem 'rdoc'
 gem 'rails', '~> 4.0.0'
-gem 'wicked_pdf', :path => '../'
-gemspec :path => '../'
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/gemfiles/4.1.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rdoc'
+gem 'rails', '~> 4.1.0'
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/gemfiles/4.2.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rdoc'
+gem 'rails', '~> 4.2.0'
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/gemfiles/rails_edge.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
 gem 'rdoc'
-gem 'rails', :git =>  "https://github.com/rails/rails.git"
-gem 'wicked_pdf', :path => '../'
-gemspec :path => '../'
+gem 'rails', git:  "https://github.com/rails/rails.git"
+gem 'wicked_pdf', path: '../'
+gemspec path: '../'

data/generators/wicked_pdf/templates/wicked_pdf.rb

@@ -1,5 +1,21 @@
+# WickedPDF Global Configuration
+#
+# Use this to set up shared configuration options for your entire application.
+# Any of the configuration options shown here can also be applied to single
+# models by passing arguments to the `render :pdf` call.
+#
+# To learn more, check out the README:
+#
+# https://github.com/mileszs/wicked_pdf/blob/master/README.md
+
 WickedPdf.config = {
-  #:wkhtmltopdf => '/usr/local/bin/wkhtmltopdf',
-  #:layout => "pdf.html",
-  :exe_path => '/usr/local/bin/wkhtmltopdf'
+  # Path to the wkhtmltopdf executable: This usually isn't needed if using
+  # one of the wkhtmltopdf-binary family of gems.
+  # exe_path: '/usr/local/bin/wkhtmltopdf',
+  #   or
+  # exe_path: Gem.bin_path('wkhtmltopdf-binary', 'wkhtmltopdf')
+
+  # Layout file to be used for all PDFs
+  # (but can be overridden in `render :pdf` calls)
+  # layout: 'pdf.html',
 }

data/generators/wicked_pdf/wicked_pdf_generator.rb

@@ -1,7 +1,7 @@
 class WickedPdfGenerator < Rails::Generator::Base
   def manifest
     record do |m|
-      m.file "wicked_pdf.rb", "config/initializers/wicked_pdf.rb"
+      m.file 'wicked_pdf.rb', 'config/initializers/wicked_pdf.rb'
     end
   end
 end

data/lib/generators/wicked_pdf_generator.rb

@@ -2,10 +2,10 @@ 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"))
+    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
+end

data/lib/wicked_pdf.rb

@@ -30,38 +30,49 @@ require 'wicked_pdf/middleware'
 
 class WickedPdf
   DEFAULT_BINARY_VERSION = Gem::Version.new('0.9.9')
-  EXE_NAME = "wkhtmltopdf"
+  BINARY_VERSION_WITHOUT_DASHES = Gem::Version.new('0.12.0')
+  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: #{@exe_path}" unless File.exists?(@exe_path)
-    raise "#{EXE_NAME} is not executable" unless File.executable?(@exe_path)
+    fail "Location of #{EXE_NAME} unknown" if @exe_path.empty?
+    fail "Bad #{EXE_NAME}'s path: #{@exe_path}" unless File.exist?(@exe_path)
+    fail "#{EXE_NAME} is not executable" unless File.executable?(@exe_path)
 
-    @binary_version = DEFAULT_BINARY_VERSION
+    retreive_binary_version
   end
 
-  def retreive_binary_version
-    begin
-      stdin, stdout, stderr = Open3.popen3(@exe_path + ' -V')
-      @binary_version = parse_version(stdout.gets(nil))
-    rescue StandardError
-    end
+  def pdf_from_html_file(filepath, options = {})
+    pdf_from_url("file:///#{filepath}", options)
   end
 
-  def pdf_from_html_file(filepath, options={})
-    if WickedPdf.config[:retreive_version]
-      retreive_binary_version
-    end
+  def pdf_from_string(string, options = {})
+    options = options.dup
+    # merge in global config options
+    options.merge!(WickedPdf.config) {|key, option, config| option}
+    string_file = WickedPdfTempfile.new("wicked_pdf.html", options[:temp_path])
+    string_file.binmode
+    string_file.write(string)
+    string_file.close
 
-    temp_path = options.delete(:temp_path)
-    generated_pdf_file = WickedPdfTempfile.new("wicked_pdf_generated_file.pdf", temp_path)
+    pdf = pdf_from_html_file(string_file.path, options)
+    pdf
+  rescue => e
+    raise "Error: #{e}"
+  ensure
+    string_file.close! if string_file
+  end
+
+  def pdf_from_url(url, options = {})
+    # merge in global config options
+    options.merge!(WickedPdf.config) {|key, option, config| option}
+    generated_pdf_file = WickedPdfTempfile.new("wicked_pdf_generated_file.pdf", options[:temp_path])
     command = [@exe_path]
     command << '-q' unless on_windows? # suppress errors on stdout
     command += parse_options(options)
-    command << "file://#{filepath}"
+    command << url
     command << generated_pdf_file.path.to_s
 
     print_command(command.inspect) if in_development_mode?
@@ -75,239 +86,257 @@ class WickedPdf
     generated_pdf_file.rewind
     generated_pdf_file.binmode
     pdf = generated_pdf_file.read
-    raise "PDF could not be generated!\n Command Error: #{err}" if pdf and pdf.rstrip.length == 0
+    fail "PDF could not be generated!\n Command Error: #{err}" if pdf && pdf.rstrip.length == 0
     pdf
-  rescue Exception => e
+  rescue => e
     raise "Failed to execute:\n#{command}\nError: #{e}"
   ensure
     generated_pdf_file.close! if generated_pdf_file && !return_file
   end
 
-  def pdf_from_string(string, options={})
-    temp_path = options.delete(:temp_path)
-    string_file = WickedPdfTempfile.new("wicked_pdf.html", temp_path)
-    string_file.binmode
-    string_file.write(string)
-    string_file.close
+  private
 
-    pdf = pdf_from_html_file(string_file.path, options)
-    pdf
-  rescue Exception => e
-    raise "Error: #{e}"
-  ensure
-    string_file.close! if string_file
+  def in_development_mode?
+    return Rails.env == 'development' if defined?(Rails)
+    RAILS_ENV == 'development' if defined?(RAILS_ENV)
   end
 
-  private
+  def get_binary_version
+    @binary_version
+  end
 
-    def in_development_mode?
-      return Rails.env == 'development' if defined?(Rails)
-      RAILS_ENV == 'development' if defined?(RAILS_ENV)
-    end
+  def on_windows?
+    RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+  end
 
-    def get_binary_version
-      @binary_version
-    end
+  def print_command(cmd)
+    p '*' * 15 + cmd + '*' * 15
+  end
 
-    def on_windows?
-      RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
-    end
+  def retreive_binary_version
+    stdin, stdout, stderr = Open3.popen3(@exe_path + ' -V')
+    @binary_version = parse_version(stdout.gets(nil))
+  rescue StandardError
+  end
 
-    def print_command(cmd)
-      p "*"*15 + cmd + "*"*15
+  def parse_version(version_info)
+    match_data = /wkhtmltopdf\s*(\d*\.\d*\.\d*\w*)/.match(version_info)
+    if match_data && (2 == match_data.length)
+      Gem::Version.new(match_data[1])
+    else
+      DEFAULT_BINARY_VERSION
     end
+  end
 
-    def parse_version(version_info)
-      match_data = /wkhtmltopdf\s*(\d*\.\d*\.\d*\w*)/.match(version_info)
-      if (match_data && (2 == match_data.length))
-        Gem::Version.new(match_data[1])
-      else
-        DEFAULT_BINARY_VERSION
-      end
-    end
+  def parse_options(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 parse_extra(options)
+    return [] if options[:extra].nil?
+    return options[:extra].split if options[:extra].respond_to?(:split)
+    options[:extra]
+  end
 
-    def parse_options(options)
-      [
-        parse_extra(options),
-        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_outline(options.delete(:outline)),
-        parse_margins(options.delete(:margin)),
-        parse_others(options),
-        parse_basic_auth(options)
-      ].flatten
+  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_extra(options)
-      return [] if options[:extra].nil?
-      return options[:extra].split if options[:extra].respond_to?(:split)
-      return options[:extra]
+  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.gsub('_', '-')}", *parts]
+    elsif type == :boolean
+      ["--#{name.gsub('_', '-')}"]
+    else
+      ["--#{name.gsub('_', '-')}", value.to_s]
+    end
+  end
 
-    def parse_basic_auth(options)
-      if options[:basic_auth]
-        user, passwd = Base64.decode64(options[:basic_auth]).split(":")
-        ["--username", user, "--password", passwd]
-      else
-        []
-      end
+  def valid_option(name)
+    if get_binary_version < BINARY_VERSION_WITHOUT_DASHES
+      "--#{name}"
+    else
+      name
     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 == :boolean
-        ["--#{name.gsub('_', '-')}"]
+  def make_options(options, names, prefix = '', type = :string)
+    return [] if options.nil?
+    names.collect do |o|
+      if options[o].blank?
+        []
       else
-        ["--#{name.gsub('_', '-')}", value.to_s]
+        make_option("#{prefix.blank? ? '' : prefix + '-'}#{o.to_s}",
+                    options[o],
+                    type)
       end
     end
+  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.to_s}", 
-                      options[o], 
-                      type)
+  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 = [] unless defined?(@hf_tempfiles)
+          @hf_tempfiles.push(tf = WickedPdfTempfile.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.to_s}-html", opt_hf[:html][:url]) unless opt_hf[:html][:url].blank?
         end
       end
-    end
+    end unless options.blank?
+    r
+  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
+  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')
+      [valid_option('cover'), arg]
+    else # HTML content
+      @hf_tempfiles ||= []
+      @hf_tempfiles << tf = WickedPdfTempfile.new('wicked_cover_pdf.html')
+      tf.write arg
+      tf.flush
+      [valid_option('cover'), tf.path]
     end
+  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')
-        ['--cover', arg]
-      else # HTML content
-        @hf_tempfiles ||= []
-        @hf_tempfiles << tf=WickedPdfTempfile.new("wicked_cover_pdf.html")
-        tf.write arg
-        tf.flush
-        ['--cover', tf.path]
-      end
+  def parse_toc(options)
+    return [] if options.nil?
+    r = [valid_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_toc(options)
-      return [] if options.nil?
-      r = ['--toc']
-      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
+  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_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_margins(options)
-      make_options(options, [:top, :bottom, :left, :right], "margin", :numeric)
+  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, [ :orientation,
-                                    :page_size,
-                                    :page_width,
-                                    :page_height,
-                                    :proxy,
-                                    :username,
-                                    :password,
-                                    :dpi,
-                                    :encoding,
-                                    :user_style_sheet,
-                                    :viewport_size])
-        r +=make_options(options, [ :cookie,
-                                    :post], "", :name_value)
-        r +=make_options(options, [ :redirect_delay,
-                                    :zoom,
-                                    :page_offset,
-                                    :javascript_delay,
-                                    :image_quality], "", :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)
-        r +=make_options(options, [ :no_stop_slow_scripts ], "", nil)
-      end
-      r
+  def parse_others(options)
+    r = []
+    unless options.blank?
+      r += make_options(options, [:proxy,
+                                  :username,
+                                  :password,
+                                  :encoding,
+                                  :user_style_sheet,
+                                  :viewport_size])
+      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], '', :boolean)
+      r += make_options(options, [:no_stop_slow_scripts], '', nil)
     end
+    r
+  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 || ''
+  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
+      detected_path = (defined?(Bundler) ? `bundle exec which wkhtmltopdf` : `which wkhtmltopdf`).chomp
+      detected_path.present? && detected_path
+    rescue
+      nil
     end
+    exe_path ||= possible_locations.map { |l| File.expand_path("#{l}/#{EXE_NAME}") }.find { |location| File.exist?(location) }
+    exe_path || ''
+  end
 end