wicked_pdf 1.1.0 → 2.8.0

data/lib/wicked_pdf/wicked_pdf_helper/assets.rb

@@ -1,17 +1,99 @@
-require 'open-uri'
+require 'net/http'
+require 'delegate'
+require 'stringio'
 
 class WickedPdf
   module WickedPdfHelper
     module Assets
       ASSET_URL_REGEX = /url\(['"]?([^'"]+?)['"]?\)/
 
+      class MissingAsset < StandardError; end
+
+      class MissingLocalAsset < MissingAsset
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+          super("Could not find asset '#{path}'")
+        end
+      end
+
+      class MissingRemoteAsset < MissingAsset
+        attr_reader :url, :response
+
+        def initialize(url, response)
+          @url = url
+          @response = response
+          super("Could not fetch asset '#{url}': server responded with #{response.code} #{response.message}")
+        end
+      end
+
+      class PropshaftAsset < SimpleDelegator
+        def content_type
+          super.to_s
+        end
+
+        def to_s
+          content
+        end
+
+        def filename
+          path.to_s
+        end
+      end
+
+      class SprocketsEnvironment
+        def self.instance
+          @instance ||= Sprockets::Railtie.build_environment(Rails.application)
+        end
+
+        def self.find_asset(*args)
+          instance.find_asset(*args)
+        end
+      end
+
+      class LocalAsset
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def content_type
+          Mime::Type.lookup_by_extension(File.extname(path).delete('.'))
+        end
+
+        def to_s
+          IO.read(path)
+        end
+
+        def filename
+          path.to_s
+        end
+      end
+
       def wicked_pdf_asset_base64(path)
         asset = find_asset(path)
-        raise "Could not find asset '#{path}'" if asset.nil?
+        raise MissingLocalAsset, path if asset.nil?
+
         base64 = Base64.encode64(asset.to_s).gsub(/\s+/, '')
         "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
       end
 
+      # Using `image_tag` with URLs when generating PDFs (specifically large PDFs with lots of pages) can cause buffer/stack overflows.
+      #
+      def wicked_pdf_url_base64(url)
+        response = Net::HTTP.get_response(URI(url))
+
+        if response.is_a?(Net::HTTPSuccess)
+          base64 = Base64.encode64(response.body).gsub(/\s+/, '')
+          "data:#{response.content_type};base64,#{Rack::Utils.escape(base64)}"
+        else
+          Rails.logger.warn("[wicked_pdf] #{response.code} #{response.message}: #{url}")
+          nil
+        end
+      end
+
       def wicked_pdf_stylesheet_link_tag(*sources)
         stylesheet_contents = sources.collect do |source|
           source = WickedPdfHelper.add_extension(source, 'css')
@@ -27,6 +109,33 @@ class WickedPdf
         end.html_safe
       end
 
+      def wicked_pdf_stylesheet_pack_tag(*sources)
+        return unless defined?(Webpacker)
+
+        if running_in_development?
+          stylesheet_pack_tag(*sources)
+        else
+          css_text = sources.collect do |source|
+            source = WickedPdfHelper.add_extension(source, 'css')
+            wicked_pdf_stylesheet_link_tag(webpacker_source_url(source))
+          end.join("\n")
+          css_text.respond_to?(:html_safe) ? css_text.html_safe : css_text
+        end
+      end
+
+      def wicked_pdf_javascript_pack_tag(*sources)
+        return unless defined?(Webpacker)
+
+        if running_in_development?
+          javascript_pack_tag(*sources)
+        else
+          sources.collect do |source|
+            source = WickedPdfHelper.add_extension(source, 'js')
+            "<script type='text/javascript'>#{read_asset(webpacker_source_url(source))}</script>"
+          end.join("\n").html_safe
+        end
+      end
+
       def wicked_pdf_image_tag(img, options = {})
         image_tag wicked_pdf_asset_path(img), options
       end
@@ -51,6 +160,16 @@ class WickedPdf
         end
       end
 
+      def wicked_pdf_asset_pack_path(asset)
+        return unless defined?(Webpacker)
+
+        if running_in_development?
+          asset_pack_path(asset)
+        else
+          wicked_pdf_asset_path webpacker_source_url(asset)
+        end
+      end
+
       private
 
       # borrowed from actionpack/lib/action_view/helpers/asset_url_helper.rb
@@ -68,15 +187,25 @@ class WickedPdf
           end
         else
           asset = find_asset(source)
-          asset ? asset.pathname : File.join(Rails.public_path, source)
+          if asset
+            # older versions need pathname, Sprockets 4 supports only filename
+            asset.respond_to?(:filename) ? asset.filename : asset.pathname
+          else
+            File.join(Rails.public_path, source)
+          end
         end
       end
 
       def find_asset(path)
         if Rails.application.assets.respond_to?(:find_asset)
-          Rails.application.assets.find_asset(path)
+          Rails.application.assets.find_asset(path, :base_path => Rails.application.root.to_s)
+        elsif defined?(Propshaft::Assembly) && Rails.application.assets.is_a?(Propshaft::Assembly)
+          PropshaftAsset.new(Rails.application.assets.load_path.find(path))
+        elsif Rails.application.respond_to?(:assets_manifest)
+          asset_path = File.join(Rails.application.assets_manifest.dir, Rails.application.assets_manifest.assets[path])
+          LocalAsset.new(asset_path) if File.file?(asset_path)
         else
-          Sprockets::Railtie.build_environment(Rails.application).find_asset(path)
+          SprocketsEnvironment.find_asset(path, :base_path => Rails.application.root.to_s)
         end
       end
 
@@ -93,27 +222,43 @@ class WickedPdf
       end
 
       def precompiled_or_absolute_asset?(source)
-        Rails.configuration.assets.compile == false ||
+        !Rails.configuration.respond_to?(:assets) ||
+          Rails.configuration.assets.compile == false ||
           source.to_s[0] == '/' ||
           source.to_s.match(/\Ahttps?\:\/\//)
       end
 
       def read_asset(source)
-        if precompiled_or_absolute_asset?(source)
-          pathname = asset_pathname(source)
-          if pathname =~ URI_REGEXP
-            read_from_uri(pathname)
-          elsif File.file?(pathname)
-            IO.read(pathname)
-          end
-        else
-          find_asset(source).to_s
+        asset = find_asset(source)
+        return asset.to_s.force_encoding('UTF-8') if asset
+
+        unless precompiled_or_absolute_asset?(source)
+          raise MissingLocalAsset, source if WickedPdf.config[:raise_on_missing_assets]
+
+          return
+        end
+
+        pathname = asset_pathname(source)
+        if pathname =~ URI_REGEXP
+          read_from_uri(pathname)
+        elsif File.file?(pathname)
+          IO.read(pathname)
+        elsif WickedPdf.config[:raise_on_missing_assets]
+          raise MissingLocalAsset, pathname if WickedPdf.config[:raise_on_missing_assets]
         end
       end
 
       def read_from_uri(uri)
-        encoding = ':UTF-8' if RUBY_VERSION > '1.8'
-        asset = open(uri, "r#{encoding}", &:read)
+        response = Net::HTTP.get_response(URI(uri))
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise MissingRemoteAsset.new(uri, response) if WickedPdf.config[:raise_on_missing_assets]
+
+          return
+        end
+
+        asset = response.body
+        asset.force_encoding('UTF-8') if asset
         asset = gzip(asset) if WickedPdf.config[:expect_gzipped_remote_assets]
         asset
       end
@@ -125,6 +270,44 @@ class WickedPdf
       rescue Zlib::GzipFile::Error
         nil
       end
+
+      def webpacker_source_url(source)
+        return unless webpacker_version
+
+        # In Webpacker 3.2.0 asset_pack_url is introduced
+        if webpacker_version >= '3.2.0'
+          if (host = Rails.application.config.asset_host)
+            asset_pack_path(source, :host => host)
+          else
+            asset_pack_url(source)
+          end
+        else
+          source_path = asset_pack_path(source)
+          # Remove last slash from root path
+          root_url[0...-1] + source_path
+        end
+      end
+
+      def running_in_development?
+        return unless webpacker_version
+
+        # :dev_server method was added in webpacker 3.0.0
+        if Webpacker.respond_to?(:dev_server)
+          Webpacker.dev_server.running?
+        else
+          Rails.env.development? || Rails.env.test?
+        end
+      end
+
+      def webpacker_version
+        if defined?(Shakapacker)
+          require 'shakapacker/version'
+          Shakapacker::VERSION
+        elsif defined?(Webpacker)
+          require 'webpacker/version'
+          Webpacker::VERSION
+        end
+      end
     end
   end
 end

data/lib/wicked_pdf/wicked_pdf_helper.rb

@@ -23,8 +23,9 @@ class WickedPdf
 
     def wicked_pdf_javascript_src_tag(jsfile, options = {})
       jsfile = WickedPdfHelper.add_extension(jsfile, 'js')
+      type = ::Mime.respond_to?(:[]) ? ::Mime[:js] : ::Mime::JS # ::Mime[:js] cannot be used in Rails 2.3.
       src = "file:///#{WickedPdfHelper.root_path.join('public', 'javascripts', jsfile)}"
-      content_tag('script', '', { 'type' => Mime::JS, 'src' => path_to_javascript(src) }.merge(options))
+      content_tag('script', '', { 'type' => type, 'src' => path_to_javascript(src) }.merge(options))
     end
 
     def wicked_pdf_javascript_include_tag(*sources)

data/lib/wicked_pdf.rb

@@ -1,48 +1,52 @@
 # wkhtml2pdf Ruby interface
-# http://code.google.com/p/wkhtmltopdf/
+# http://wkhtmltopdf.org/
 
 require 'logger'
 require 'digest/md5'
 require 'rbconfig'
+require 'open3'
 
-if (RbConfig::CONFIG['target_os'] =~ /mswin|mingw/) && (RUBY_VERSION < '1.9')
-  require 'win32/open3'
-else
-  require 'open3'
-end
-
-begin
-  require 'active_support/core_ext/module/attribute_accessors'
-rescue LoadError
-  require 'active_support/core_ext/class/attribute_accessors'
-end
-
-begin
-  require 'active_support/core_ext/object/blank'
-rescue LoadError
-  require 'active_support/core_ext/blank'
-end
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/object/blank'
 
 require 'wicked_pdf/version'
 require 'wicked_pdf/railtie'
+require 'wicked_pdf/option_parser'
 require 'wicked_pdf/tempfile'
+require 'wicked_pdf/binary'
 require 'wicked_pdf/middleware'
+require 'wicked_pdf/progress'
 
 class WickedPdf
   DEFAULT_BINARY_VERSION = Gem::Version.new('0.9.9')
-  BINARY_VERSION_WITHOUT_DASHES = Gem::Version.new('0.12.0')
-  EXE_NAME = 'wkhtmltopdf'.freeze
   @@config = {}
-  cattr_accessor :config
-  attr_accessor :binary_version
+  cattr_accessor :config, :silence_deprecations
+
+  include Progress
+
+  def self.config=(config)
+    ::Kernel.warn 'WickedPdf.config= is deprecated and will be removed in future versions. Use WickedPdf.configure instead.' unless @@silence_deprecations
+
+    @@config = config
+  end
+
+  def self.configure
+    config = OpenStruct.new(@@config)
+    yield config
+
+    @@config.merge! config.to_h
+  end
+
+  def self.clear_config
+    @@config = {}
+  end
 
   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.exist?(@exe_path)
-    raise "#{EXE_NAME} is not executable" unless File.executable?(@exe_path)
+    @binary = Binary.new(wkhtmltopdf_binary_path, DEFAULT_BINARY_VERSION)
+  end
 
-    retrieve_binary_version
+  def binary_version
+    @binary.version
   end
 
   def pdf_from_html_file(filepath, options = {})
@@ -52,51 +56,58 @@ class WickedPdf
   def pdf_from_string(string, options = {})
     options = options.dup
     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
-
-    pdf = pdf_from_html_file(string_file.path, options)
-    pdf
+    string_file = WickedPdf::Tempfile.new('wicked_pdf.html', options[:temp_path])
+    string_file.write_in_chunks(string)
+    pdf_from_html_file(string_file.path, options)
   ensure
-    string_file.close! if string_file
+    if options[:delete_temporary_files] && string_file
+      string_file.close!
+    elsif string_file
+      string_file.close
+    end
   end
 
-  def pdf_from_url(url, options = {})
+  def pdf_from_url(url, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
     # 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)
+    generated_pdf_file = WickedPdf::Tempfile.new('wicked_pdf_generated_file.pdf', options[:temp_path])
+    command = [@binary.path]
+    command.unshift(@binary.xvfb_run_path) if options[:use_xvfb]
+    command += option_parser.parse(options)
     command << url
     command << generated_pdf_file.path.to_s
 
     print_command(command.inspect) if in_development_mode?
 
-    err = Open3.popen3(*command) do |_stdin, _stdout, stderr|
-      stderr.read
+    if track_progress?(options)
+      invoke_with_progress(command, options)
+    else
+      _out, err, status = Open3.capture3(*command)
+      err = [status.to_s, err].join("\n") if !err.empty? || !status.success?
     end
     if options[:return_file]
       return_file = options.delete(:return_file)
       return generated_pdf_file
     end
-    generated_pdf_file.rewind
-    generated_pdf_file.binmode
-    pdf = generated_pdf_file.read
+
+    pdf = generated_pdf_file.read_in_chunks
+
+    raise "Error generating PDF\n Command Error: #{err}" if options[:raise_on_all_errors] && !err.empty?
     raise "PDF could not be generated!\n Command Error: #{err}" if pdf && pdf.rstrip.empty?
+
     pdf
-  rescue => e
+  rescue StandardError => e
     raise "Failed to execute:\n#{command}\nError: #{e}"
   ensure
+    clean_temp_files
     generated_pdf_file.close! if generated_pdf_file && !return_file
   end
 
   private
 
   def in_development_mode?
-    return Rails.env == 'development' if defined?(Rails)
+    return Rails.env == 'development' if defined?(Rails.env)
+
     RAILS_ENV == 'development' if defined?(RAILS_ENV)
   end
 
@@ -105,238 +116,16 @@ class WickedPdf
   end
 
   def print_command(cmd)
-    p '*' * 15 + cmd + '*' * 15
-  end
-
-  def retrieve_binary_version
-    _stdin, stdout, _stderr = Open3.popen3(@exe_path + ' -V')
-    @binary_version = parse_version(stdout.gets(nil))
-  rescue
-    DEFAULT_BINARY_VERSION
-  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]
+    Rails.logger.debug '[wicked_pdf]: ' + cmd
   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 option_parser
+    @option_parser ||= OptionParser.new(binary_version)
   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
+  def clean_temp_files
+    return unless option_parser.hf_tempfiles.present?
 
-  def valid_option(name)
-    if binary_version < BINARY_VERSION_WITHOUT_DASHES
-      "--#{name}"
-    else
-      name
-    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}",
-                    options[o],
-                    type)
-      end
-    end
-  end
-
-  def parse_header_footer(options)
-    r = []
-    [: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 = 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}-html", opt_hf[:html][:url]) unless opt_hf[:html][:url].blank?
-      end
-    end unless options.blank?
-    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')
-      [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_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_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,
-                                  :no_stop_slow_scripts], '', :boolean)
-    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
-      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 || ''
+    option_parser.hf_tempfiles.each { |file| File.delete(file) }
   end
 end

data/test/fixtures/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"
+  timeout: 500