capybara-simulated 0.7.0 → 0.9.0

data/lib/capybara/simulated/node.rb

@@ -122,16 +122,39 @@ module Capybara
         self
       end
 
-      def scroll_to(*, **)       ; self ; end
+      # Capybara's driver `scroll_to` contract (from Element#scroll_to): a target element + align
+      # symbol, a position symbol (`:top`/`:bottom`/`:center`), or an `[x, y]` coordinate pair.
+      # `self` is the element it was called on — the document root for a session-level scroll (routed
+      # via `find('/html')`), else an element. Drives a real scroll offset in the layout engine.
+      def scroll_to(target = nil, arg = nil, coords = nil)
+        check_stale
+        if target
+          browser.scroll_to(handle_id, target.handle_id, arg)
+        elsif coords
+          browser.scroll_to(handle_id, nil, nil, coords[0], coords[1])
+        elsif arg
+          browser.scroll_to(handle_id, nil, arg)
+        end
+        self
+      end
+
+      # Capybara's `Element#scroll_to(:current, offset: [dx, dy])` calls this after the position
+      # handling above — a relative scroll from wherever the element is now.
+      def scroll_by(dx, dy)
+        check_stale
+        browser.scroll_by(handle_id, dx, dy)
+        self
+      end
 
       # Capybara's standard rect API. No layout engine — but
-      # Discourse's `wait_for_animation` helper polls `element.rect[:x]`
-      # twice and waits for the values to stabilise, which they
-      # immediately do here (constant zeros) since we never animate.
-      # That unblocks every test guarded by an animation settle.
+      # The element's coarse border-box (viewport-relative), from the layout engine — backs the
+      # spatial selectors (`:above`/`:below`/`:near`) and coordinate drag. Deterministic per layout
+      # generation (memoised; only a DOM/style mutation changes it), so Discourse's
+      # `wait_for_animation` — which polls `element.rect[:x]` twice and waits for it to stabilise —
+      # still settles immediately when nothing is animating.
       def rect
         check_stale
-        {x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, bottom: 0, right: 0}
+        browser.rect(handle_id)
       end
 
       def send_keys(*keys)
@@ -195,7 +218,10 @@ module Capybara
       def selected?        = browser.option_selected?(handle_id)
       def checked?         = !!self['checked']
       def readonly?        = !!self['readonly']
-      def obscured?(*)     = !visible?
+      def obscured?(*)
+        check_stale
+        browser.obscured?(handle_id)
+      end
       def synchronize(*)   = yield
       def style(names = [])
         check_stale

data/lib/capybara/simulated/quickjs_runtime.rb

@@ -13,6 +13,23 @@
 
 require 'digest'
 require 'quickjs'
+begin
+  # Intl moved out of the quickjs gem in 0.19. bridge.js patches Intl.DateTimeFormat, so the
+  # companion gem is required for the QuickJS engine — say so plainly rather than letting a bare
+  # LoadError name a file the user never asked for.
+  require 'quickjs-polyfill-intl/datetimeformat'
+rescue LoadError
+  raise LoadError, <<~MSG
+    capybara-simulated's QuickJS engine needs the `quickjs-polyfill-intl` gem
+    (quickjs 0.19 moved Intl out of the core gem, and the DOM bridge uses
+    Intl.DateTimeFormat). Add it next to quickjs:
+
+        gem 'quickjs', '>= 0.19'
+        gem 'quickjs-polyfill-intl'
+
+    Or use the V8 engine (`gem 'rusty_racer'`), which has ICU built in.
+  MSG
+end
 
 require_relative 'runtime_shared'
 require_relative 'worker_runtime'
@@ -150,6 +167,19 @@ module Capybara
         normalize(result)
       end
 
+      # QuickJS has no per-frame realms (iframes share the one VM): `within_frame` falls back to
+      # the same realm, and any realm id routes to the single global context.
+      def supports_frames? = false
+
+      def realm_call(_realm_id, name, *args) = call(name, *args)
+
+      # No per-frame realms, so no realm is ever "alive" as a distinct browsing context —
+      # every client id resolves to 'client-window' (the single global). Defined so a
+      # caller that gates realm routing on it (deliver_worker_messages) works on both engines.
+      def frame_realm_alive?(_realm_id) = false
+
+      def frame_realm_ids = []
+
       # bridge.js owns the virtual clock; we drive it from Ruby because
       # Capybara's polling cadence is wall-clock-anchored.
       def drain_timers(max_ms = nil)
@@ -216,28 +246,44 @@ module Capybara
       # already the inter-test reset point.
       def reset_page = rebuild_ctx
 
-      # NOTE: intentionally NO `dispose` — Browser#dispose gates its
-      # `@runtime.dispose` call on `respond_to?(:dispose)`, so QuickJS skips it.
-      # QuickJS VMs aren't pinned by a process-wide registry the way V8 isolates
-      # are in V8Runtime's `@@live`; an aux window's Browser becomes unreferenced
-      # on close and Ruby GC's dfree frees its `@vm` (the same lifecycle
-      # `rebuild_ctx` already relies on). Adding a `@vm = nil` dispose would only
-      # introduce a NoMethodError window for any stray post-close call (eval/call
-      # don't all nil-guard `@vm`) with no leak benefit.
+      # PERMANENTLY drop this runtime. Distinct from `rebuild_ctx` above, which
+      # deliberately does NOT `dispose!` — that runs per visit, on every example,
+      # and `dispose!` blocks on the quickjs GC with the GVL held. Here it runs
+      # once, when a session is dropped for good, and the cost is the point.
+      #
+      # This used to be intentionally absent, on the reasoning that Ruby GC's
+      # dfree would reach an unreferenced `@vm` on its own. Measured, it does not
+      # in time to matter: 30 sessions created and dropped in a loop held 1979 MB
+      # with no dispose and 1971 MB with one, because `Browser#dispose` gates on
+      # `respond_to?(:dispose)` and so did nothing at all here. The suite's peak
+      # RSS is what pays for it.
+      #
+      # The old note's hazard — a stray post-close `eval`/`call` finding `@vm`
+      # nil — is real, so this leaves `@vm` in place and lets the gem's own
+      # freed-VM handling answer; `Driver#disposed?` keeps the live-driver walk
+      # from stepping a dropped runtime in the first place.
+      def dispose
+        @vm&.dispose!
+      rescue StandardError
+        nil
+      end
 
       # bridge.js patches `Intl.DateTimeFormat`; rusty_racer ships ICU built-in but
       # QuickJS gates it behind a polyfill flag (other surfaces bridge.js touches —
       # URL / TextEncoder / atob/btoa / crypto — already route through Ruby host fns,
       # so POLYFILL_INTL is the only one we strictly need).
       #
-      # PERF (rule 3): quickjs is pinned to `~> 0.18.0` in the Gemfile. quickjs 0.19
-      # both split the Intl polyfills into a separate quickjs-polyfill-intl gem (which
-      # eval's them per VM at ~226 ms — vs this single bundled flag's ~140 ms) AND
-      # regressed interpreter execution ~2.8× (measured: the QuickJS spec suite ran
-      # 5.6 min on 0.18 vs 15.5 min on 0.19 with an equivalent Intl set). The 0.19
-      # migration is recorded in the cross-window / quickjs-CI memory; re-migrate to
-      # 0.19 + quickjs-polyfill-intl once that upstream perf regression is fixed.
-      INTL_FEATURES = [Quickjs::POLYFILL_INTL].freeze
+      # Since 0.19 the Intl polyfills live in the separate `quickjs-polyfill-intl`
+      # gem, registered by name instead of quickjs's old bundled `POLYFILL_INTL`
+      # flag. `:polyfill_intl_datetimeformat_all` is the whole DateTimeFormat chain
+      # (getcanonicallocales → locale → pluralrules → numberformat → datetimeformat)
+      # as ONE registration — the only chain bridge.js needs, and cheaper than
+      # requiring the five links separately.
+      #
+      # PERF (rule 3): the polyfill source is eval'd per VM, and the VM-pool pre-warm
+      # used to be GVL-serial, which put every feature on the critical path. quickjs
+      # now releases the GVL while loading polyfills, so the pre-warm overlaps.
+      INTL_FEATURES = [:polyfill_intl_datetimeformat_all].freeze
       #
       # `max_stack_size: 0` — `JS_SetMaxStackSize` measures C stack
       # delta from runtime construction; Ruby callers reach QuickJS
@@ -352,11 +398,22 @@ module Capybara
       # host fns attached *after* the replay (so snapshot_stubs.js's
       # no-ops don't overwrite real ones), `__csim_isWorker` set, +
       # the per-worker postMessage routed through `post_back`.
-      def self.build_worker(browser, post_back)
+      def self.build_worker(browser, post_back, broadcast_out = nil, sw_hooks = {})
         vm = Quickjs::VM.new(**VM_OPTIONS)
         bridge_runnable.run(on: vm)
         attach_host_fns(vm, browser)
         vm.define_function('__csim_workerPostMessage') {|data| post_back.call(data); nil }
+        # A worker's BroadcastChannel fan-out routes through the thread-safe outbox, not
+        # `browser.broadcast_to_windows` (cross-thread inbox mutation). See v8_runtime#build_worker.
+        vm.define_function('__csimBroadcast') {|name, data, _rid, origin| broadcast_out&.call(name, data, origin); nil } if broadcast_out
+        # Service-worker → main-thread signals via the outbox (see v8_runtime#build_worker).
+        vm.define_function('__csim_swPostToClient') {|client_id, data| sw_hooks[:post_to_client]&.call(client_id, data); nil } if sw_hooks[:post_to_client]
+        vm.define_function('__csim_swFocusClient')  {|client_id|       sw_hooks[:focus_client]&.call(client_id);       nil } if sw_hooks[:focus_client]
+        vm.define_function('__csim_swClaim') { sw_hooks[:claim]&.call; nil } if sw_hooks[:claim]
+        vm.define_function('__csim_swFetchRespond') {|fetch_id, resp, realm_id| sw_hooks[:fetch_respond]&.call(fetch_id, resp, realm_id); nil } if sw_hooks[:fetch_respond]
+        vm.define_function('__csim_swFetchStream') {|fetch_id, kind, payload, realm_id| sw_hooks[:fetch_stream]&.call(fetch_id, kind, payload, realm_id); nil } if sw_hooks[:fetch_stream]
+        vm.define_function('__csim_workerPortPost')     {|channel, data| sw_hooks[:port_post]&.call(channel, data); nil } if sw_hooks[:port_post]
+        vm.define_function('__csim_workerPortEndpoint') {|channel|       sw_hooks[:port_endpoint]&.call(channel); nil } if sw_hooks[:port_endpoint]
         # Override main's __setTimersActive so worker's empty-timer-map
         # flip doesn't race main's `polling?` gate. See v8_runtime's
         # build_worker for the long-form rationale.