dommy 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6306b86751026b1b48072c497fd34cd008c5b0bfe1838ae62ab3896d89a2aa3f
-  data.tar.gz: 817d56deed527b5f2718242937bb1a30a7d22738ca8f09276750505cf9368b5a
+  metadata.gz: 64a22d9ba17102a03881baedbda66b5236b8c4499140d779e4c4acba86583241
+  data.tar.gz: e111a114c5a7ae9485a3e99af339e70a59dce6b9a83a837639ac6564873a8d4e
 SHA512:
-  metadata.gz: bfce9a98c80d522db534045b6ee378d0bdfb8e1f03646173e4fc74fd5e8ed46e35e723fe4ce5f7828cdab9d71b6e567c2022ad63d01f2f70af8a0baf0acd34cf
-  data.tar.gz: 6b0aa54054201df72970198f18450268d53cbe434b3da15bd9b49cd68eb98b9d94ae1acf80d40b668706052385fa8597e4580b683c472760ee970a10ee13d2f4
+  metadata.gz: 67c651bd499d2cd0d6cf1fb862b11a9f0f6b68ba1814abe40732b990e5b66b9b5f0494fd33cb989e4b7a5f64faa3a8a152e8979231f4c082f32187999188030a
+  data.tar.gz: e7e8ee9194687b9fe6be28646e9f80d32631f3cf78e5b9fefbab5fd913b9a1d6116ab819bae3a54030f2fefc6e4fa8e478c8ab2667cc086e009c5ebb1a7c9481

data/lib/dommy/bridge.rb

@@ -57,9 +57,20 @@ module Dommy
     class JSValue
       attr_reader :ref
 
-      def initialize(ref, label = nil)
+      # `stack_frames` are the value's JS stack, when the tag that crossed
+      # carried one. Ruby cannot reach through a ref to read `.stack`, so an
+      # error-shaped value brings its frames with it (see host_runtime.js
+      # tagValue) and reporting uses them for the source position.
+      attr_reader :stack_frames
+
+      # The value's JS constructor name, when the tag carried one.
+      attr_reader :js_name
+
+      def initialize(ref, label = nil, stack_frames = nil, js_name = nil)
         @ref = ref
         @label = label
+        @stack_frames = stack_frames
+        @js_name = js_name
       end
 
       def to_s = (@label || "[object]").to_s
@@ -75,9 +86,11 @@ module Dommy
     class ThrowValue < RuntimeError
       attr_reader :value
 
-      def initialize(value)
+      # `message` overrides the value's string form, for a caller that can say
+      # more about it than `to_s` can (a JS error's kind, say).
+      def initialize(value, message = nil)
         @value = value
-        super(value.to_s)
+        super(message || value.to_s)
       end
     end
 

data/lib/dommy/browser.rb

@@ -23,24 +23,14 @@ module Dommy
     # 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
+    attr_reader :window, :runtime, :console
 
-      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
+    # The ledger of errors the page left unhandled (`Dommy::Js::ErrorLog`);
+    # shared with the other hosts so strict mode behaves the same everywhere.
+    attr_reader :error_log
 
-    attr_reader :window, :runtime, :js_errors, :console
+    # The errors themselves, as a browser console's scrollback.
+    def js_errors = @error_log.errors
 
     # Build a browser and (unless `execute_scripts: false`) boot its scripts. In
     # block form the browser is yielded and disposed afterward, returning the
@@ -72,16 +62,13 @@ module Dommy
       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 = []
+      @error_log = Js::ErrorLog.new(strict: strict)
       @console = []
-      @acknowledged = 0
-      @allow_errors = false
       @disposed = false
       @pending_navigation = nil
       @runtime = nil
@@ -238,22 +225,19 @@ module Dommy
 
     # 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
+    def allow_js_errors(&block)
+      @error_log.allow(&block)
     end
 
+    # Tear the realm down, then fail on anything the page left unhandled and
+    # nobody has reported. Disposing first means the failure cannot leave a live
+    # VM behind.
     def dispose
       return if @disposed
 
       @disposed = true
-      pending = unacknowledged
       @runtime&.dispose
-      raise JsError, pending if @strict && !pending.empty?
+      @error_log.check!(context: current_url)
     end
 
     private
@@ -268,8 +252,19 @@ module Dommy
       # 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)
+      # Every uncaught error the page produces goes through the window's
+      # "report an exception" / "notify about rejected promises" funnel, and only
+      # what the page left unhandled lands here. A page that installs its own
+      # `window.onerror` / `unhandledrejection` handler and cancels the event
+      # suppresses the failure, exactly as it would in a browser.
+      window.__internal_on_unhandled_error__ { |err| @error_log.record(err) }
+      # A rejection the page handled after we reported it is retracted, so it
+      # stops failing anything (WHATWG `rejectionhandled`).
+      window.__internal_on_rejection_handled__ { |record| @error_log.retract(record) }
+      runtime.on_unhandled_rejection { |err| report_rejection(window, err) }
+      if runtime.respond_to?(:on_callback_error)
+        runtime.on_callback_error { |err| Internal::ExceptionReport.report_at(window, err) }
+      end
       runtime.on_log { |log| @console << log }
       runtime.define_host_object("document", window.document)
       runtime.install_window(window)
@@ -285,24 +280,35 @@ module Dommy
       # Installed whenever a runtime is attached — an embedder that drives script
       # boot itself (`execute_scripts: false`) still needs inline handlers wired.
       doc.inline_handler_wirer = lambda do
-        Js::ScriptBoot.wire_inline_handlers(runtime, on_error: ->(e) { @js_errors << e })
+        Js::ScriptBoot.wire_inline_handlers(runtime, on_error: ->(e) { @error_log.record(e) })
       end
       return unless @execute_scripts
 
+      # `on_error:` here is only the windowless fallback — a booted document has
+      # a window, so a throwing script reports through it (see ScriptBoot).
+
       # 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 })
+          resources: @resources, on_error: ->(e) { @error_log.record(e) })
       end
       Js::ScriptBoot.run_document_scripts(
-        runtime, doc, resources: @resources, on_error: ->(e) { @js_errors << e }
+        runtime, doc, resources: @resources, on_error: ->(e) { @error_log.record(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
 
+    # Route an unhandled promise rejection through the page's own
+    # `unhandledrejection` handling first. The engine decides WHEN a rejection
+    # counts as unhandled (see Window#__internal_report_rejection__).
+    def report_rejection(window, error)
+      value = Internal::ExceptionReport.error_value(error)
+      window.__internal_report_rejection__(value, host_error: error)
+    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
@@ -400,8 +406,6 @@ module Dommy
       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"
@@ -410,18 +414,10 @@ module Dommy
       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.
+    # In strict mode, fail on anything the page left unhandled since the last
+    # checkpoint. The ledger drains itself, so each error is reported 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
+      @error_log.check!(context: current_url)
     end
   end
 end

data/lib/dommy/callable_invoker.rb

@@ -20,6 +20,22 @@ module Dommy
       end
     end
 
+    # Invoke `callback` so a JS throw SURFACES as a Ruby exception instead of
+    # being swallowed by the bridge. WHATWG requires a task's exception to be
+    # reported at the global ("report an exception") rather than silently
+    # dropped, so the entry points that own a task — a timer / rAF callback —
+    # invoke this form and report whatever comes out. The plain `invoke` keeps
+    # the swallowing behavior for callers that handle their own errors.
+    def invoke_raising(callback, *args)
+      return if callback.nil?
+
+      if callback.respond_to?(:__js_invoke__)
+        callback.__js_invoke__(args, raising: true)
+      else
+        invoke(callback, *args)
+      end
+    end
+
     # 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). A JS function listener's `this` must be the event's

data/lib/dommy/compression_streams.rb

@@ -10,43 +10,18 @@ module Dommy
   # finalizes and emits the compressed/decompressed bytes downstream.
   #
   # Spec: https://wicg.github.io/compression/
-  class CompressionStream
+  class CompressionStream < TransformStream
     SUPPORTED = %w[gzip deflate deflate-raw].freeze
 
-    attr_reader :readable, :writable
-
     def initialize(window, format)
       raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
 
-      @buffer = +""
+      buffer = +""
       compressor = build_compressor(format.to_s)
-
-      @readable = ReadableStream.new(window)
-      controller = TransformStreamDefaultController.new(@readable)
-
-      @writable = WritableStream.new(
-        window,
-        {
-          "write" => proc { |chunk| @buffer << coerce(chunk) },
-          "close" => proc do
-            compressed = compressor.call(@buffer)
-            controller.enqueue(compressed)
-            @readable.__internal_close__
-          end,
-          "abort" => proc { |r| @readable.__internal_error__(r) }
-        }
-      )
-    end
-
-    def __js_get__(key)
-      case key
-      when "readable"
-        @readable
-      when "writable"
-        @writable
-      else
-        Bridge::ABSENT
-      end
+      super(window, {
+        "transform" => proc { |chunk, _controller| buffer << coerce(chunk); nil },
+        "flush" => proc { |controller| controller.enqueue(compressor.call(buffer)); nil }
+      })
     end
 
     private
@@ -79,43 +54,18 @@ module Dommy
     end
   end
 
-  class DecompressionStream
+  class DecompressionStream < TransformStream
     SUPPORTED = %w[gzip deflate deflate-raw].freeze
 
-    attr_reader :readable, :writable
-
     def initialize(window, format)
       raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
 
-      @buffer = +""
+      buffer = +""
       decompressor = build_decompressor(format.to_s)
-
-      @readable = ReadableStream.new(window)
-      controller = TransformStreamDefaultController.new(@readable)
-
-      @writable = WritableStream.new(
-        window,
-        {
-          "write" => proc { |chunk| @buffer << coerce(chunk) },
-          "close" => proc do
-            plain = decompressor.call(@buffer)
-            controller.enqueue(plain)
-            @readable.__internal_close__
-          end,
-          "abort" => proc { |r| @readable.__internal_error__(r) }
-        }
-      )
-    end
-
-    def __js_get__(key)
-      case key
-      when "readable"
-        @readable
-      when "writable"
-        @writable
-      else
-        Bridge::ABSENT
-      end
+      super(window, {
+        "transform" => proc { |chunk, _controller| buffer << coerce(chunk); nil },
+        "flush" => proc { |controller| controller.enqueue(decompressor.call(buffer)); nil }
+      })
     end
 
     private

data/lib/dommy/document.rb

@@ -810,11 +810,11 @@ module Dommy
       href = base_el["href"].to_s
       return doc_url if href.empty?
 
-      begin
-        URI.join(doc_url.to_s.empty? ? "about:blank" : doc_url, href).to_s
-      rescue URI::InvalidURIError
-        doc_url
-      end
+      # HTML "document base URL": the frozen base URL is the href parsed
+      # against the document's URL; one that does not parse falls back.
+      URL.new(href, doc_url.to_s.empty? ? nil : doc_url).href
+    rescue Bridge::TypeError
+      doc_url
     end
 
     # `document.domain` — host portion of the URL. Real browsers

data/lib/dommy/element.rb

@@ -2623,9 +2623,8 @@ module Dommy
     # so `a.href = "http://example.org/?ä"` reads back percent-encoded — which is
     # what the URL parser produces and what `URI.join` does not.
     def resolve_url(raw)
-      win = @document.default_view
-      base = win&.location ? win.location.href : ""
-      base = nil if base.to_s.empty?
+      base = @document.base_uri.to_s
+      base = nil if base.empty?
       Internal::UrlParser.serialize(Internal::UrlParser.parse(raw.to_s, base))
     rescue Internal::UrlParser::Failure
       raw.to_s