capybara-lightpanda 0.1.0 → 0.2.0

data/lib/capybara/lightpanda/driver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "forwardable"
+require "uri"
 
 module Capybara
   module Lightpanda
@@ -16,6 +17,7 @@ module Capybara
         @app = app
         @options = options
         @browser = nil
+        @started = false
       end
 
       def browser
@@ -30,6 +32,7 @@ module Capybara
       end
 
       def visit(url)
+        @started = true
         browser.go_to(url)
       end
 
@@ -84,11 +87,26 @@ module Capybara
         unwrap_script_result(browser.evaluate_async(script.strip, *native_args(args)))
       end
 
+      # -- Network Inspection --
+
+      # Network tracker (lazily auto-enabled). Exposes `traffic`, `clear`,
+      # `wait_for_idle`, header overrides, etc. Cuprite parity.
+      def network
+        browser.network
+      end
+
+      # Block until in-flight HTTP traffic settles. Auto-enables the tracker
+      # on first call so callers don't have to remember to flip it on.
+      # Returns true on success, false on timeout.
+      def wait_for_network_idle(timeout: 5, connections: 0)
+        network.enable
+        network.wait_for_idle(timeout: timeout, connections: connections)
+      end
+
       # -- Cookie Management --
 
       def set_cookie(name, value, **options)
-        cookie_options = {}
-        cookie_options[:domain] = options[:domain] if options[:domain]
+        cookie_options = { domain: options[:domain] || default_domain }
         cookie_options[:path] = options[:path] if options[:path]
         cookie_options[:secure] = options[:secure] if options.key?(:secure)
         if options.key?(:httpOnly) || options.key?(:http_only)
@@ -182,6 +200,7 @@ module Capybara
         browser.clear_frames
         browser.reset_modals
         browser.cookies.clear
+        browser.network.clear
         browser.go_to("about:blank")
       rescue StandardError
         @browser&.quit
@@ -232,6 +251,24 @@ module Capybara
         args.map { |a| a.is_a?(Capybara::Node::Element) ? a.base : a }
       end
 
+      # Lightpanda's `Network.setCookie` requires either `domain` or `url`
+      # (storage.zig → Cookie.parseDomain). When the caller doesn't supply one,
+      # use the host of the current page if any, else `Capybara.app_host`,
+      # else loopback. Cuprite parity — lets pre-visit cookie setup just work.
+      def default_domain
+        candidate = (@started && safe_uri_host(browser.current_url)) ||
+                    safe_uri_host(Capybara.app_host)
+        candidate || "127.0.0.1"
+      end
+
+      def safe_uri_host(url)
+        return nil if url.nil? || url.empty? || url == "about:blank"
+
+        URI(url).host
+      rescue URI::InvalidURIError
+        nil
+      end
+
       # Walk through evaluate-script results turning DOM-node markers (the
       # `{ "__lightpanda_node__" => "..." }` hashes produced by `Browser#unwrap_call_result`)
       # into Lightpanda::Node instances so Capybara can wrap them as elements.

data/lib/capybara/lightpanda/errors.rb

@@ -9,34 +9,52 @@ module Capybara
     class BinaryError < Error; end
     class UnsupportedPlatformError < Error; end
 
-    class DeadBrowserError < Error; end
     class TimeoutError < Error; end
 
+    # Base class for any error originating from a CDP response or live browser
+    # state. Lets callers `rescue BrowserError` to catch the whole CDP family
+    # in one go (mirrors ferrum's hierarchy). Accepts either a CDP error hash
+    # (`{"message" => ..., "code" => ...}`) or a plain string for callsites
+    # that raise with a literal message.
     class BrowserError < Error
       attr_reader :response
 
-      def initialize(response)
-        @response = response
-        super(response["message"])
+      def initialize(response_or_message = nil)
+        if response_or_message.is_a?(Hash)
+          @response = response_or_message
+          super(response_or_message["message"])
+        else
+          @response = nil
+          super
+        end
+      end
+
+      def code
+        @response&.dig("code")
+      end
+
+      def data
+        @response&.dig("data")
       end
     end
 
-    class JavaScriptError < Error
-      attr_reader :class_name, :message
+    class DeadBrowserError < BrowserError; end
+    class NodeNotFoundError < BrowserError; end
+    class NoExecutionContextError < BrowserError; end
+
+    class JavaScriptError < BrowserError
+      attr_reader :class_name, :stack_trace
 
       def initialize(response)
         @class_name = response.dig("exceptionDetails", "exception", "className")
-        @message = response.dig("exceptionDetails", "exception",
-                                "description") || response.dig("exceptionDetails", "text")
-
-        super(@message)
+        @stack_trace = response.dig("exceptionDetails", "stackTrace")
+        message = response.dig("exceptionDetails", "exception", "description") ||
+                  response.dig("exceptionDetails", "text")
+        super(message)
       end
     end
 
-    class NodeNotFoundError < Error; end
-    class NoExecutionContextError < Error; end
-
-    class ObsoleteNode < Error
+    class ObsoleteNode < BrowserError
       attr_reader :node
 
       def initialize(node, message = nil)
@@ -45,7 +63,7 @@ module Capybara
       end
     end
 
-    class MouseEventFailed < Error
+    class MouseEventFailed < BrowserError
       attr_reader :node, :selector, :position
 
       PATTERN = /at position \((\d+),\s*(\d+)\).*selector:\s*(.+)/i

data/lib/capybara/lightpanda/javascripts/index.js

@@ -822,43 +822,36 @@
     // cascade. Available in iframes too because index.js is registered via
     // Page.addScriptToEvaluateOnNewDocument.
 
-    // Returns true if `el` is visible per Capybara's semantics: not in an
-    // unrendered tag (HEAD/SCRIPT/TEMPLATE/etc), no `hidden` attribute on
-    // self/ancestor, no closed-<details> ancestor, not visibility:hidden, and
-    // (when checkVisibility() is unavailable) not display:none.
+    // Returns true if `el` is visible per Capybara's semantics. Lightpanda's
+    // UA stylesheet (PR #2294, nightly ≥5918) puts `display:none` on
+    // HEAD/SCRIPT/STYLE/NOSCRIPT/TEMPLATE/TITLE and `[type=hidden]`, and
+    // `[hidden]` / closed-<details> children also resolve to `display:none`
+    // through the cascade — so a single display:none walk catches the
+    // unrendered-element cases without an explicit tag list. `visibility`
+    // and offsetParent stay explicit because they aren't covered by display.
+    // `checkVisibility()` does the parent walk for us when available.
     //
     // `opts.checkOffsetParent` (default true): when true, also rejects
-    // elements with offsetParent === null as a fallback for ancestor display:none.
-    // The visible_text walker passes false because it already short-circuits
-    // when descending into hidden subtrees.
+    // elements with `offsetParent === null` as a fallback for ancestor
+    // `display:none`. The visible_text walker passes false because it
+    // already short-circuits when descending into hidden subtrees.
     isVisible: function(el, opts) {
       if (!el || el.nodeType !== 1) return false;
       var checkOffsetParent = !opts || opts.checkOffsetParent !== false;
       var TAG = (el.tagName || '').toUpperCase();
-      if (TAG === 'HEAD' || TAG === 'TEMPLATE' || TAG === 'NOSCRIPT' ||
-          TAG === 'SCRIPT' || TAG === 'STYLE' || TAG === 'TITLE') return false;
-      if (TAG === 'INPUT' && (el.type || '').toLowerCase() === 'hidden') return false;
-
-      var node = el;
-      while (node && node.nodeType === 1) {
-        if (node.hasAttribute && node.hasAttribute('hidden')) return false;
-        var parent = node.parentNode;
-        if (parent && parent.nodeType === 1) {
-          var ptag = (parent.tagName || '').toUpperCase();
-          if (ptag === 'HEAD' || ptag === 'TEMPLATE' || ptag === 'NOSCRIPT') return false;
-          if (ptag === 'DETAILS' && !parent.open) {
-            var ntag = (node.tagName || '').toUpperCase();
-            if (ntag !== 'SUMMARY') return false;
-          }
-        }
-        node = parent;
-      }
 
       var win = el.ownerDocument.defaultView || window;
       var style = win.getComputedStyle(el);
       if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
-      if (typeof el.checkVisibility === 'function') return el.checkVisibility();
-      if (style.display === 'none') return false;
+      if (typeof el.checkVisibility === 'function') {
+        if (!el.checkVisibility()) return false;
+      } else {
+        var node = el;
+        while (node && node.nodeType === 1) {
+          if (win.getComputedStyle(node).display === 'none') return false;
+          node = node.parentElement;
+        }
+      }
       if (checkOffsetParent && el.offsetParent === null && style.position !== 'fixed' &&
           TAG !== 'BODY' && TAG !== 'HTML') return false;
       return true;
@@ -893,36 +886,18 @@
       return !el.contains(hit);
     },
 
-    // HTML defines a disabled form control as one whose own `disabled`
-    // attribute is set OR whose ancestor select/optgroup/fieldset is disabled
-    // (with a fieldset-disabled exception for descendants of its first legend).
-    // `el.disabled` only reflects the element's own attribute, so we walk
-    // up the tree to honor the inherited cases.
+    // Capybara's `Node#disabled?` is more permissive than CSS `:disabled`:
+    // an `<option>` inside a disabled `<select>` or a disabled `<fieldset>`
+    // is reported as disabled, even though those don't match CSS `:disabled`
+    // per the HTML spec. Mirrors Cuprite's behavior so the shared specs pass.
     isDisabled: function(el) {
-      if (el.disabled) return true;
-      var tag = (el.tagName || '').toUpperCase();
-      if (tag === 'OPTION') {
+      if (el.matches && el.matches(':disabled')) return true;
+      if ((el.tagName || '').toUpperCase() === 'OPTION') {
         var p = el.parentElement;
-        while (p && (p.tagName || '').toUpperCase() === 'OPTGROUP') {
+        while (p) {
           if (p.disabled) return true;
           p = p.parentElement;
         }
-        if (p && (p.tagName || '').toUpperCase() === 'SELECT' && p.disabled) return true;
-      }
-      var FORM = { INPUT:1, BUTTON:1, SELECT:1, TEXTAREA:1, OPTION:1 };
-      if (FORM[tag]) {
-        var node = el.parentElement;
-        while (node) {
-          if ((node.tagName || '').toUpperCase() === 'FIELDSET' && node.disabled) {
-            var firstLegend = null;
-            for (var c = node.firstElementChild; c; c = c.nextElementSibling) {
-              if ((c.tagName || '').toUpperCase() === 'LEGEND') { firstLegend = c; break; }
-            }
-            if (firstLegend && firstLegend.contains(el)) return false;
-            return true;
-          }
-          node = node.parentElement;
-        }
       }
       return false;
     },
@@ -988,7 +963,12 @@
         for (var i = 0; i < node.childNodes.length; i++) {
           out += walk(node.childNodes[i]);
         }
-        if (isBlock) out = '\n' + out + '\n';
+        // Block-level elements get wrapped in \n…\n only when they actually
+        // contribute visible text. An empty <div> between two inline siblings
+        // would otherwise introduce a phantom line break that Chrome's
+        // innerText algorithm collapses out (required line breaks around
+        // empty blocks coalesce in the line-collapse pass).
+        if (isBlock && /\S/.test(out)) out = '\n' + out + '\n';
         return out;
       }
 
@@ -1015,94 +995,4 @@
       };
     };
   }
-
-  // --- ID-shorthand rewriter for querySelector/querySelectorAll ---
-  // Lightpanda has a CSS-engine bug where `#id` selectors fail after the body is
-  // modified via innerHTML and then replaced (e.g. Turbo Drive's snapshot+swap).
-  // `[id="..."]` always works, so rewrite `#foo` -> `[id="foo"]` outside of
-  // brackets and quoted strings before delegating to the native engine.
-
-  (function() {
-    if (typeof Document === 'undefined' || typeof Element === 'undefined') return;
-
-    function rewriteIdShorthand(selector) {
-      if (typeof selector !== 'string' || selector.indexOf('#') < 0) return selector;
-      var out = '', i = 0, n = selector.length, depth = 0, quote = null;
-      while (i < n) {
-        var c = selector.charAt(i);
-        if (quote) {
-          out += c;
-          if (c === '\\' && i + 1 < n) { out += selector.charAt(i + 1); i += 2; continue; }
-          if (c === quote) quote = null;
-          i++; continue;
-        }
-        if (c === '"' || c === "'") { quote = c; out += c; i++; continue; }
-        if (c === '[') { depth++; out += c; i++; continue; }
-        if (c === ']') { if (depth > 0) depth--; out += c; i++; continue; }
-        if (c === '\\' && i + 1 < n) { out += c + selector.charAt(i + 1); i += 2; continue; }
-        if (c === '#' && depth === 0) {
-          var j = i + 1, start = j;
-          while (j < n) {
-            var cc = selector.charCodeAt(j);
-            if (cc === 92 && j + 1 < n) { j += 2; continue; }
-            // CSS identifier chars: A-Z a-z 0-9 _ - or non-ASCII (>= 128)
-            if ((cc >= 48 && cc <= 57) || (cc >= 65 && cc <= 90) ||
-                (cc >= 97 && cc <= 122) || cc === 45 || cc === 95 || cc >= 128) { j++; continue; }
-            break;
-          }
-          if (j > start) {
-            var id = selector.substring(start, j);
-            out += '[id="' + id.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"]';
-            i = j; continue;
-          }
-        }
-        out += c; i++;
-      }
-      return out;
-    }
-
-    function patch(proto) {
-      if (!proto) return;
-      var origQS = proto.querySelector;
-      var origQSA = proto.querySelectorAll;
-      if (typeof origQS === 'function') {
-        proto.querySelector = function(s) { return origQS.call(this, rewriteIdShorthand(s)); };
-      }
-      if (typeof origQSA === 'function') {
-        proto.querySelectorAll = function(s) { return origQSA.call(this, rewriteIdShorthand(s)); };
-      }
-    }
-
-    patch(Document.prototype);
-    patch(Element.prototype);
-    if (typeof DocumentFragment !== 'undefined') patch(DocumentFragment.prototype);
-  })();
-
-  // --- requestSubmit polyfill ---
-  // Required for Turbo form interception. Turbo listens for the `submit` event,
-  // but form.submit() doesn't fire it. requestSubmit() does.
-
-  if (typeof HTMLFormElement !== 'undefined' && !HTMLFormElement.prototype.requestSubmit) {
-    HTMLFormElement.prototype.requestSubmit = function(submitter) {
-      if (submitter) {
-        var validTypes = {submit: 1, image: 1};
-        if (!validTypes[(submitter.type || '').toLowerCase()]) {
-          throw new TypeError('The specified element is not a submit button.');
-        }
-        if (submitter.form !== this) {
-          throw new DOMException('The specified element is not owned by this form element.', 'NotFoundError');
-        }
-      }
-      var event;
-      if (typeof SubmitEvent === 'function') {
-        event = new SubmitEvent('submit', {bubbles: true, cancelable: true, submitter: submitter || null});
-      } else {
-        event = new Event('submit', {bubbles: true, cancelable: true});
-        event.submitter = submitter || null;
-      }
-      if (this.dispatchEvent(event)) {
-        this.submit();
-      }
-    };
-  }
 })();

data/lib/capybara/lightpanda/keyboard.rb

@@ -73,18 +73,59 @@ module Capybara
         @browser = browser
       end
 
+      # A top-level modifier symbol (`:shift`, `:ctrl`, `:alt`, `:meta`) is
+      # held for the remainder of the call — `send_keys('ocean', :shift, 'side')`
+      # types `oceanSIDE`. Modifier presses fire `keyDown` (not `rawKeyDown`)
+      # so JS keydown handlers see the modifier event; CDP's `rawKeyDown` is
+      # documented as "no JS keyDown event is generated" and would hide the
+      # modifier from listeners that count keydown events.
       def type(*keys)
+        active_mods = []
         keys.each do |key|
           case key
-          when Symbol then dispatch_key(key)
-          when String then key.each_char { |char| dispatch_char(char) }
-          when Array  then type_with_modifiers(key)
+          when Symbol
+            if MODIFIERS.key?(key)
+              press_modifier(key, active_mods)
+            else
+              dispatch_key_with_mods(key, active_mods)
+            end
+          when String
+            key.each_char { |char| dispatch_char_with_mods(char, active_mods) }
+          when Array
+            type_with_modifiers(key)
           end
         end
+        release_modifiers(active_mods)
       end
 
       private
 
+      def press_modifier(mod, active_mods)
+        return if active_mods.include?(mod)
+
+        send_key_event("keyDown", KEYS[mod])
+        active_mods << mod
+      end
+
+      def release_modifiers(active_mods)
+        active_mods.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
+        active_mods.clear
+      end
+
+      def dispatch_key_with_mods(key, active_mods)
+        return dispatch_key(key) if active_mods.empty?
+
+        modifier_value = active_mods.sum { |m| MODIFIERS[m] }
+        dispatch_modified(key, modifier_value, active_mods)
+      end
+
+      def dispatch_char_with_mods(char, active_mods)
+        return dispatch_char(char) if active_mods.empty?
+
+        modifier_value = active_mods.sum { |m| MODIFIERS[m] }
+        dispatch_modified_char(char, modifier_value, active_mods)
+      end
+
       def dispatch_key(key)
         definition = KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
         raw_dispatch(definition)
@@ -98,7 +139,7 @@ module Capybara
         modifiers, chars = keys.partition { |k| k.is_a?(Symbol) && MODIFIERS.key?(k) }
         modifier_value = modifiers.sum { |m| MODIFIERS[m] }
 
-        modifiers.each { |m| send_key_event("rawKeyDown", KEYS[m]) }
+        modifiers.each { |m| send_key_event("keyDown", KEYS[m]) }
         chars.each { |key| dispatch_modified(key, modifier_value, modifiers) }
         modifiers.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
       end