dommy 0.6.0 → 0.7.0

data/lib/dommy/event.rb

@@ -54,24 +54,30 @@ module Dommy
       # Per spec, dispatchEvent must receive an Event instance.
       raise TypeError, "dispatchEvent requires an Event, got #{event.class}" unless event.is_a?(Event)
 
-      event.__prepare_for_dispatch__(self)
+      event.__internal_prepare_for_dispatch__(self)
       path = if event.bubbles?
         event.__js_get__("composed") ? composed_bubble_path(event) : event_bubble_path
       else
         [self]
       end
 
-      event.__record_path__(path) if event.respond_to?(:__record_path__)
+      event.__internal_record_path__(path) if event.respond_to?(:__internal_record_path__)
       path.each do |target|
-        event.__set_current_target__(target)
-        target.__deliver_event__(event)
+        event.__internal_set_current_target__(target)
+        target.__internal_deliver_event__(event)
         break if event.propagation_stopped?
       end
 
+      # WHATWG: after dispatch completes, currentTarget reverts to
+      # null and eventPhase reverts to NONE. Dommy derives
+      # eventPhase from currentTarget, so clearing it here covers
+      # both spec requirements.
+      event.__internal_set_current_target__(nil)
+
       !event.default_prevented?
     end
 
-    def __deliver_event__(event)
+    def __internal_deliver_event__(event)
       listeners = listeners_for(event.type).dup
       listeners.each do |entry|
         invoke_listener(entry.listener, event)
@@ -106,7 +112,7 @@ module Dommy
     def event_bubble_path
       path = [self]
       current = self
-      while (current = current.send(:__event_parent__))
+      while (current = current.send(:__internal_event_parent__))
         path << current
       end
 
@@ -116,12 +122,12 @@ module Dommy
     # Build the propagation path with optional shadow-boundary
     # crossing. When the in-flight event has `composed: true`, the
     # walk continues from a ShadowRoot to its host; otherwise it
-    # stops at the shadow boundary (nil from `__event_parent__`).
+    # stops at the shadow boundary (nil from `__internal_event_parent__`).
     def composed_bubble_path(event)
       path = [self]
       current = self
       loop do
-        nxt = current.send(:__event_parent__)
+        nxt = current.send(:__internal_event_parent__)
         if nxt.nil? && event.respond_to?(:__js_get__) && event.__js_get__("composed")
           # Try to cross a shadow boundary
           if current.is_a?(ShadowRoot)
@@ -148,12 +154,12 @@ module Dommy
     private
 
     def enclosing_shadow_root_of(target)
-      return nil unless target.respond_to?(:__node__)
+      return nil unless target.respond_to?(:__dommy_backend_node__)
 
       doc = target.instance_variable_get(:@document)
-      return nil unless doc && doc.respond_to?(:__shadow_root_containing__)
+      return nil unless doc && doc.respond_to?(:__internal_shadow_root_containing__)
 
-      doc.__shadow_root_containing__(target.__node__)
+      doc.__internal_shadow_root_containing__(target.__dommy_backend_node__)
     end
 
     public
@@ -178,6 +184,12 @@ module Dommy
   class StandaloneEventTarget
     include EventTarget
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[addEventListener removeEventListener dispatchEvent].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "addEventListener"
@@ -191,7 +203,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
   end
@@ -232,11 +244,11 @@ module Dommy
       @immediate_propagation_stopped
     end
 
-    def __prepare_for_dispatch__(target)
+    def __internal_prepare_for_dispatch__(target)
       @target ||= target
     end
 
-    def __set_current_target__(target)
+    def __internal_set_current_target__(target)
       @current_target = target
     end
 
@@ -276,6 +288,12 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[preventDefault stopPropagation stopImmediatePropagation composedPath initEvent].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "preventDefault"
@@ -314,7 +332,7 @@ module Dommy
     # Per spec, `load` events do not propagate to the Window when
     # composed paths are computed (resource-finished signal stays at
     # the target).
-    def __record_path__(targets)
+    def __internal_record_path__(targets)
       @composed_path = if @type == "load"
         targets.reject { |t| t.is_a?(Window) }
       else
@@ -640,6 +658,12 @@ module Dommy
       end
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[item].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "item"
@@ -823,7 +847,7 @@ module Dommy
     # signal. Convenient for APIs that need an already-cancelled token.
     def self.abort(reason = nil)
       signal = new
-      signal.__mark_aborted__(reason)
+      signal.__internal_mark_aborted__(reason)
       signal
     end
 
@@ -836,9 +860,9 @@ module Dommy
       signal = new
       reason = DOMException::TimeoutError.new("operation timed out")
       if scheduler
-        scheduler.set_timeout(proc { signal.__mark_aborted__(reason) }, ms.to_i)
+        scheduler.set_timeout(proc { signal.__internal_mark_aborted__(reason) }, ms.to_i)
       else
-        signal.__schedule_thread_timeout__(ms.to_i, reason)
+        signal.__internal_schedule_thread_timeout__(ms.to_i, reason)
       end
 
       signal
@@ -853,12 +877,12 @@ module Dommy
       list = Array(signals).select { |s| s.is_a?(AbortSignal) }
       already = list.find(&:aborted?)
       if already
-        composite.__mark_aborted__(already.reason)
+        composite.__internal_mark_aborted__(already.reason)
         return composite
       end
 
       list.each do |sig|
-        sig.add_event_listener("abort", proc { composite.__mark_aborted__(sig.reason) })
+        sig.add_event_listener("abort", proc { composite.__internal_mark_aborted__(sig.reason) })
       end
 
       composite
@@ -871,11 +895,11 @@ module Dommy
 
     # Background-thread timeout used by `AbortSignal.timeout` when no
     # scheduler is provided. Kept package-private; tests can also
-    # drive the abort manually via `__mark_aborted__`.
-    def __schedule_thread_timeout__(ms, reason)
+    # drive the abort manually via `__internal_mark_aborted__`.
+    def __internal_schedule_thread_timeout__(ms, reason)
       Thread.new do
         sleep(ms.to_f / 1000.0)
-        __mark_aborted__(reason)
+        __internal_mark_aborted__(reason)
       end
 
       nil
@@ -912,6 +936,12 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[addEventListener removeEventListener dispatchEvent throwIfAborted].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "addEventListener"
@@ -925,7 +955,7 @@ module Dommy
       end
     end
 
-    def __mark_aborted__(reason = nil)
+    def __internal_mark_aborted__(reason = nil)
       return if @aborted
 
       @aborted = true
@@ -949,10 +979,16 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[abort].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "abort"
-        @signal.__mark_aborted__(args[0])
+        @signal.__internal_mark_aborted__(args[0])
       end
     end
   end

data/lib/dommy/event_source.rb

@@ -4,9 +4,9 @@ module Dommy
   # `EventSource` (Server-Sent Events). Like `WebSocket`, dommy
   # provides simulation seams instead of network IO:
   #
-  #   es.__simulate_open__
-  #   es.__simulate_message__(data, event: "msg", id: "1")
-  #   es.__simulate_error__
+  #   es.__test_simulate_open__
+  #   es.__test_simulate_message__(data, event: "msg", id: "1")
+  #   es.__test_simulate_error__
   #
   # Auto-opens on a microtask after construction, mirroring real
   # browser behavior.
@@ -31,7 +31,7 @@ module Dommy
       @with_credentials = !!(opts["withCredentials"] || opts[:withCredentials])
       @inline_handlers = {}
 
-      @window.scheduler.queue_microtask(proc { __simulate_open__ })
+      @window.scheduler.queue_microtask(proc { __test_simulate_open__ })
     end
 
     def close
@@ -41,14 +41,14 @@ module Dommy
 
     # --- Test seams ------------------------------------------------
 
-    def __simulate_open__
+    def __test_simulate_open__
       return if @ready_state != CONNECTING
 
       @ready_state = OPEN
       dispatch_event(Event.new("open"))
     end
 
-    def __simulate_message__(data, event: "message", id: nil, retry_ms: nil)
+    def __test_simulate_message__(data, event: "message", id: nil, retry_ms: nil)
       return if @ready_state != OPEN
 
       payload = {"data" => data.to_s}
@@ -57,7 +57,7 @@ module Dommy
       dispatch_event(MessageEvent.new(event.to_s, payload))
     end
 
-    def __simulate_error__
+    def __test_simulate_error__
       dispatch_event(Event.new("error"))
     end
 
@@ -101,7 +101,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 

data/lib/dommy/fetch.rb

@@ -227,8 +227,10 @@ module Dommy
           rejected(err)
         end
 
-      when "arrayBuffer", "blob"
-        immediate(@body)
+      when "arrayBuffer"
+        immediate(@body.bytes)
+      when "blob"
+        immediate(Blob.new([@body], "type" => @headers.__js_call__("get", ["content-type"]) || ""))
       when "clone"
         Response.new(
           @window,
@@ -280,15 +282,21 @@ module Dommy
       when "entries"
         @hash.to_a
       when "has"
-        @hash.key?(args[0].to_s)
+        # Match `get`'s case-insensitive lookup: try the raw name
+        # first, then the Title-Case canonical form. WHATWG defines
+        # header names as case-insensitive throughout the Headers API.
+        name = args[0].to_s
+        @hash.key?(name) || @hash.key?(Headers.canonical(name))
       when "forEach"
-        # Browser API: forEach(callback) — callback(value, key)
+        # WHATWG: forEach(callback) — callback(value, key, headers).
+        # Pass `self` as the third argument so consumers that read
+        # `(_, _, h) => h.get("Foo")` work the same as in a browser.
         cb = args[0]
         @hash.each do |k, v|
           if cb.respond_to?(:__js_call__)
-            cb.__js_call__("call", [v, k])
+            cb.__js_call__("call", [v, k, self])
           elsif cb.respond_to?(:call)
-            cb.call(v, k)
+            cb.call(v, k, self)
           end
         end
 

data/lib/dommy/file_reader.rb

@@ -114,7 +114,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 
@@ -145,8 +145,8 @@ module Dommy
 
     # Returns the blob's raw bytes as a binary String.
     def extract_raw(blob)
-      if blob.respond_to?(:__bytes__)
-        blob.__bytes__.to_s
+      if blob.respond_to?(:__dommy_bytes__)
+        blob.__dommy_bytes__.to_s
       else
         blob.to_s
       end

data/lib/dommy/form_data.rb

@@ -146,7 +146,7 @@ module Dommy
         next if name.empty?
         next if disabled?(el)
 
-        case el.__node__.name
+        case el.__dommy_backend_node__.name
         when "input"
           collect_input(el, name)
         when "select"
@@ -198,8 +198,6 @@ module Dommy
       # File / Blob values pass through unchanged (multipart form
       # encoding handles them); other values are stringified per spec.
       return value if value.is_a?(Blob)
-      # Backward-compat: embedders' own file-marker objects.
-      return value if value.respond_to?(:__file_marker__)
       return "" if value.nil?
 
       value.to_s

data/lib/dommy/history.rb

@@ -58,14 +58,17 @@ module Dommy
 
     def push(state, url)
       @stack = @stack[0..@cursor]
-      @location.__set_url__(url.to_s) if url
-      @stack << {state: state, url: nil}
+      @location.__internal_set_url__(url.to_s) if url
+      # WHATWG: pushState serializes the state via structured-clone
+      # so subsequent caller-side mutation of the original cannot
+      # affect history.state.
+      @stack << {state: Dommy.structured_clone(state), url: nil}
       @cursor = @stack.size - 1
     end
 
     def replace(state, url)
-      @location.__set_url__(url.to_s) if url
-      @stack[@cursor] = {state: state, url: nil}
+      @location.__internal_set_url__(url.to_s) if url
+      @stack[@cursor] = {state: Dommy.structured_clone(state), url: nil}
     end
 
     def go(delta)

data/lib/dommy/html_collection.rb

@@ -46,9 +46,9 @@ module Dommy
       return nil if key.empty?
 
       to_a.find do |el|
-        next false unless el.respond_to?(:__node__)
+        next false unless el.respond_to?(:__dommy_backend_node__)
 
-        el.__node__["id"].to_s == key || el.__node__["name"].to_s == key
+        el.__dommy_backend_node__["id"].to_s == key || el.__dommy_backend_node__["name"].to_s == key
       end
     end
 
@@ -125,7 +125,7 @@ module Dommy
     # accepts either another option (insert before that node) or an
     # integer index. Strings/`null` append.
     def add(option, before = nil)
-      return nil unless option.respond_to?(:__node__)
+      return nil unless option.respond_to?(:__dommy_backend_node__)
 
       case before
       when nil
@@ -134,7 +134,7 @@ module Dommy
         anchor = item(before)
         anchor ? @owner.insert_before(option, anchor) : @owner.append_child(option)
       else
-        if before.respond_to?(:__node__)
+        if before.respond_to?(:__dommy_backend_node__)
           @owner.insert_before(option, before)
         else
           @owner.append_child(option)