palapala_pdf 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4a479307ef1a9d4ebe8aee6d8b3f2d7da1f96c854252ba69cc19bbaba45f6cf
-  data.tar.gz: d8f184150f5b43eb1abcbaceaf4e37a643b9a3fdfbcca7dff075f56ec1d5622b
+  metadata.gz: 467a7808449c84b0d2ddbd56c16a791ce1e3148636d911e8010fd3804f306abf
+  data.tar.gz: 7680b71baec5030b0992383f77c3098ac12da223d88057a36a4a985f97755c35
 SHA512:
-  metadata.gz: a094985ed908279fac68ed43d7fbf83b333591d97ca723af840263425c94d530647388417bd935618680f402e617af6097c55eb8e09a98dd69df5a61a7eaa495
-  data.tar.gz: '07382dfb24841886ba2c09ae20b240701cb57d37963f16fd8e9e135f299f63962a5c4f09f6f14d4b2a0e86ae33a80cd2bc45426605b9137f3cdbc70c50cb34b2'
+  metadata.gz: 2533a247040eed4962a337ebd15e9bf51c875ed562242e44b791597d46dc69079e182980f9053cb3519525f6283c249f32dde0ee5668f9bccb2f9a10843d33f9
+  data.tar.gz: '07527904c55f1f0b99d98c1854ac369722c548f4626f5fe5ead3bf49d3bd573fc68ff9f4514cdbdf0acf4fb6c4bead8b80e10f34b3b55ee9fd3cc8f7ddf08436'

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/Puppeteer/NodeJS 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 in Ruby:
+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,19 +51,20 @@ 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
 ```
-
-2. **Create a PDF from HTML**:
+1. **Create a PDF from HTML**:
 
 Create a PDF file from HTML in `irb`
 
@@ -67,14 +76,14 @@ in IRB, load palapala and create a PDF from an HTML snippet:
 
 ```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')
 ```
 
-Instantiate a new Palapala::PDF object with your HTML content and generate the PDF binary data.
+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
+binary_data = Palapala::Pdf.new("<h1>Hello, world! #{Time.now}</h1>").binary_data
 ```
 
 ## Paged CSS
@@ -88,7 +97,7 @@ When using Chromium-based rendering engines, headers and footers are not control
 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
-Palapala::PDF.new(
+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>',
@@ -119,50 +128,9 @@ todo example
   </html>
 ```
 
-## Customisation
-
-### Ferrum
-
-It is Ruby clean and high-level API to Chrome. All you need is Ruby and
-[Chrome](https://www.google.com/chrome/) or
-[Chromium](https://www.chromium.org/). Ferrum connects to the browser by [CDP
-protocol](https://chromedevtools.github.io/devtools-protocol/).
-
-Highlighting some key Ferrum options in the context of PDF generation
-
-* options `Hash`
-  * `:headless` (String | Boolean) - Set browser as headless or not, `true` by default. You can set `"new"` to support
-      [new headless mode](https://developer.chrome.com/articles/new-headless/).
-  * `:xvfb` (Boolean) - Run browser in a virtual framebuffer, `false` by default.
-  * `:extensions` (Array[String | Hash]) - An array of paths to files or JS
-      source code to be preloaded into the browser e.g.:
-      `["/path/to/script.js", { source: "window.secret = 'top'" }]`
-  * `:logger` (Object responding to `puts`) - When present, debug output is
-      written to this object.
-  * `:timeout` (Numeric) - The number of seconds we'll wait for a response when
-      communicating with browser. Default is 5.
-  * `:js_errors` (Boolean) - When true, JavaScript errors get re-raised in Ruby.
-  * `:pending_connection_errors` (Boolean) - When main frame is still waiting for slow responses while timeout is
-      reached `PendingConnectionsError` is raised. It's better to figure out why you have slow responses and fix or
-      block them rather than turn this setting off. Default is true.
-  * `:browser_path` (String) - Path to Chrome binary, you can also set ENV
-      variable as `BROWSER_PATH=some/path/chrome`.
-  * `:browser_options` (Hash) - Additional command line options,
-      [see them all](https://peter.sh/experiments/chromium-command-line-switches/)
-      e.g. `{ "ignore-certificate-errors" => nil }`
-  * `:ignore_default_browser_options` (Boolean) - Ferrum has a number of default
-      options it passes to the browser, if you set this to `true` then only
-      options you put in `:browser_options` will be passed to the browser,
-      except required ones of course.
-  * `:url` (String) - URL for a running instance of Chrome. If this is set, a
-      browser process will not be spawned.
-  * `:process_timeout` (Integer) - How long to wait for the Chrome process to
-      respond on startup.
-  * `:ws_max_receive_size` (Integer) - How big messages to accept from Chrome
-      over the web socket, in bytes. Defaults to 64MB. Incoming messages larger
-      than this will cause a `Ferrum::DeadBrowserError`.
-
-More [details](https://github.com/rubycdp/ferrum#customization)
+## Raw parameters (Page.printToPDF)
+
+See (Page.printToPDF)[https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-printToPDF]
 
 ## Development
 
@@ -190,66 +158,71 @@ Your support is greatly appreciated and helps maintain the project!
 
 ## Findings
 
-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?
+- 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
 ```
 
+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.
 
 ## Rails
 
-### `send_data`
+### `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.
 
-Here's an example of how to use `send_data` to send a PDF file:
-
-```ruby
-def download_pdf
-    pdf_data = Palapala::PDF.new("<h1>Hello, world! #{Time.now}</h1>").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.
-
-### `render_to_string`
-
 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:
+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
+    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.ferrum_opts = { 'no-sandbox': nil }
+  config.opts = { 'no-sandbox': nil }
 end
 ```
-(from Ferrum) It has also been reported that the Chrome process repeatedly crashes when running inside a Docker container on an M1 Mac preventing Ferrum from working. Ferrum should work as expected when deployed to a Docker container on a non-M1 Mac.
+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
 

data/lib/palapala/pdf.rb

@@ -1,13 +1,10 @@
 # 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
   # @param page_ranges Empty string means all pages, e.g., "1-3, 5, 7-9"
-  class PDF
+  class Pdf
     def initialize(content = nil,
-                   url: nil,
                    header_html: nil,
                    footer_html: nil,
                    generate_tagged_pdf: Palapala.defaults.fetch(:generate_tagged_pdf, false),
@@ -16,7 +13,6 @@ module Palapala
                    page_ranges: Palapala.defaults.fetch(:page_ranges, nil),
                    margin: Palapala.defaults.fetch(:margin, {}))
       @content = content
-      @url = url
       @header_html = header_html
       @footer_html = footer_html
       @generate_tagged_pdf = generate_tagged_pdf
@@ -31,36 +27,17 @@ module Palapala
     end
 
     def save(path, **opts)
-      pdf(path:, **opts)
+      File.binwrite(path, pdf(**opts))
     end
 
     private
 
-    def pdf(**opts)
-      browser_context = browser.contexts.create
-      browser_page = browser_context.page
-      # # output console logs for this page
-      if Palapala.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
-      opts[:path] ? opts[:path] : pdf_binary_data
+    def renderer
+      Thread.current[:renderer] ||= Renderer.new
     end
 
-    def data_url
-      encoded_html = Base64.strict_encode64(@content)
-      "data:text/html;base64,#{encoded_html}"
+    def pdf(**opts)
+      renderer.html_to_pdf(@content, params: opts_with_defaults.merge(opts))
     end
 
     def opts_with_defaults
@@ -83,26 +60,7 @@ module Palapala
       opts[:marginLeft] = @margin[:left] unless @margin[:left].nil?
       opts[:marginBottom] = @margin[:bottom] unless @margin[:bottom].nil?
       opts[:marginRight] = @margin[:right] unless @margin[:right].nil?
-
-      puts "opts: #{opts}" if Palapala&.debug
       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.2'
+  VERSION = '0.1.4'
 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,9 @@
 # frozen_string_literal: true
 
+require_relative 'palapala/version'
 require_relative 'palapala/pdf'
+require_relative 'palapala/web_socket_client'
+require_relative 'palapala/renderer'
 
 # Main module for the gem
 module Palapala
@@ -9,12 +12,11 @@ module Palapala
   end
 
   class << self
-    attr_accessor :ferrum_opts
-    attr_accessor :defaults
-    attr_accessor :debug
+    attr_accessor :defaults, :debug, :headless_chrome_url, :headless_chrome_path
   end
 
-  self.ferrum_opts = {}
+  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'
+  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,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: palapala_pdf
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-25 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:
     - - "~>"
@@ -24,8 +24,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-description: This gem uses Ferrum to render HTML into a PDF using Chrom(e)(ium) with
-  minimal dependencies.
+- !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: