capybara-lightpanda 0.9.0 → 0.11.0

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

@@ -92,61 +92,25 @@ function isContentEditable(el) {
   return false;
 }
 
-// visibleText's block-detection tables. A node is block-level if its computed
-// `display` is in BLOCK_DISP or its tag is in BLOCK_TAG (the tag table catches
-// elements whose display we can't resolve and elements that are block by UA
-// default). Hoisted to IIFE scope so they're built once at injection, not
-// re-allocated on every visibleText() call.
-var BLOCK_DISP = { BLOCK:1, FLEX:1, GRID:1, 'LIST-ITEM':1, TABLE:1, 'TABLE-ROW':1,
-                   'TABLE-CAPTION':1, 'TABLE-CELL':1 };
-var BLOCK_TAG = { ADDRESS:1, ARTICLE:1, ASIDE:1, BLOCKQUOTE:1, DETAILS:1, DIALOG:1,
-                  DIV:1, DL:1, DT:1, DD:1, FIELDSET:1, FIGCAPTION:1, FIGURE:1,
-                  FOOTER:1, FORM:1, H1:1, H2:1, H3:1, H4:1, H5:1, H6:1, HEADER:1,
-                  HGROUP:1, HR:1, LI:1, MAIN:1, NAV:1, OL:1, P:1, PRE:1, SECTION:1,
-                  TABLE:1, TR:1, UL:1 };
-
-// Walk descendants and accumulate text from visible nodes only. Inserts
-// newlines around block-display containers so paragraphs/lists render with
-// natural breaks (Capybara expects this from Chrome's innerText).
-// Lightpanda's innerText returns textContent verbatim (no rendering, so no
-// hidden-descendant filtering), so we DIY the visibility filtering here.
+// Capybara's "visible text" = WebDriver getText semantics, which native
+// innerText alone doesn't provide at two edges: a non-rendered element must
+// yield "" (innerText returns textContent per the HTML getter's step 1), and a
+// ShadowRoot/DocumentFragment has no innerText at all. So we gate on visibility
+// and otherwise delegate the rendered-text collection — block line breaks +
+// display:none descendant skipping + whitespace — to native innerText
+// (Lightpanda #2785/#2795, guaranteed by the build floor). node.rb#visible_text
+// normalizes the whitespace on top.
 function visibleText(el) {
-  // Collapse runs of ASCII whitespace (preserving NBSP) to a single space —
-  // matches Chrome's innerText whitespace handling for text nodes.
-  function normText(s) {
-    return s.replace(/[\t\n\r\f\v ]+/g, ' ');
-  }
-
-  function walk(node) {
-    if (node.nodeType === 3) return normText(node.nodeValue);
-    // DocumentFragment / ShadowRoot — no element of its own to test
-    // for visibility, just walk children.
-    if (node.nodeType === 11) {
-      var fout = '';
-      for (var k = 0; k < node.childNodes.length; k++) fout += walk(node.childNodes[k]);
-      return fout;
-    }
-    if (node.nodeType !== 1) return '';
-    if (!isVisible(node)) return '';
-    var tag = (node.tagName || '').toUpperCase();
-    if (tag === 'TEXTAREA') return node.value || '';
-    if (tag === 'BR') return '\n';
-    var win = node.ownerDocument.defaultView || window;
-    var style = win.getComputedStyle(node);
-    var disp = (style.display || '').toUpperCase();
-    var isBlock = BLOCK_DISP[disp] || BLOCK_TAG[tag];
-    var out = '';
-    for (var i = 0; i < node.childNodes.length; i++) {
-      out += walk(node.childNodes[i]);
-    }
-    // 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;
+  if (el.nodeType === 1) return isVisible(el) ? el.innerText : '';
+  // ShadowRoot / DocumentFragment: no innerText of its own. Concatenate the
+  // native innerText of each visible element child with the text nodes between
+  // them — collapsing the latter's whitespace to a single space so template
+  // newlines between inline children render as a separating space, not a break.
+  var out = '';
+  for (var i = 0; i < el.childNodes.length; i++) {
+    var c = el.childNodes[i];
+    if (c.nodeType === 3) out += c.nodeValue.replace(/[\t\n\r\f\v ]+/g, ' ');
+    else if (c.nodeType === 1 && isVisible(c)) out += c.innerText;
   }
-
-  return walk(el);
+  return out;
 }

data/lib/capybara/lightpanda/network.rb

@@ -150,10 +150,11 @@ module Capybara
       # The handlers also capture the last top-level navigation response
       # (mirrors capybara-playwright-driver's navigation_request? hook). CDP
       # normally marks the main-document response via
-      # `Network.responseReceived.type`, but Lightpanda omits that field on
-      # responses (only emits `type` on requestWillBeSent) — so match the
-      # long way: remember the document requestId, store the response whose
-      # requestId equals it.
+      # `Network.responseReceived.type`. Lightpanda only started emitting that
+      # field on responses in build 8318 (#3037) — far above the gem's floor —
+      # so match the long way instead: remember the document requestId, store
+      # the response whose requestId equals it. Works on every supported build;
+      # don't "simplify" it to read response.type until the floor clears 8318.
       def subscribe
         @request_handler = build_request_handler
         @response_handler = build_response_handler
@@ -161,6 +162,16 @@ module Capybara
         browser.on("Network.responseReceived", &@response_handler)
       end
 
+      # Redirects follow Chrome's shape (Lightpanda since #3175, build ≥8602):
+      # every followed hop re-emits requestWillBeSent with the SAME requestId
+      # and the 3xx riding along as `redirectResponse`; the 3xx never gets a
+      # responseReceived of its own. So the hop's event is what closes the
+      # previous entry — without it that entry stays `response: nil` forever,
+      # pending_connections wedges at ≥1 and every wait_for_idle burns its
+      # full timeout after the first redirect (Ferrum's
+      # subscribe_request_will_be_sent does the same close). Deliberately NOT
+      # fed into @last_navigation_response: status_code must report the final
+      # hop, and the redirected requestWillBeSent resets it below anyway.
       def build_request_handler
         lambda do |params|
           if params["type"] == "Document"
@@ -175,6 +186,9 @@ module Capybara
             response: nil,
           }
           @traffic_mutex.synchronize do
+            if (redirect = params["redirectResponse"]) && (previous = last_open_entry(params["requestId"]))
+              previous[:response] = response_summary(redirect)
+            end
             @traffic << entry
             @traffic.shift(@traffic.size - TRAFFIC_LIMIT) if @traffic.size > TRAFFIC_LIMIT
           end
@@ -190,18 +204,30 @@ module Capybara
             }
           end
           @traffic_mutex.synchronize do
-            request = @traffic.find { |t| t[:request_id] == params["requestId"] }
+            # Last open entry, not `find`: after a redirect chain several
+            # entries share the requestId and only the newest is still open.
+            request = last_open_entry(params["requestId"])
             next unless request
 
-            request[:response] = {
-              status: params.dig("response", "status"),
-              headers: params.dig("response", "headers"),
-              mime_type: params.dig("response", "mimeType"),
-            }
+            request[:response] = response_summary(params["response"])
           end
         end
       end
 
+      # Caller holds @traffic_mutex.
+      def last_open_entry(request_id)
+        @traffic.reverse_each.find { |t| t[:request_id] == request_id && t[:response].nil? }
+      end
+
+      def response_summary(response)
+        response ||= {}
+        {
+          status: response["status"],
+          headers: response["headers"],
+          mime_type: response["mimeType"],
+        }
+      end
+
       def unsubscribe
         browser.off("Network.requestWillBeSent", @request_handler) if @request_handler
         browser.off("Network.responseReceived", @response_handler) if @response_handler