dommy 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47c59ce209a6e63313db2b6685126910463abfc26020ec5f24a7b7494b67b10f
-  data.tar.gz: 43980f4f5eb7b2c5bfe76e41bd2786e9c8cad571df1eb882e0e6d5107fbe04c6
+  metadata.gz: 64a22d9ba17102a03881baedbda66b5236b8c4499140d779e4c4acba86583241
+  data.tar.gz: e111a114c5a7ae9485a3e99af339e70a59dce6b9a83a837639ac6564873a8d4e
 SHA512:
-  metadata.gz: b2627fa8969554f7ecb7a04ed16c331a77e604b44a9ca9e95412a89e48412744a3dd606892255e93eb56988cfda5214000a15821bbc5eb6ed7d18701740b3262
-  data.tar.gz: 632bddbea02093111566d46ba9fc44af35ed17879bf9921c4ad477a138d44b83e2c2761337d34f5bdfa31cc150353a4b7afe47b0cca8d817e79eda95d7b556ad
+  metadata.gz: 67c651bd499d2cd0d6cf1fb862b11a9f0f6b68ba1814abe40732b990e5b66b9b5f0494fd33cb989e4b7a5f64faa3a8a152e8979231f4c082f32187999188030a
+  data.tar.gz: e7e8ee9194687b9fe6be28646e9f80d32631f3cf78e5b9fefbab5fd913b9a1d6116ab819bae3a54030f2fefc6e4fa8e478c8ab2667cc086e009c5ebb1a7c9481

data/lib/dommy/backend/makiri_adapter.rb

@@ -43,18 +43,6 @@ module Dommy
         node.clone_node(deep)
       end
 
-      # Makiri documents have no node-level clone; re-parsing the serialized
-      # document reproduces the full tree. Dispatch on the document kind so an XML
-      # document round-trips through the XML parser (case/namespaces/CDATA) and an
-      # HTML document through the HTML parser.
-      def clone_document(doc)
-        if doc.is_a?(::Makiri::XML::Document)
-          ::Makiri::XML::Document.parse(doc.to_xml)
-        else
-          ::Makiri::HTML::Document.parse(doc.to_html)
-        end
-      end
-
       # A fresh, empty HTML-backed document (children dropped so it starts with no
       # documentElement). The backing for a shallow clone of an HTML document.
       def empty_document
@@ -233,8 +221,8 @@ module Dommy
       end
 
       # Both Makiri document families (HTML and XML) mint a real PI node and
-      # serialize it (HTML as `<?target data>`, XML as `<?target data?>`), so PIs
-      # — unlike CDATA — need no HTML-document fallback.
+      # serialize it as `<?target data?>`, so PIs — unlike CDATA — need no
+      # HTML-document fallback.
       def create_processing_instruction(target, data, doc)
         doc.create_processing_instruction(target, data)
       end

data/lib/dommy/backend.rb

@@ -53,11 +53,6 @@ module Dommy
         current.clone_node(node, deep: deep)
       end
 
-      # Deep copy of a whole document (DOM cloneNode on the document).
-      def clone_document(doc)
-        current.clone_document(doc)
-      end
-
       # A fresh, empty HTML-backed document.
       def empty_document
         current.empty_document

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/custom_elements.rb

@@ -86,19 +86,16 @@ module Dommy
       promise
     end
 
-    # Walk `root`'s subtree and re-wrap any nodes whose tag is now
+    # Walk `root`'s shadow-including subtree and re-wrap any nodes whose tag is now
     # registered; fires `connectedCallback` for each upgraded node
     # that's currently attached to a document tree.
     def upgrade(root)
       return nil unless root.respond_to?(:__dommy_backend_node__)
 
-      walk_descendants(root.__dommy_backend_node__) do |nk|
-        next unless nk.element?
+      @window.document.__internal_each_shadow_including_element__(root.__dommy_backend_node__) do |nk|
         next unless @definitions.key?(nk.name)
 
-        # Force re-wrap by clearing the document's cached wrapper.
-        @window.document.__internal_reset_wrapper__(nk)
-        wrapped = @window.document.wrap_node(nk)
+        wrapped = rewrap_for_upgrade(@window.document, nk)
         next unless wrapped
 
         replay_observed_attributes(wrapped)
@@ -137,6 +134,22 @@ module Dommy
       list&.each { |p| p.fulfill(klass) }
     end
 
+    # Re-wrap `nk` as its definition's class, or nil when there is nothing to
+    # upgrade. An element that is already an instance of the class is left alone:
+    # upgrading an element that is already custom does nothing. The new wrapper
+    # is told which one it replaces, because a script may hold the element — a
+    # JS-defined element upgrades that reference in place.
+    def rewrap_for_upgrade(doc, nk)
+      previous = doc.__internal_peek_wrapper__(nk)
+      klass = @definitions[nk.name]
+      return nil if klass.is_a?(Module) && previous.is_a?(klass)
+
+      doc.__internal_reset_wrapper__(nk)
+      wrapped = doc.wrap_node(nk)
+      wrapped.__internal_upgraded_from__(previous) if previous && wrapped.respond_to?(:__internal_upgraded_from__)
+      wrapped
+    end
+
     # When define() lands after the matching element is already in
     # the document, those nodes need upgrading: re-wrap them with the
     # new class and fire connectedCallback.
@@ -145,11 +158,11 @@ module Dommy
       # Match by tag name rather than interpolating `name` into a CSS selector:
       # a spec-valid custom element name may contain "." (a CSS class selector
       # char) or other metacharacters, which would corrupt the query.
-      doc.backend_doc.css("*").each do |nk|
+      # Shadow trees included, in shadow-including tree order (define step 18).
+      doc.__internal_each_shadow_including_element__(doc.backend_doc) do |nk|
         next unless nk.name == name
 
-        doc.__internal_reset_wrapper__(nk)
-        wrapped = doc.wrap_node(nk)
+        wrapped = rewrap_for_upgrade(doc, nk)
         next unless wrapped
 
         replay_observed_attributes(wrapped)
@@ -178,12 +191,5 @@ module Dommy
         )
       end
     end
-
-    def walk_descendants(node, &blk)
-      yield node
-      return unless node.respond_to?(:children)
-
-      node.children.each { |c| walk_descendants(c, &blk) }
-    end
   end
 end