adzap-wicked_pdf 2.0.0.beta1

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rails/version'
+require 'bundler/gem_tasks'
+
+desc 'Default: run unit tests.'
+task :default => [:test, :rubocop]
+
+desc 'Test the wicked_pdf plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Run RuboCop'
+task :rubocop do
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end
+
+desc 'Generate documentation for the wicked_pdf gem.'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WickedPdf'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/gemfiles/4.2.gemfile

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

data/gemfiles/5.0.gemfile

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

data/gemfiles/5.1.gemfile

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

data/gemfiles/5.2.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rdoc'
+gem 'rails', '~> 5.2'
+gem 'sqlite3', '~> 1.3.6'
+gem 'bootsnap' # required to run `rake test` in Rails 5.2
+gem 'mocha', '= 1.3' # newer versions blow up
+
+gemspec path: '../'

data/gemfiles/rails_edge.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rdoc'
+gem 'rails', git:  'https://github.com/rails/rails.git'
+gem 'sqlite3', '~> 1.3.6'
+gem 'bootsnap' # required to run `rake test` in Rails 6.0
+gem 'mocha', '= 1.3' # newer versions blow up
+
+gemspec path: '../'

data/generators/wicked_pdf/templates/wicked_pdf.rb

@@ -0,0 +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/adzap/wicked_pdf/blob/master/README.md
+
+WickedPdf.config = {
+  # 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

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

data/init.rb

@@ -0,0 +1,2 @@
+require 'wicked_pdf'
+require 'wicked_pdf_tempfile'

data/lib/generators/wicked_pdf_generator.rb

@@ -0,0 +1,6 @@
+class WickedPdfGenerator < Rails::Generators::Base
+  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

data/lib/wicked_pdf.rb

@@ -0,0 +1,29 @@
+# wkhtml2pdf Ruby interface
+# http://wkhtmltopdf.org/
+
+require 'logger'
+require 'digest/md5'
+require 'rbconfig'
+require 'open3'
+
+require 'active_support/core_ext/object/blank'
+
+require 'wicked_pdf/version'
+require 'wicked_pdf/tempfile'
+require 'wicked_pdf/binary'
+require 'wicked_pdf/option_parser'
+require 'wicked_pdf/progress'
+require 'wicked_pdf/command'
+require 'wicked_pdf/document'
+require 'wicked_pdf/railtie' if defined?(Rails.env)
+require 'wicked_pdf/middleware'
+
+module WickedPdf
+  class << self
+    attr_accessor :config
+  end
+
+  def self.new(command = WickedPdf::Command.new)
+    WickedPdf::Document.new(command)
+  end
+end

data/lib/wicked_pdf/asset_helper.rb

@@ -0,0 +1,141 @@
+require 'open-uri'
+
+module WickedPdf
+  module AssetHelper
+    ASSET_URL_REGEX = /url\(['"]?([^'"]+?)['"]?\)/
+
+    def self.root_path
+      String === Rails.root ? Pathname.new(Rails.root) : Rails.root
+    end
+
+    def self.add_extension(filename, extension)
+      filename.to_s.split('.').include?(extension) ? filename : "#{filename}.#{extension}"
+    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
+
+    def wicked_pdf_stylesheet_link_tag(*sources)
+      stylesheet_contents = sources.collect do |source|
+        source = WickedPdf::AssetHelper.add_extension(source, 'css')
+        "<style type='text/css'>#{read_asset(source)}</style>"
+      end.join("\n")
+
+      stylesheet_contents.gsub(ASSET_URL_REGEX) do
+        if Regexp.last_match[1].starts_with?('data:')
+          "url(#{Regexp.last_match[1]})"
+        else
+          "url(#{wicked_pdf_asset_path(Regexp.last_match[1])})"
+        end
+      end.html_safe
+    end
+
+    def wicked_pdf_image_tag(img, options = {})
+      image_tag wicked_pdf_asset_path(img), options
+    end
+
+    def wicked_pdf_javascript_src_tag(jsfile, options = {})
+      jsfile = WickedPdf::AssetHelper.add_extension(jsfile, 'js')
+      javascript_include_tag wicked_pdf_asset_path(jsfile), options
+    end
+
+    def wicked_pdf_javascript_include_tag(*sources)
+      sources.collect do |source|
+        source = WickedPdf::AssetHelper.add_extension(source, 'js')
+        "<script type='text/javascript'>#{read_asset(source)}</script>"
+      end.join("\n").html_safe
+    end
+
+    def wicked_pdf_asset_path(asset)
+      if (pathname = asset_pathname(asset).to_s) =~ URI_REGEXP
+        pathname
+      else
+        "file:///#{pathname}"
+      end
+    end
+
+    private
+
+    # borrowed from actionpack/lib/action_view/helpers/asset_url_helper.rb
+    URI_REGEXP = %r{^[-a-z]+://|^(?:cid|data):|^//}
+
+    def asset_pathname(source)
+      if precompiled_or_absolute_asset?(source)
+        asset = asset_path(source)
+        pathname = prepend_protocol(asset)
+        if pathname =~ URI_REGEXP
+          # asset_path returns an absolute URL using asset_host if asset_host is set
+          pathname
+        else
+          File.join(Rails.public_path, asset.sub(/\A#{Rails.application.config.action_controller.relative_url_root}/, ''))
+        end
+      else
+        asset = find_asset(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, :base_path => Rails.application.root.to_s)
+      else
+        Sprockets::Railtie.build_environment(Rails.application).find_asset(path, :base_path => Rails.application.root.to_s)
+      end
+    end
+
+    # will prepend a http or default_protocol to a protocol relative URL
+    # or when no protcol is set.
+    def prepend_protocol(source)
+      protocol = WickedPdf.config[:default_protocol] || 'http'
+      if source[0, 2] == '//'
+        source = [protocol, ':', source].join
+      elsif source[0] != '/' && !source[0, 8].include?('://')
+        source = [protocol, '://', source].join
+      end
+      source
+    end
+
+    def precompiled_or_absolute_asset?(source)
+      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
+      end
+    end
+
+    def read_from_uri(uri)
+      encoding = ':UTF-8'
+      asset = open(uri, "r#{encoding}", &:read)
+      asset = gzip(asset) if WickedPdf.config[:expect_gzipped_remote_assets]
+      asset
+    end
+
+    def gzip(asset)
+      stringified_asset = StringIO.new(asset)
+      gzipper = Zlib::GzipReader.new(stringified_asset)
+      gzipper.read
+    rescue Zlib::GzipFile::Error
+      nil
+    end
+  end
+end

data/lib/wicked_pdf/binary.rb

@@ -0,0 +1,56 @@
+module WickedPdf
+  class Binary
+    EXE_NAME = 'wkhtmltopdf'.freeze
+    DEFAULT_BINARY_VERSION = Gem::Version.new('0.9.9')
+
+    attr_reader :path, :default_version
+
+    def initialize(binary_path = nil, default_version = DEFAULT_BINARY_VERSION)
+      @path = binary_path || find_binary_path
+      @default_version = default_version
+
+      raise "Location of #{EXE_NAME} unknown" if @path.empty?
+      raise "Bad #{EXE_NAME}'s path: #{@path}" unless File.exist?(@path)
+      raise "#{EXE_NAME} is not executable" unless File.executable?(@path)
+    end
+
+    def version
+      @version ||= retrieve_binary_version
+    end
+
+    def parse_version_string(version_info)
+      match_data = /wkhtmltopdf\s*(\d*\.\d*\.\d*\w*)/.match(version_info)
+      if match_data && (match_data.length == 2)
+        Gem::Version.new(match_data[1])
+      else
+        default_version
+      end
+    end
+
+    private
+
+    def retrieve_binary_version
+      _stdin, stdout, _stderr = Open3.popen3(@path + ' -V')
+      parse_version_string(stdout.gets(nil))
+    rescue StandardError
+      default_version
+    end
+
+    def find_binary_path
+      return WickedPdf.config[:exe_path] if WickedPdf.config[:exe_path]
+
+      begin
+        detected_path = (defined?(Bundler) ? Bundler.which('wkhtmltopdf') : `which wkhtmltopdf`).chomp
+        return detected_path if detected_path.present?
+      rescue StandardError
+        nil
+      end
+
+      possible_locations = (ENV['PATH'].split(':') + %w[/usr/bin /usr/local/bin]).uniq
+      possible_locations += %w[~/bin] if ENV.key?('HOME')
+
+      exe_path ||= possible_locations.map { |l| File.expand_path("#{l}/#{EXE_NAME}") }.find { |location| File.exist?(location) }
+      exe_path || ''
+    end
+  end
+end

data/lib/wicked_pdf/command.rb

@@ -0,0 +1,52 @@
+module WickedPdf
+  class Command
+    attr_reader :binary, :option_parser
+
+    def initialize(binary: Binary.new, option_parser: nil)
+      @binary = binary
+      @option_parser = option_parser || OptionParser.new(@binary.version)
+    end
+
+    def execute(options, *args)
+      command = [binary.path]
+      command += option_parser.parse(options)
+      command += args
+
+      print_command(command.inspect) if in_development_mode?
+
+      if track_progress?(options)
+        Progress.new(options[:progress]).execute(command)
+      else
+        begin
+          err = Open3.popen3(*command) do |_stdin, _stdout, stderr|
+            stderr.read
+          end
+        rescue StandardError => e
+          raise "Failed to execute:\n#{command}\nError: #{e}"
+        end
+
+        raise "Error generating PDF\n Command Error: #{err}" if options[:raise_on_all_errors] && !err.empty?
+        err
+      end
+    end
+
+    private
+
+    def in_development_mode?
+      defined?(Rails.env) && Rails.env.development?
+    end
+
+    def print_command(cmd)
+      # TODO: if no Rails what then?
+      Rails.logger.debug '[wicked_pdf]: ' + cmd
+    end
+
+    def track_progress?(options)
+      options[:progress] && !on_windows?
+    end
+
+    def on_windows?
+      RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+    end
+  end
+end

data/lib/wicked_pdf/document.rb

@@ -0,0 +1,47 @@
+module WickedPdf
+  class Document
+    def initialize(command = Command.new)
+      @command = command
+    end
+
+    def pdf_from_html_file(filepath, options = {})
+      pdf_from_url("file:///#{filepath}", options)
+    end
+
+    def pdf_from_string(string, options = {})
+      options = options.dup
+      options.merge!(WickedPdf.config) { |_key, option, _config| option }
+      string_file = WickedPdf::Tempfile.new('wicked_pdf.html', options[:temp_path])
+      string_file.binmode
+      string_file.write(string)
+      string_file.close
+
+      pdf_from_html_file(string_file.path, options)
+    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 = WickedPdf::Tempfile.new('wicked_pdf_generated_file.pdf', options[:temp_path])
+
+      result = @command.execute(options, url, generated_pdf_file.path.to_s)
+
+      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
+
+      raise "PDF could not be generated!\n Command Error: #{result}" if pdf && pdf.rstrip.empty?
+
+      pdf
+    ensure
+      generated_pdf_file.close! if generated_pdf_file && !return_file
+    end
+  end
+end