capybara-lightpanda 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11c82a5cc9cde03ae1a231efb72764a35c77beda531118960fb499c209348a3e
-  data.tar.gz: 66f4b3190f2dcc158925fd26e7b7b0590a8460d9789737d8bb08c3d5f9deed6b
+  metadata.gz: 6b898fd26a9e25f95263b605f022264cd2a132bbca82081bd931fe542c88673e
+  data.tar.gz: 4776e1326f56cd6f123538b130dfb7de1edb1a745a45574e31520a1a5227ce94
 SHA512:
-  metadata.gz: 1dc37a8e9df8fb0533718e9aa17f35cb7dc162251a0f5f46e036b054afcbeec2da928277ac3af60ac592493d80357913f1f8d2384d671baa2e802905b6357c09
-  data.tar.gz: 95c360b046406da232e6104fe9cb10aa158fedc2ff4e3cdeaa7c12042bc3bd725d9825bd8e2c730365e46c0f9f884c02c4a523af1ce9e4d582fc5aa760093e99
+  metadata.gz: 025d4fd23a6f0b4379c6e34d878610b657a06dcf33ab5490b606e5e42ed2e452475860283df232f8c397bbf1b48144f0d89be33bf7e5a70fe430a14e26bfb1a7
+  data.tar.gz: 16193011f9ea880c74300a45491ab5dbe36abe55e0a080fe1f65edf36d9722daf6e9842de361f498068952970f3f2d975a64d8b92eb8ecaf2600c01b342caf34

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.11.0] - 2026-08-25
+
+> **Update Lightpanda before upgrading.** This release requires a Lightpanda nightly build ≥ 8796 (2026-08-25 or newer). **No tagged Lightpanda release is new enough yet**: 0.3.7 is below the floor and is now refused, so version pinning is unavailable until Lightpanda ships its next release — CI runs on the rolling nightly in the meantime.
+
+### Added
+
+- **Drag and drop between elements.** `element.drag_to(target)` performs an HTML5 drag — `dragstart` through `drop` with a shared `DataTransfer`, so dropzone pages and `setData`/`getData` handlers behave as in Chrome, and drag events carry whole-number coordinates like Chrome's. Libraries that only respond to real mouse movement (SortableJS's fallback mode) remain out of reach — there is still no layout engine to drive a pointer through.
+- **`load_images` driver option.** `load_images: true` makes the browser fetch `<img>` sources over the network, so image requests appear in `network.traffic` and are counted by `wait_for_network_idle` — useful for suites that assert on image traffic. Off by default (images are skipped entirely, as before). Needs a nightly from 2026-08-26 onward.
+- **Screenshots show the page.** `save_screenshot` — and the automatic failure screenshots capybara-screenshot takes — now produce a real rendering of the page's content instead of a fixed placeholder image. It is a text-layout rendering, useful for seeing what the DOM held at failure time; pixel-accurate visual regression still needs a full browser.
+
+### Removed
+
+- The internal workaround for reading an element's `draggable` state is gone now that the browser answers natively — no change required on your end.
+
 ## [0.10.0] - 2026-08-19
 
 > **Update Lightpanda before upgrading.** This release requires a Lightpanda nightly build ≥ 8448 **or a tagged release ≥ 0.3.7**. The driver refuses to start below either floor and tells you which version it found. If you pin the browser (see below), pin `0.3.7` or newer.

data/README.md

@@ -57,7 +57,7 @@ driven_by :lightpanda
 > Lightpanda is a headless agentic browser, not a layout engine. External `<link rel="stylesheet">` **are** fetched and applied (the gem enables this by default), and `@media` / `window.matchMedia()` evaluate against the `window_size` you configure — so a mobile-only CTA gated by `@media (max-width: …)` resolves at the width you ask for. What's missing is *layout*: nothing reflows, `getBoundingClientRect` stays synthetic, and there is no real scroll. Specs that assert on pixel geometry, scrolling, or screenshots — plus the two that catch people out, a second browser tab and a menu revealed purely by CSS `:hover` — should stay on Cuprite (or whichever full-browser driver you were already using). The [per-spec dual-driver setup](https://navidemad.github.io/capybara-lightpanda/docs/#dual-per-spec) routes that minority to Cuprite and the structural majority to Lightpanda for speed.
 
 > [!TIP]
-> For reproducible CI, pin the browser: `Capybara::Lightpanda::Binary.required_version = "0.3.7"`. Without a pin the driver tracks Lightpanda's rolling `nightly` tag, which moves under you. See [Pinning the browser version](https://navidemad.github.io/capybara-lightpanda/docs/#pinning).
+> For reproducible CI, pin the browser: `Capybara::Lightpanda::Binary.required_version = "0.3.8"`. (0.3.8 is the first release that will clear the gem's current floor, nightly build 8796 — until upstream tags it, the driver needs the rolling `nightly` tag.) Without a pin the driver tracks Lightpanda's rolling `nightly` tag, which moves under you. See [Pinning the browser version](https://navidemad.github.io/capybara-lightpanda/docs/#pinning).
 
 ## Credits
 

data/lib/capybara/lightpanda/node.rb

@@ -211,6 +211,41 @@ module Capybara
         nil
       end
 
+      # Maps Capybara's documented drop_modifiers aliases onto the DragEvent
+      # init keys (`ctrlKey`, `metaKey`, ...). Same table as Cuprite's #315.
+      DRAG_MODIFIER_ALIASES = { control: :ctrl, command: :meta, cmd: :meta }.freeze
+
+      # Capybara's `Element#drag_to` — HTML5 half only. HTML5_DRAG_JS replays
+      # Capybara's own Selenium HTML5_DRAG_DROP_SCRIPT (the same source
+      # Cuprite's drag.js ports): dragstart on the draggable ancestor, then
+      # dragenter -> 2x dragover -> dragleave/drop -> dragend, setTimeout-paced,
+      # sharing one DataTransfer so `setData` in the page's dragstart handler is
+      # readable at drop. Runs through `evaluate_async` (the script signals
+      # completion via the appended callback), so the drag has fully played out
+      # before this method returns.
+      #
+      # The legacy path is coordinate-based mouse dragging, which Lightpanda
+      # cannot express (no layout to produce coordinates from) — it raises
+      # instead of silently no-oping. `html5: nil` auto-detects like Selenium
+      # does, via LEGACY_DRAG_CHECK_JS: we dispatch a synthetic mousedown where
+      # Selenium presses a real button, then apply the same
+      # prevented-or-no-draggable-ancestor test.
+      #
+      # `steps:`/`scroll:` (Cuprite's legacy-path knobs) are accepted and
+      # ignored so suites migrating from cuprite don't ArgumentError.
+      def drag_to(other, html5: nil, delay: 0.05, drop_modifiers: [], **)
+        keys = Array(drop_modifiers).map { |m| DRAG_MODIFIER_ALIASES.fetch(m.to_sym, m.to_sym).to_s }
+        html5 = !call(LEGACY_DRAG_CHECK_JS) if html5.nil?
+        unless html5
+          raise NotImplementedError,
+                "drag_to needs coordinate mouse dispatch for non-HTML5 (legacy) drags, which Lightpanda " \
+                "cannot do (no layout). Pass `html5: true` to force HTML5 DragEvent simulation."
+        end
+
+        driver.browser.evaluate_async(HTML5_DRAG_JS, self, other, (delay * 1000).to_i, keys)
+        nil
+      end
+
       def select_option
         call(SELECT_OPTION_JS)
       end
@@ -645,6 +680,151 @@ module Capybara
         }
       JS
 
+      # Selenium's MOUSEDOWN_TRACKER + LEGACY_DRAG_CHECK folded into one round
+      # trip. Selenium presses a real mouse button before checking; we dispatch
+      # a synthetic mousedown so drag libraries that preventDefault on it
+      # (mouse-based / fallback DnD) still steer the check toward the legacy
+      # path. Returns true when the drag would need the legacy (coordinate)
+      # path: mousedown prevented / never observed, or no draggable ancestor.
+      LEGACY_DRAG_CHECK_JS = <<~JS
+        function() {
+          var doc = this.ownerDocument || document;
+          var prevented = null;
+          doc.addEventListener('mousedown', function(ev) { prevented = ev.defaultPrevented; }, { once: true });
+          this.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+          if (prevented === true || prevented === null) return true;
+          var el = this;
+          do {
+            if (el.draggable) return false;
+          } while ((el = el.parentElement));
+          return true;
+        }
+      JS
+
+      # Ported near-verbatim from Capybara's Selenium driver
+      # (capybara/selenium/extensions/html5_drag.rb, HTML5_DRAG_DROP_SCRIPT) —
+      # the same source Cuprite's #315 drag.js ports — kept close to ease
+      # future syncs. Upstream quirks preserved deliberately: `rectPt.top` in
+      # pointOnRect (DOMPoint has no .top, that branch just falls through), the
+      # undeclared `key` loop variable, and `callback.call(true)`. The
+      # `source.draggable` reads are native — the HTMLElement.draggable IDL
+      # shipped upstream in #3257 (build 8793, guaranteed by the floor; the
+      # `_lightpanda.isDraggable` polyfill was retired with that bump).
+      # Coordinates come from getBoundingClientRect, which Lightpanda
+      # synthesizes without layout — dropzones reading clientX/Y get
+      # plausible-but-synthetic (integer since #3259) numbers.
+      HTML5_DRAG_JS = <<~JS
+        function rectCenter(rect){
+          return new DOMPoint(
+            (rect.left + rect.right)/2,
+            (rect.top + rect.bottom)/2
+          );
+        }
+
+        function pointOnRect(pt, rect) {
+          var rectPt = rectCenter(rect);
+          var slope = (rectPt.y - pt.y) / (rectPt.x - pt.x);
+
+          if (pt.x <= rectPt.x) { // left side
+            var minXy = slope * (rect.left - pt.x) + pt.y;
+            if (rect.top <= minXy && minXy <= rect.bottom)
+              return new DOMPoint(rect.left, minXy);
+          }
+
+          if (pt.x >= rectPt.x) { // right side
+            var maxXy = slope * (rect.right - pt.x) + pt.y;
+            if (rect.top <= maxXy && maxXy <= rect.bottom)
+              return new DOMPoint(rect.right, maxXy);
+          }
+
+          if (pt.y <= rectPt.y) { // top side
+            var minYx = (rectPt.top - pt.y) / slope + pt.x;
+            if (rect.left <= minYx && minYx <= rect.right)
+              return new DOMPoint(minYx, rect.top);
+          }
+
+          if (pt.y >= rectPt.y) { // bottom side
+            var maxYx = (rect.bottom - pt.y) / slope + pt.x;
+            if (rect.left <= maxYx && maxYx <= rect.right)
+              return new DOMPoint(maxYx, rect.bottom);
+          }
+
+          return new DOMPoint(pt.x,pt.y);
+        }
+
+        function dragEnterTarget() {
+          target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+          var targetRect = target.getBoundingClientRect();
+          var sourceCenter = rectCenter(source.getBoundingClientRect());
+
+          for (var i = 0; i < drop_modifier_keys.length; i++) {
+            key = drop_modifier_keys[i];
+            if (key == "control"){
+              key = "ctrl"
+            }
+            opts[key + 'Key'] = true;
+          }
+
+          var dragEnterEvent = new DragEvent('dragenter', opts);
+          target.dispatchEvent(dragEnterEvent);
+
+          // fire 2 dragover events to simulate dragging with a direction
+          var entryPoint = pointOnRect(sourceCenter, targetRect)
+          var dragOverOpts = Object.assign({clientX: entryPoint.x, clientY: entryPoint.y}, opts);
+          var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+          target.dispatchEvent(dragOverEvent);
+          window.setTimeout(dragOnTarget, step_delay);
+        }
+
+        function dragOnTarget() {
+          var targetCenter = rectCenter(target.getBoundingClientRect());
+          var dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
+          var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+          target.dispatchEvent(dragOverEvent);
+          window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
+        }
+
+        function dragLeave(drop, dragOverOpts) {
+          var dragLeaveOptions = Object.assign({}, opts, dragOverOpts);
+          var dragLeaveEvent = new DragEvent('dragleave', dragLeaveOptions);
+          target.dispatchEvent(dragLeaveEvent);
+          if (drop) {
+            var dropEvent = new DragEvent('drop', dragLeaveOptions);
+            target.dispatchEvent(dropEvent);
+          }
+          var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
+          source.dispatchEvent(dragEndEvent);
+          callback.call(true);
+        }
+
+        var source = arguments[0],
+            target = arguments[1],
+            step_delay = arguments[2],
+            drop_modifier_keys = arguments[3],
+            callback = arguments[4];
+
+        var dt = new DataTransfer();
+        var opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+
+        while (source && !source.draggable) {
+          source = source.parentElement;
+        }
+
+        if (source.tagName == 'A'){
+          dt.setData('text/uri-list', source.href);
+          dt.setData('text', source.href);
+        }
+        if (source.tagName == 'IMG'){
+          dt.setData('text/uri-list', source.src);
+          dt.setData('text', source.src);
+        }
+
+        var dragEvent = new DragEvent('dragstart', opts);
+        source.dispatchEvent(dragEvent);
+
+        window.setTimeout(dragEnterTarget, step_delay);
+      JS
+
       VISIBLE_JS = "function() { return _lightpanda.isVisible(this); }"
 
       VISIBLE_TEXT_JS = "function() { return _lightpanda.visibleText(this); }"

data/lib/capybara/lightpanda/options.rb

@@ -47,9 +47,16 @@ module Capybara
       # a runaway confirm cancels the action and the spec can still pass. false
       # (default, Cuprite parity) warns on stderr; true raises
       # UnhandledModalError from the action that opened it.
+      # load_images: passes `--load-resources image` so `<img>` elements are
+      # fetched over the network (upstream #3230, build >= 8834). Off by
+      # default, matching Lightpanda's default of skipping image fetches
+      # entirely. When on, image requests ride the Network domain like any
+      # other — they show in `network.traffic` and count toward
+      # `wait_for_network_idle`. On builds < 8834 the flag is a fatal
+      # UnknownOption at boot, so only enable against binaries that have it.
       attr_accessor :host, :port, :timeout, :handshake_timeout, :process_timeout,
                     :window_size, :browser_path, :headless, :logger, :save_path,
-                    :raise_on_unhandled_modal
+                    :raise_on_unhandled_modal, :load_images
       attr_writer :ws_url
 
       def initialize(options = {})
@@ -63,6 +70,7 @@ module Capybara
         @headless = options.fetch(:headless, true)
         @save_path = options[:save_path]
         @raise_on_unhandled_modal = options.fetch(:raise_on_unhandled_modal, false)
+        @load_images = options.fetch(:load_images, false)
         @ws_url = options[:ws_url]
         @logger = parse_logger(options[:logger])
       end
@@ -88,6 +96,7 @@ module Capybara
           logger: logger,
           save_path: save_path,
           raise_on_unhandled_modal: raise_on_unhandled_modal,
+          load_images: load_images,
         }
         h[:ws_url] = @ws_url if @ws_url
         h

data/lib/capybara/lightpanda/process.rb

@@ -180,7 +180,8 @@ module Capybara
       # set, merged 2026-07-30) — a use-after-free in exactly the path
       # `Node#select_option`/`Node#set` on a <select> drives, i.e. a browser
       # crash surfacing as DeadBrowserError mid-spec.
-      # Build 8448 = the #3087 merge (6d824c88) — now the binding floor.
+      # Build 8448 = the #3087 merge (6d824c88) — the binding floor of the
+      # 2026-07-30 bump.
       # Subsumed by 8448, recorded so they are not re-derived: build 8298 made
       # Network.enable idempotent (the gem never hit it — the Notification is
       # per-BrowserContext and Network#enable's @enabled guard means one enable
@@ -191,7 +192,16 @@ module Capybara
       # `window_size` option. Note the override only reached
       # Page.getLayoutMetrics later (~build 8300); the gem does not depend on
       # that half, so it is NOT part of the floor.
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("8448")
+      #
+      # 2026-08-25 bump 8448 -> 8796: #3257 (HTMLElement.draggable IDL, build
+      # 8793) and #3259 (MouseEvent coordinate getters floor to integers
+      # Chrome-style, build 8796; PointerEvent stays fractional). The floor
+      # guarantees native `.draggable`, so the drag scripts in node.rb read it
+      # verbatim — the `_lightpanda.isDraggable` polyfill was retired with
+      # this bump — and drag events carry integer clientX/Y (the shared spec
+      # asserting that runs un-skipped). Build 8796 = the #3259 merge
+      # (341a01570), which is also the 2026-08-25 nightly cut.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("8796")
 
       # Second, equivalent floor for the *release* channel.
       #
@@ -200,15 +210,21 @@ module Capybara
       # bare "0.3.6" carrying no commit counter at all, and MINIMUM_NIGHTLY_BUILD
       # has nothing to compare against. Releases are cut from the same trunk, so
       # a release is acceptable exactly when its own commit count clears the
-      # nightly floor: 0.3.7 is build 8671, well past the #3087 merge (8448)
-      # this floor exists for. (0.3.6 is only 8318 — it predates the optgroup
-      # fix and everything after it, which is why this pin had to move.)
+      # nightly floor. As of 2026-08-25 NO published release clears the 8796
+      # floor — 0.3.7 (build 8671) predates the draggable-IDL and
+      # coordinate-flooring fixes the floor exists for — so this pin names the
+      # NEXT release. 0.3.8 is not tagged yet; any future tag is cut from a
+      # trunk already past build 8834, so it clears the floor by construction.
+      # Until upstream tags it, the release channel is deliberately unusable
+      # (nightly-only), reported with the standard too-old error. When 0.3.8
+      # ships: verify `git rev-list --count 0.3.8` >= 8796 and update the
+      # lockstep table in process_test.rb.
       #
       # INVARIANT: every MINIMUM_NIGHTLY_BUILD bump must also move this to the
       # first release containing that build (`git rev-list --count <tag>` in the
       # browser repo tells you). Leaving it behind would let the release channel
       # silently accept a binary the nightly channel rejects.
-      MINIMUM_RELEASE = Gem::Version.new("0.3.7")
+      MINIMUM_RELEASE = Gem::Version.new("0.3.8")
 
       attr_reader :pid, :ws_url, :version, :nightly_build, :release
 
@@ -371,6 +387,12 @@ module Capybara
           "--cdp-max-message-size",
           (100 * 1024 * 1024).to_s,
         ]
+        # Opt-in image fetching (upstream #3230, build >= 8834). Deliberately
+        # NOT always-on like --enable-external-stylesheets: images never feed
+        # the DOM predicates, so the default spends no bandwidth on them. On
+        # builds < 8834 the flag is a fatal UnknownOption at boot — see
+        # Options#load_images.
+        base.push("--load-resources", "image") if @options.load_images
         extra = ENV.fetch("LIGHTPANDA_EXTRA_ARGS", "").split
         base + extra
       end

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.10.0"
+    VERSION = "0.11.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Navid Emad