wicked_pdf 1.0.3 → 2.6.3

data/lib/wicked_pdf.rb

@@ -1,47 +1,35 @@
 # 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'
   @@config = {}
   cattr_accessor :config
 
+  include Progress
+
   def initialize(wkhtmltopdf_binary_path = nil)
-    @exe_path = wkhtmltopdf_binary_path || find_wkhtmltopdf_binary_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 = Binary.new(wkhtmltopdf_binary_path, DEFAULT_BINARY_VERSION)
+  end
 
-    retreive_binary_version
+  def binary_version
+    @binary.version
   end
 
   def pdf_from_html_file(filepath, options = {})
@@ -51,44 +39,44 @@ 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
-  rescue => e
-    raise "Error: #{e}"
+    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
+    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
+    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 += parse_options(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
+      err = Open3.popen3(*command) do |_stdin, _stdout, stderr|
+        stderr.read
+      end
     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
-    fail "PDF could not be generated!\n Command Error: #{err}" if pdf && pdf.rstrip.length == 0
+
+    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
     generated_pdf_file.close! if generated_pdf_file && !return_file
@@ -97,12 +85,9 @@ class WickedPdf
   private
 
   def in_development_mode?
-    return Rails.env == 'development' if defined?(Rails)
-    RAILS_ENV == 'development' if defined?(RAILS_ENV)
-  end
+    return Rails.env == 'development' if defined?(Rails.env)
 
-  def get_binary_version
-    @binary_version
+    RAILS_ENV == 'development' if defined?(RAILS_ENV)
   end
 
   def on_windows?
@@ -110,232 +95,10 @@ class WickedPdf
   end
 
   def print_command(cmd)
-    p '*' * 15 + cmd + '*' * 15
-  end
-
-  def retreive_binary_version
-    _stdin, stdout, _stderr = Open3.popen3(@exe_path + ' -V')
-    @binary_version = parse_version(stdout.gets(nil))
-  rescue StandardError
-  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
+    Rails.logger.debug '[wicked_pdf]: ' + cmd
   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_basic_auth(options)
-    if options[:basic_auth]
-      user, passwd = Base64.decode64(options[:basic_auth]).split(':')
-      ['--username', user, '--password', passwd]
-    else
-      []
-    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 == :name_value
-      parts = value.to_s.split(' ')
-      ["--#{name.tr('_', '-')}", *parts]
-    elsif type == :boolean
-      ["--#{name.tr('_', '-')}"]
-    else
-      ["--#{name.tr('_', '-')}", value.to_s]
-    end
-  end
-
-  def valid_option(name)
-    if get_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}")
-      r += make_options(opt_hf, [:font_size, :spacing], "#{hf}", :numeric)
-      r += make_options(opt_hf, [:line], "#{hf}", :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])
-      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
-      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 || ''
+    OptionParser.new(binary_version).parse(options)
   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/fixtures/wicked.js

@@ -0,0 +1 @@
+// Wicked js

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
@@ -17,11 +39,58 @@ class PdfHelperTest < ActionController::TestCase
     @ac = nil
   end
 
-  if Rails::VERSION::MAJOR == 2
-    test 'should prerender header and footer :template options' do
-      options = @ac.send(:prerender_header_and_footer,
-                         :header => { :html => { :template => 'hf.html.erb' } })
-      assert_match /^file:\/\/\/.*wicked_header_pdf.*\.html/, options[:header][:html][:url]
+  test 'should prerender header and footer :template options' do
+    options = @ac.send(:prerender_header_and_footer,
+                       :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 %i[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

data/test/functional/wicked_pdf_helper_assets_test.rb

@@ -2,14 +2,29 @@ require 'test_helper'
 require 'action_view/test_case'
 
 class WickedPdfHelperAssetsTest < ActionView::TestCase
-  include WickedPdfHelper::Assets
+  include WickedPdf::WickedPdfHelper::Assets
 
   if Rails::VERSION::MAJOR > 3 || (Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR > 0)
     test 'wicked_pdf_asset_base64 returns a base64 encoded asset' do
-      source = File.new('test/fixtures/wicked.css', 'r')
-      destination = Rails.root.join('app', 'assets', 'stylesheets', 'wicked.css')
-      File.open(destination, 'w') { |f| f.write(source) }
-      assert_match /data:text\/css;base64,.+/, wicked_pdf_asset_base64('wicked.css')
+      assert_match %r{data:text\/css;base64,.+}, wicked_pdf_asset_base64('wicked.css')
+    end
+
+    test 'wicked_pdf_stylesheet_link_tag should inline the stylesheets passed in' do
+      Rails.configuration.assets.expects(:compile => true)
+      assert_equal "<style type='text/css'>/* Wicked styles */\n\n</style>",
+                   wicked_pdf_stylesheet_link_tag('wicked')
+    end
+
+    test 'wicked_pdf_image_tag should return the same as image_tag when passed a full path' do
+      Rails.configuration.assets.expects(:compile => true)
+      assert_equal image_tag("file:///#{Rails.root.join('public', 'pdf')}"),
+                   wicked_pdf_image_tag('pdf')
+    end
+
+    test 'wicked_pdf_javascript_include_tag should inline the javascripts passed in' do
+      Rails.configuration.assets.expects(:compile => true)
+      assert_equal "<script type='text/javascript'>// Wicked js\n;\n</script>",
+                   wicked_pdf_javascript_include_tag('wicked')
     end
 
     test 'wicked_pdf_asset_path should return a url when assets are served by an asset server' do
@@ -18,45 +33,91 @@ class WickedPdfHelperAssetsTest < ActionView::TestCase
     end
 
     test 'wicked_pdf_asset_path should return a url when assets are served by an asset server using HTTPS' do
-      expects(:asset_path => 'https://assets.domain.com/dummy.png', 'precompiled_asset?' => true)
+      Rails.configuration.assets.expects(:compile => false)
+      expects(:asset_path => 'https://assets.domain.com/dummy.png')
       assert_equal 'https://assets.domain.com/dummy.png', wicked_pdf_asset_path('dummy.png')
     end
 
     test 'wicked_pdf_asset_path should return a url with a protocol when assets are served by an asset server with relative urls' do
+      Rails.configuration.assets.expects(:compile => false)
       expects(:asset_path => '//assets.domain.com/dummy.png')
-      expects('precompiled_asset?' => true)
       assert_equal 'http://assets.domain.com/dummy.png', wicked_pdf_asset_path('dummy.png')
     end
 
     test 'wicked_pdf_asset_path should return a url with a protocol when assets are served by an asset server with no protocol set' do
+      Rails.configuration.assets.expects(:compile => false)
       expects(:asset_path => 'assets.domain.com/dummy.png')
-      expects('precompiled_asset?' => true)
       assert_equal 'http://assets.domain.com/dummy.png', wicked_pdf_asset_path('dummy.png')
     end
 
-    test 'wicked_pdf_asset_path should return a path when assets are precompiled' do
-      expects('precompiled_asset?' => false)
+    test 'wicked_pdf_asset_path should return a path' do
+      Rails.configuration.assets.expects(:compile => true)
       path = wicked_pdf_asset_path('application.css')
 
-      assert path.include?('/assets/stylesheets/application.css')
+      assert path.include?('/app/assets/stylesheets/application.css')
+      assert path.include?('file:///')
+
+      Rails.configuration.assets.expects(:compile => false)
+      expects(:asset_path => '/assets/application-6fba03f13d6ff1553477dba03475c4b9b02542e9fb8913bd63c258f4de5b48d9.css')
+      path = wicked_pdf_asset_path('application.css')
+
+      assert path.include?('/public/assets/application-6fba03f13d6ff1553477dba03475c4b9b02542e9fb8913bd63c258f4de5b48d9.css')
       assert path.include?('file:///')
     end
 
+    # This assets does not exists so probably it doesn't matter what is
+    # returned, but lets ensure that returned value is the same when assets
+    # are precompiled and when they are not
+    test 'wicked_pdf_asset_path should return a path when asset does not exist' do
+      Rails.configuration.assets.expects(:compile => true)
+      path = wicked_pdf_asset_path('missing.png')
+
+      assert path.include?('/public/missing.png')
+      assert path.include?('file:///')
+
+      Rails.configuration.assets.expects(:compile => false)
+      expects(:asset_path => '/missing.png')
+      path = wicked_pdf_asset_path('missing.png')
+
+      assert path.include?('/public/missing.png')
+      assert path.include?('file:///')
+    end
+
+    test 'wicked_pdf_asset_path should return a url when asset is url' do
+      Rails.configuration.assets.expects(:compile => true)
+      expects(:asset_path => 'http://example.com/rails.png')
+      assert_equal 'http://example.com/rails.png', wicked_pdf_asset_path('http://example.com/rails.png')
+
+      Rails.configuration.assets.expects(:compile => false)
+      expects(:asset_path => 'http://example.com/rails.png')
+      assert_equal 'http://example.com/rails.png', wicked_pdf_asset_path('http://example.com/rails.png')
+    end
+
+    test 'wicked_pdf_asset_path should return a url when asset is url without protocol' do
+      Rails.configuration.assets.expects(:compile => true)
+      expects(:asset_path => '//example.com/rails.png')
+      assert_equal 'http://example.com/rails.png', wicked_pdf_asset_path('//example.com/rails.png')
+
+      Rails.configuration.assets.expects(:compile => false)
+      expects(:asset_path => '//example.com/rails.png')
+      assert_equal 'http://example.com/rails.png', wicked_pdf_asset_path('//example.com/rails.png')
+    end
+
     test 'WickedPdfHelper::Assets::ASSET_URL_REGEX should match various URL data type formats' do
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(\'/asset/stylesheets/application.css\');'
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url("/asset/stylesheets/application.css");'
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(/asset/stylesheets/application.css);'
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(\'http://assets.domain.com/dummy.png\');'
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url("http://assets.domain.com/dummy.png");'
-      assert_match WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(http://assets.domain.com/dummy.png);'
-      assert_no_match WickedPdfHelper::Assets::ASSET_URL_REGEX, '.url { \'http://assets.domain.com/dummy.png\' }'
-    end
-
-    test 'set_protocol should properly set the protocol when the asset is precompiled' do
-      assert_equal 'http://assets.domain.com/dummy.png', set_protocol('//assets.domain.com/dummy.png')
-      assert_equal '/assets.domain.com/dummy.png', set_protocol('/assets.domain.com/dummy.png')
-      assert_equal 'http://assets.domain.com/dummy.png', set_protocol('http://assets.domain.com/dummy.png')
-      assert_equal 'https://assets.domain.com/dummy.png', set_protocol('https://assets.domain.com/dummy.png')
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(\'/asset/stylesheets/application.css\');'
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url("/asset/stylesheets/application.css");'
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(/asset/stylesheets/application.css);'
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(\'http://assets.domain.com/dummy.png\');'
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url("http://assets.domain.com/dummy.png");'
+      assert_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, 'url(http://assets.domain.com/dummy.png);'
+      assert_no_match WickedPdf::WickedPdfHelper::Assets::ASSET_URL_REGEX, '.url { \'http://assets.domain.com/dummy.png\' }'
+    end
+
+    test 'prepend_protocol should properly set the protocol when the asset is precompiled' do
+      assert_equal 'http://assets.domain.com/dummy.png', prepend_protocol('//assets.domain.com/dummy.png')
+      assert_equal '/assets.domain.com/dummy.png', prepend_protocol('/assets.domain.com/dummy.png')
+      assert_equal 'http://assets.domain.com/dummy.png', prepend_protocol('http://assets.domain.com/dummy.png')
+      assert_equal 'https://assets.domain.com/dummy.png', prepend_protocol('https://assets.domain.com/dummy.png')
     end
   end
 end

data/test/functional/wicked_pdf_helper_test.rb

@@ -2,25 +2,27 @@ require 'test_helper'
 require 'action_view/test_case'
 
 class WickedPdfHelperTest < ActionView::TestCase
-  if Rails::VERSION::MAJOR == 2
-    test 'wicked_pdf_stylesheet_link_tag should inline the stylesheets passed in' do
-      assert_equal "<style type='text/css'>/* Wicked styles */\n</style>",
-                   wicked_pdf_stylesheet_link_tag('../../../fixtures/wicked')
-    end
+  include WickedPdf::WickedPdfHelper
 
-    test 'wicked_pdf_image_tag should return the same as image_tag when passed a full path' do
-      assert_equal image_tag("file:///#{Rails.root.join('public', 'images', 'pdf')}"),
-                   wicked_pdf_image_tag('pdf')
-    end
+  test 'wicked_pdf_stylesheet_link_tag should inline the stylesheets passed in' do
+    assert_equal "<style type='text/css'>/* Wicked styles */\n</style>",
+                 wicked_pdf_stylesheet_link_tag('../../../fixtures/wicked')
+  end
 
+  test 'wicked_pdf_image_tag should return the same as image_tag when passed a full path' do
+    assert_equal image_tag("file:///#{Rails.root.join('public', 'images', 'pdf')}"),
+                 wicked_pdf_image_tag('pdf')
+  end
+
+  if Rails::VERSION::MAJOR == 2
     test 'wicked_pdf_javascript_src_tag should return the same as javascript_src_tag when passed a full path' do
       assert_equal javascript_src_tag("file:///#{Rails.root.join('public', 'javascripts', 'pdf')}", {}),
                    wicked_pdf_javascript_src_tag('pdf')
     end
+  end
 
-    test 'wicked_pdf_include_tag should return many wicked_pdf_javascript_src_tags' do
-      assert_equal [wicked_pdf_javascript_src_tag('foo'), wicked_pdf_javascript_src_tag('bar')].join("\n"),
-                   wicked_pdf_javascript_include_tag('foo', 'bar')
-    end
+  test 'wicked_pdf_include_tag should return many wicked_pdf_javascript_src_tags' do
+    assert_equal [wicked_pdf_javascript_src_tag('foo'), wicked_pdf_javascript_src_tag('bar')].join("\n"),
+                 wicked_pdf_javascript_include_tag('foo', 'bar')
   end
 end