wicked_pdf 1.1.0 → 2.1.0

data/lib/wicked_pdf/middleware.rb

@@ -80,7 +80,7 @@ class WickedPdf
 
     def set_request_to_render_as_pdf(env)
       @render_pdf = true
-      %w(PATH_INFO REQUEST_URI).each { |e| env[e] = env[e].sub(%r{\.pdf\b}, '') }
+      %w[PATH_INFO REQUEST_URI].each { |e| env[e] = env[e].sub(%r{\.pdf\b}, '') }
       env['HTTP_ACCEPT'] = concat(env['HTTP_ACCEPT'], Rack::Mime.mime_type('.html'))
       env['Rack-Middleware-WickedPdf'] = 'true'
     end

data/lib/wicked_pdf/pdf_helper.rb

@@ -8,7 +8,11 @@ class WickedPdf
       base.class_eval do
         alias_method_chain :render, :wicked_pdf
         alias_method_chain :render_to_string, :wicked_pdf
-        after_filter :clean_temp_files
+        if respond_to?(:after_action)
+          after_action :clean_temp_files
+        else
+          after_filter :clean_temp_files
+        end
       end
     end
 
@@ -19,47 +23,46 @@ class WickedPdf
 
       base.class_eval do
         after_action :clean_temp_files
+      end
+    end
 
-        alias_method :render_without_wicked_pdf, :render
-        alias_method :render_to_string_without_wicked_pdf, :render_to_string
-
-        def render(options = nil, *args, &block)
-          render_with_wicked_pdf(options, *args, &block)
-        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
-      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)
       if options.is_a?(Hash) && options.key?(:pdf)
-        log_pdf_creation
         options[:basic_auth] = set_basic_auth(options)
         make_and_send_pdf(options.delete(:pdf), (WickedPdf.config || {}).merge(options))
-      else
+      elsif respond_to?(:render_without_wicked_pdf)
+        # support alias_method_chain (module included)
         render_without_wicked_pdf(options, *args, &block)
+      else
+        # support inheritance (module prepended)
+        method(:render).super_method.call(options, *args, &block)
       end
     end
 
     def render_to_string_with_wicked_pdf(options = nil, *args, &block)
       if options.is_a?(Hash) && options.key?(:pdf)
-        log_pdf_creation
         options[:basic_auth] = set_basic_auth(options)
         options.delete :pdf
         make_pdf((WickedPdf.config || {}).merge(options))
-      else
+      elsif respond_to?(:render_to_string_without_wicked_pdf)
+        # support alias_method_chain (module included)
         render_to_string_without_wicked_pdf(options, *args, &block)
+      else
+        # support inheritance (module prepended)
+        method(:render_to_string).super_method.call(options, *args, &block)
       end
     end
 
     private
 
-    def log_pdf_creation
-      logger.info '*' * 15 + 'WICKED' + '*' * 15 if logger && logger.respond_to?(:info)
-    end
-
     def set_basic_auth(options = {})
       options[:basic_auth] ||= WickedPdf.config.fetch(:basic_auth) { false }
       return unless options[:basic_auth] && request.env['HTTP_AUTHORIZATION']
@@ -76,8 +79,10 @@ class WickedPdf
         :template => options[:template],
         :layout => options[:layout],
         :formats => options[:formats],
-        :handlers => options[:handlers]
+        :handlers => options[:handlers],
+        :assigns => options[:assigns]
       }
+      render_opts[:inline] = options[:inline] if options[:inline]
       render_opts[:locals] = options[:locals] if options[:locals]
       render_opts[:file] = options[:file] if options[:file]
       html_string = render_to_string(render_opts)
@@ -97,8 +102,10 @@ class WickedPdf
           :layout => options[:layout],
           :formats => options[:formats],
           :handlers => options[:handlers],
+          :assigns => options[:assigns],
           :content_type => 'text/html'
         }
+        render_opts[:inline] = options[:inline] if options[:inline]
         render_opts[:locals] = options[:locals] if options[:locals]
         render_opts[:file] = options[:file] if options[:file]
         render(render_opts)
@@ -121,7 +128,8 @@ class WickedPdf
           :template => options[hf][:html][:template],
           :layout => options[hf][:html][:layout],
           :formats => options[hf][:html][:formats],
-          :handlers => options[hf][:html][:handlers]
+          :handlers => options[hf][:html][:handlers],
+          :assigns => options[hf][:html][:assigns]
         }
         render_opts[:locals] = options[hf][:html][:locals] if options[hf][:html][:locals]
         render_opts[:file] = options[hf][:html][:file] if options[:file]

data/lib/wicked_pdf/progress.rb

@@ -0,0 +1,33 @@
+class WickedPdf
+  module Progress
+    require 'pty' if RbConfig::CONFIG['target_os'] !~ /mswin|mingw/ # no support for windows
+    require 'English'
+
+    def track_progress?(options)
+      options[:progress] && !on_windows?
+    end
+
+    def invoke_with_progress(command, options)
+      output = []
+      begin
+        PTY.spawn(command.join(' ')) do |stdout, _stdin, pid|
+          begin
+            stdout.sync
+            stdout.each_line("\r") do |line|
+              output << line.chomp
+              options[:progress].call(line) if options[:progress]
+            end
+          rescue Errno::EIO # rubocop:disable Lint/HandleExceptions
+            # child process is terminated, this is expected behaviour
+          ensure
+            ::Process.wait pid
+          end
+        end
+      rescue PTY::ChildExited
+        puts 'The child process exited!'
+      end
+      err = output.join('\n')
+      raise "#{command} failed (exitstatus 0). Output was: #{err}" unless $CHILD_STATUS && $CHILD_STATUS.exitstatus.zero?
+    end
+  end
+end

data/lib/wicked_pdf/railtie.rb

@@ -3,48 +3,19 @@ require 'wicked_pdf/wicked_pdf_helper'
 require 'wicked_pdf/wicked_pdf_helper/assets'
 
 class WickedPdf
-  if defined?(Rails)
-
-    if Rails::VERSION::MAJOR >= 5
-
-      class WickedRailtie < Rails::Railtie
-        initializer 'wicked_pdf.register' do |_app|
-          ActionController::Base.send :prepend, PdfHelper
-          ActionView::Base.send :include, WickedPdfHelper::Assets
-        end
-      end
-
-    elsif Rails::VERSION::MAJOR == 4
-
-      class WickedRailtie < Rails::Railtie
-        initializer 'wicked_pdf.register' do |_app|
-          ActionController::Base.send :include, PdfHelper
-          ActionView::Base.send :include, WickedPdfHelper::Assets
-        end
-      end
-
-    elsif Rails::VERSION::MAJOR == 3
-
-      class WickedRailtie < Rails::Railtie
-        initializer 'wicked_pdf.register' do |_app|
-          ActionController::Base.send :include, PdfHelper
-          if Rails::VERSION::MINOR > 0 && Rails.configuration.assets.enabled
-            ActionView::Base.send :include, WickedPdfHelper::Assets
+  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
-            ActionView::Base.send :include, WickedPdfHelper
+            ActionController::Base.send :include, PdfHelper
           end
+          ActionView::Base.send :include, WickedPdfHelper::Assets
         end
       end
-
-    elsif Rails::VERSION::MAJOR == 2
-
-      unless ActionController::Base.instance_methods.include? 'render_with_wicked_pdf'
-        ActionController::Base.send :include, PdfHelper
-      end
-      unless ActionView::Base.instance_methods.include? 'wicked_pdf_stylesheet_link_tag'
-        ActionView::Base.send :include, WickedPdfHelper
-      end
-
     end
 
     if Mime::Type.lookup_by_extension(:pdf).nil?

data/lib/wicked_pdf/version.rb

@@ -1,3 +1,3 @@
 class WickedPdf
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.1.0'.freeze
 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/wicked_pdf_helper/assets.rb

@@ -1,4 +1,6 @@
-require 'open-uri'
+require 'net/http'
+# If webpacker is used, need to check for version
+require 'webpacker/version' if defined?(Webpacker)
 
 class WickedPdf
   module WickedPdfHelper
@@ -27,6 +29,32 @@ 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 +79,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 +106,20 @@ 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)
         else
-          Sprockets::Railtie.build_environment(Rails.application).find_asset(path)
+          Sprockets::Railtie.build_environment(Rails.application).find_asset(path, :base_path => Rails.application.root.to_s)
         end
       end
 
@@ -93,7 +136,8 @@ 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
@@ -112,8 +156,8 @@ class WickedPdf
       end
 
       def read_from_uri(uri)
-        encoding = ':UTF-8' if RUBY_VERSION > '1.8'
-        asset = open(uri, "r#{encoding}", &:read)
+        asset = Net::HTTP.get(URI(uri))
+        asset.force_encoding('UTF-8') if asset
         asset = gzip(asset) if WickedPdf.config[:expect_gzipped_remote_assets]
         asset
       end
@@ -125,6 +169,28 @@ class WickedPdf
       rescue Zlib::GzipFile::Error
         nil
       end
+
+      def webpacker_source_url(source)
+        return unless defined?(Webpacker) && defined?(Webpacker::VERSION)
+        # In Webpacker 3.2.0 asset_pack_url is introduced
+        if Webpacker::VERSION >= '3.2.0'
+          asset_pack_url(source)
+        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 defined?(Webpacker)
+        # :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
     end
   end
 end

data/test/fixtures/database.yml

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

data/test/fixtures/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link wicked.js
+//= link wicked.css

data/test/functional/pdf_helper_test.rb

@@ -5,10 +5,32 @@ module ActionController
     def render_to_string(opts = {})
       opts.to_s
     end
+
+    def self.alias_method_chain(_target, _feature); end
+  end
+end
+
+module ActionControllerMock
+  class Base
+    def render(_)
+      [:base]
+    end
+
+    def render_to_string; end
+
+    def self.after_action(_); end
   end
 end
 
 class PdfHelperTest < ActionController::TestCase
+  module SomePatch
+    def render(_)
+      super.tap do |s|
+        s << :patched
+      end
+    end
+  end
+
   def setup
     @ac = ActionController::Base.new
   end
@@ -22,4 +44,53 @@ class PdfHelperTest < ActionController::TestCase
                        :header => { :html => { :template => 'hf.html.erb' } })
     assert_match %r{^file:\/\/\/.*wicked_header_pdf.*\.html}, options[:header][:html][:url]
   end
+
+  test 'should not interfere with already prepended patches' do
+    # Emulate railtie
+    if Rails::VERSION::MAJOR >= 5
+      # this spec tests the following:
+      # if another gem prepends a render method to ActionController::Base
+      # before wicked_pdf does, does calling render trigger an infinite loop?
+      # this spec fails with 6392bea1fe3a41682dfd7c20fd9c179b5a758f59 because PdfHelper
+      # aliases the render method prepended by the other gem to render_without_pdf, then
+      # base_evals its own definition of render, which calls render_with_pdf -> render_without_pdf.
+      # If the other gem uses the prepend inhertinance pattern (calling super instead of aliasing),
+      # when it calls super it calls the base_eval'd version of render instead of going up the
+      # inheritance chain, causing an infinite loop.
+
+      # This fiddling with consts is required to get around the fact that PdfHelper checks
+      # that it is being prepended to ActionController::Base
+      OriginalBase = ActionController::Base
+      ActionController.send(:remove_const, :Base)
+      ActionController.const_set(:Base, ActionControllerMock::Base)
+
+      # Emulate another gem being loaded before wicked
+      ActionController::Base.prepend(SomePatch)
+      ActionController::Base.prepend(::WickedPdf::PdfHelper)
+
+      begin
+        # test that wicked's render method is actually called
+        ac = ActionController::Base.new
+        ac.expects(:render_with_wicked_pdf)
+        ac.render(:cats)
+
+        # test that calling render does not trigger infinite loop
+        ac = ActionController::Base.new
+        assert_equal [:base, :patched], ac.render(:cats)
+      rescue SystemStackError
+        assert_equal true, false # force spec failure
+      ensure
+        ActionController.send(:remove_const, :Base)
+        ActionController.const_set(:Base, OriginalBase)
+      end
+    end
+  end
+
+  test 'should call after_action instead of after_filter when able' do
+    ActionController::Base.expects(:after_filter).with(:clean_temp_files).never
+    ActionController::Base.expects(:after_action).with(:clean_temp_files).once
+    ActionController::Base.class_eval do
+      include ::WickedPdf::PdfHelper
+    end
+  end
 end