wicked_pdf 2.1.0 → 2.6.0

data/lib/wicked_pdf/option_parser.rb

@@ -0,0 +1,229 @@
+class WickedPdf
+  class OptionParser
+    BINARY_VERSION_WITHOUT_DASHES = Gem::Version.new('0.12.0')
+
+    attr_reader :binary_version
+
+    def initialize(binary_version = WickedPdf::DEFAULT_BINARY_VERSION)
+      @binary_version = binary_version
+    end
+
+    def parse(options)
+      [
+        parse_extra(options),
+        parse_others(options),
+        parse_global(options),
+        parse_outline(options.delete(:outline)),
+        parse_header_footer(:header => options.delete(:header),
+                            :footer => options.delete(:footer),
+                            :layout => options[:layout]),
+        parse_cover(options.delete(:cover)),
+        parse_toc(options.delete(:toc)),
+        parse_basic_auth(options)
+      ].flatten
+    end
+
+    def valid_option(name)
+      if binary_version < BINARY_VERSION_WITHOUT_DASHES
+        "--#{name}"
+      else
+        name
+      end
+    end
+
+    private
+
+    def parse_extra(options)
+      return [] if options[:extra].nil?
+      return options[:extra].split if options[:extra].respond_to?(:split)
+
+      options[:extra]
+    end
+
+    def parse_basic_auth(options)
+      if options[:basic_auth]
+        user, passwd = Base64.decode64(options[:basic_auth]).split(':')
+        ['--username', user, '--password', passwd]
+      else
+        []
+      end
+    end
+
+    def parse_header_footer(options)
+      r = []
+      unless options.blank?
+        %i[header footer].collect do |hf|
+          next if options[hf].blank?
+
+          opt_hf = options[hf]
+          r += make_options(opt_hf, %i[center font_name left right], hf.to_s)
+          r += make_options(opt_hf, %i[font_size spacing], hf.to_s, :numeric)
+          r += make_options(opt_hf, [:line], hf.to_s, :boolean)
+          if options[hf] && options[hf][:content]
+            @hf_tempfiles = [] unless defined?(@hf_tempfiles)
+            @hf_tempfiles.push(tf = WickedPdf::Tempfile.new("wicked_#{hf}_pdf.html"))
+            tf.write options[hf][:content]
+            tf.flush
+            options[hf][:html] = {}
+            options[hf][:html][:url] = "file:///#{tf.path}"
+          end
+          unless opt_hf[:html].blank?
+            r += make_option("#{hf}-html", opt_hf[:html][:url]) unless opt_hf[:html][:url].blank?
+          end
+        end
+      end
+      r
+    end
+
+    def parse_cover(argument)
+      arg = argument.to_s
+      return [] if arg.blank?
+
+      # Filesystem path or URL - hand off to wkhtmltopdf
+      if argument.is_a?(Pathname) || (arg[0, 4] == 'http')
+        [valid_option('cover'), arg]
+      else # HTML content
+        @hf_tempfiles ||= []
+        @hf_tempfiles << tf = WickedPdf::Tempfile.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, %i[font_name header_text], 'toc')
+        r += make_options(options, [:xsl_style_sheet])
+        r += make_options(options, %i[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, %i[no_dots
+                                      disable_links
+                                      disable_back_links], 'toc', :boolean)
+        r += make_options(options, %i[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, %i[top bottom left right], 'margin', :numeric)
+    end
+
+    def parse_global(options)
+      r = []
+      unless options.blank?
+        r += make_options(options, %i[orientation
+                                      dpi
+                                      page_size
+                                      page_width
+                                      title
+                                      log_level])
+        r += make_options(options, %i[lowquality
+                                      grayscale
+                                      no_pdf_compression
+                                      quiet], '', :boolean)
+        r += make_options(options, %i[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, %i[proxy
+                                      username
+                                      password
+                                      encoding
+                                      user_style_sheet
+                                      viewport_size
+                                      window_status])
+        r += make_options(options, %i[cookie
+                                      post], '', :name_value)
+        r += make_options(options, %i[redirect_delay
+                                      zoom
+                                      page_offset
+                                      javascript_delay], '', :numeric)
+        r += make_options(options, %i[book
+                                      default_header
+                                      disable_javascript
+                                      enable_plugins
+                                      disable_internal_links
+                                      disable_external_links
+                                      keep_relative_links
+                                      print_media_type
+                                      disable_local_file_access
+                                      enable_local_file_access
+                                      disable_smart_shrinking
+                                      use_xserver
+                                      no_background
+                                      images
+                                      no_images
+                                      no_stop_slow_scripts], '', :boolean)
+      end
+      r
+    end
+
+    def make_options(options, names, prefix = '', type = :string)
+      return [] if options.nil?
+
+      names.collect do |o|
+        if options[o].blank?
+          []
+        else
+          make_option("#{prefix.blank? ? '' : prefix + '-'}#{o}",
+                      options[o],
+                      type)
+        end
+      end
+    end
+
+    def make_option(name, value, type = :string)
+      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]
+      elsif type == :boolean
+        if value
+          ["--#{name.tr('_', '-')}"]
+        else
+          []
+        end
+      else
+        ["--#{name.tr('_', '-')}", value.to_s]
+      end
+    end
+  end
+end

data/lib/wicked_pdf/pdf_helper.rb

@@ -1,21 +1,5 @@
 class WickedPdf
   module PdfHelper
-    def self.included(base)
-      # Protect from trying to augment modules that appear
-      # as the result of adding other gems.
-      return if base != ActionController::Base
-
-      base.class_eval do
-        alias_method_chain :render, :wicked_pdf
-        alias_method_chain :render_to_string, :wicked_pdf
-        if respond_to?(:after_action)
-          after_action :clean_temp_files
-        else
-          after_filter :clean_temp_files
-        end
-      end
-    end
-
     def self.prepended(base)
       # Protect from trying to augment modules that appear
       # as the result of adding other gems.
@@ -26,52 +10,52 @@ class WickedPdf
       end
     end
 
-    def render(options = nil, *args, &block)
-      render_with_wicked_pdf(options, *args, &block)
-    end
-
-    def render_to_string(options = nil, *args, &block)
-      render_to_string_with_wicked_pdf(options, *args, &block)
-    end
-
-    def render_with_wicked_pdf(options = nil, *args, &block)
+    def render(*args)
+      options = args.first
       if options.is_a?(Hash) && options.key?(:pdf)
-        options[:basic_auth] = set_basic_auth(options)
-        make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
-      elsif respond_to?(:render_without_wicked_pdf)
-        # support alias_method_chain (module included)
-        render_without_wicked_pdf(options, *args, &block)
+        render_with_wicked_pdf(options)
       else
-        # support inheritance (module prepended)
-        method(:render).super_method.call(options, *args, &block)
+        super
       end
     end
 
-    def render_to_string_with_wicked_pdf(options = nil, *args, &block)
+    def render_to_string(*args)
+      options = args.first
       if options.is_a?(Hash) && options.key?(:pdf)
-        options[:basic_auth] = set_basic_auth(options)
-        options.delete :pdf
-        make_pdf((WickedPdf.config || {}).merge(options))
-      elsif respond_to?(:render_to_string_without_wicked_pdf)
-        # support alias_method_chain (module included)
-        render_to_string_without_wicked_pdf(options, *args, &block)
+        render_to_string_with_wicked_pdf(options, *args, &block)
       else
-        # support inheritance (module prepended)
-        method(:render_to_string).super_method.call(options, *args, &block)
+        super
       end
     end
 
+    def render_with_wicked_pdf(options)
+      raise ArgumentError, 'missing keyword: pdf' unless options.is_a?(Hash) && options.key?(:pdf)
+
+      options[:basic_auth] = set_basic_auth(options)
+      make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
+    end
+
+    def render_to_string_with_wicked_pdf(options)
+      raise ArgumentError, 'missing keyword: pdf' unless options.is_a?(Hash) && options.key?(:pdf)
+
+      options[:basic_auth] = set_basic_auth(options)
+      options.delete :pdf
+      make_pdf((WickedPdf.config || {}).merge(options))
+    end
+
     private
 
     def set_basic_auth(options = {})
       options[:basic_auth] ||= WickedPdf.config.fetch(:basic_auth) { false }
       return unless options[:basic_auth] && request.env['HTTP_AUTHORIZATION']
+
       request.env['HTTP_AUTHORIZATION'].split(' ').last
     end
 
     def clean_temp_files
       return unless defined?(@hf_tempfiles)
-      @hf_tempfiles.each(&:close!)
+
+      @hf_tempfiles.each(&:close)
     end
 
     def make_pdf(options = {})
@@ -119,10 +103,11 @@ class WickedPdf
     # Given an options hash, prerenders content for the header and footer sections
     # to temp files and return a new options hash including the URLs to these files.
     def prerender_header_and_footer(options)
-      [:header, :footer].each do |hf|
+      %i[header footer].each do |hf|
         next unless options[hf] && options[hf][:html] && options[hf][:html][:template]
+
         @hf_tempfiles = [] unless defined?(@hf_tempfiles)
-        @hf_tempfiles.push(tf = WickedPdfTempfile.new("wicked_#{hf}_pdf.html"))
+        @hf_tempfiles.push(tf = WickedPdf::Tempfile.new("wicked_#{hf}_pdf.html"))
         options[hf][:html][:layout] ||= options[:layout]
         render_opts = {
           :template => options[hf][:html][:template],

data/lib/wicked_pdf/railtie.rb

@@ -6,21 +6,12 @@ class WickedPdf
   if defined?(Rails.env)
     class WickedRailtie < Rails::Railtie
       initializer 'wicked_pdf.register', :after => 'remotipart.controller_helper' do |_app|
-        ActiveSupport.on_load(:action_controller) do
-          if ActionController::Base.respond_to?(:prepend) &&
-             Object.method(:new).respond_to?(:super_method)
-            ActionController::Base.send :prepend, PdfHelper
-          else
-            ActionController::Base.send :include, PdfHelper
-          end
-          ActionView::Base.send :include, WickedPdfHelper::Assets
-        end
+        ActiveSupport.on_load(:action_controller) { ActionController::Base.send :prepend, PdfHelper }
+        ActiveSupport.on_load(:action_view) { include WickedPdfHelper::Assets }
       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?
 
   end
 end

data/lib/wicked_pdf/tempfile.rb

@@ -1,13 +1,42 @@
 require 'tempfile'
 
 class WickedPdf
-  class WickedPdfTempfile < Tempfile
-    # ensures the Tempfile's filename always keeps its extension
+  class Tempfile < ::Tempfile
     def initialize(filename, temp_dir = nil)
       temp_dir ||= Dir.tmpdir
       extension = File.extname(filename)
-      basename  = File.basename(filename, extension)
+      basename = File.basename(filename, extension)
       super([basename, extension], temp_dir)
     end
+
+    def write_in_chunks(input_string)
+      binmode
+      string_io = StringIO.new(input_string)
+      write(string_io.read(chunk_size)) until string_io.eof?
+      close
+      self
+    rescue Errno::EINVAL => e
+      raise e, file_too_large_message
+    end
+
+    def read_in_chunks
+      rewind
+      binmode
+      output_string = ''
+      output_string << read(chunk_size) until eof?
+      output_string
+    rescue Errno::EINVAL => e
+      raise e, file_too_large_message
+    end
+
+    private
+
+    def chunk_size
+      1024 * 1024
+    end
+
+    def file_too_large_message
+      'The HTML file is too large! Try reducing the size or using the return_file option instead.'
+    end
   end
 end

data/lib/wicked_pdf/version.rb

@@ -1,3 +1,3 @@
 class WickedPdf
-  VERSION = '2.1.0'.freeze
+  VERSION = '2.6.0'.freeze
 end

data/lib/wicked_pdf/wicked_pdf_helper/assets.rb

@@ -1,19 +1,46 @@
 require 'net/http'
-# If webpacker is used, need to check for version
-require 'webpacker/version' if defined?(Webpacker)
 
 class WickedPdf
   module WickedPdfHelper
     module Assets
       ASSET_URL_REGEX = /url\(['"]?([^'"]+?)['"]?\)/
 
+      class PropshaftAsset < SimpleDelegator
+        def content_type
+          super.to_s
+        end
+
+        def to_s
+          content
+        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?
+
         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')
@@ -31,6 +58,7 @@ class WickedPdf
 
       def wicked_pdf_stylesheet_pack_tag(*sources)
         return unless defined?(Webpacker)
+
         if running_in_development?
           stylesheet_pack_tag(*sources)
         else
@@ -118,6 +146,8 @@ class WickedPdf
       def find_asset(path)
         if Rails.application.assets.respond_to?(:find_asset)
           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))
         else
           Sprockets::Railtie.build_environment(Rails.application).find_asset(path, :base_path => Rails.application.root.to_s)
         end
@@ -171,10 +201,15 @@ class WickedPdf
       end
 
       def webpacker_source_url(source)
-        return unless defined?(Webpacker) && defined?(Webpacker::VERSION)
+        return unless webpacker_version
+
         # In Webpacker 3.2.0 asset_pack_url is introduced
-        if Webpacker::VERSION >= '3.2.0'
-          asset_pack_url(source)
+        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
@@ -183,7 +218,8 @@ class WickedPdf
       end
 
       def running_in_development?
-        return unless defined?(Webpacker)
+        return unless webpacker_version
+
         # :dev_server method was added in webpacker 3.0.0
         if Webpacker.respond_to?(:dev_server)
           Webpacker.dev_server.running?
@@ -191,6 +227,15 @@ class WickedPdf
           Rails.env.development? || Rails.env.test?
         end
       end
+
+      def webpacker_version
+        return unless defined?(Webpacker)
+
+        # If webpacker is used, need to check for version
+        require 'webpacker/version'
+
+        Webpacker::VERSION
+      end
     end
   end
 end