breezy_pdf 0.0.1

data/lib/breezy_pdf/intercept/private_url.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module BreezyPDF::Intercept
+  # :nodoc
+  class PrivateUrl < Base
+    def call
+      BreezyPDF.logger.info(
+        "[BreezyPDF] Requesting render of #{public_url} with metadata: #{html_private_asset.metadata}"
+      )
+
+      response = BreezyPDF::RenderRequest.new(public_url, html_private_asset.metadata).submit
+
+      BreezyPDF.logger.info("[BreezyPDF] Redirect to pdf at #{response.download_url}")
+      [
+        302,
+        { "Location" => response.download_url, "Content-Type" => "text/html", "Content-Length" => "0" },
+        []
+      ]
+    end
+
+    private
+
+    def public_url
+      @public_url ||= BreezyPDF::Uploads::Base.new(
+        html_private_asset.filename, html_private_asset.content_type, html_private_asset.file_path
+      ).public_url
+    end
+
+    def html_private_asset
+      @html_private_asset ||= BreezyPDF::PrivateAssets::HTML.new(base_url, body)
+    end
+
+    def status
+      @status ||= response[0]
+    end
+
+    def headers
+      @headers ||= response[1]
+    end
+
+    def body
+      @body ||= response[2].respond_to?(:body) ? response[2].body : response[2].join
+    end
+
+    def response
+      @response ||= app.call(doctored_env)
+    end
+
+    def doctored_env
+      env.dup.tap do |hash|
+        hash["PATH_INFO"] = path
+      end
+    end
+
+    def path
+      path = env["PATH_INFO"]
+
+      BreezyPDF.middleware_path_matchers.each do |regex|
+        path = path.gsub(regex, "")
+      end
+
+      path
+    end
+
+    def base_url
+      "#{env['rack.url_scheme']}://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}"
+    end
+  end
+end

data/lib/breezy_pdf/intercept/public_url.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module BreezyPDF::Intercept
+  # :nodoc
+  class PublicUrl < Base
+    def call
+      BreezyPDF.logger.info("[BreezyPDF] Requesting render of #{public_url}")
+      response = BreezyPDF::RenderRequest.new(public_url).submit
+
+      [
+        302,
+        { "Location" => response.download_url, "Content-Type" => "text/html", "Content-Length" => "0" },
+        []
+      ]
+    end
+
+    private
+
+    def public_url
+      "#{env['rack.url_scheme']}://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}" \
+      "#{path}?#{env['QUERY_STRING']}"
+    end
+
+    def path
+      path = env["PATH_INFO"]
+
+      BreezyPDF.middleware_path_matchers.each do |regex|
+        path = path.gsub(regex, "")
+      end
+
+      path
+    end
+  end
+end

data/lib/breezy_pdf/intercept.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # :nodoc
+  module Intercept
+    autoload :Base,       "breezy_pdf/intercept/base"
+    autoload :PublicUrl,  "breezy_pdf/intercept/public_url"
+    autoload :PrivateUrl, "breezy_pdf/intercept/private_url"
+  end
+end

data/lib/breezy_pdf/interceptor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # Intercept a Rack request
+  class Interceptor
+    attr_reader :app, :env
+
+    def initialize(app, env)
+      @app = app
+      @env = env
+    end
+
+    def intercept!
+      if intercept?
+        BreezyPDF.logger.info("[BreezyPDF] Intercepting request for PDF rendering")
+        intercept.new(@app, @env).call
+      else
+        app.call(env)
+      end
+    end
+
+    private
+
+    def intercept?
+      get? && matching_uri?
+    end
+
+    def matching_uri?
+      matchers.any? { |regex| env["REQUEST_URI"].match?(regex) }
+    end
+
+    def get?
+      env["REQUEST_METHOD"].match?(/get/i)
+    end
+
+    def matchers
+      @matchers ||= BreezyPDF.middleware_path_matchers
+    end
+
+    def intercept
+      if BreezyPDF.treat_urls_as_private
+        BreezyPDF::Intercept::PrivateUrl
+      else
+        BreezyPDF::Intercept::PublicUrl
+      end
+    end
+  end
+end

data/lib/breezy_pdf/middleware.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # :nodoc
+  class Middleware
+    def initialize(app, _options = {})
+      @app = app
+    end
+
+    def call(env)
+      Interceptor.new(@app, env).intercept!
+    end
+  end
+end

data/lib/breezy_pdf/private_assets/asset.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BreezyPDF::PrivateAssets
+  # :nodoc
+  class Asset
+    def initialize(base_url, asset_path_or_url)
+      @base_url          = base_url
+      @asset_path_or_url = asset_path_or_url
+    end
+
+    def content_type
+      io_object.content_type
+    end
+
+    def filename
+      @filename ||= URI(asset_url).path.split("/").last
+    end
+
+    def file_path
+      file.path
+    end
+
+    private
+
+    def file
+      @file ||= if io_object.is_a?(StringIO)
+                  Tempfile.new.tap do |f|
+                    f.write io_object.to_s
+                  end
+                else
+                  io_object
+                end
+    end
+
+    def io_object
+      @io_object ||= open(asset_url)
+    end
+
+    def asset_url
+      @asset_url ||= if URI(@asset_path_or_url).host
+                       @asset_path_or_url
+                     else
+                       "#{@base_url}#{@asset_path_or_url}"
+                     end
+    end
+  end
+end

data/lib/breezy_pdf/private_assets/html.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module BreezyPDF::PrivateAssets
+  # :nodoc
+  class HTML
+    def initialize(base_url, html_fragment)
+      @base_url      = base_url
+      @html_fragment = html_fragment
+    end
+
+    def content_type
+      "text/html"
+    end
+
+    def filename
+      @filename ||= "#{SecureRandom.hex}.html"
+    end
+
+    def file_path
+      file.path
+    end
+
+    def metadata
+      @metadata ||= BreezyPDF.extract_metadata ? Hash[*meta_tags] : {}
+    end
+
+    private
+
+    def file
+      @file ||= Tempfile.new(filename).tap do |f|
+        f.write(modified_html_fragment)
+        f.rewind
+      end
+    end
+
+    def modified_html_fragment
+      @modified_html_fragment ||= modify_html_fragment!
+    end
+
+    def modify_html_fragment!
+      if BreezyPDF.filter_elements
+        @html_fragment = BreezyPDF::HTML::Strip.new(
+          @html_fragment
+        ).stripped_fragment
+      end
+
+      if BreezyPDF.upload_assets
+        @html_fragment = BreezyPDF::HTML::Publicize.new(
+          @base_url, @html_fragment
+        ).public_fragment
+      end
+
+      @html_fragment
+    end
+
+    def parsed_document
+      @parsed_document ||= Nokogiri::HTML(modified_html_fragment)
+    end
+
+    def meta_tags
+      @meta_tags ||= parsed_document.css(%(meta[name^="breezy-pdf-"])).collect do |tag|
+        [tag["name"].gsub(/^breezy\-pdf\-/, ""), tag["content"]]
+      end.flatten
+    end
+  end
+end

data/lib/breezy_pdf/private_assets.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # :nodoc
+  module PrivateAssets
+    autoload :HTML, "breezy_pdf/private_assets/html"
+    autoload :Asset, "breezy_pdf/private_assets/asset"
+  end
+end

data/lib/breezy_pdf/render_request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # Request conversion of a public URL to PDF
+  class RenderRequest
+    def initialize(public_url, metadata = nil)
+      @public_url = public_url
+      @metadata   = metadata
+    end
+
+    def submit
+      client.post("/pdf/public_urls", url_to_render: @public_url, metadata: @metadata.to_h)
+    end
+
+    private
+
+    def client
+      @client ||= Client.new
+    end
+  end
+end

data/lib/breezy_pdf/response.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # API HTTP Response
+  class Response
+    def initialize(http_response)
+      @http_response = http_response
+      BreezyPDF.logger.fatal("[BreezyPDF] Network request failed: #{@http_response.body}") if failure?
+    end
+
+    def success?
+      code >= 200 && code < 400
+    end
+
+    def failure?
+      !success?
+    end
+
+    def method_missing(method, *_args, &_blk)
+      if body.keys.include?(method.to_s)
+        body[method.to_s]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, *)
+      body.keys.include?(method.to_s)
+    end
+
+    private
+
+    def code
+      @code ||= @http_response.code.to_i
+    end
+
+    def body
+      @body ||= JSON.parse(@http_response.body)
+    rescue JSON::ParserError => e
+      BreezyPDF.logger.fatal("[BreezyPDF] Server responded with invalid JSON: #{e}")
+      raise e
+    end
+  end
+end

data/lib/breezy_pdf/uploads/base.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module BreezyPDF::Uploads
+  # Upload an asset
+  class Base
+    def initialize(filename, content_type, file_path)
+      @filename     = filename
+      @content_type = content_type
+      @file_path    = file_path
+    end
+
+    def public_url
+      BreezyPDF.logger.info(%([BreezyPDF] Starting private asset upload for #{@filename}))
+      upload!
+      complete_upload!
+
+      BreezyPDF.logger.info(%([BreezyPDF] Private asset upload for #{@filename} completed))
+      resource.presigned_url
+    end
+
+    private
+
+    def client
+      @client ||= BreezyPDF::Client.new
+    end
+
+    def file
+      @file ||= File.open(@file_path)
+    end
+
+    def complete_upload!
+      BreezyPDF.logger.info(%([BreezyPDF] Initiating completion of private asset upload for #{@filename}))
+      client.put("/uploads/#{resource.id}", {})
+    rescue Net::HTTP => error
+      BreezyPDF.logger.fatal(%([BreezyPDF] Unable to complete private asset upload for #{@filename}))
+      raise CompletionError, error.message
+    end
+
+    def upload!
+      BreezyPDF.logger.info(%([BreezyPDF] Initiating private asset upload of #{@filename}))
+      upload_response = upload_http.request(upload_request)
+
+      return if upload_response.code.to_i == 204
+
+      raise UploadError, "HTTP Status: #{upload_response.code}: #{upload_response.body}"
+    rescue Net::HTTP => error
+      BreezyPDF.logger.fatal(%([BreezyPDF] Unable to upload private asset #{@filename}))
+      raise UploadError, error.message
+    end
+
+    def resource
+      BreezyPDF.logger.info(%([BreezyPDF] Initiating presign of private asset upload #{@filename}))
+      @resource ||= client.post("/uploads", filename: @filename, size: file.size, content_type: @content_type)
+    rescue Net::HTTP => error
+      BreezyPDF.logger.fatal(%([BreezyPDF] Unable to presign private asset upload for #{@filename}))
+      raise PresignError, error.message
+    end
+
+    def upload_uri
+      @upload_uri ||= URI.parse(resource.presigned_upload_url)
+    end
+
+    def upload_http
+      @upload_http ||= Net::HTTP.new(upload_uri.host, upload_uri.port).tap { |http| http.use_ssl = true }
+    end
+
+    def upload_request
+      @upload_request ||= Net::HTTP::Post.new(upload_uri.request_uri).tap do |post|
+        file_form_data = FileFormData.new(resource.presigned_upload_fields, @content_type, @filename, file)
+
+        post.content_type = "multipart/form-data; boundary=#{file_form_data.boundary}"
+        post.body = file_form_data.data
+      end
+    end
+  end
+end

data/lib/breezy_pdf/uploads/file_form_data.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module BreezyPDF::Uploads
+  # Compose the form data for an HTTP POST of a file
+  class FileFormData
+    def initialize(fields, content_type, filename, file)
+      @fields       = fields
+      @content_type = content_type
+      @filename     = filename
+      @file         = file
+    end
+
+    def data
+      @data ||= [
+        field_data,
+        file_data,
+        closing_data
+      ].join
+    end
+
+    def boundary
+      @boundary ||= SecureRandom.hex
+    end
+
+    private
+
+    def field_data
+      field_data = []
+
+      @fields.each do |key, value|
+        field_data << "--#{boundary}\r\n"
+        field_data << %(Content-Disposition: form-data; name="#{key}"\r\n\r\n)
+        field_data << value.chomp + "\r\n"
+      end
+
+      field_data.join
+    end
+
+    def file_data
+      BreezyPDF.logger.info(%([BreezyPDF] Compressing file contents for #{@filename}))
+      [
+        "--#{boundary}\r\n",
+        %(Content-Disposition: form-data; name="file"; filename="#{@filename}"\r\n),
+        "Content-Type: #{@content_type}\r\n\r\n",
+        BreezyPDF::Gzip.compress(@file.read)
+      ].join
+    end
+
+    def closing_data
+      [
+        "--#{boundary}\r\n",
+        %(Content-Disposition: form-data; name="submit"\r\n\r\n),
+        %(Upload) + "\r\n",
+        "--#{boundary}--"
+      ].join
+    end
+  end
+end

data/lib/breezy_pdf/uploads.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # :nodoc
+  module Uploads
+    autoload :Base,         "breezy_pdf/uploads/base"
+    autoload :FileFormData, "breezy_pdf/uploads/file_form_data"
+
+    PresignError    = Class.new(BreezyPDFError)
+    UploadError     = Class.new(BreezyPDFError)
+    CompletionError = Class.new(BreezyPDFError)
+  end
+end

data/lib/breezy_pdf/util.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  # Utility methods
+  module Util
+    def mattr_reader(*syms)
+      syms.each do |sym|
+        raise NameError, "invalid attribute name: #{sym}" unless /\A[_A-Za-z]\w*\z/.match?(sym)
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          @@#{sym} = nil unless defined? @@#{sym}
+          def self.#{sym}
+            @@#{sym}
+          end
+        EOS
+
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+        class_variable_set("@@#{sym}", yield) if block_given?
+      end
+    end
+
+    def mattr_writer(*syms)
+      syms.each do |sym|
+        raise NameError, "invalid attribute name: #{sym}" unless /\A[_A-Za-z]\w*\z/.match?(sym)
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          @@#{sym} = nil unless defined? @@#{sym}
+          def self.#{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+        send("#{sym}=", yield) if block_given?
+      end
+    end
+
+    def mattr_accessor(*syms, &blk)
+      mattr_reader(*syms, &blk)
+      mattr_writer(*syms)
+    end
+  end
+end

data/lib/breezy_pdf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BreezyPDF
+  VERSION = "0.0.1"
+end

data/lib/breezy_pdf.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+require "json"
+require "tempfile"
+require "securerandom"
+require "zlib"
+require "stringio"
+require "open-uri"
+
+require "nokogiri"
+require "concurrent"
+
+require "breezy_pdf/util"
+require "breezy_pdf/gzip"
+
+# :nodoc
+module BreezyPDF
+  extend BreezyPDF::Util
+
+  autoload :VERSION,       "breezy_pdf/version"
+  autoload :RenderRequest, "breezy_pdf/render_request"
+  autoload :Client,        "breezy_pdf/client"
+  autoload :Response,      "breezy_pdf/response"
+  autoload :Middleware,    "breezy_pdf/middleware"
+  autoload :Interceptor,   "breezy_pdf/interceptor"
+  autoload :Uploads,       "breezy_pdf/uploads"
+  autoload :Intercept,     "breezy_pdf/intercept"
+  autoload :PrivateAssets, "breezy_pdf/private_assets"
+  autoload :HTML,          "breezy_pdf/html"
+
+  BreezyPDFError = Class.new(StandardError)
+
+  mattr_accessor :secret_api_key
+  @@secret_api_key = nil
+
+  mattr_accessor :base_url
+  @@base_url = "https://www.breezypdf.com/api"
+
+  mattr_accessor :middleware_path_matchers
+  @@middleware_path_matchers = [/\.pdf$/]
+
+  mattr_accessor :treat_urls_as_private
+  @@treat_urls_as_private = true
+
+  mattr_accessor :upload_assets
+  @@upload_assets = true
+
+  mattr_accessor :asset_selectors
+  @@asset_selectors = %w(img script link[rel="stylesheet"])
+
+  mattr_accessor :asset_path_matchers
+  @@asset_path_matchers = {
+    href: %r{^\/\w+},
+    src:  %r{^\/\w+}
+  }
+
+  mattr_accessor :extract_metadata
+  @@extract_metadata = true
+
+  mattr_accessor :threads
+  @@threads = 1
+
+  mattr_accessor :filter_elements
+  @@filter_elements = false
+
+  mattr_accessor :filter_elements_selectors
+  @@filtered_element_selectors = %w[.breezy-pdf-remove]
+
+  mattr_accessor :logger
+  @@logger = Logger.new(STDOUT)
+  @@logger.level = Logger::FATAL
+
+  def self.setup
+    yield self
+  end
+end

data/test.html

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <title>Hello</title>
+  </head>
+  <body>
+    <h1>Hey there!</h1>
+  </body>
+</html>