my_pdfkit 0.1.0.0

data/lib/my_pdfkit/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class MyPDFKit
+  class Configuration
+    attr_accessor :meta_tag_prefix, :root_url
+    attr_writer :use_xvfb, :verbose
+    attr_reader :default_options
+
+    def initialize
+      @verbose         = false
+      @use_xvfb        = false
+      @meta_tag_prefix = 'pdfkit-'
+      @default_options = {
+        :disable_smart_shrinking => false,
+        :quiet => true,
+        :page_size => 'Letter',
+        :margin_top => '0.75in',
+        :margin_right => '0.75in',
+        :margin_bottom => '0.75in',
+        :margin_left => '0.75in',
+        :encoding => 'UTF-8'
+      }
+    end
+
+    def wkhtmltopdf
+      @wkhtmltopdf ||= default_wkhtmltopdf
+    end
+
+    def default_wkhtmltopdf
+      return @default_command_path if @default_command_path
+      if defined?(Bundler::GemfileError) && File.exist?('Gemfile')
+        @default_command_path = `bundle exec which wkhtmltopdf`.chomp.lines.last
+      end
+      @default_command_path = `which wkhtmltopdf`.chomp if @default_command_path.nil? || @default_command_path.empty?
+      @default_command_path
+    end
+
+    def wkhtmltopdf=(path)
+      if File.exist?(path)
+        @wkhtmltopdf = path
+      else
+        warn "No executable found at #{path}. Will fall back to #{default_wkhtmltopdf}"
+        @wkhtmltopdf = default_wkhtmltopdf
+      end
+    end
+
+    def executable
+      using_xvfb? ? ['xvfb-run', wkhtmltopdf] : wkhtmltopdf
+    end
+
+    def using_xvfb?
+      @use_xvfb
+    end
+
+    def quiet?
+      !@verbose
+    end
+
+    def verbose?
+      @verbose
+    end
+
+    def default_options=(options)
+      @default_options.merge!(options)
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure MyPDFKit someplace sensible,
+  # like config/initializers/my_pdfkit.rb
+  #
+  # @example
+  #   MyPDFKit.configure do |config|
+  #     config.wkhtmltopdf = '/usr/bin/wkhtmltopdf'
+  #     config.use_xvfb    = true
+  #     config.verbose     = true
+  #   end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/my_pdfkit/html_preprocessor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class MyPDFKit
+  module HTMLPreprocessor
+
+    # Change relative paths to absolute, and relative protocols to absolute protocols
+    def self.process(html, root_url, protocol)
+      html = translate_relative_paths(html, root_url) if root_url
+      html = translate_relative_protocols(html, protocol) if protocol
+      html
+    end
+
+    private
+
+    def self.translate_relative_paths(html, root_url)
+      # Try out this regexp using rubular http://rubular.com/r/hiAxBNX7KE
+      html.gsub(/(href|src)=(['"])\/([^\/"']([^\"']*|[^"']*))?['"]/, "\\1=\\2#{root_url}\\3\\2")
+    end
+
+    def self.translate_relative_protocols(body, protocol)
+      # Try out this regexp using rubular http://rubular.com/r/0Ohk0wFYxV
+      body.gsub(/(href|src)=(['"])\/\/([^\"']*|[^"']*)['"]/, "\\1=\\2#{protocol}://\\3\\2")
+    end
+  end
+end

data/lib/my_pdfkit/middleware.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+class MyPDFKit
+  class Middleware
+    def initialize(app, options = {}, conditions = {})
+      @app        = app
+      @options    = options
+      @conditions = conditions
+      @render_pdf = false
+      @caching    = @conditions.delete(:caching) { false }
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @request    = Rack::Request.new(env)
+      @render_pdf = false
+
+      set_request_to_render_as_pdf(env) if render_as_pdf?
+      status, headers, response = @app.call(env)
+
+      begin
+        content_type_header = headers.has_key?('Content-Type') ? 'Content-Type' : 'content-type'
+        if rendering_pdf? && headers[content_type_header] =~ /text\/html|application\/xhtml\+xml/
+          body = response.respond_to?(:body) ? response.body : response.join
+          body = body.join if body.is_a?(Array)
+
+          root_url = root_url(env)
+          protocol = protocol(env)
+          options = @options.merge(root_url: root_url, protocol: protocol)
+
+          if headers['MyPDFKit-javascript-delay']
+            options.merge!(javascript_delay: headers.delete('MyPDFKit-javascript-delay').to_i)
+          end
+
+          body = MyPDFKit.new(body, options).to_pdf
+          response = [body]
+
+          if headers['MyPDFKit-save-pdf']
+            File.open(headers['MyPDFKit-save-pdf'], 'wb') { |file| file.write(body) } rescue nil
+            headers.delete('MyPDFKit-save-pdf')
+          end
+
+          unless @caching
+            # Do not cache PDFs
+            headers.delete('etag')
+            headers.delete('cache-control')
+          end
+
+          headers['content-length'] = (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+          headers[content_type_header]   = 'application/pdf'
+          headers['content-disposition'] ||= @conditions[:disposition] || 'inline'
+        end
+      rescue StandardError => e
+        status = 500
+        response = [e.message]
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    def root_url(env)
+      MyPDFKit.configuration.root_url || "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}/"
+    end
+
+    def protocol(env)
+      env['rack.url_scheme']
+    end
+
+    def rendering_pdf?
+      @render_pdf
+    end
+
+    def render_as_pdf?
+      request_path = @request.path
+      return false unless request_path.end_with?('.pdf')
+
+      if @conditions[:only]
+        conditions_as_regexp(@conditions[:only]).any? do |pattern|
+          pattern === request_path
+        end
+      elsif @conditions[:except]
+        conditions_as_regexp(@conditions[:except]).none? do |pattern|
+          pattern === request_path
+        end
+      else
+        true
+      end
+    end
+
+    def set_request_to_render_as_pdf(env)
+      @render_pdf = true
+
+      path = @request.path.sub(%r{\.pdf$}, '')
+      path = path.sub(@request.script_name, '')
+
+      %w[PATH_INFO REQUEST_URI].each { |e| env[e] = path }
+
+      env['HTTP_ACCEPT'] = concat(env['HTTP_ACCEPT'], Rack::Mime.mime_type('.html'))
+      env['Rack-Middleware-MyPDFKit'] = 'true'
+    end
+
+    def concat(accepts, type)
+      (accepts || '').split(',').unshift(type).compact.join(',')
+    end
+
+    def conditions_as_regexp(conditions)
+      Array(conditions).map do |pattern|
+        pattern.is_a?(Regexp) ? pattern : Regexp.new("^#{pattern}")
+      end
+    end
+  end
+end

data/lib/my_pdfkit/os.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class MyPDFKit
+  module OS
+    def self.host_is_windows?
+      !(RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince/).nil?
+    end
+
+    def self.shell_escape_for_os(args)
+      if (host_is_windows?)
+        # Windows reserved shell characters are: & | ( ) < > ^
+        # See http://technet.microsoft.com/en-us/library/cc723564.aspx#XSLTsection123121120120
+        args.map { |arg| arg.gsub(/([&|()<>^])/,'^\1') }.join(" ")
+      else
+        args.shelljoin
+      end
+    end
+  end
+end

data/lib/my_pdfkit/pdfkit.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'tempfile'
+
+class MyPDFKit
+  class Error < StandardError; end
+
+  class NoExecutableError < Error
+    def initialize
+      msg = "No wkhtmltopdf executable found at #{MyPDFKit.configuration.wkhtmltopdf}\n" \
+            ">> Please install wkhtmltopdf - https://github.com/pdfkit/MyPDFKit/wiki/Installing-WKHTMLTOPDF"
+      super(msg)
+    end
+  end
+
+  class ImproperSourceError < Error
+    def initialize(msg)
+      super("Improper Source: #{msg}")
+    end
+  end
+
+  class ImproperWkhtmltopdfExitStatus < Error
+    def initialize(invoke)
+      super("Command failed (exitstatus=#{$?.exitstatus}): #{invoke}")
+    end
+  end
+
+  attr_accessor :source, :stylesheets
+  attr_reader :renderer
+
+  def initialize(url_file_or_html, options = {})
+    @source = Source.new(url_file_or_html)
+
+    @stylesheets = []
+
+    options = MyPDFKit.configuration.default_options.merge(options)
+    options.delete(:quiet) if MyPDFKit.configuration.verbose?
+    options.merge! find_options_in_meta(url_file_or_html) unless source.url?
+    @root_url = options.delete(:root_url)
+    @protocol = options.delete(:protocol)
+    @renderer = WkHTMLtoPDF.new options
+    @renderer.normalize_options
+
+    raise NoExecutableError unless File.exist?(MyPDFKit.configuration.wkhtmltopdf)
+  end
+
+  def command(path = nil)
+    args = [*executable]
+    args.concat(@renderer.options_for_command)
+    args << @source.to_input_for_command
+    args << (path ? path.to_s : '-')
+    args
+  end
+
+  def options
+    # TODO(cdwort,sigmavirus24): Replace this with an attr_reader for @renderer instead in 1.0.0
+    @renderer.options
+  end
+
+  def executable
+    MyPDFKit.configuration.executable
+  end
+
+  def to_pdf(path=nil)
+    preprocess_html
+    append_stylesheets
+
+    invoke = command(path)
+
+    result = IO.popen(invoke, "wb+") do |pdf|
+      pdf.puts(@source.to_s) if @source.html?
+      pdf.close_write
+      pdf.gets(nil) if path.nil?
+    end
+
+    # $? is thread safe per
+    # http://stackoverflow.com/questions/2164887/thread-safe-external-process-in-ruby-plus-checking-exitstatus
+    raise ImproperWkhtmltopdfExitStatus, invoke if empty_result?(path, result) || !successful?($?)
+    return result
+  end
+
+  def to_file(path)
+    self.to_pdf(path)
+    File.new(path)
+  end
+
+  protected
+
+  def find_options_in_meta(content)
+    # Read file if content is a File
+    content = content.read if content.is_a?(File) || content.is_a?(Tempfile)
+
+    found = {}
+    content.scan(/<meta [^>]*>/) do |meta|
+      if meta.match(/name=["']#{MyPDFKit.configuration.meta_tag_prefix}/)
+        name = meta.scan(/name=["']#{MyPDFKit.configuration.meta_tag_prefix}([^"']*)/)[0][0].split
+        found[name] = meta.scan(/content=["']([^"'\\]+)["']/)[0][0]
+      end
+    end
+
+    tuple_keys = found.keys.select { |k| k.is_a? Array }
+    tuple_keys.each do |key|
+      value = found.delete key
+      new_key = key.shift
+      found[new_key] ||= {}
+      found[new_key][key] = value
+    end
+
+    found
+  end
+
+  def style_tag_for(stylesheet)
+    style = "<style>#{File.read(stylesheet)}</style>"
+    style = style.html_safe if style.respond_to?(:html_safe)
+    style
+  end
+
+  def preprocess_html
+    if @source.html?
+      processed_html = MyPDFKit::HTMLPreprocessor.process(@source.to_s, @root_url, @protocol)
+      @source = Source.new(processed_html)
+    end
+  end
+
+  def append_stylesheets
+    raise ImproperSourceError, 'Stylesheets may only be added to an HTML source' if stylesheets.any? && !@source.html?
+
+    stylesheets.each do |stylesheet|
+      if @source.to_s.match(/<\/head>/)
+        @source = Source.new(@source.to_s.gsub(/(<\/head>)/) {|s|
+          style_tag_for(stylesheet) + (s.respond_to?(:html_safe) ? s.html_safe : s)
+        })
+      else
+        @source.to_s.insert(0, style_tag_for(stylesheet))
+      end
+    end
+  end
+
+  def successful?(status)
+    return true if status.success?
+
+    # Some of the codes: https://code.google.com/p/wkhtmltopdf/issues/detail?id=1088
+    # returned when assets are missing (404): https://code.google.com/p/wkhtmltopdf/issues/detail?id=548
+    return true if status.exitstatus == 2 && @renderer.error_handling?
+
+    false
+  end
+
+  def empty_result?(path, result)
+    (path && File.size(path) == 0) || (path.nil? && result.to_s.strip.empty?)
+  end
+end

data/lib/my_pdfkit/source.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'uri'
+
+class MyPDFKit
+  class Source
+    SOURCE_FROM_STDIN = '-'
+
+    def initialize(url_file_or_html)
+      @source = url_file_or_html
+      # @source is assumed to be modifiable, so make sure it is.
+      @source = @source.dup if @source.is_a?(String) && @source.frozen?
+    end
+
+    def url?
+      @is_url ||= @source.is_a?(String) && @source.match(/\Ahttp/)
+    end
+
+    def file?
+      @is_file ||= @source.kind_of?(File) || @source.kind_of?(Tempfile)
+    end
+
+    def html?
+      @is_html ||= !(url? || file?)
+    end
+
+    def to_input_for_command
+      if file?
+        @source.path
+      elsif url?
+        escaped_url
+      else
+        SOURCE_FROM_STDIN
+      end
+    end
+
+    def to_s
+      file? ? @source.path : @source
+    end
+
+    private
+
+    def escaped_url
+      url_needs_escaping? ? URI::DEFAULT_PARSER.escape(@source) : @source
+    end
+
+    def url_needs_escaping?
+      URI::DEFAULT_PARSER.escape(URI::DEFAULT_PARSER.unescape(@source)) != @source
+    end
+  end
+end

data/lib/my_pdfkit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class MyPDFKit
+  VERSION = '0.1.0.0'
+end

data/lib/my_pdfkit/wkhtmltopdf.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class MyPDFKit
+  class WkHTMLtoPDF
+    attr_reader :options
+    # Pulled from: 
+    # https://github.com/wkhtmltopdf/wkhtmltopdf/blob/6a57c1449797d6cb915921fb747f3ac36199241f/docs/usage/wkhtmltopdf.txt#L104
+    REPEATABLE_OPTIONS = %w[--allow --bypass-proxy-for --cookie --custom-header --post --post-file --run-script --replace].freeze
+    SPECIAL_OPTIONS = %w[cover toc].freeze
+
+    def initialize(options)
+      @options = options
+    end
+  
+    def normalize_options
+      # TODO(cdwort,sigmavirus24): Make this method idempotent in a future release so it can be called repeatedly
+      normalized_options = {}
+  
+      @options.each do |key, value|
+        next if !value
+  
+        # The actual option for wkhtmltopdf
+        normalized_key = normalize_arg key
+        normalized_key = "--#{normalized_key}" unless SPECIAL_OPTIONS.include?(normalized_key)
+  
+        # If the option is repeatable, attempt to normalize all values
+        if REPEATABLE_OPTIONS.include? normalized_key
+          normalize_repeatable_value(normalized_key, value) do |normalized_unique_key, normalized_value|
+            normalized_options[normalized_unique_key] = normalized_value
+          end
+        else # Otherwise, just normalize it like usual
+          normalized_options[normalized_key] = normalize_value(value)
+        end
+      end
+  
+      @options = normalized_options
+    end
+
+    def error_handling?
+      @options.key?('--ignore-load-errors') ||
+        # wkhtmltopdf v0.10.0 beta4 replaces ignore-load-errors with load-error-handling
+        # https://code.google.com/p/wkhtmltopdf/issues/detail?id=55
+        %w(skip ignore).include?(@options['--load-error-handling'])
+    end
+
+    def options_for_command
+      @options.to_a.flatten.compact
+    end
+  
+    private
+  
+    def normalize_arg(arg)
+      arg.to_s.downcase.gsub(/[^a-z0-9]/,'-')
+    end
+  
+    def normalize_value(value)
+      case value
+      when nil
+        nil
+      when TrueClass, 'true' #ie, ==true, see http://www.ruby-doc.org/core-1.9.3/TrueClass.html
+        nil
+      when Hash
+        value.to_a.flatten.collect{|x| normalize_value(x)}.compact
+      when Array
+        value.flatten.collect{|x| x.to_s}
+      else
+        value.to_s
+      end
+    end
+  
+    def normalize_repeatable_value(option_name, value)
+      case value
+      when Hash, Array
+        value.each do |(key, val)|
+          yield [[option_name, normalize_value(key)], normalize_value(val)]
+        end
+      else
+        yield [[option_name, normalize_value(value)], nil]
+      end
+    end
+  end
+end

data/lib/my_pdfkit.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'my_pdfkit/source'
+require 'my_pdfkit/pdfkit'
+require 'my_pdfkit/middleware'
+require 'my_pdfkit/html_preprocessor'
+require 'my_pdfkit/os'
+require 'my_pdfkit/configuration'
+require 'my_pdfkit/wkhtmltopdf'
+require 'my_pdfkit/version'

data/my_pdfkit.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "my_pdfkit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "my_pdfkit"
+  s.version     = MyPDFKit::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jared Pace", "Relevance"]
+  s.email       = ["jared@codewordstudios.com"]
+  s.homepage    = "https://github.com/pdfkit/pdfkit"
+  s.summary     = "HTML+CSS -> PDF"
+  s.description = "Uses wkhtmltopdf to create PDFs using HTML"
+  s.license     = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  p `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 2.5"
+
+  s.requirements << "wkhtmltopdf"
+
+  # Development Dependencies
+  s.add_development_dependency(%q<activesupport>, [">= 4.1.11"])
+  s.add_development_dependency(%q<mocha>, [">= 0.9.10"])
+  s.add_development_dependency(%q<rack-test>, [">= 0.5.6"])
+  s.add_development_dependency(%q<rake>, [">= 12.3.3"])
+  s.add_development_dependency(%q<rdoc>, [">= 4.0.1"])
+  s.add_development_dependency(%q<rspec>, ["~> 3.0"])
+end