palapala_pdf 0.1.23 → 0.1.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12be6d622065fdadf2611578279b723532a6ab68b25a2c5b9790692757058c17
-  data.tar.gz: 890152aa05e9ea2823e19ed1a2ec27eade4271951bbb6c948f44bc68d074a09f
+  metadata.gz: cf35b002c0b5f5b0f33c5bb3513e8127180c3ceaf4855452e891b9b5833e4b04
+  data.tar.gz: de883c2a261e227e427d5a29efeaffc3b18fb7285e5eb9c65e529e1554d40378
 SHA512:
-  metadata.gz: 2d42e1f4c2de6eea69f8b42e57340ff191f9e87f77b42df05c3b4dca4acc21fb6d9847f2aea19085522071f0a5b37c5c62a512f5f4ceaee6e29267dc5638c359
-  data.tar.gz: c61845987b64ba8de756e05c81a7451da67e7eb59e50dd39e0a3c2088d201560fcd4f1723d8193c8e367c3578a7cfe2a475171c07209cbfb00dc4200d9313653
+  metadata.gz: 4803547a2761565e67a17bb2770d4e2e6a79f01e55ace46101a438450c729ad97a399245891bf791a84135c41e7f5c33c89809097ca5375e1850187d82871580
+  data.tar.gz: 484fc20cc82ce043cdeeef636faec03f261ba7e7e3cdc7d2c40e1a042250510bda84ccac1e54be5b3fadc48f7817e0376a98b25b6a58b4b7e52efd91e34a6697

data/README.md

@@ -40,8 +40,40 @@ bundle add palapala_pdf
 
 ## Usage Instructions
 
+The gem can be used in Rails context as wel as in plain Ruby context.
+
+**Create a PDF from HTML**
+
+Load palapala and create a PDF file from an HTML snippet:
+
+```ruby
+require "palapala"
+Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").save('hello.pdf')
+```
+
+Instantiate a new Palapala::Pdf object with your HTML content and generate the PDF binary data:
+
+```ruby
+require "palapala"
+binary_data = Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").binary_data
+```
+
 To create a PDF from HTML content using the `Palapala` library, follow these steps:
 
+**Render PDFs from Rails controllers**
+
+Use the `pdf` renderer in Rails controllers to render a PDF from the current action.
+Inspired by Chris Oliver's code shared at RailsWorld2025.
+
+```ruby
+  def show
+    respond_to do |format|
+      format.html
+      format.pdf { render pdf: {}, disposition: :inline, filename: "example.pdf" }
+    end
+  end
+```
+
 **Configuration from inside Ruby**
 
 Configure the `Palapala` library with the necessary options, such as the URL for the browser and default settings like scale and format.
@@ -79,22 +111,6 @@ HEADLESS_CHROME_URL=http://192.168.1.1:9222 ruby examples/performance_benchmark.
 HEADLESS_CHROME_PATH=/var/to/chrome ruby examples/performance_benchmark.rb
 ```
 
-**Create a PDF from HTML**
-
-Load palapala and create a PDF file from an HTML snippet:
-
-```ruby
-require "palapala"
-Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").save('hello.pdf')
-```
-
-Instantiate a new Palapala::Pdf object with your HTML content and generate the PDF binary data:
-
-```ruby
-require "palapala"
-binary_data = Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").binary_data
-```
-
 ## Advanced Examples
 
 - headers and footers
@@ -230,6 +246,15 @@ $CHROME_PATH --disable-gpu --remote-debugging-port=9222 --disable-software-raste
 
 *It has also been reported that the Chrome process repeatedly crashes when running inside a Docker container on an M1 Mac. Chrome should work asexpected when deployed to a Docker container on a non-M1 Mac.*
 
+The gem comes with an executable `chrome-headless-server` that installs chrome headless (using npx) and runs it, so once the gem is installed you can simple do this
+
+```
+> chrome-headless-server
+Installing/launching chrome-headless-shell@stable
+Launching chrome-headless-shell at chrome-headless-shell/mac_arm-140.0.7339.80/chrome-headless-shell-mac-arm64/chrome-headless-shell
+Google Chrome for Testing 140.0.7339.80
+DevTools listening on ws://127.0.0.1:9222/devtools/browser/e2565da0-8bf0-45f0-9cfc-86211db70a99
+```
 
 ## Thread-safety
 
@@ -278,3 +303,7 @@ Ensure the script is executable
 ```sh
 chmod +x bin/start
 ```
+
+# REFERENCES
+
+Info to process : https://nathanfriend.com/2019/04/15/pdf-gotchas-with-headless-chrome.html

data/bin/chrome-headless-server

@@ -7,5 +7,5 @@ Palapala.setup do |config|
   config.debug = true
 end
 
-pid = Palapala::ChromeProcess.spawn_chrome_headless_server
+pid = Palapala::ChromeProcess.spawn_chrome_headless_server_with_npx
 Process.wait(pid)

data/examples/performance_benchmark.rb

@@ -12,12 +12,16 @@ Palapala.debug = $debug
 
 # @param concurrency Number of concurrent threads
 # @param iterations Number of iterations per thread
-def benchmark(concurrency, iterations)
+def benchmark(concurrency, iterations, html_size: 1)
   time = Benchmark.realtime do
     threads = (1..concurrency).map do |i|
       Thread.new do
         iterations.times do |j|
-          doc = "Hello #{i}, world #{j}! #{Time.now}."
+          # doc = "Hello #{i}, <b>world</b> #{j}! <i>#{Time.now}</i>. 00001: 0123456789 The quick brown fox jumps over the lazy dog.\n"
+          doc = "Hello #{i}, world #{j}! <i>#{Time.now}</i>. 00001: 0123456789 The quick brown fox jumps over the lazy dog.\n"
+          # make doc double the size untiul it's bigger than html_size
+          doc *= (html_size / doc.bytesize) + 1
+          doc = "<html><body><pre>#{doc}</pre></body></html>"
           pdf = Palapala::Pdf.new(doc)
           $save ? pdf.save("tmp/benchmark_#{i}_#{j}.pdf") : pdf.binary_data
         end
@@ -34,4 +38,18 @@ benchmark(1, 5)
 puts "Starting benchmark..."
 benchmark(1, 10)
 benchmark(2, 20 / 2)
-benchmark(4, 320 / 4)
+puts "Starting benchmark step 2 (small docs)..."
+benchmark(2, 20)
+benchmark(2, 40)
+benchmark(2, 80)
+benchmark(4, 40)
+benchmark(8, 20)
+puts "Starting benchmark step 2 (medium docs)..."
+benchmark(2, 20, html_size: 10_000)
+benchmark(2, 40, html_size: 10_000)
+benchmark(2, 80, html_size: 10_000)
+benchmark(4, 40, html_size: 10_000)
+benchmark(8, 20, html_size: 10_000)
+puts "Starting benchmark with html size 2 000 000 ..."
+# benchmark(1, 1, html_size: 1_500_000)
+benchmark(1, 1, html_size: 2_000_000)

data/examples/test_large_file.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# Test script to debug large file processing
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'benchmark'
+require 'palapala'
+
+# Enable debug logging
+Palapala.debug = true
+
+puts "Testing large file processing..."
+
+# Generate a large HTML file (> 2MB)
+doc = "Hello, world! <i>#{Time.now}</i>. 00001: 0123456789 The quick brown fox jumps over the lazy dog.\n"
+# make doc double the size untiul it's bigger than html_size
+doc *= (2_000_000 / doc.bytesize) + 1
+# doc *= (10_000 / doc.bytesize) + 1
+large_html = "<html><body><pre>#{doc}</pre></body></html>"
+
+# save the generated file as large_file.html
+# File.write("large_file.html", large_html)
+
+puts "Generated HTML: #{large_html.bytesize} bytes"
+
+begin
+  puts "Starting PDF generation..."
+  pdf_data = Palapala::Renderer.html_to_pdf(large_html)
+  puts "Success! Generated PDF: #{pdf_data.length} bytes"
+rescue => e
+  puts "Error: #{e.message}"
+  puts "Backtrace: #{e.backtrace.first(5).join("\n")}"
+end

data/lib/palapala/asset_helper.rb

@@ -0,0 +1,66 @@
+# sourced from ferrum_pdf (modified)
+module Palapala
+  class BaseAsset
+    def initialize(asset)
+      @asset = asset
+    end
+  end
+
+  class PropshaftAsset < BaseAsset
+    def content_type
+      @asset.content_type.to_s
+    end
+
+    def content
+      @asset.content
+    end
+  end
+
+  class SprocketsAsset < BaseAsset
+    def content_type
+      @asset.content_type
+    end
+
+    def content
+      @asset.source
+    end
+  end
+
+  class AssetFinder
+    class << self
+      def find(path)
+        if Rails.application.assets.respond_to?(:load_path)
+          propshaft_asset(path)
+        elsif Rails.application.assets.respond_to?(:find_asset)
+          sprockets_asset(path)
+        else
+          nil
+        end
+      end
+
+      def propshaft_asset(path)
+        (asset = Rails.application.assets.load_path.find(path)) ? PropshaftAsset.new(asset) : nil
+      end
+
+      def sprockets_asset(path)
+        (asset = Rails.application.assets.find_asset(path)) ? SprocketsAsset.new(asset) : nil
+      end
+    end
+  end
+
+  module AssetsHelper
+    def palapala_pdf_inline_stylesheet(path)
+      (asset = AssetFinder.find(path)) ? "<style>#{asset.content}</style>".html_safe : nil
+    end
+
+    def palapala_pdf_inline_javascript(path)
+      (asset = AssetFinder.find(path)) ? "<script>#{asset.content}</script>".html_safe : nil
+    end
+
+    def palapala_pdf_base64_asset(path)
+      return nil unless (asset = AssetFinder.find(path))
+
+      "data:#{asset.content_type};base64,#{Base64.encode64(asset.content).gsub(/\s+/, "")}"
+    end
+  end
+end

data/lib/palapala/html_preprocessor.rb

@@ -0,0 +1,33 @@
+module Palapala
+  # Helper module for preparing HTML for conversion
+  #
+  # Sourced from the PDFKit project (through ferrum_pdf)
+  # @see https://github.com/pdfkit/pdfkit
+  module HTMLPreprocessor
+    # Change relative paths to absolute, and relative protocols to absolute protocols
+    #
+    #   process("Some HTML", "https://example.org")
+    #
+    def self.process(html, base_url)
+      return html if base_url.blank?
+
+      base_url += "/" unless base_url.end_with? "/"
+      protocol = base_url.split("://").first
+      html = translate_relative_paths(html, base_url) if base_url
+      html = translate_relative_protocols(html, protocol) if protocol
+      html
+    end
+
+    def self.translate_relative_paths(html, base_url)
+      # Try out this regexp using rubular http://rubular.com/r/hiAxBNX7KE
+      html.gsub(%r{(href|src)=(['"])/([^/"']([^"']*|[^"']*))?['"]}, "\\1=\\2#{base_url}\\3\\2")
+    end
+    private_class_method :translate_relative_paths
+
+    def self.translate_relative_protocols(body, protocol)
+      # Try out this regexp using rubular http://rubular.com/r/0Ohk0wFYxV
+      body.gsub(%r{(href|src)=(['"])//([^"']*|[^"']*)['"]}, "\\1=\\2#{protocol}://\\3\\2")
+    end
+    private_class_method :translate_relative_protocols
+  end
+end

data/lib/palapala/persistent_server.rb

@@ -0,0 +1,104 @@
+require 'webrick'
+require 'securerandom'
+require 'socket'
+
+module Palapala
+  # Persistent server that stays running and serves HTML content from memory
+  # Eliminates the overhead of creating/destroying servers for each PDF
+  class PersistentServer
+    @@instance = nil
+    @@files = {}
+    @@mutex = Mutex.new
+
+    def self.instance
+      @@mutex.synchronize do
+        @@instance ||= new
+      end
+    end
+
+    def initialize(port: 9223)
+      @port = find_available_port(port)
+      @server = WEBrick::HTTPServer.new(
+        Port: @port,
+        Logger: WEBrick::Log.new("/dev/null"),
+        AccessLog: []
+      )
+
+      # Custom handler to serve files from memory
+      @server.mount_proc '/file' do |req, res|
+        file_key = req.path.sub('/file/', '')
+
+        @@mutex.synchronize do
+          if @@files.key?(file_key)
+            res.status = 200
+            res['Content-Type'] = 'text/html'
+            res.body = @@files[file_key]
+          else
+            res.status = 404
+            res.body = 'File not found'
+          end
+        end
+      end
+
+      # Start server in background thread
+      @thread = Thread.new { @server.start }
+
+      # Wait for server to be ready
+      sleep 0.1 until @server.status == :Running
+    end
+
+    # Serve HTML content and return URL
+    def serve_html(html)
+      puts "PersistentServer: Serving HTML content (#{html.bytesize} bytes)" if defined?(Palapala) && Palapala.debug
+      key = SecureRandom.hex
+      @@mutex.synchronize do
+        @@files[key] = html
+        puts "PersistentServer: Stored content with key #{key}" if defined?(Palapala) && Palapala.debug
+      end
+      url = "http://localhost:#{@port}/file/#{key}"
+      puts "PersistentServer: Returning URL #{url}" if defined?(Palapala) && Palapala.debug
+      url
+    end
+
+    # Clean up served content
+    def cleanup(key)
+      @@mutex.synchronize do
+        @@files.delete(key)
+      end
+    end
+
+    # Get current port
+    def port
+      @port
+    end
+
+    # Check if server is running
+    def running?
+      @server.status == :Running
+    end
+
+    # Stop the server
+    def stop
+      @server.shutdown
+      @thread.join
+    end
+
+    private
+
+    # Find an available port starting from the preferred port
+    def find_available_port(preferred_port)
+      port = preferred_port
+      loop do
+        begin
+          server = TCPServer.new(port)
+          server.close
+          return port
+        rescue Errno::EADDRINUSE
+          port += 1
+          # Prevent infinite loop - if we can't find a port within 100 attempts, raise
+          raise "Could not find available port starting from #{preferred_port}" if port > preferred_port + 100
+        end
+      end
+    end
+  end
+end

data/lib/palapala/railtie.rb

@@ -0,0 +1,24 @@
+module Palapala
+  class Railtie < ::Rails::Railtie
+    initializer "palapala_pdf.assets_helper" do
+      ActiveSupport.on_load(:action_view) do
+        include Palapala::AssetsHelper
+      end
+    end
+
+    initializer "ferrum_pdf.controller" do
+      ActiveSupport.on_load(:action_controller) do
+        # render pdf: { pdf options }, template: "whatever", disposition: :inline, filename: "example.pdf"
+        ActionController.add_renderer :pdf do |pdf_options, options|
+          send_data_options = options.extract!(:disposition, :filename, :status)
+          url = pdf_options.delete(:url)
+          html = render_to_string(**options.with_defaults(formats: [ :html ])) if url.blank?
+          base_url = request.base_url
+          processed_html = Palapala::HTMLPreprocessor.process(html, base_url)
+          pdf = Palapala::Pdf.new(processed_html).binary_data
+          send_data(pdf, **send_data_options.with_defaults(type: :pdf))
+        end
+      end
+    end
+  end
+end

data/lib/palapala/renderer.rb

@@ -3,6 +3,7 @@ require "net/http"
 require "websocket/driver"
 require_relative "./web_socket_client"
 require_relative "./chrome_process"
+require_relative "./persistent_server"
 require 'tempfile'
 require 'webrick'
 
@@ -44,7 +45,7 @@ module Palapala
 
     # Callback to handle the incomming WebSocket messages
     def on_message(e)
-      puts "Received: #{e.data[0..64]}" if Palapala.debug
+      puts "Received: #{e.data[0..128]}" if Palapala.debug
       @response = JSON.parse(e.data) # Parse the JSON response
       if @response["error"] # Raise an error if the response contains an error
         raise "#{@response["error"]["message"]}: #{@response["error"]["data"]} (#{@response["error"]["code"]})"
@@ -60,15 +61,20 @@ module Palapala
     # Process the WebSocket messages until some state is true
     def process_until(&block)
       loop do
-        @driver.parse(@client.read)
-        return if block.call
-        return if @driver.state == :closed
+        begin
+          @driver.parse(@client.read)
+          return if block.call
+          return if @driver.state == :closed
+        rescue EOFError => e
+          puts "WebSocket connection lost: #{e.message}" if Palapala.debug
+          raise "Chrome process appears to have died. WebSocket connection lost."
+        end
       end
     end
 
     # Method to send a message (text) and wait for a response
     def send_and_wait(message, &)
-      puts "\nSending: #{message}" if Palapala.debug
+      puts "\nSending: #{message.to_s[0..128]}" if Palapala.debug
       @driver.text(message)
       process_until(&)
     end
@@ -81,19 +87,52 @@ module Palapala
     # Method to send a CDP command and wait for the matching event to get the result
     # @return [Hash] The result of the command
     def send_command_and_wait_for_result(method, params: {})
+      puts "Waiting for result of #{method}..." if Palapala.debug
       send_command(method, params:) do
         @response && @response["id"] == current_id
       end
+      puts "Got result for #{method}" if Palapala.debug
       @response["result"]
     end
 
+    # Method to send a CDP command and wait for the result with timeout
+    # @return [Hash] The result of the command
+    def send_command_and_wait_for_result_with_timeout(method, params: {}, timeout: 300)
+      puts "Waiting for result of #{method} (timeout: #{timeout}s)..." if Palapala.debug
+
+      result = nil
+      error = nil
+
+      thread = Thread.new do
+        begin
+          send_command(method, params:) do
+            @response && @response["id"] == current_id
+          end
+          result = @response["result"]
+        rescue => e
+          error = e
+        end
+      end
+
+      unless thread.join(timeout)
+        thread.kill
+        raise "Timeout: #{method} took longer than #{timeout} seconds"
+      end
+
+      raise error if error
+      puts "Got result for #{method}" if Palapala.debug
+      result
+    end
+
     # Method to send a CDP command and wait for a specific method to be called
     def send_command_and_wait_for_event(method, event_name:, params: {})
+      puts "Waiting for event #{event_name} from #{method}..." if Palapala.debug
       send_command(method, params:) do
         # chrome refuses to load pages that are bigger than 2MB and returns a net::ERR_ABORTED error
         raise "Page cannot be loaded" if @response.dig("result", "errorText") == "net::ERR_ABORTED"
         @response && @response["method"] == event_name
       end
+      puts "Got event #{event_name}" if Palapala.debug
     end
 
     # Convert HTML content to PDF
@@ -101,16 +140,35 @@ module Palapala
     # @param html [String] The HTML content to convert to PDF
     # @param params [Hash] Additional parameters to pass to the CDP command
     def html_to_pdf(html, params: {})
-      server = start_local_server(html)
+      puts "Starting PDF generation for #{html.bytesize} bytes" if Palapala.debug
+
+      # Use data URL for small content (< 2MB after base64 encoding), persistent server for larger content
+      # Base64 encoding increases size by ~33%, so check original size < 1.2MB to be safe
+      if html.bytesize < 1_200_000
+        puts "Using data URL for small content" if Palapala.debug
+        url = data_url_for_html(html)
+        cleanup_key = nil
+      else
+        puts "Using persistent server for large content" if Palapala.debug
+        server = PersistentServer.instance
+        url = server.serve_html(html)
+        cleanup_key = url.split('/').last
+        puts "Served content at URL: #{url}" if Palapala.debug
+      end
+
       begin
-        url = "http://localhost:#{server[:port]}/"
-        send_command_and_wait_for_event("Page.navigate", params: { url: url },
-                                                             event_name: "Page.frameStoppedLoading")
-        result = send_command_and_wait_for_result("Page.printToPDF", params:)
+        puts "Navigating to URL..." if Palapala.debug
+      send_command_and_wait_for_event("Page.navigate", params: { url: url }, event_name: "Page.frameStoppedLoading")
+        puts "Page loaded, generating PDF..." if Palapala.debug
+        result = send_command_and_wait_for_result_with_timeout("Page.printToPDF", params:)
+        puts "PDF generated, decoding..." if Palapala.debug
         Base64.decode64(result["data"])
       ensure
-        server[:thread].kill # Stop the server after use
-        server[:file].unlink # Delete the temporary file
+        # Clean up served content if using persistent server
+        if cleanup_key
+          puts "Cleaning up content key: #{cleanup_key}" if Palapala.debug
+          PersistentServer.instance.cleanup(cleanup_key)
+        end
       end
     end
 
@@ -121,7 +179,8 @@ module Palapala
 
     def self.html_to_pdf(html, params: {})
       thread_local_instance.html_to_pdf(html, params: params)
-    rescue StandardError
+    rescue StandardError => e
+      puts "PDF generation failed: #{e.message}" if Palapala.debug
       reset # Reset the renderer on error, the websocket connection might be broken
       thread_local_instance.html_to_pdf(html, params: params) # Retry (once)
     end
@@ -142,19 +201,26 @@ module Palapala
       request = Net::HTTP::Put.new(uri)
       request["Content-Type"] = "application/json"
       response = http.request(request)
-      tab_info = JSON.parse(response.body)
-      websocket_url = tab_info["webSocketDebuggerUrl"]
-      puts "WebSocket URL: #{websocket_url}" if Palapala.debug
-      websocket_url
-    end
 
-    private
+      # Check if response is valid JSON
+      begin
+        tab_info = JSON.parse(response.body)
+        websocket_url = tab_info["webSocketDebuggerUrl"]
+        puts "WebSocket URL: #{websocket_url}" if Palapala.debug
+        websocket_url
+      rescue JSON::ParserError => e
+        puts "Chrome response error: #{response.body}" if Palapala.debug
+        raise "Chrome is not responding properly. Response: #{response.body}"
+      end
+    end
 
     # Convert the HTML content to a data URL
     def data_url_for_html(html)
       "data:text/html;base64,#{Base64.strict_encode64(html)}"
     end
 
+    private
+
     def start_local_server(html)
       file = Tempfile.new(["html_content", ".html"])
       file.write(html)

data/lib/palapala/version.rb

@@ -1,3 +1,3 @@
 module Palapala
-  VERSION = "0.1.23"
+  VERSION = "0.1.26"
 end

data/lib/palapala.rb

@@ -1,6 +1,16 @@
 require_relative "palapala/pdf"
 require_relative "palapala/helper"
+require_relative "palapala/asset_helper"
 require_relative "palapala/version"
+require_relative "palapala/html_preprocessor"
+
+# Only load railtie if Rails is present
+begin
+  require "rails"
+  require_relative "palapala/railtie"
+rescue LoadError
+  # Rails not available, skip railtie
+end
 
 module Palapala
   def self.setup
@@ -34,7 +44,7 @@ module Palapala
   self.chrome_headless_shell_version = ENV.fetch("CHROME_HEADLESS_SHELL_VERSION", "stable")
   self.chrome_params = ENV.fetch("HEADLESS_CHROME_PARAMS", nil)&.split || []
 
-  if !ENV["DYNO"].nil? || File.exist?('/.dockerenv')
+  if !ENV["DYNO"].nil? || File.exist?("/.dockerenv")
     self.chrome_params ||= []
     self.chrome_params << "--no-sandbox"
   end

data/palapala_pdf.gemspec

@@ -37,6 +37,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'base64', '~> 0'
   spec.add_dependency 'websocket-driver', '~> 0'
   spec.add_dependency 'combine_pdf', '~> 1'
+  spec.add_dependency 'webrick'
+  spec.add_dependency "rails", ">= 6.0.0"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: palapala_pdf
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 0.1.26
 platform: ruby
 authors:
 - Koen Handekyn
 bindir: bin
 cert_chain: []
-date: 2025-04-29 00:00:00.000000000 Z
+date: 2025-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -51,6 +51,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 description: This gem uses faw web sockets to render HTML into a PDF using Chrom(e)(ium)
   with minimal dependencies.
 email:
@@ -80,10 +108,15 @@ files:
 - examples/paged_css.pdf
 - examples/paged_css.rb
 - examples/performance_benchmark.rb
+- examples/test_large_file.rb
 - lib/palapala.rb
+- lib/palapala/asset_helper.rb
 - lib/palapala/chrome_process.rb
 - lib/palapala/helper.rb
+- lib/palapala/html_preprocessor.rb
 - lib/palapala/pdf.rb
+- lib/palapala/persistent_server.rb
+- lib/palapala/railtie.rb
 - lib/palapala/renderer.rb
 - lib/palapala/version.rb
 - lib/palapala/web_socket_client.rb