dommy 0.7.0 → 0.8.0

data/lib/dommy/file_reader.rb

@@ -45,7 +45,8 @@ module Dommy
     alias readAsDataURL read_as_data_url
 
     def read_as_array_buffer(blob)
-      schedule_read(blob) { |raw| raw.bytes }
+      # readAsArrayBuffer's result is an ArrayBuffer — cross it as a bare one.
+      schedule_read(blob) { |raw| Bridge::ArrayBuffer.new(raw.bytes) }
     end
 
     alias readAsArrayBuffer read_as_array_buffer
@@ -89,10 +90,17 @@ module Dommy
 
     def __js_set__(key, value)
       event = inline_event_for(key)
-      set_inline_handler(event, value) if event
+      return Bridge::UNHANDLED unless event
+
+      set_inline_handler(event, value)
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[
+      readAsText readAsDataURL readAsArrayBuffer readAsBinaryString abort addEventListener
+      removeEventListener dispatchEvent
+    ]
     def __js_call__(method, args)
       case method
       when "readAsText"
@@ -108,7 +116,7 @@ module Dommy
       when "addEventListener"
         add_event_listener(args[0], args[1], args[2])
       when "removeEventListener"
-        remove_event_listener(args[0], args[1])
+        remove_event_listener(args[0], args[1], args[2])
       when "dispatchEvent"
         dispatch_event(args[0])
       end

data/lib/dommy/form_data.rb

@@ -108,6 +108,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[append set get getAll has delete keys values entries forEach]
     def __js_call__(method, args)
       case method
       when "append"

data/lib/dommy/history.rb

@@ -9,9 +9,10 @@ module Dommy
     def initialize(window, location)
       @window = window
       @location = location
-      # Initial entry mirrors the live Location. Bookmark URL is
-      # resynthesized lazily from Location each time we read it.
-      @stack = [{state: nil, url: nil}]
+      # Each entry records the full href it navigated to, so back/forward can
+      # restore Location to it (and fire popstate) — a restoration that
+      # framework routers like Turbo's depend on to swap the cached snapshot.
+      @stack = [{state: nil, url: @location.href}]
       @cursor = 0
       @scroll_restoration = "auto"
     end
@@ -34,11 +35,15 @@ module Dommy
         # values silently retain the current value.
         v = value.to_s
         @scroll_restoration = v if %w[auto manual].include?(v)
+      else
+        return Bridge::UNHANDLED
       end
 
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[pushState replaceState back forward go]
     def __js_call__(method, args)
       case method
       when "pushState"
@@ -57,18 +62,43 @@ module Dommy
     private
 
     def push(state, url)
+      resolved = resolve_url!(url)
       @stack = @stack[0..@cursor]
-      @location.__internal_set_url__(url.to_s) if url
+      @location.__internal_set_url__(resolved) if resolved
       # 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}
+      @stack << {state: Dommy.structured_clone(state), url: @location.href}
       @cursor = @stack.size - 1
     end
 
     def replace(state, url)
-      @location.__internal_set_url__(url.to_s) if url
-      @stack[@cursor] = {state: Dommy.structured_clone(state), url: nil}
+      resolved = resolve_url!(url)
+      @location.__internal_set_url__(resolved) if resolved
+      @stack[@cursor] = {state: Dommy.structured_clone(state), url: @location.href}
+    end
+
+    # WHATWG "URL and history update steps": resolve the given URL against the
+    # document URL; a parse failure or a cross-origin result is a SecurityError
+    # (same-document history entries must stay same-origin).
+    def resolve_url!(url)
+      return nil if url.nil? || url.equal?(Bridge::UNDEFINED)
+
+      current = @location.href.to_s
+      resolved =
+        begin
+          current.empty? ? URL.new(url.to_s) : URL.new(url.to_s, current)
+        rescue StandardError
+          raise DOMException::SecurityError, "A history state object with URL '#{url}' cannot be created in a document with URL '#{current}'."
+        end
+
+      unless current.empty?
+        if resolved.origin != URL.new(current).origin
+          raise DOMException::SecurityError, "A history state object with URL '#{resolved.href}' cannot be created in a document with origin '#{URL.new(current).origin}'."
+        end
+      end
+
+      resolved.href
     end
 
     def go(delta)
@@ -76,7 +106,12 @@ module Dommy
       return if target < 0 || target >= @stack.size
 
       @cursor = target
-      @window.fire_popstate(@stack[@cursor][:state])
+      entry = @stack[@cursor]
+      # Restore Location to the target entry's URL BEFORE firing popstate, so a
+      # listener that reads `location` (Turbo's restoration visit, the WHATWG
+      # traversal steps) sees the destination, not the page we came from.
+      @location.__internal_set_url__(entry[:url]) if entry[:url]
+      @window.fire_popstate(entry[:state])
     end
   end
 end

data/lib/dommy/html_collection.rb

@@ -22,6 +22,25 @@ module Dommy
       @compute = compute
     end
 
+    # Shared `getElementsByTagNameNS(namespace, localName)` — a live collection
+    # of descendants of `root` matching the (namespace, localName) filter, where
+    # "*" matches any. An empty-string namespace means the null namespace.
+    def self.elements_by_tag_name_ns(root, document, namespace, local_name)
+      ns = namespace.to_s
+      ns_filter = ns == "*" ? :any : (ns.empty? ? nil : ns)
+      local = local_name.to_s
+      new do
+        nodes = local == "*" ? root.css("*") : root.css(local)
+        nodes.filter_map do |node|
+          el = document.wrap_node(node)
+          next nil unless el
+
+          el_ns = el.respond_to?(:namespace_uri) ? el.namespace_uri : nil
+          (ns_filter == :any || el_ns == ns_filter) ? el : nil
+        end
+      end
+    end
+
     def length
       to_a.length
     end
@@ -42,7 +61,10 @@ module Dommy
     # `namedItem(name)` returns the first element whose `id` or
     # `name` attribute equals `name`. Returns nil if no match.
     def named_item(name)
-      key = name.to_s
+      # A numeric argument (`namedItem(2147483648)`) crosses from JS as a Float
+      # for values past int32; format it as an integer string so it matches an
+      # `id`/`name` attribute like "2147483648" (not "2147483648.0").
+      key = (name.is_a?(Float) && name.finite? && name == name.to_i) ? name.to_i.to_s : name.to_s
       return nil if key.empty?
 
       to_a.find do |el|
@@ -91,14 +113,41 @@ module Dommy
         item(key)
       else
         s = key.to_s
-        if s.match?(/\A\d+\z/)
+        if s.match?(/\A\d+\z/) && s.to_i < 4_294_967_295
+          # A valid array index (0 ≤ n < 2^32-1) is a pure indexed lookup — out
+          # of range yields nil (→ undefined), never a named fallback.
           item(s.to_i)
         else
+          # Non-array-index strings (negative, ≥ 2^32-1, or names) use the named
+          # getter.
           named_item(s) || (s == "length" ? length : nil)
         end
       end
     end
 
+    # WebIDL "supported property names" for HTMLCollection: in tree order, each
+    # element contributes its non-empty `id`, then (if it is in the HTML
+    # namespace) its non-empty `name` — ignoring duplicates.
+    def __js_named_props__
+      names = []
+      to_a.each do |el|
+        next unless el.respond_to?(:__dommy_backend_node__)
+
+        node = el.__dommy_backend_node__
+        id = node["id"].to_s
+        names << id if !id.empty? && !names.include?(id)
+
+        name = node["name"].to_s
+        next if name.empty? || names.include?(name)
+
+        html_ns = !el.respond_to?(:namespace_uri) || el.namespace_uri == "http://www.w3.org/1999/xhtml"
+        names << name if html_ns
+      end
+      names
+    end
+
+    include Bridge::Methods
+    js_methods %w[item namedItem]
     def __js_call__(method, args)
       case method
       when "item"
@@ -188,11 +237,15 @@ module Dommy
         self.selected_index = value
       when "length"
         self.length = value
+      else
+        return Bridge::UNHANDLED
       end
 
       nil
     end
 
+    # Adds add/remove on top of the inherited item/namedItem (else -> super).
+    js_methods %w[add remove]
     def __js_call__(method, args)
       case method
       when "add"