lightpanda 0.0.1 → 0.1.0

data/lib/lightpanda/cookies.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Cookies
+    attr_reader :browser
+
+    def initialize(browser)
+      @browser = browser
+    end
+
+    def all
+      result = browser.command("Network.getAllCookies")
+
+      result["cookies"] || []
+    end
+
+    def get(name)
+      all.find { |cookie| cookie["name"] == name }
+    end
+
+    def set(name:, value:, domain: nil, path: "/", secure: false, http_only: false, expires: nil)
+      params = {
+        name: name,
+        value: value,
+        path: path,
+        secure: secure,
+        httpOnly: http_only
+      }
+
+      params[:domain] = domain if domain
+      params[:expires] = expires.to_i if expires
+
+      browser.command("Network.setCookie", **params)
+    end
+
+    def remove(name:, domain: nil, path: "/")
+      params = { name: name, path: path }
+      params[:domain] = domain if domain
+
+      browser.command("Network.deleteCookies", **params)
+    end
+
+    def clear
+      browser.command("Network.clearBrowserCookies")
+    end
+  end
+end

data/lib/lightpanda/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Error < StandardError; end
+
+  class ProcessTimeoutError < Error; end
+  class BinaryNotFoundError < Error; end
+  class BinaryError < Error; end
+  class UnsupportedPlatformError < Error; end
+
+  class DeadBrowserError < Error; end
+  class TimeoutError < Error; end
+
+  class BrowserError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(response["message"])
+    end
+  end
+
+  class JavaScriptError < Error
+    attr_reader :class_name, :message
+
+    def initialize(response)
+      @class_name = response.dig("exceptionDetails", "exception", "className")
+      @message = response.dig("exceptionDetails", "exception",
+                              "description") || response.dig("exceptionDetails", "text")
+
+      super(@message)
+    end
+  end
+
+  class NodeNotFoundError < Error; end
+  class NoExecutionContextError < Error; end
+
+  class NoSuchPageError < Error; end
+  class StatusError < Error; end
+end

data/lib/lightpanda/network.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Network
+    attr_reader :browser
+
+    def initialize(browser)
+      @browser = browser
+      @traffic = []
+      @enabled = false
+    end
+
+    def enable
+      return if @enabled
+
+      browser.command("Network.enable")
+      subscribe
+      @enabled = true
+    end
+
+    def disable
+      return unless @enabled
+
+      browser.command("Network.disable")
+      @enabled = false
+    end
+
+    def traffic
+      @traffic.dup
+    end
+
+    def clear
+      @traffic.clear
+    end
+
+    def wait_for_idle(timeout: 5, connections: 0) # rubocop:disable Naming/PredicateMethod
+      started_at = Time.now
+
+      while Time.now - started_at < timeout
+        pending = @traffic.count { |t| t[:response].nil? }
+        return true if pending <= connections
+
+        sleep 0.1
+      end
+
+      false
+    end
+
+    private
+
+    def subscribe
+      browser.on("Network.requestWillBeSent") do |params|
+        @traffic << {
+          request_id: params["requestId"],
+          url: params.dig("request", "url"),
+          method: params.dig("request", "method"),
+          timestamp: params["timestamp"],
+          response: nil
+        }
+      end
+
+      browser.on("Network.responseReceived") do |params|
+        request = @traffic.find { |t| t[:request_id] == params["requestId"] }
+
+        next unless request
+
+        request[:response] = {
+          status: params.dig("response", "status"),
+          headers: params.dig("response", "headers"),
+          mime_type: params.dig("response", "mimeType")
+        }
+      end
+    end
+  end
+end

data/lib/lightpanda/options.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Options
+    DEFAULT_TIMEOUT = ENV.fetch("LIGHTPANDA_DEFAULT_TIMEOUT", 5).to_i
+    DEFAULT_PROCESS_TIMEOUT = ENV.fetch("LIGHTPANDA_PROCESS_TIMEOUT", 10).to_i
+    DEFAULT_HOST = "127.0.0.1"
+    DEFAULT_PORT = 9222
+    DEFAULT_WINDOW_SIZE = [1024, 768].freeze
+
+    attr_accessor :host, :port, :timeout, :process_timeout, :window_size, :browser_path, :headless
+    attr_writer :ws_url
+
+    def initialize(options = {})
+      @host = options.fetch(:host, DEFAULT_HOST)
+      @port = options.fetch(:port, DEFAULT_PORT)
+      @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
+      @process_timeout = options.fetch(:process_timeout, DEFAULT_PROCESS_TIMEOUT)
+      @window_size = options.fetch(:window_size, DEFAULT_WINDOW_SIZE)
+      @browser_path = options[:browser_path]
+      @headless = options.fetch(:headless, true)
+      @ws_url = options[:ws_url]
+    end
+
+    def ws_url
+      @ws_url || "ws://#{host}:#{port}/"
+    end
+
+    def ws_url?
+      !@ws_url.nil?
+    end
+
+    def to_h
+      {
+        host: host,
+        port: port,
+        timeout: timeout,
+        process_timeout: process_timeout,
+        window_size: window_size,
+        browser_path: browser_path,
+        headless: headless,
+        ws_url: ws_url
+      }
+    end
+  end
+end

data/lib/lightpanda/process.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Process
+    READY_PATTERN = /server running.*address=(\d+\.\d+\.\d+\.\d+:\d+)/
+
+    attr_reader :pid, :ws_url
+
+    def initialize(options)
+      @options = options
+      @pid = nil
+      @ws_url = nil
+      @stdout_r = nil
+      @stdout_w = nil
+      @stderr_r = nil
+      @stderr_w = nil
+    end
+
+    def start
+      binary_path = @options.browser_path || Binary.find_or_download
+
+      raise BinaryNotFoundError, "Lightpanda binary not found" unless binary_path
+
+      @stdout_r, @stdout_w = IO.pipe
+      @stderr_r, @stderr_w = IO.pipe
+
+      @pid = spawn_process(binary_path)
+
+      @stdout_w.close
+      @stderr_w.close
+
+      wait_for_ready
+    end
+
+    def stop
+      return unless @pid
+
+      begin
+        ::Process.kill("TERM", @pid)
+        ::Process.wait(@pid)
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already dead
+      end
+
+      cleanup_pipes
+      @pid = nil
+    end
+
+    def alive?
+      return false unless @pid
+
+      ::Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    private
+
+    def spawn_process(binary_path)
+      args = build_args
+
+      ::Process.spawn(
+        binary_path, *args,
+        out: @stdout_w,
+        err: @stderr_w,
+        pgroup: true
+      )
+    end
+
+    def build_args
+      %W[
+        serve
+        --host #{@options.host}
+        --port #{@options.port}
+        --log_level info
+      ]
+    end
+
+    def wait_for_ready
+      started_at = Time.now
+      output = +""
+
+      catch(:ready) do
+        while Time.now - started_at < @options.process_timeout
+          ready = IO.select([@stdout_r, @stderr_r], nil, nil, 0.1)
+
+          next unless ready
+
+          ready[0].each do |io|
+            chunk = io.read_nonblock(1024)
+            output << chunk
+
+            if (match = output.match(READY_PATTERN))
+              @ws_url = "ws://#{match[1]}/"
+              throw(:ready)
+            end
+          rescue IO::WaitReadable
+            # No data available yet
+          rescue EOFError
+            # Pipe closed
+          end
+        end
+
+        stop
+
+        raise ProcessTimeoutError,
+              "Lightpanda failed to start within #{@options.process_timeout} seconds.\nOutput: #{output}"
+      end
+    end
+
+    def cleanup_pipes
+      [@stdout_r, @stdout_w, @stderr_r, @stderr_w].each do |pipe|
+        pipe&.close unless pipe&.closed?
+      end
+    end
+  end
+end

data/lib/lightpanda/version.rb

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

data/lib/lightpanda.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "lightpanda/version"
+require_relative "lightpanda/errors"
+require_relative "lightpanda/options"
+require_relative "lightpanda/binary"
+require_relative "lightpanda/process"
+require_relative "lightpanda/client"
+require_relative "lightpanda/network"
+require_relative "lightpanda/cookies"
+require_relative "lightpanda/browser"
 
 module Lightpanda
-  class Error < StandardError; end
-  # Your code goes here...
+  class << self
+    def new(**options)
+      Browser.new(**options)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Marco Roth
@@ -60,8 +60,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - README.md
 - lib/lightpanda.rb
+- lib/lightpanda/binary.rb
+- lib/lightpanda/browser.rb
+- lib/lightpanda/capybara.rb
+- lib/lightpanda/capybara/driver.rb
+- lib/lightpanda/capybara/node.rb
+- lib/lightpanda/client.rb
+- lib/lightpanda/client/subscriber.rb
+- lib/lightpanda/client/web_socket.rb
+- lib/lightpanda/cookies.rb
+- lib/lightpanda/errors.rb
+- lib/lightpanda/network.rb
+- lib/lightpanda/options.rb
+- lib/lightpanda/process.rb
 - lib/lightpanda/version.rb
 homepage: https://github.com/marcoroth/lightpanda-ruby
 licenses: