palapala_pdf 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ceecc9fff4323ef8cdf26b9e20aeb35f21610e8b55f716a0b8e0c27c0e38613
-  data.tar.gz: 4f9f412514ad9a9b63e4b6484488ff245bb0769352374a652845749ac230b6e6
+  metadata.gz: 95d833844d730f058d59abd1eaaee467dde4fa8b4f3b9d01dd441646675c585b
+  data.tar.gz: b30cd15b438c71801ec9f8b0c0c61ae2aa47543cc59bd36975dd52b9974af98a
 SHA512:
-  metadata.gz: 62c62530b7034a687012bea224b8d284616cef97a2e749ab26151ee2e925ffb3b72ab0d96b13e970ab9d2630bca188c1e134ca59e81bcb37f245dbb1b888f000
-  data.tar.gz: 352245729e62e3df55c23848b684af2deb642b3d506de83ef71f8cf0bc4964ac94219baac3e06e776957f15cb15fba41cf3f864ecb4a381c7e057bed75e598f6
+  metadata.gz: f34c4baea12a5f2577da4bc629319470f7f46dddd3b1ad05b142d0abba6598caefe2128d93035a6d58d65e9357cec32e461a5650fae99606eeae749ded843621
+  data.tar.gz: ac072fb99db23b9b3d7895f4cbd8fed028dd6b5555d1ea1b8ebbc341e4845f901f75a07d4df621691340d754b2d624fc5638d6e2725922fd248d7879441a86a3

data/README.md

@@ -2,13 +2,13 @@
 
 This project is a Ruby gem that provides functionality for generating PDF files from HTML using the Chrome browser. It allows you to easily convert HTML content into PDF documents, making it convenient for tasks such as generating reports, invoices, or any other printable documents. The gem provides a simple and intuitive API for converting HTML to PDF, and it leverages the power and flexibility of the Chrome browser's rendering engine to ensure accurate and high-quality PDF output. With this gem, you can easily integrate PDF generation capabilities into your Ruby applications.
 
-At the core, this project leverages the same rendering engine as [Grover](https://github.com/Studiosity/grover), but with significantly reduced overhead and dependencies. Instead of relying on the full Grover stack, this project builds on [Ferrum](https://github.com/rubycdp/ferrum) to enable direct communication from Ruby to a headless Chrome or Chromium browser. This approach ensures efficient, thread-safe operations, providing a streamlined alternative for rendering tasks without sacrificing performance or flexibility.
+At the core, this project leverages the same rendering engine as [Grover](https://github.com/Studiosity/grover), but with significantly reduced overhead and dependencies. Instead of relying on the full Grover/Puppeteer/NodeJS stack, this project uses a raw web socket to enable direct communication from Ruby to a headless Chrome or Chromium browser. This approach ensures efficieny while providing a streamlined alternative for rendering tasks without sacrificing performance or flexibility.
 
-This is how easy and powerfull PDF generation should be:
+This is how easy and powerfull PDF generation can be in Ruby:
 
 ```ruby
 require "palapala"
-Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").save('hello.pdf')
+Palapala::PDF.new("<h1>Hello, world! #{Time.now}</h1>").save('hello.pdf')
 ```
 
 And this while having the most modern HTML/CSS/JS availlable to you: flex, grid, canvas, you name it.
@@ -27,15 +27,23 @@ If you are not using bundler to manage dependencies, you can install the gem by
 $ gem install palapala_pdf
 ```
 
-Palapala PDF uses [Ferrum](https://github.com/rubycdp/ferrum) inside and that one is pretty good at finding your Chrome or Chromium.
+Palapala PDF connects to Chrome over a web socket connection.
 
-If you want the highest throughput, then use an external Chrome/Chromium. Just start it with (9222 is the default port):
+An external Chrome/Chromium is expected.
+Just start it with the following command (9222 is the default port):
 
 ```sh
-chrome --headless --disable-gpu --remote-debugging-port=9222
+/path/to/chrome --headless --disable-gpu --remote-debugging-port=9222
 ```
 
-Then you can run Palapala PDF against that Chrome/Chromium instance (see configuration).
+Alternatively, Palapala PDF will try to launch Chrome as a child process.
+It guesses the path to Chrome, or you configure it like this:
+
+```ruby
+Palapala.setup do |config|
+    config.headless_chrome_path = '/usr/bin/google-chrome-stable' # path to Chrome executable
+end
+```
 
 ## Usage Instructions
 
@@ -43,21 +51,22 @@ To create a PDF from HTML content using the `Palapala` library, follow these ste
 
 1. **Configuration**:
 
-Configure the `Palapala` library with the necessary options, such as the URL for the Ferrum browser and default settings like scale and format.
+Configure the `Palapala` library with the necessary options, such as the URL for the browser and default settings like scale and format.
 
 In a Rails context, this could be inside an initializer.
 
 ```ruby
 Palapala.setup do |config|
     # run against an external chrome/chromium or leave this out to run against a chrome that is started as a child process
-    config.ferrum_opts = { url: 'http://localhost:9222' }
+    config.debug = true
+    config.headless_chrome_url = 'http://localhost:9222' # run against a remote Chrome instance
+    # config.headless_chrome_path = '/usr/bin/google-chrome-stable' # path to Chrome executable
     config.defaults = { scale: 1, format: :A4 }
 end
 ```
+1. **Create a PDF from HTML**:
 
-2. **Create a PDF from HTML**:
-
-Create a PDF file from HTML in IRB
+Create a PDF file from HTML in `irb`
 
 ```sh
 gem install palapala_pdf
@@ -65,22 +74,64 @@ gem install palapala_pdf
 
 in IRB, load palapala and create a PDF from an HTML snippet:
 
-```sh
->irb
+```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"
-Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").save('hello.pdf')
+binary_data = Palapala::PDF.new("<h1>Hello, world! #{Time.now}</h1>").binary_data
 ```
 
-Instantiate a new Palapala::Pdf object with your HTML content and generate the PDF binary data.
+## Paged CSS
+
+Paged CSS is a subset of CSS designed for styling printed documents. It extends standard CSS to handle pagination, page sizes, headers, footers, and other aspects of printed content. Paged CSS is commonly used in scenarios where web content needs to be converted to PDFs or other paginated formats.
+
+### Headers and Footers
+
+When using Chromium-based rendering engines, headers and footers are not controlled by the Paged CSS standard but are instead managed through specific settings in the rendering engine.
+
+With palapala PDF headers and footers are defined using `header_html` and `footer_html` options. These allow you to insert HTML content directly into the header or footer areas.
 
 ```ruby
-require "palapala"
-binary_data = Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").binary_data
+Palapala::PDF.new(
+  "<p>Hello world</>",
+  header_html: '<div style="text-align: center;">Page <span class="pageNumber"></span> of <span class="totalPages"></span></div>',
+  footer_html: '<div style="text-align: center;">Generated with Palapala PDF</div>',
+  margin: { top: "2cm", bottom: "2cm"}
+).save("test.pdf")
+```
+
+### Page size, orientation and margins
+
+#### With CSS
+
+todo example
+
+#### As params
+
+todo example
+
+## JS based rendering
+
+```html
+  <html>
+    <script type="text/javascript">
+      document.addEventListener("DOMContentLoaded", () => {
+        document.body.innerHTML += "<p>Current time from JS: " + new Date().toLocaleString() + "</p>";
+      });
+    </script>
+    <body><p>Default body text.</p></body>
+  </html>
 ```
 
+## Raw parameters (Page.printToPDF)
+
+See (Page.printToPDF)[https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-printToPDF]
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -107,26 +158,80 @@ Your support is greatly appreciated and helps maintain the project!
 
 ## Findings
 
-For Chrome, mode headless=new seems to be slower for pdf rendering cases.
+- For Chrome, mode headless=new seems to be slower for pdf rendering cases.
+- On mac m3 (aug 24), chromium (brew install chromium) is about 3x slower then chrome? Maybe the chromium that get's installed is not ARM optimized?
 
 ## Primitive benchmark
 
-On a macbook m3, the throughput for 'hello world' PDF generation can reach around 25 docs/second when allowing for some concurrency. As Chrome is actually also very efficient, it scales really well for complex documents also. If you run this in Rails, the concurrency is being taken care of either by the front end thread pool or by the workers and you shouldn't have to think about this. (Using an external Chrome)
+On a macbook m3, the throughput for 'hello world' PDF generation can reach around 300 docs/second when allowing for some concurrency. As Chrome is actually also very efficient, it scales really well for complex documents also. If you run this in Rails, the concurrency is being taken care of either by the front end thread pool or by the workers and you shouldn't have to think about this. (Using an external Chrome)
+
+Note: it renders `"Hello #{i}, world #{j}! #{Time.now}."` where i is the thread and j is the iteration counter within the thread and persists it to an SSD (which is very fast these days).
 
+### benchmarking 20 docs: 1x20, 2x10, 4x5
 
+```sh
+c:1, n:20 : Throughput = 159.41 docs/sec, Total time = 0.1255 seconds
+c:2, n:10 : Throughput = 124.91 docs/sec, Total time = 0.1601 seconds
+c:4, n:5  : Throughput = 196.40 docs/sec, Total time = 0.1018 seconds
 ```
-benchmarking 20 docs: 1x20, 2x10, 4x5, 5x4, 20x1 (c is concurrency, n is iterations)
-Total time c:1, n:20 = 1.2048690000083297 seconds
-Total time c:2, n:10 = 0.8969700000016019 seconds
-Total time c:4, n:5 = 0.7497870000079274 seconds
-Total time c:5, n:4 = 0.72492800001055 seconds
-Total time c:20, n:1 = 0.7156629998935387 seconds
+
+### benchmarking 320 docs: 1x320, 4x80, 8x40
+
+```sh
+c:1, n:320 : Throughput = 184.99 docs/sec, Total time = 1.7299 seconds
+c:4, n:80  : Throughput = 302.50 docs/sec, Total time = 1.0578 seconds
+c:8, n:40  : Throughput = 254.29 docs/sec, Total time = 1.2584 seconds
 ```
 
-## Advanced stuf
+This is about a factor 100x faster then what you typically get with Grover and still 10x faster then with many alternatives. It's effectively that fast that you can run this for a lot of uses cases straight from e.g. your Ruby On Rails web worker in the controller on a single machine and still scale to lot's of users.
 
-### Headers and Footers
+## Rails
+
+### `send_data` and `render_to_string`
+
+The `send_data` method in Rails is used to send binary data as a file download to the user's browser. It allows you to send any type of data, such as PDF files, images, or CSV files, directly to the user without saving the file on the server.
+
+The `render_to_string` method in Rails is used to render a view template to a string without sending it as a response to the user's browser. It allows you to generate HTML or other text-based content that can be used in various ways, such as sending it as an email, saving it to a file, or manipulating it further before sending it as a response.
+
+Here's an example of how to use `render_to_string` to render a view template to a string and send the pdf using `send_data`:
+
+```ruby
+def download_pdf
+    html_string = render_to_string(template: "example/template", layout: "print", locals: { } )
+    pdf_data = Palapala::PDF.new(html_string).binary_data
+    send_data pdf_data, filename: "document.pdf", type: "application/pdf"
+end
+```
+
+In this example, `pdf_data` is the binary data of the PDF file. The `filename` option specifies the name of the file that will be downloaded by the user, and the `type` option specifies the MIME type of the file.
+
+## Docker
+
+In docker as root you must pass the no-sandbox browser option:
+
+```ruby
+Palapala.setup do |config|
+  config.opts = { 'no-sandbox': nil }
+end
+```
+It has also been reported that the Chrome process repeatedly crashes when running inside a Docker container on an M1 Mac. Chrome should work as expected when deployed to a Docker container on a non-M1 Mac.
+
+## Thread-safety
+
+Behind the scenes, a websocket is openend and stored on Thread.current for subsequent requests. Hence, the code is
+thread safe in the sense that every web socket get's a new tab in the underlying chromium and get an isolated context.
+
+For performance reasons, the code uses a low level websocket connection that does all it's work on the curent thread
+so we can avoid synchronisation penalties.
+
+## Heroku
+
+possible buildpacks
+
+https://github.com/heroku/heroku-buildpack-chrome-for-testing
+
+this buildpack install chrome and chromedriver, which is actually not needed, but it's maintained
 
-### Title pages
+https://elements.heroku.com/buildpacks/heroku/heroku-buildpack-google-chrome
 
-### Page sizes in CSS
+this buildpack installs chrome, which is all we need, but it's deprecated

data/lib/palapala/pdf.rb

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
 
-require 'ferrum'
-
 module Palapala
   # Page class to generate PDF from HTML content using Chrome in headless mode in a thread-safe way
-  class Pdf
+  # @param page_ranges Empty string means all pages, e.g., "1-3, 5, 7-9"
+  class PDF
     def initialize(content = nil,
-                   url: nil,
-                   path: nil,
                    header_html: nil,
                    footer_html: nil,
-                   generate_tagged_pdf: false,
-                   prefer_css_page_size: true,
+                   generate_tagged_pdf: Palapala.defaults.fetch(:generate_tagged_pdf, false),
+                   prefer_css_page_size: Palapala.defaults.fetch(:prefer_css_page_size, true),
                    scale: Palapala.defaults.fetch(:scale, 1),
-                   page_ranges: Palapala.defaults.fetch(:page_ranges, ''),
+                   page_ranges: Palapala.defaults.fetch(:page_ranges, nil),
                    margin: Palapala.defaults.fetch(:margin, {}))
       @content = content
-      @url = url
-      @path = path
       @header_html = header_html
       @footer_html = footer_html
       @generate_tagged_pdf = generate_tagged_pdf
@@ -27,82 +22,45 @@ module Palapala
       @margin = margin
     end
 
-    def pdf(**opts)
-      browser_context = browser.contexts.create
-      browser_page = browser_context.page
-      # # output console logs for this page
-      if opts[:debug]
-        browser_page.on('Runtime.consoleAPICalled') do |params|
-          params['args'].each { |r| puts(r['value']) }
-        end
-      end
-      # open the page
-      url = @url || data_url
-      browser_page.go_to(url)
-      # Wait for the page to load
-      browser_page.network.wait_for_idle
-      # Generate PDF
-      pdf_binary_data = browser_page.pdf(**opts_with_defaults.merge(opts))
-      # Dispose the context
-      browser_context.dispose
-      # Return the PDF data
-      pdf_binary_data
-    end
-
     def binary_data(**opts)
       pdf(**opts)
     end
 
     def save(path, **opts)
-      pdf(path:, **opts)
+      File.binwrite(path, pdf(**opts))
     end
 
     private
 
-    def data_url
-      encoded_html = Base64.strict_encode64(@content)
-      "data:text/html;base64,#{encoded_html}"
+    def renderer
+      Thread.current[:renderer] ||= Renderer.new
+    end
+
+    def pdf(**opts)
+      renderer.html_to_pdf(@content, params: opts_with_defaults.merge(opts))
     end
 
     def opts_with_defaults
       opts = { scale: @scale,
                printBackground: true,
                dispayHeaderFooter: true,
-               pageRanges: @page_ranges, # Empty string means all pages, e.g., "1-3, 5, 7-9"
                encoding: :binary,
-               preferCSSPageSize: true,
-               headerTemplate: @header_html || '',
-               footerTemplate: @footer_html || '' }
+               preferCSSPageSize: @prefer_css_page_size }
 
+      opts[:headerTemplate] = @header_html unless @header_html.nil?
+      opts[:footerTemplate] = @footer_html unless @footer_html.nil?
+      opts[:pageRanges] = @page_ranges unless @page_ranges.nil?
       opts[:path] = @path unless @path.nil?
       opts[:generateTaggedPDF] = @generate_tagged_pdf unless @generate_tagged_pdf.nil?
       opts[:format] = @format unless @format.nil?
-      opts[:paperWidth] = @paper_width unless @paper_width.nil?
-      opts[:paperHeight] = @paper_height unless @paper_height.nil?
+      # opts[:paperWidth] = @paper_width unless @paper_width.nil?
+      # opts[:paperHeight] = @paper_height unless @paper_height.nil?
       opts[:landscape] = @landscape unless @landscape.nil?
       opts[:marginTop] = @margin[:top] unless @margin[:top].nil?
       opts[:marginLeft] = @margin[:left] unless @margin[:left].nil?
       opts[:marginBottom] = @margin[:bottom] unless @margin[:bottom].nil?
       opts[:marginRight] = @margin[:right] unless @margin[:right].nil?
-
       opts
     end
-
-    def browser
-      # accordng to the docs ferrum is thread safe, however, under heavy load
-      # we are seeing some issues, so we are using thread locals to have a
-      # browser per thread
-      Thread.current[:browser] ||= new_browser
-      # @@browser ||= new_browser
-    end
-
-    def new_browser
-      Ferrum::Browser.new(Palapala.ferrum_opts)
-    end
-
-    # # TODO use method from template class
-    # def cm_to_inches(value)
-    #   value / 2.54
-    # end
   end
 end

data/lib/palapala/renderer.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "websocket/driver"
+
+module Palapala
+  # Render HTML content to PDF using Chrome in headless mode with minimal dependencies
+  class Renderer
+    def initialize
+      # Create an instance of WebSocketClient with the WebSocket URL
+      @client = Palapala::WebSocketClient.new(websocket_url)
+      # Create the WebSocket driver
+      @driver = WebSocket::Driver.client(@client)
+      # Register the on_message callback
+      @driver.on(:message, &method(:on_message))
+      # Start the WebSocket handshake
+      @driver.start
+      # Initialize the protocol to get the page events
+      send_command_and_wait_for_result("Page.enable")
+    end
+
+    # Callback to handle the incomming WebSocket messages
+    def on_message(e)
+      puts "Received: #{e.data[0..64]}" if Palapala.debug
+      @response = JSON.parse(e.data) # Parse the JSON response
+    end
+
+    # Update the current ID to the next ID (increment by 1)
+    def next_id = @id = (@id || 0) + 1
+
+    # Get the current ID
+    def current_id = @id
+
+    # 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
+      end
+    end
+
+    # Method to send a message (text) and wait for a response
+    def send_and_wait(message, &)
+      puts "\nSending: #{message}" if Palapala.debug
+      @driver.text(message)
+      process_until(&)
+    end
+
+    # Method to send a CDP command and wait for some state to be true
+    def send_command(method, params: {}, &block)
+      send_and_wait(JSON.generate({ id: next_id, method:, params: }), &block)
+    end
+
+    # 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: {})
+      send_command(method, params:) do
+        @response && @response["id"] == current_id
+      end
+      @response["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: {})
+      send_command(method, params:) do
+        @response && @response["method"] == event_name
+      end
+    end
+
+    # Convert HTML content to PDF
+    # See https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-printToPDF
+    # @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: {})
+      send_command_and_wait_for_event("Page.navigate", params: { url: data_url_for_html(html) },
+                                                       event_name: "Page.frameStoppedLoading")
+      result = send_command_and_wait_for_result("Page.printToPDF", params:)
+      Base64.decode64(result["data"])
+    end
+
+    def close
+      @driver.close
+      @client.close
+    end
+
+    private
+
+    def data_url_for_html(html)
+      "data:text/html;base64,#{Base64.strict_encode64(html)}"
+    end
+
+    # Open a new tab in the remote chrome and return the WebSocket URL
+    def websocket_url
+      ChromeProcess.spawn_chrome
+      uri = URI("#{Palapala.headless_chrome_url}/json/new")
+      http = Net::HTTP.new(uri.host, uri.port)
+      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
+
+    # Manage the Chrome child process
+    module ChromeProcess
+      def self.port_in_use?(port = 9222, host = "127.0.0.1")
+        server = TCPServer.new(host, port)
+        server.close
+        false
+      rescue Errno::EADDRINUSE
+        true
+      end
+
+      def self.chrome_process_healthy?
+        return false if @chrome_process_id.nil?
+
+        begin
+          Process.kill(0, @chrome_process_id) # Check if the process is alive
+          true
+        rescue Errno::ESRCH, Errno::EPERM
+          false
+        end
+      end
+
+      def self.kill_chrome
+        return if @chrome_process_id.nil?
+
+        Process.kill("KILL", @chrome_process_id) # Kill the process
+        Process.wait(@chrome_process_id) # Wait for the process to finish
+      end
+
+      def self.chrome_path
+        return Palapala.headless_chrome_path if Palapala.headless_chrome_path
+
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/
+          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+        when /linux/
+          "/usr/bin/google-chrome" # or "/usr/bin/chromium-browser"
+        when /win|mingw|cygwin/
+          "#{ENV["ProgramFiles(x86)"]}\\Google\\Chrome\\Application\\chrome.exe"
+        else
+          raise "Unsupported OS"
+        end
+      end
+
+      def self.spawn_chrome
+        return if port_in_use?
+        return if chrome_process_healthy?
+
+        # Define the path and parameters separately
+        # chrome_path = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+        params = ["--headless", "--disable-gpu", "--remote-debugging-port=9222"]
+
+        # Spawn the process with the path and parameters
+        @chrome_process_id = Process.spawn(chrome_path, *params)
+
+        # Wait until the port is in use
+        until port_in_use?
+          sleep 0.1
+        end
+        # Detach the process so it runs in the background
+        Process.detach(@chrome_process_id)
+
+        at_exit do
+          if @chrome_process_id
+            begin
+              Process.kill("TERM", @chrome_process_id)
+              Process.wait(@chrome_process_id)
+              puts "Child process #{@chrome_process_id} terminated."
+            rescue Errno::ESRCH
+              puts "Child process #{@chrome_process_id} is already terminated."
+            rescue Errno::ECHILD
+              puts "No child process #{@chrome_process_id} found."
+            end
+          end
+        end
+
+        # Handle when the process is killed
+        trap("SIGCHLD") do
+          while (@chrome_process_id = Process.wait(-1, Process::WNOHANG))
+            break if @chrome_process_id.nil?
+
+            puts "Process #{@chrome_process_id} was killed."
+            # Handle the error or restart the process if necessary
+            @chrome_process_id = nil
+          end
+        rescue Errno::ECHILD
+          @chrome_process_id = nil
+        end
+      end
+    end
+  end
+end

data/lib/palapala/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Palapala
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/palapala/web_socket_client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'socket'
+
+module Palapala
+  # Create a socket wrapper that conforms to what the websocket-driver expects
+  class WebSocketClient
+    attr_reader :url
+
+    def initialize(url)
+      @url = url
+      uri = URI.parse(url)
+      @socket = TCPSocket.new(uri.host, uri.port)
+    end
+
+    def write(data)
+      @socket.write(data)
+    end
+
+    def read
+      @socket.readpartial(1024)
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/lib/palapala.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'palapala/pdf'
+require_relative 'palapala/web_socket_client'
+require_relative 'palapala/renderer'
 
 # Main module for the gem
 module Palapala
@@ -8,19 +10,12 @@ module Palapala
     yield self
   end
 
-  def self.ferrum_opts=(ferrum_opts)
-    @ferrum_opts = ferrum_opts
+  class << self
+    attr_accessor :defaults, :debug, :headless_chrome_url, :headless_chrome_path
   end
 
-  def self.ferrum_opts
-    @ferrum_opts
-  end
-
-  def self.defaults=(defaults)
-    @defaults = defaults
-  end
-
-  def self.defaults
-    @defaults ||= {}
-  end
+  self.headless_chrome_url = 'http://localhost:9222'
+  self.headless_chrome_path = nil
+  self.defaults = {}
+  self.debug = false
 end

data/palapala_pdf.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email = ['github.com@handekyn.com']
 
   spec.summary = 'Convert HTML into PDF directly from Ruby using Chrome/Chromium.'
-  spec.description = 'This gem uses Ferrum to render HTML into a PDF using Chrom(e)(ium) with minimal dependencies.'
+  spec.description = 'This gem uses faw web sockets to render HTML into a PDF using Chrom(e)(ium) with minimal dependencies.'
   spec.homepage = 'https://github.com/palapala-app/palapala_pdf'
   spec.required_ruby_version = '>= 3.1'
   spec.license = 'MIT'
@@ -34,7 +34,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # Uncomment to register a new dependency of your gem
-  spec.add_dependency 'ferrum', '~> 0.15'
+  spec.add_dependency 'base64', '~> 0'
+  spec.add_dependency 'websocket-driver', '~> 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,31 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: palapala_pdf
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-23 00:00:00.000000000 Z
+date: 2024-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ferrum
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
-description: This gem uses Ferrum to render HTML into a PDF using Chrom(e)(ium) with
-  minimal dependencies.
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  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'
+description: This gem uses faw web sockets to render HTML into a PDF using Chrom(e)(ium)
+  with minimal dependencies.
 email:
 - github.com@handekyn.com
 executables: []
@@ -40,7 +54,9 @@ files:
 - Rakefile
 - lib/palapala.rb
 - lib/palapala/pdf.rb
+- lib/palapala/renderer.rb
 - lib/palapala/version.rb
+- lib/palapala/web_socket_client.rb
 - palapala_pdf.gemspec
 homepage: https://github.com/palapala-app/palapala_pdf
 licenses: