RubyGems - dommy - Versions diffs - 0.8.1 → 0.10.0 - Mend

dommy 0.8.1 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (121) hide show

checksums.yaml +4 -4
data/README.md +3 -3
data/lib/dommy/animation.rb +4 -0
data/lib/dommy/attr.rb +57 -13
data/lib/dommy/backend/makiri_adapter.rb +364 -0
data/lib/dommy/backend.rb +143 -33
data/lib/dommy/blob.rb +50 -6
data/lib/dommy/bridge.rb +11 -0
data/lib/dommy/browser.rb +420 -0
data/lib/dommy/callable_invoker.rb +6 -2
data/lib/dommy/compression_streams.rb +4 -0
data/lib/dommy/crypto.rb +4 -0
data/lib/dommy/css.rb +487 -50
data/lib/dommy/custom_elements.rb +2 -2
data/lib/dommy/data_transfer.rb +2 -0
data/lib/dommy/data_uri.rb +35 -0
data/lib/dommy/deferred_response.rb +59 -0
data/lib/dommy/document.rb +901 -275
data/lib/dommy/dom_exception.rb +2 -0
data/lib/dommy/dom_parser.rb +7 -17
data/lib/dommy/element.rb +940 -353
data/lib/dommy/event.rb +529 -17
data/lib/dommy/fetch.rb +577 -53
data/lib/dommy/form_data.rb +2 -0
data/lib/dommy/history.rb +26 -3
data/lib/dommy/html_canvas_element.rb +230 -0
data/lib/dommy/html_collection.rb +150 -27
data/lib/dommy/html_elements.rb +1968 -282
data/lib/dommy/interaction/debug.rb +35 -0
data/lib/dommy/interaction/dom_summary.rb +131 -0
data/lib/dommy/interaction/driver.rb +385 -0
data/lib/dommy/interaction/event_synthesis.rb +164 -0
data/lib/dommy/interaction/field_interactor.rb +177 -0
data/lib/dommy/interaction/form_submission.rb +268 -0
data/lib/dommy/interaction/locator.rb +158 -0
data/lib/dommy/interaction/role_query.rb +58 -0
data/lib/dommy/interaction.rb +32 -0
data/lib/dommy/internal/accessibility_tree.rb +215 -0
data/lib/dommy/internal/accessible_description.rb +38 -0
data/lib/dommy/internal/accessible_name.rb +301 -0
data/lib/dommy/internal/aria_role.rb +252 -0
data/lib/dommy/internal/aria_snapshot.rb +64 -0
data/lib/dommy/internal/aria_state.rb +151 -0
data/lib/dommy/internal/child_node.rb +199 -0
data/lib/dommy/internal/css/calc.rb +242 -0
data/lib/dommy/internal/css/cascade.rb +472 -0
data/lib/dommy/internal/css/color.rb +381 -0
data/lib/dommy/internal/css/computed_style_declaration.rb +130 -0
data/lib/dommy/internal/css/counters.rb +227 -0
data/lib/dommy/internal/css/custom_properties.rb +183 -0
data/lib/dommy/internal/css/media_query.rb +302 -0
data/lib/dommy/internal/css/parser.rb +265 -0
data/lib/dommy/internal/css/property_registry.rb +512 -0
data/lib/dommy/internal/css/rule_index.rb +494 -0
data/lib/dommy/internal/css/supports.rb +158 -0
data/lib/dommy/internal/css/ua_stylesheet.rb +53 -0
data/lib/dommy/internal/css_pseudo_handlers.rb +283 -42
data/lib/dommy/internal/css_rule_text.rb +160 -0
data/lib/dommy/internal/dom_matching.rb +80 -9
data/lib/dommy/internal/element_matching.rb +109 -0
data/lib/dommy/internal/global_functions.rb +55 -9
data/lib/dommy/internal/mutation_coordinator.rb +122 -11
data/lib/dommy/internal/namespaces.rb +49 -5
data/lib/dommy/internal/node_wrapper_cache.rb +217 -38
data/lib/dommy/internal/observer_manager.rb +6 -0
data/lib/dommy/internal/observer_matcher.rb +6 -8
data/lib/dommy/internal/parent_node.rb +98 -57
data/lib/dommy/internal/selector_ast.rb +124 -0
data/lib/dommy/internal/selector_index.rb +146 -0
data/lib/dommy/internal/selector_matcher.rb +845 -0
data/lib/dommy/internal/selector_parser.rb +321 -132
data/lib/dommy/internal/shadow_root_registry.rb +9 -2
data/lib/dommy/internal/template_content_registry.rb +26 -18
data/lib/dommy/internal/xml_serialization.rb +344 -0
data/lib/dommy/intersection_observer.rb +2 -0
data/lib/dommy/js/bridge_conformance.rb +80 -0
data/lib/dommy/js/constructor_resolver.rb +44 -0
data/lib/dommy/js/custom_element_bridge.rb +101 -0
data/lib/dommy/js/dom_interfaces.rb +177 -0
data/lib/dommy/js/handle_table.rb +60 -0
data/lib/dommy/js/host_bridge.rb +538 -0
data/lib/dommy/js/host_runtime.js +2357 -0
data/lib/dommy/js/import_map.rb +58 -0
data/lib/dommy/js/marshaller.rb +240 -0
data/lib/dommy/js/module_loader.rb +99 -0
data/lib/dommy/js/observable_runtime.js +742 -0
data/lib/dommy/js/runtime.rb +115 -0
data/lib/dommy/js/script_boot.rb +301 -0
data/lib/dommy/js/wire_tags.rb +62 -0
data/lib/dommy/location.rb +78 -13
data/lib/dommy/media_query_list.rb +50 -14
data/lib/dommy/message_channel.rb +22 -6
data/lib/dommy/minitest/assertions.rb +27 -0
data/lib/dommy/mutation_observer.rb +89 -5
data/lib/dommy/navigation.rb +263 -0
data/lib/dommy/navigator.rb +34 -2
data/lib/dommy/node.rb +198 -35
data/lib/dommy/notification.rb +2 -0
data/lib/dommy/parser.rb +1 -1
data/lib/dommy/performance.rb +21 -1
data/lib/dommy/promise.rb +94 -10
data/lib/dommy/range.rb +187 -33
data/lib/dommy/resources.rb +178 -0
data/lib/dommy/rspec/capy_style_matchers.rb +126 -0
data/lib/dommy/scheduler.rb +165 -13
data/lib/dommy/screen.rb +91 -0
data/lib/dommy/shadow_root.rb +109 -13
data/lib/dommy/storage.rb +63 -11
data/lib/dommy/streams.rb +6 -0
data/lib/dommy/text_codec.rb +7 -1
data/lib/dommy/tree_walker.rb +51 -46
data/lib/dommy/url.rb +17 -3
data/lib/dommy/version.rb +1 -1
data/lib/dommy/web_socket.rb +45 -2
data/lib/dommy/window.rb +322 -15
data/lib/dommy/worker.rb +8 -4
data/lib/dommy/xml_http_request.rb +76 -9
data/lib/dommy.rb +38 -1
metadata +82 -14
data/lib/dommy/backend/nokogiri_adapter.rb +0 -127
data/lib/dommy/backend/nokolexbor_adapter.rb +0 -117

data/lib/dommy/browser.rb ADDED Viewed

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+module Dommy
+  # A lightweight test browser: parse HTML, build window/document, run its
+  # classic `<script>` tags (inline + external via a resources adapter), fire
+  # DOMContentLoaded/load, and collect JS errors / console output. For
+  # standalone HTML + JS (bundled SPA, fixture HTML); the Rack/Rails entry point
+  # is `Dommy::Rack::Session` (a later phase).
+  #
+  #   Dommy::Browser.open(html, resources: Dommy::Resources.static("/app.js" => "...")) do |b|
+  #     b.settle
+  #     b.evaluate('document.querySelector("h1").textContent')
+  #   end
+  #
+  # JS errors are not swallowed: in strict mode (default) any unhandled rejection
+  # or uncaught script error fails at the next checkpoint (after boot, after
+  # `settle`, at dispose). Wrap intentional errors in `allow_js_errors { … }`.
+  class Browser
+    # Capybara-vocabulary finding / scoping / field interaction / click /
+    # matchers come from the shared interaction layer; each interaction's events
+    # are dispatched Ruby-side (synchronously invoking JS handlers), then
+    # `after_interaction` drains the runtime's microtasks so promise reactions
+    # settle before the next line.
+    include Dommy::Interaction::Driver
+    # Raised in strict mode when JS errors were collected and not acknowledged.
+    class JsError < StandardError
+      attr_reader :causes
+      def initialize(causes)
+        @causes = causes
+        super(build_message(causes))
+      end
+      private
+      def build_message(causes)
+        lines = causes.map { |e| "  #{e.class}: #{e.message}" }
+        "#{causes.length} uncaught JS error(s):\n#{lines.join("\n")}"
+      end
+    end
+    attr_reader :window, :runtime, :js_errors, :console
+    # Build a browser and (unless `execute_scripts: false`) boot its scripts. In
+    # block form the browser is yielded and disposed afterward, returning the
+    # block value.
+    def self.open(html, **opts)
+      browser = new(html, **opts)
+      return browser unless block_given?
+      begin
+        yield browser
+      ensure
+        browser.dispose
+      end
+    end
+    # Start a navigable session by fetching the initial document from
+    # `resources`, rather than passing literal HTML. Links / forms / location
+    # then perform real cross-document navigation (fetch → replace Window + JS
+    # realm), with the browser handle (history, resources, error log) surviving.
+    #   Dommy::Browser.visit("http://localhost/", resources: my_resources)
+    def self.visit(url, resources:, **opts)
+      browser = new("<!doctype html><html><head></head><body></body></html>",
+        url: "about:blank", resources: resources, navigable: true, **opts)
+      browser.visit(url, replace: true)
+      browser
+    end
+    def initialize(html, url: "http://localhost/", resources: nil, execute_scripts: true, strict: true, settle: true,
+      wasm_memory_shim: false, backend: nil, navigable: false, same_origin: false)
+      @resources = resources
+      @same_origin = same_origin
+      @strict = strict
+      @backend = backend
+      @execute_scripts = execute_scripts
+      @settle_after_boot = settle
+      @wasm_memory_shim = wasm_memory_shim
+      @navigable = navigable
+      @js_errors = []
+      @console = []
+      @acknowledged = 0
+      @allow_errors = false
+      @disposed = false
+      @pending_navigation = nil
+      @runtime = nil
+      @window = Dommy.parse(html)
+      @window.location.__internal_set_url__(url) if url
+      install_runtime(@window)
+      if navigable
+        @fetcher = Navigation::Fetcher.new(@resources, same_origin: @same_origin)
+        @history = Navigation::JointHistory.new
+        @window.navigation_delegate = self
+        @history.push(current_url, window: @window, windex: @window.history.__internal_index__)
+      end
+      check_js_errors!
+    end
+    def document = @window.document
+    # Current document HTML (serialized).
+    def html = @window.document.document_element&.outer_html
+    # The current document's URL (the address bar).
+    def current_url = @window.location.href
+    # The joint (tab) history of a navigable browser, or nil for a plain
+    # single-document browser.
+    attr_reader :history
+    # Programmatically navigate to `url` (a Ruby-initiated visit). Only
+    # meaningful for a navigable browser; performs the fetch + document swap
+    # immediately (there is no JS on the stack).
+    def visit(url, replace: false)
+      raise "browser is not navigable (use Browser.visit or navigable: true)" unless @navigable
+      @pending_navigation = {url: url.to_s, method: "GET", source: :visit, replace: replace}
+      flush_navigation!
+      self
+    end
+    # Reload the current document (re-fetch, replace the current history entry).
+    def reload
+      visit(current_url, replace: true)
+    end
+    # Move back / forward one entry in the joint history. A same-document target
+    # (the entry's window is still live) traverses in place (popstate); a
+    # document-boundary target is re-fetched (no bfcache — D2).
+    def back = traverse(-1)
+    def forward = traverse(1)
+    # --- NavigationDelegate port (see Dommy::Navigation) ---
+    # A cross-document navigation intent (link / form / location). Navigation is
+    # a task: rather than swap the Window + JS realm synchronously (which may run
+    # while the outgoing realm's JS is still on the stack — e.g. `location.href =`
+    # inside a script), record it and perform the fetch + swap at the next drain
+    # boundary (settle / after_interaction / advance_time). Ruby-initiated visits
+    # flush immediately since no JS is on the stack.
+    def navigate(url:, source:, method: "GET", body: nil, params: nil, enctype: nil, headers: {}, replace: false)
+      @pending_navigation = {
+        url: url, method: method, body: body, params: params, enctype: enctype,
+        headers: headers, replace: replace, source: source
+      }
+      nil
+    end
+    # A cross-document history traversal. Ruby-initiated (back / forward), so it
+    # runs immediately: a same-document target (its window is still live)
+    # traverses in place (popstate); a document-boundary target is re-fetched.
+    def traverse(delta)
+      return self unless @navigable
+      entry = delta.negative? ? @history.back : @history.forward
+      return self unless entry
+      if entry.window && entry.window.equal?(@window)
+        @window.history.__internal_go_to__(entry.windex)
+        @runtime.drain_microtasks
+        check_js_errors!
+      else
+        perform_navigation!({url: entry.url, method: "GET", source: :traverse}, rebind: true)
+      end
+      self
+    end
+    # Evaluate an expression / statement body and return the decoded value.
+    def evaluate(js)
+      result = @runtime.evaluate(js)
+      check_js_errors!
+      result
+    end
+    # Run JS for side effects.
+    def execute(js)
+      @runtime.execute(js)
+      check_js_errors!
+      nil
+    end
+    # Settle the work ready at the current virtual time: drain microtasks, run
+    # due-now timers, flush requestAnimationFrame. Does NOT fire a future
+    # `setTimeout(300)` — use `advance_time(300)` for debounce/throttle.
+    def settle
+      @runtime.settle
+      flush_navigation!
+      check_js_errors!
+      self
+    end
+    # Advance virtual time by `ms`, running timers that come due, then settle.
+    def advance_time(ms)
+      @window.scheduler.advance_time(ms)
+      @runtime.drain_microtasks
+      flush_navigation!
+      check_js_errors!
+      self
+    end
+    # An interaction's events have been dispatched (Ruby-side, synchronously
+    # invoking JS handlers); drain the runtime's microtasks so promise reactions
+    # land before the next line, then enforce strict mode.
+    def after_interaction
+      @runtime.drain_microtasks
+      flush_navigation!
+      check_js_errors!
+    end
+    # Click a submit-capable button. The button's click event fires (JS may
+    # handle / preventDefault it); if it is an un-prevented submit button, the
+    # owning form's submission algorithm runs (a real SubmitEvent a SPA can
+    # intercept, then the delegate navigation). In a navigable browser that
+    # follows the submit for real; otherwise the delegate just records it.
+    def click_button(locator)
+      button = finder.find_button(locator)
+      # An un-prevented click runs the button's activation behavior — a submit
+      # button submits its owning form (real SubmitEvent + delegate navigation),
+      # so a navigable browser follows the submit for real.
+      Dommy::Interaction::EventSynthesis.click(button)
+      after_interaction
+      button
+    end
+    # Click a link, firing its click event so SPA JS (Turbo, React Router, …)
+    # can intercept. An un-prevented click runs the anchor's activation behavior
+    # (follow-the-hyperlink); in a navigable browser that navigates for real,
+    # otherwise the delegate records it.
+    def click_link(locator)
+      link = finder.find_link(locator)
+      Dommy::Interaction::EventSynthesis.click(link)
+      after_interaction
+      link
+    end
+    # Suppress strict-mode failure for JS errors raised inside the block (they
+    # stay collected in #js_errors for inspection). For tests that expect errors.
+    def allow_js_errors
+      prev = @allow_errors
+      @allow_errors = true
+      yield
+    ensure
+      @allow_errors = prev
+      @acknowledged = @js_errors.length
+    end
+    def dispose
+      return if @disposed
+      @disposed = true
+      pending = unacknowledged
+      @runtime&.dispose
+      raise JsError, pending if @strict && !pending.empty?
+    end
+    private
+    # Build a fresh JS realm for `window`, wire error/console/fetch/external-
+    # script seams, and boot its `<script>` tags. Disposes the previous realm
+    # first (a no-op on the initial load), so a navigation tears the outgoing
+    # realm — and with it every pending timer / microtask on the old Window's
+    # scheduler — down before the new page runs.
+    def install_runtime(window)
+      @runtime&.dispose
+      # The JS engine is pluggable: `@backend` selects a registered runtime
+      # (nil → the configured default, QuickJS when dommy-js-quickjs is loaded).
+      runtime = Js.build_runtime(@backend)
+      runtime.on_unhandled_rejection { |err| @js_errors << err }
+      runtime.on_callback_error { |err| @js_errors << err } if runtime.respond_to?(:on_callback_error)
+      runtime.on_log { |log| @console << log }
+      runtime.define_host_object("document", window.document)
+      runtime.install_window(window)
+      runtime.install_browser_globals
+      # Opt-in WPT scaffolding (common/sab.js derives SharedArrayBuffer through
+      # WebAssembly.Memory); off by default so real pages don't see the shim.
+      runtime.install_wasm_memory_shim if @wasm_memory_shim && runtime.respond_to?(:install_wasm_memory_shim)
+      window.globals["__fetch_handler__"] = Resources::FetchHandler.new(@resources) if @resources
+      @runtime = runtime
+      return unless @execute_scripts
+      doc = window.document
+      # Dynamically-inserted `<script src>` (webpack/Vite on-demand chunks)
+      # fetch + run through the same resources adapter, after boot.
+      doc.external_script_runner = lambda do |element, src|
+        Js::ScriptBoot.run_external_script(runtime, doc, element, src,
+          resources: @resources, on_error: ->(e) { @js_errors << e })
+      end
+      Js::ScriptBoot.run_document_scripts(
+        runtime, doc, resources: @resources, on_error: ->(e) { @js_errors << e }
+      )
+      # Leave the page in a ready state: run on-load promises, due-now timers,
+      # and rAF (not future timers). `settle: false` observes it mid-flight.
+      runtime.settle if @settle_after_boot
+    end
+    # Perform a recorded navigation: fetch the target (following redirects),
+    # fire the old document's unload, then replace the Window + JS realm with the
+    # freshly parsed document and update the joint history. A network miss or a
+    # non-document response leaves the current page in place.
+    MAX_META_REFRESHES = 20
+    def perform_navigation!(nav, rebind: false, refresh_depth: 0)
+      response, final_url = @fetcher.request(
+        method: nav[:method] || "GET", url: nav[:url], params: nav[:params],
+        body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
+      )
+      return unless response&.success? && document_response?(response)
+      # Fire the outgoing document's unload sequence while its realm is still
+      # alive, then surface any of its errors before the realm is torn down.
+      fire_unload(@window)
+      check_js_errors!
+      new_window = Dommy.parse(response.body)
+      new_window.location.__internal_set_url__(final_url)
+      new_window.navigation_delegate = self
+      @window = new_window
+      install_runtime(new_window)
+      windex = new_window.history.__internal_index__
+      if rebind || nav[:replace]
+        @history.rebind_current(url: final_url, window: new_window, windex: windex)
+      else
+        @history.push(final_url, window: new_window, windex: windex)
+      end
+      follow_meta_refresh!(refresh_depth)
+    end
+    # If the freshly loaded document asks for an immediate `<meta http-equiv=
+    # refresh>`, follow it (as a replace, like a redirect), capped so a page that
+    # refreshes to itself can't loop forever.
+    def follow_meta_refresh!(depth)
+      return if depth >= MAX_META_REFRESHES
+      target = meta_refresh_target(@window.document)
+      return unless target
+      perform_navigation!({url: target, method: "GET", source: :meta_refresh},
+        rebind: true, refresh_depth: depth + 1)
+    end
+    # The resolved URL a `<meta http-equiv="refresh" content="0; url=…">` points
+    # at, or nil when the document has none (or a refresh with no URL, which just
+    # reloads and is left alone to avoid a busy loop).
+    def meta_refresh_target(document)
+      document.query_selector_all("meta").each do |meta|
+        next unless meta.get_attribute("http-equiv").to_s.casecmp?("refresh")
+        _delay, separator, rest = meta.get_attribute("content").to_s.partition(";")
+        next if separator.empty?
+        url = rest.strip.sub(/\Aurl\s*=\s*/i, "").gsub(/\A["']|["']\z/, "").strip
+        return resolve_against_current(url) unless url.empty?
+      end
+      nil
+    end
+    def resolve_against_current(url)
+      URI.join(current_url, url).to_s
+    rescue URI::InvalidURIError
+      url
+    end
+    # Perform a pending navigation recorded by the delegate (JS-initiated
+    # location.href= / form submit / link click). Called at drain boundaries so
+    # the swap never runs with the outgoing realm's JS on the stack.
+    def flush_navigation!
+      return unless @navigable
+      nav = @pending_navigation
+      return unless nav
+      @pending_navigation = nil
+      perform_navigation!(nav)
+    end
+    def fire_unload(window)
+      window.dispatch_event(Dommy::Event.new("pagehide"))
+      window.dispatch_event(Dommy::Event.new("unload"))
+    end
+    # Only HTML/XML responses replace the document; other content types (a JSON
+    # API hit, an image) leave the current page. A response with no Content-Type
+    # is treated as a document (fixtures commonly omit it).
+    def document_response?(response)
+      headers = response.headers || {}
+      key = headers.keys.find { |k| k.to_s.casecmp?("content-type") }
+      content_type = key ? headers[key].to_s.downcase : ""
+      content_type.empty? || content_type.include?("html") || content_type.include?("xml")
+    end
+    def unacknowledged = @js_errors[@acknowledged..] || []
+    def submit_button?(button)
+      if button.tag_name == "BUTTON"
+        button.type == "submit"
+      else
+        %w[submit image].include?(button.type)
+      end
+    end
+    # In strict mode, fail on any JS error collected since the last
+    # acknowledgement. Marks all current errors acknowledged so each is reported
+    # at most once.
+    def check_js_errors!
+      return if @allow_errors
+      return unless @strict
+      pending = unacknowledged
+      return if pending.empty?
+      @acknowledged = @js_errors.length
+      raise JsError, pending
+    end
+  end
+end

data/lib/dommy/callable_invoker.rb CHANGED Viewed

@@ -22,12 +22,16 @@ module Dommy
     # Invoke a DOM event listener per the EventTarget rule: an object with
     # `handle_event`, else a Ruby callable, else a JS-bridged callable (tried in
-    # that order).
-    def invoke_listener(listener, event)
+    # that order). A JS function listener's `this` must be the event's
+    # currentTarget (the node the listener is attached to), so pass it through
+    # when the bridge supports an explicit receiver.
+    def invoke_listener(listener, event, current_target = nil)
       if listener.respond_to?(:handle_event)
         listener.handle_event(event)
       elsif listener.respond_to?(:call) && !listener.is_a?(Module)
         listener.call(event)
+      elsif listener.respond_to?(:__js_call_with_this__)
+        listener.__js_call_with_this__([event], current_target)
       elsif listener.respond_to?(:__js_call__)
         listener.__js_call__("call", [event])
       end

data/lib/dommy/compression_streams.rb CHANGED Viewed

@@ -44,6 +44,8 @@ module Dommy
         @readable
       when "writable"
         @writable
+      else
+        Bridge::ABSENT
       end
     end
@@ -111,6 +113,8 @@ module Dommy
         @readable
       when "writable"
         @writable
+      else
+        Bridge::ABSENT
       end
     end

data/lib/dommy/crypto.rb CHANGED Viewed

@@ -59,6 +59,8 @@ module Dommy
       case key
       when "subtle"
         subtle
+      else
+        Bridge::ABSENT
       end
     end
@@ -396,6 +398,8 @@ module Dommy
         {"name" => @algorithm_name, "hash" => {"name" => @hash_name}}
       when "usages"
         @usages
+      else
+        Bridge::ABSENT
       end
     end
   end