lightpanda 0.0.1 → 0.1.0

data/lib/lightpanda/capybara/driver.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "capybara"
+
+module Lightpanda
+  module Capybara
+    class Driver < ::Capybara::Driver::Base
+      attr_reader :app, :options
+
+      def initialize(app, options = {})
+        super()
+
+        @app = app
+        @options = options
+        @browser = nil
+      end
+
+      def browser
+        @browser ||= Lightpanda::Browser.new(@options)
+      end
+
+      def visit(url)
+        browser.go_to(url)
+      end
+
+      def current_url
+        browser.current_url
+      end
+
+      def html
+        browser.body
+      end
+      alias body html
+
+      def title
+        browser.title
+      end
+
+      def find_xpath(selector)
+        nodes = browser.evaluate(<<~JS)
+          (function() {
+            var result = document.evaluate(
+              #{selector.inspect},
+              document,
+              null,
+              XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+              null
+            );
+            var nodes = [];
+            for (var i = 0; i < result.snapshotLength; i++) {
+              nodes.push(result.snapshotItem(i));
+            }
+            return nodes;
+          })()
+        JS
+
+        wrap_nodes(nodes || [])
+      end
+
+      def find_css(selector)
+        count = browser.evaluate("document.querySelectorAll(#{selector.inspect}).length")
+
+        return [] if count.nil? || count.zero?
+
+        (0...count).map do |index|
+          Node.new(self, { selector: selector, index: index }, index)
+        end
+      end
+
+      def evaluate_script(script, *_args)
+        browser.evaluate(script)
+      end
+
+      def execute_script(script, *_args)
+        browser.execute(script)
+        nil
+      end
+
+      def reset!
+        browser.go_to("about:blank")
+      rescue StandardError
+        nil
+      end
+
+      def quit
+        @browser&.quit
+        @browser = nil
+      end
+
+      def needs_server?
+        true
+      end
+
+      def wait?
+        true
+      end
+
+      def invalid_element_errors
+        [Lightpanda::NodeNotFoundError, Lightpanda::NoExecutionContextError]
+      end
+
+      private
+
+      def wrap_nodes(nodes)
+        return [] unless nodes.is_a?(Array)
+
+        nodes.map.with_index do |node_data, index|
+          Node.new(self, node_data, index)
+        end
+      end
+    end
+  end
+end

data/lib/lightpanda/capybara/node.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  module Capybara
+    class Node < ::Capybara::Driver::Node
+      attr_reader :selector_info
+
+      def initialize(driver, native, _index)
+        super(driver, native)
+
+        @selector_info = native # { selector: "h1", index: 0 }
+      end
+
+      def text
+        evaluate_on("this.textContent")
+      end
+
+      def visible_text
+        evaluate_on("this.innerText")
+      end
+
+      def [](name)
+        evaluate_on("this.getAttribute(#{name.to_s.inspect})")
+      end
+
+      def value
+        evaluate_on(<<~JS)
+          (function(el) {
+            if (el.tagName === 'SELECT' && el.multiple) {
+              return Array.from(el.selectedOptions).map(o => o.value);
+            }
+            return el.value;
+          })(this)
+        JS
+      end
+
+      def style(styles)
+        styles.each_with_object({}) do |style, result|
+          result[style] = evaluate_on("window.getComputedStyle(this).#{style}")
+        end
+      end
+
+      def click(_keys = [], **_options)
+        evaluate_on("this.click()")
+      end
+
+      def right_click(_keys = [], **_options)
+        evaluate_on(<<~JS)
+          this.dispatchEvent(new MouseEvent('contextmenu', {bubbles: true, cancelable: true}))
+        JS
+      end
+
+      def double_click(_keys = [], **_options)
+        evaluate_on(<<~JS)
+          this.dispatchEvent(new MouseEvent('dblclick', {bubbles: true, cancelable: true}))
+        JS
+      end
+
+      def hover
+        evaluate_on(<<~JS)
+          this.dispatchEvent(new MouseEvent('mouseover', {bubbles: true, cancelable: true}))
+        JS
+      end
+
+      def set(value, **_options)
+        if tag_name == "input"
+          type = self["type"]
+          case type
+          when "checkbox", "radio"
+            if value
+              evaluate_on("this.checked = true; this.dispatchEvent(new Event('change', {bubbles: true}))")
+            else
+              evaluate_on("this.checked = false; this.dispatchEvent(new Event('change', {bubbles: true}))")
+            end
+          when "file"
+            raise NotImplementedError, "File inputs need special handling via CDP. File uploads not yet supported"
+          else
+            set_text_value(value)
+          end
+        elsif tag_name == "textarea"
+          set_text_value(value)
+        elsif self["contenteditable"]
+          evaluate_on("this.innerHTML = #{value.to_s.inspect}")
+        end
+      end
+
+      def select_option
+        evaluate_on(<<~JS)
+          this.selected = true;
+          var event = new Event('change', {bubbles: true});
+          this.parentElement.dispatchEvent(event);
+        JS
+      end
+
+      def unselect_option
+        select = find_xpath("./ancestor::select")[0]
+
+        if select && !select["multiple"]
+          raise ::Capybara::UnselectNotAllowed, "Cannot unselect option from single select"
+        end
+
+        evaluate_on(<<~JS)
+          this.selected = false;
+          var event = new Event('change', {bubbles: true});
+          this.parentElement.dispatchEvent(event);
+        JS
+      end
+
+      def send_keys(*args)
+        args.each do |key|
+          next unless key.is_a?(String)
+
+          evaluate_on(<<~JS)
+            this.focus();
+            this.value += #{key.inspect};
+            this.dispatchEvent(new Event('input', {bubbles: true}));
+          JS
+        end
+      end
+
+      def tag_name
+        evaluate_on("this.tagName.toLowerCase()")
+      end
+
+      def visible?
+        selector = @selector_info[:selector]
+        index = @selector_info[:index]
+
+        js = <<~JS
+          (function() {
+            var el = document.querySelectorAll(#{selector.inspect})[#{index}];
+            if (!el) return false;
+            var style = window.getComputedStyle(el);
+            var isVisible = style.display !== 'none' &&
+                   style.visibility !== 'hidden' &&
+                   el.offsetParent !== null;
+            return isVisible;
+          })()
+        JS
+
+        driver.browser.evaluate(js)
+      end
+
+      def checked?
+        evaluate_on("this.checked")
+      end
+
+      def selected?
+        evaluate_on("this.selected")
+      end
+
+      def disabled?
+        evaluate_on("this.disabled")
+      end
+
+      def readonly?
+        evaluate_on("this.readOnly")
+      end
+
+      def multiple?
+        evaluate_on("this.multiple")
+      end
+
+      def path
+        evaluate_on(<<~JS)
+          (function(el) {
+            if (!el) return '';
+            var path = [];
+
+            while (el && el.nodeType === Node.ELEMENT_NODE) {
+              var selector = el.nodeName.toLowerCase();
+              if (el.id) {
+                selector += '#' + el.id;
+                path.unshift(selector);
+                break;
+              } else {
+                var sibling = el;
+                var nth = 1;
+                while (sibling = sibling.previousElementSibling) {
+                  if (sibling.nodeName.toLowerCase() === selector) nth++;
+                }
+                if (nth > 1) selector += ':nth-of-type(' + nth + ')';
+              }
+              path.unshift(selector);
+              el = el.parentNode;
+            }
+            return path.join(' > ');
+          })(this)
+        JS
+      end
+
+      def find_xpath(selector)
+        driver.find_xpath(selector)
+      end
+
+      def find_css(selector)
+        count = evaluate_on("this.querySelectorAll(#{selector.inspect}).length")
+
+        return [] if count.nil? || count.zero?
+
+        (0...count).map do |idx|
+          child_selector = "#{element_selector} #{selector}"
+
+          Node.new(driver, { selector: child_selector, index: idx }, idx)
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && selector_info == other.selector_info
+      end
+
+      private
+
+      def element_selector
+        if @selector_info.is_a?(Hash)
+          selector = @selector_info[:selector]
+          index = @selector_info[:index]
+
+          index.positive? ? "#{selector}:nth-of-type(#{index + 1})" : selector
+        else
+          "*"
+        end
+      end
+
+      def set_text_value(value) # rubocop:disable Naming/AccessorMethodName
+        evaluate_on(<<~JS)
+          this.focus();
+          this.value = #{value.to_s.inspect};
+          this.dispatchEvent(new Event('input', {bubbles: true}));
+          this.dispatchEvent(new Event('change', {bubbles: true}));
+        JS
+      end
+
+      def evaluate_on(expression)
+        selector = @selector_info[:selector]
+        index = @selector_info[:index]
+
+        expr = expression.strip
+        expr = "return #{expr}" unless expr.start_with?("return ") || expr.include?("\n")
+
+        full_expression = <<~JS
+          (function() {
+            var elements = document.querySelectorAll(#{selector.inspect});
+            var el = elements[#{index}];
+            if (!el) return null;
+            return (function() { #{expr} }).call(el);
+          })()
+        JS
+
+        driver.browser.evaluate(full_expression)
+      end
+    end
+  end
+end

data/lib/lightpanda/capybara.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "capybara"
+require "lightpanda"
+
+require_relative "capybara/driver"
+require_relative "capybara/node"
+
+module Lightpanda
+  module Capybara
+    class << self
+      def configure
+        yield(configuration) if block_given?
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+    end
+
+    class Configuration
+      attr_accessor :host, :port, :timeout, :headless, :browser_path
+
+      def initialize
+        @host = "127.0.0.1"
+        @port = 9222
+        @timeout = 5
+        @headless = true
+        @browser_path = nil
+      end
+
+      def to_h
+        {
+          host: host,
+          port: port,
+          timeout: timeout,
+          browser_path: browser_path
+        }
+      end
+    end
+  end
+end
+
+Capybara.register_driver(:lightpanda) do |app|
+  Lightpanda::Capybara::Driver.new(app, Lightpanda::Capybara.configuration.to_h)
+end

data/lib/lightpanda/client/subscriber.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Client
+    class Subscriber
+      def initialize
+        @subscriptions = Hash.new { |h, k| h[k] = [] }
+        @mutex = Mutex.new
+      end
+
+      def subscribe(event, &block)
+        @mutex.synchronize do
+          @subscriptions[event] << block
+        end
+      end
+
+      def unsubscribe(event, block = nil)
+        @mutex.synchronize do
+          if block
+            @subscriptions[event].delete(block)
+          else
+            @subscriptions.delete(event)
+          end
+        end
+      end
+
+      def dispatch(event, params)
+        callbacks = @mutex.synchronize { @subscriptions[event].dup }
+
+        callbacks.each { |callback| callback.call(params) }
+      end
+
+      def subscribed?(event)
+        @mutex.synchronize { @subscriptions.key?(event) && @subscriptions[event].any? }
+      end
+
+      def clear
+        @mutex.synchronize { @subscriptions.clear }
+      end
+    end
+  end
+end

data/lib/lightpanda/client/web_socket.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "websocket/driver"
+
+module Lightpanda
+  class Client
+    class WebSocket
+      attr_reader :url, :messages
+
+      def initialize(url, options)
+        @url = url
+        @options = options
+        @socket = nil
+        @driver = nil
+        @thread = nil
+        @status = :closed
+        @messages = Queue.new
+
+        connect
+      end
+
+      def send_message(message)
+        raise DeadBrowserError, "WebSocket is not open" unless @status == :open
+
+        @driver.text(message)
+      end
+
+      def close
+        return if @status == :closed
+
+        @status = :closing
+        @driver&.close
+        @thread&.kill
+        @socket&.close
+        @status = :closed
+      end
+
+      def closed?
+        @status == :closed
+      end
+
+      def open?
+        @status == :open
+      end
+
+      def write(data)
+        @socket.write(data)
+      rescue Errno::EPIPE, Errno::ECONNRESET, IOError
+        @status = :closed
+      end
+
+      private
+
+      def connect
+        uri = URI.parse(@url)
+
+        @socket = connect_with_retry(uri.host, uri.port)
+        @driver = ::WebSocket::Driver.client(self)
+
+        setup_callbacks
+
+        @driver.start
+
+        read_handshake_response
+        start_reader_thread
+      end
+
+      def connect_with_retry(host, port, retries: 10, delay: 0.1)
+        retries.times do |i|
+          return TCPSocket.new(host, port)
+        rescue Errno::ECONNREFUSED
+          raise if i == retries - 1
+
+          sleep delay
+        end
+      end
+
+      def setup_callbacks
+        @driver.on(:open) do
+          @status = :open
+        end
+
+        @driver.on(:message) do |event|
+          message = parse_message(event.data)
+          @messages << message if message
+        end
+
+        @driver.on(:close) do
+          @status = :closed
+        end
+
+        @driver.on(:error) do |event|
+          @status = :error
+
+          raise DeadBrowserError, "WebSocket error: #{event.message}"
+        end
+      end
+
+      def start_reader_thread
+        @thread = Thread.new do
+          Thread.current.abort_on_exception = true
+
+          loop do
+            break if @status == :closed || @status == :closing
+
+            begin
+              next unless @socket.wait_readable(0.1)
+
+              data = @socket.readpartial(4096)
+              @driver.parse(data)
+            rescue IOError
+              @status = :closed
+              break
+            end
+          end
+        end
+      end
+
+      def read_handshake_response
+        started_at = Time.now
+
+        while @status != :open && Time.now - started_at < @options.timeout
+          next unless @socket.wait_readable(0.1)
+
+          begin
+            data = @socket.readpartial(4096)
+            @driver.parse(data)
+          rescue EOFError
+            raise DeadBrowserError, "Connection closed during handshake"
+          end
+        end
+
+        raise TimeoutError, "WebSocket connection timeout" unless @status == :open
+      end
+
+      def parse_message(data)
+        JSON.parse(data)
+      rescue JSON::ParserError => e
+        warn "Failed to parse WebSocket message: #{e.message}"
+
+        nil
+      end
+    end
+  end
+end

data/lib/lightpanda/client.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "json"
+require "concurrent-ruby"
+
+require_relative "client/web_socket"
+require_relative "client/subscriber"
+
+module Lightpanda
+  class Client
+    attr_reader :ws_url, :options
+
+    def initialize(ws_url, options)
+      @ws_url = ws_url
+      @options = options
+      @ws = WebSocket.new(ws_url, options)
+      @command_id = 0
+      @pendings = Concurrent::Hash.new
+      @subscriber = Subscriber.new
+      @mutex = Mutex.new
+
+      start_message_thread
+    end
+
+    def command(method, params = {}, async: false, session_id: nil)
+      message = build_message(method, params, session_id: session_id)
+
+      if async
+        @ws.send_message(JSON.generate(message))
+        return true
+      end
+
+      pending = Concurrent::IVar.new
+      @pendings[message[:id]] = pending
+
+      @ws.send_message(JSON.generate(message))
+
+      response = pending.value!(@options.timeout)
+      raise TimeoutError, "Command #{method} timed out after #{@options.timeout}s" if response.nil?
+
+      handle_error(response) if response["error"]
+
+      response["result"]
+    ensure
+      @pendings.delete(message[:id]) if message
+    end
+
+    def on(event, &)
+      @subscriber.subscribe(event, &)
+    end
+
+    def off(event, block = nil)
+      @subscriber.unsubscribe(event, block)
+    end
+
+    def close
+      @running = false
+      @message_thread&.kill
+      @ws&.close
+      @subscriber.clear
+      @pendings.clear
+    end
+
+    def closed?
+      @ws.closed?
+    end
+
+    private
+
+    def build_message(method, params, session_id: nil)
+      id = next_command_id
+      message = { id: id, method: method, params: params }
+      message[:sessionId] = session_id if session_id
+
+      message
+    end
+
+    def next_command_id
+      @mutex.synchronize { @command_id += 1 }
+    end
+
+    def start_message_thread
+      @running = true
+
+      @message_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+
+        while @running && !@ws.closed?
+          message = @ws.messages.pop
+          next unless message
+
+          handle_message(message)
+        end
+      end
+    end
+
+    def handle_message(message)
+      if message["id"]
+        pending = @pendings[message["id"]]
+        pending&.set(message)
+      elsif message["method"]
+        @subscriber.dispatch(message["method"], message["params"])
+      end
+    end
+
+    def handle_error(response)
+      error = response["error"]
+      message = error["message"]
+      error["code"]
+
+      case message
+      when /No node with given id found/i
+        raise NodeNotFoundError, message
+      when /Cannot find context with specified id/i, /Execution context was destroyed/i
+        raise NoExecutionContextError, message
+      else
+        raise BrowserError, error
+      end
+    end
+  end
+end