dommy 0.8.0 → 0.9.0

data/lib/dommy/mutation_observer.rb

@@ -63,6 +63,8 @@ module Dommy
         @attribute_namespace
       when "oldValue"
         @old_value
+      else
+        Bridge::ABSENT
       end
     end
   end
@@ -76,6 +78,12 @@ module Dommy
       @records = []
       @scheduled = false
       @registered_docs = []
+      # Transient registered observers (WHATWG DOM): when a node is removed from
+      # an observed subtree, its subtree keeps being observed until the next
+      # microtask checkpoint, so mutations inside the just-removed subtree (e.g.
+      # removing its children in the same task) are still recorded. Each entry is
+      # { root: wrapped removed node, source: the registration that matched }.
+      @transients = []
     end
 
     include Bridge::Methods
@@ -102,16 +110,37 @@ module Dommy
     # or nil if target doesn't match any observed scope.
     def find_matching_entry(target_wrapped)
       matcher = Internal::ObserverMatcher.new
-      @observed.find do |entry|
-        observed_wrapped = entry[:target]
+      entry = @observed.find do |e|
+        observed_wrapped = e[:target]
         next false unless observed_wrapped
 
         if observed_wrapped.is_a?(Document)
-          matcher.matches_document?(target_wrapped, subtree: entry[:subtree])
+          matcher.matches_document?(target_wrapped, subtree: e[:subtree])
         else
-          matcher.matches?(observed_wrapped, target_wrapped, subtree: entry[:subtree])
+          matcher.matches?(observed_wrapped, target_wrapped, subtree: e[:subtree])
         end
       end
+      return entry if entry
+
+      # A transient registered observer matches the removed node itself and its
+      # (now-detached) descendants, with the source registration's options.
+      transient = @transients.find do |t|
+        root = t[:root]
+        root && (root.equal?(target_wrapped) || matcher.matches?(root, target_wrapped, subtree: true))
+      end
+      transient && transient[:source]
+    end
+
+    # Register a transient registered observer for a node just removed from an
+    # observed subtree (see @transients). Carries the matched registration's
+    # options so subsequent mutations inside the removed subtree record the same
+    # types. Deduped by node identity.
+    def add_transient(root_wrapped, source_entry)
+      return unless root_wrapped && source_entry && source_entry[:subtree]
+      return if @transients.any? { |t| t[:root].equal?(root_wrapped) }
+
+      @transients << {root: root_wrapped, source: source_entry}
+      nil
     end
 
     def enqueue(record)
@@ -217,17 +246,34 @@ module Dommy
       out = @records.dup
       @records.clear
       @scheduled = false
+      # A microtask checkpoint ends the transient registrations' lifetime.
+      @transients.clear
       out
     end
 
     def flush
       @scheduled = false
+      @transients.clear
       return if @records.empty?
 
       records = @records.dup
       @records.clear
       # Per spec the callback receives (mutationRecords, observer) and is invoked
       # with `this` set to the observer.
+      invoke_observer_callback(records)
+    rescue StandardError => e
+      # A throwing observer callback MUST NOT escape its dispatch — WHATWG says to
+      # report the exception and keep notifying the other observers, and a page's
+      # JS must not be derailed by it. The engine swallows this for callbacks
+      # (HostBridge#invoke_callback, raising:false), but that has proven
+      # engine/Ruby-version-dependent, so guard here too. Without this, one broken
+      # observer (e.g. an image lazy-loader that throws on a batch of <img>
+      # mutations) cascades into a blank / "something went wrong" page.
+      __dommy_dump_mo_failure__(records, e) if ENV["DOMMY_MO_DEBUG"]
+      nil
+    end
+
+    def invoke_observer_callback(records)
       if @callback.respond_to?(:__js_call_with_this__)
         @callback.__js_call_with_this__([records, self], self)
       elsif @callback.respond_to?(:__js_call__)
@@ -237,6 +283,45 @@ module Dommy
       end
     end
 
+    # Diagnostic only (DOMMY_MO_DEBUG=1): when a page's MutationObserver callback
+    # throws, append what it was handed + the error to a log file, so an
+    # otherwise-unreproducible failure (e.g. note.com's React #446 inside its
+    # resource observer) can be traced to the records/DOM it choked on.
+    def __dommy_dump_mo_failure__(records, error)
+      path = ENV["DOMMY_MO_DEBUG"]
+      path = "/tmp/dommy_mo_debug.log" if path == "1" || path.to_s.empty?
+      lines = ["=== MutationObserver callback raised: #{error.class}: #{error.message.to_s[0, 200]}",
+               "  observing #{@observed.size} target(s): " +
+                 @observed.first(3).map { |e|
+                   t = e[:target]
+                   "#{t.respond_to?(:__js_get__) ? t.__js_get__("nodeName") : t.class} " \
+                     "{childList:#{e[:child_list]},subtree:#{e[:subtree]},attrs:#{e[:attributes]},cdata:#{e[:character_data]}}"
+                 }.inspect[0, 200],
+               "  #{records.size} record(s):"]
+      records.first(40).each { |r| lines << "    - #{__dommy_record_summary__(r)}" }
+      (error.backtrace || []).grep(/\.js:/).first(6).each { |f| lines << "    js@ #{f[0, 140]}" }
+      ::File.open(path, "a") { |f| f.puts(lines.join("\n")) }
+    rescue StandardError
+      nil
+    end
+
+    def __dommy_record_summary__(record)
+      get = ->(key) { record.respond_to?(:__js_get__) ? record.__js_get__(key) : nil }
+      name = ->(n) { n.respond_to?(:__js_get__) ? n.__js_get__("nodeName") : n.class.name }
+      added = __dommy_node_names__(get.call("addedNodes"), name)
+      removed = __dommy_node_names__(get.call("removedNodes"), name)
+      "type=#{get.call("type")} target=#{name.call(get.call("target"))} " \
+        "added=#{added.first(6).inspect} removed=#{removed.first(6).inspect} attr=#{get.call("attributeName").inspect}"
+    rescue StandardError => e
+      "(summary failed: #{e.class})"
+    end
+
+    def __dommy_node_names__(list, name)
+      (list.respond_to?(:to_a) ? list.to_a : []).map { |n| name.call(n) }
+    rescue StandardError
+      []
+    end
+
     # A MutationObserverInit member is a WebIDL `boolean`, so its value is
     # converted with JS ToBoolean — any object (e.g. `attributes: ["abc"]`) is
     # truthy; only false / 0 / "" / null / undefined / NaN are falsy.

data/lib/dommy/navigator.rb

@@ -8,7 +8,8 @@ module Dommy
   class Navigator
     DEFAULT_USER_AGENT = "Mozilla/5.0 (Dommy) Ruby"
 
-    attr_accessor :user_agent, :language, :languages, :platform, :vendor, :on_line, :cookie_enabled
+    attr_accessor :user_agent, :language, :languages, :platform, :vendor, :on_line, :cookie_enabled,
+      :hardware_concurrency, :max_touch_points
 
     def initialize(window)
       @window = window
@@ -19,6 +20,8 @@ module Dommy
       @vendor = "Dommy"
       @on_line = true
       @cookie_enabled = true
+      @hardware_concurrency = 8 # logical CPU count reported to JS
+      @max_touch_points = 0     # 0 => not a touch device
       @clipboard = Clipboard.new(window)
       @permissions = Permissions.new(window)
       @geolocation = Geolocation.new(window)
@@ -43,6 +46,15 @@ module Dommy
 
     alias canShare can_share
 
+    # `navigator.sendBeacon(url, data)` — fire-and-forget POST used for analytics.
+    # Dommy does not emit the request (no background egress); it just reports
+    # success so callers that feature-detect `sendBeacon` take the beacon path.
+    def send_beacon(_url, _data = nil)
+      true
+    end
+
+    alias sendBeacon send_beacon
+
     # Vibration API. No-op in dommy, but the requested pattern is
     # recorded so tests can assert "we asked to vibrate".
     def vibrate(pattern)
@@ -91,6 +103,10 @@ module Dommy
         @on_line
       when "cookieEnabled"
         @cookie_enabled
+      when "hardwareConcurrency"
+        @hardware_concurrency
+      when "maxTouchPoints"
+        @max_touch_points
       when "clipboard"
         @clipboard
       when "permissions"
@@ -103,11 +119,17 @@ module Dommy
         @locks
       when "storage"
         @storage
+      else
+        # An unknown navigator property is genuinely absent: JS `undefined` value
+        # AND `"x" in navigator` false — so feature detection like
+        # `navigator.scheduling !== undefined` / `"serviceWorker" in navigator`
+        # both take the not-supported path instead of dereferencing null.
+        Bridge::ABSENT
       end
     end
 
     include Bridge::Methods
-    js_methods %w[share canShare vibrate getBattery]
+    js_methods %w[share canShare vibrate getBattery sendBeacon]
     def __js_call__(method, args)
       case method
       when "share"
@@ -118,6 +140,8 @@ module Dommy
         vibrate(args[0])
       when "getBattery"
         get_battery
+      when "sendBeacon"
+        send_beacon(args[0], args[1])
       end
     end
 
@@ -307,6 +331,8 @@ module Dommy
         @state
       when "onchange"
         @onchange
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -484,6 +510,8 @@ module Dommy
         @type
       when "released"
         @released
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -525,6 +553,8 @@ module Dommy
         @discharging_time
       when "level"
         @level
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -602,6 +632,8 @@ module Dommy
         name
       when "mode"
         mode
+      else
+        Bridge::ABSENT
       end
     end
   end

data/lib/dommy/node.rb

@@ -58,20 +58,23 @@ module Dommy
         if key.is_a?(Integer) || key.to_s.match?(/\A-?\d+\z/)
           token = item(key.to_i)
           token.nil? ? Bridge::UNDEFINED : token
+        else
+          Bridge::ABSENT # unknown non-index property
         end
       end
     end
 
     include Bridge::Methods
-    # keys/values/entries/Symbol.iterator are provided JS-side (the array-like
-    # prototype) so they return real iterators, not arrays — see host_runtime.js.
-    js_methods %w[item forEach]
+    # forEach/keys/values/entries/Symbol.iterator come from the array-like
+    # prototype JS-side (the actual %Array.prototype% functions) — see NodeList
+    # and host_runtime.js. A host `forEach` would shadow that and break the call
+    # (a JS callback arrives as a HostCallback, not a block). Only `item` needs a
+    # host method.
+    js_methods %w[item]
     def __js_call__(method, args)
       case method
       when "item"
         item(args[0])
-      when "forEach"
-        for_each(&args[0])
       end
     end
   end
@@ -167,20 +170,24 @@ module Dommy
         if key.is_a?(Integer) || key.to_s.match?(/\A-?\d+\z/)
           token = item(key.to_i)
           token.nil? ? Bridge::UNDEFINED : token
+        else
+          Bridge::ABSENT # unknown non-index property
         end
       end
     end
 
     include Bridge::Methods
-    # keys/values/entries/Symbol.iterator are provided JS-side (the array-like
-    # prototype) so they return real iterators, not arrays — see host_runtime.js.
-    js_methods %w[item forEach]
+    # forEach/keys/values/entries/Symbol.iterator are provided JS-side (the
+    # array-like prototype is seeded with the actual %Array.prototype% functions)
+    # so `list.forEach === Array.prototype.forEach` and they return real
+    # iterators, not arrays — see host_runtime.js. Exposing a host `forEach` here
+    # would shadow that prototype copy (and a JS callback reaches Ruby as a
+    # HostCallback, not a block). Only `item` needs a host method.
+    js_methods %w[item]
     def __js_call__(method, args)
       case method
       when "item"
         item(args[0])
-      when "forEach"
-        for_each(&args[0])
       end
     end
   end
@@ -271,7 +278,7 @@ module Dommy
       # The topmost node of an attached subtree is the Nokogiri document, which
       # has no element wrapper — map it to the Document. A detached node's root is
       # itself.
-      return @document if @document && node.equal?(@document.nokogiri_doc)
+      return @document if @document && node.equal?(@document.backend_doc)
 
       (@document && @document.wrap_node(node)) || self
     end
@@ -286,10 +293,13 @@ module Dommy
       wanted = namespace_prefix_arg(prefix)
       nk = nearest_namespaceable_node
       while nk.respond_to?(:element?) && nk.element?
-        nk.namespace_definitions.each do |d|
+        Backend.namespace_definitions(nk).each do |d|
           return d.href if normalize_ns_prefix(d.prefix) == wanted
         end
-        return nk.namespace ? nk.namespace.href : HTML_NAMESPACE if wanted.nil?
+        if wanted.nil?
+          ns = Backend.namespace_of(nk)
+          return ns ? ns.href : HTML_NAMESPACE
+        end
 
         nk = nk.parent
       end
@@ -304,7 +314,7 @@ module Dommy
 
       nk = nearest_namespaceable_node
       while nk.respond_to?(:element?) && nk.element?
-        nk.namespace_definitions.each do |d|
+        Backend.namespace_definitions(nk).each do |d|
           return d.prefix if d.href == ns && d.prefix
         end
         nk = nk.parent

data/lib/dommy/notification.rb

@@ -66,6 +66,8 @@ module Dommy
         @tag
       when "data"
         @data
+      else
+        Bridge::ABSENT
       end
     end
 

data/lib/dommy/parser.rb

@@ -8,7 +8,7 @@ module Dommy
   # Known quirks (vary by backend):
   # - Nokogiri (libxml2): `<table>`-only fragments wrap children in
   #   an implicit `<tbody>`; `<select>` reparents non-option children.
-  # - Nokolexbor (Lexbor): similar behavior, slightly different edge
+  # - Makiri (Lexbor): similar behavior, slightly different edge
   #   cases for malformed input.
   #
   # `owner_doc` is critical: when a node parsed via a detached

data/lib/dommy/performance.rb

@@ -11,10 +11,26 @@ module Dommy
     def initialize(window)
       @window = window
       @entries = []
+      # In browser mode (dommynx sets DOMMY_REAL_TIME_PERFORMANCE) `now` tracks
+      # REAL wall-clock, not the deterministic scheduler's virtual clock. Virtual
+      # time only advances between tasks (in advance_time), so it is FROZEN inside
+      # a long synchronous task — and a concurrent renderer (React's scheduler)
+      # decides when to yield by watching performance.now() cross a ~5ms frame
+      # budget. With a frozen clock it never crosses, so React renders the entire
+      # fiber tree in ONE eval that overruns the eval timeout ("InternalError:
+      # interrupted"). A real clock lets it slice the work and yield (via
+      # MessageChannel), so each eval stays short. Off by default → tests keep the
+      # deterministic virtual clock.
+      @real_time = !ENV["DOMMY_REAL_TIME_PERFORMANCE"].to_s.empty?
+      @real_origin = nil
     end
 
     def now
-      @window.scheduler.now_ms.to_f
+      return @window.scheduler.now_ms.to_f unless @real_time
+
+      current = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      @real_origin ||= current
+      current - @real_origin
     end
 
     def mark(name, options = nil)
@@ -90,6 +106,8 @@ module Dommy
         now
       when "timeOrigin"
         0.0
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -144,6 +162,8 @@ module Dommy
         duration
       when "detail"
         detail
+      else
+        Bridge::ABSENT
       end
     end
   end

data/lib/dommy/promise.rb

@@ -14,7 +14,7 @@ module Dommy
       when "name"
         @name
       else
-        nil
+        Bridge::ABSENT
       end
     end
 
@@ -52,13 +52,15 @@ module Dommy
     end
 
     include Bridge::Methods
-    js_methods %w[then catch]
+    js_methods %w[then catch finally]
     def __js_call__(method, args)
       case method
       when "then"
         attach_then(args[0], args[1])
       when "catch"
         attach_then(nil, args[0])
+      when "finally"
+        attach_finally(args[0])
       else
         nil
       end
@@ -86,7 +88,7 @@ module Dommy
     # microtask drain — that's a sign that real-time work (e.g. a
     # `setTimeout`) needs to advance via `advance_time` first.
     def await
-      @window&.scheduler&.drain_microtasks
+      drive_until_settled
 
       case @state
       when :fulfilled
@@ -94,12 +96,29 @@ module Dommy
       when :rejected
         raise unwrap_rejection(@value)
       else
-        raise "Promise#await: still pending after microtask drain"
+        raise "Promise#await: still pending after draining the event loop"
       end
     end
 
     private
 
+    # Drive the event loop over the work that is ready NOW until this promise
+    # settles: `advance_time(0)` runs the microtask checkpoint plus every task
+    # already due (a fetch's setTimeout(0) delivery and anything it queues),
+    # WITHOUT moving the clock forward. A promise waiting on a real delay
+    # (setTimeout(100)) is left pending — that still needs an explicit
+    # `advance_time`, so #await reports it pending rather than silently jumping
+    # virtual time. Bounded against a self-rescheduling setTimeout(0).
+    def drive_until_settled
+      sched = @window&.scheduler
+      return unless sched
+
+      64.times do
+        sched.advance_time(0)
+        break unless @state == :pending && sched.next_due_timer_at == sched.now_ms
+      end
+    end
+
     def unwrap_rejection(value)
       case value
       when Exception
@@ -118,10 +137,47 @@ module Dommy
       child
     end
 
+    # ES2018 `finally(onFinally)` — run `onFinally` (no args) whichever way the
+    # promise settles, then PASS THROUGH the original value/reason. Equivalent to
+    # `then(v => P.resolve(onFinally()).then(() => v),
+    #       e => P.resolve(onFinally()).then(() => { throw e }))`:
+    # onFinally can't change the resolution value, but if it throws or returns a
+    # rejected promise that rejection wins, and a returned promise is awaited
+    # before passing through. A non-callable onFinally is a plain passthrough.
+    # `fetch(...).finally(hideSpinner)` is ubiquitous, so a missing `finally`
+    # crashes real bundles (hatena's ad/guide scripts hit exactly this).
+    def attach_finally(on_finally)
+      return attach_then(on_finally, on_finally) unless callable?(on_finally)
+
+      on_fulfilled = proc { |value| coerce_to_promise(call_finally(on_finally)).__js_call__("then", [proc { value }]) }
+      on_rejected = proc { |reason|
+        coerce_to_promise(call_finally(on_finally)).__js_call__("then", [proc { raise Bridge::ThrowValue.new(reason) }])
+      }
+      attach_then(on_fulfilled, on_rejected)
+    end
+
+    # Invoke onFinally with no arguments, in raising mode so a throw rejects the
+    # finally-chain (run_handler's rescue carries the thrown value through).
+    def call_finally(on_finally)
+      if on_finally.respond_to?(:__js_call_with_raise__)
+        on_finally.__js_call_with_raise__([])
+      else
+        on_finally.call
+      end
+    end
+
+    def coerce_to_promise(value)
+      value.is_a?(PromiseValue) ? value : self.class.resolve(@window, value)
+    end
+
     def settle(state, value)
       return self if settled?
 
-      if value.is_a?(PromiseValue)
+      # Only RESOLUTION adopts a promise — fulfilling with a host promise takes
+      # its eventual state (Promises/A+ §2.3.2). A rejection REASON is never
+      # resolved: `reject(aPromise)` rejects WITH that promise as the reason, so
+      # `then(null, r => r === aPromise)` holds (2.3.3.3.2 with a promise reason).
+      if state == :fulfilled && value.is_a?(PromiseValue)
         return adopt(value)
       end
 
@@ -168,15 +224,22 @@ module Dommy
 
     def run_handler(handler)
       callback = @state == :fulfilled ? handler.on_fulfilled : handler.on_rejected
-      if callback.nil?
+      unless callable?(callback)
+        # §2.2.7.3/.4: a non-function handler (`then(5)`, `then(null, {})`) passes
+        # the settled state straight through to the child, value/reason intact.
         propagate(handler.child)
         return
       end
 
-      result = CallableInvoker.invoke(callback, @value)
-      if result.is_a?(PromiseValue) && !result.equal?(handler.child)
-        # Adopt the returned thenable. The continuation procs return nil so their
-        # `self`-returning fulfill/reject don't get re-adopted (infinite chain).
+      result = invoke_handler(callback, @value)
+      if result.equal?(handler.child)
+        # §2.3.1: a handler returning its own promise is a cycle — reject with a
+        # TypeError rather than adopting itself forever.
+        handler.child.reject(Bridge::TypeError.new("Chaining cycle detected for promise"))
+      elsif result.is_a?(PromiseValue)
+        # Adopt the returned host promise. The continuation procs return nil so
+        # their `self`-returning fulfill/reject don't get re-adopted (infinite
+        # chain).
         result.__js_call__(
           "then",
           [
@@ -188,10 +251,31 @@ module Dommy
         handler.child.fulfill(result)
       end
 
+    rescue Bridge::ThrowValue => e
+      # §2.2.7.2: the handler threw — reject the child with the thrown value
+      # ITSELF (identity preserved across the bridge), not a wrapping ErrorValue.
+      handler.child.reject(e.value)
     rescue StandardError => e
       handler.child.reject(ErrorValue.new(e.message, name: e.class.to_s))
     end
 
+    # A callable handler is a JS function (HostCallback) or a Ruby proc; a plain
+    # value (number, null, object) is not, and triggers §2.2.7.3/.4 passthrough.
+    def callable?(callback)
+      callback.respond_to?(:__js_call__) || callback.respond_to?(:call)
+    end
+
+    # Invoke a `.then` handler. A JS callback is invoked in RAISING mode so a
+    # thrown value re-raises as a Bridge::ThrowValue (§2.2.7.2) instead of being
+    # swallowed; a Ruby callable raises naturally.
+    def invoke_handler(callback, value)
+      if callback.respond_to?(:__js_call_with_raise__)
+        callback.__js_call_with_raise__([value])
+      else
+        CallableInvoker.invoke(callback, value)
+      end
+    end
+
     def propagate(child)
       @state == :fulfilled ? child.fulfill(@value) : child.reject(@value)
     end