dommy 0.6.0 → 0.7.0

data/lib/dommy/html_elements.rb

@@ -154,6 +154,12 @@ module Dommy
   # `<form>` — element collection, submit/reset, and a stubbed
   # validation surface.
   class HTMLFormElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[submit reset requestSubmit checkValidity reportValidity].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def name
       reflected_string("name")
     end
@@ -211,7 +217,7 @@ module Dommy
       el = self
       HTMLCollection.new do
         el
-          .__node__
+          .__dommy_backend_node__
           .css("input, select, textarea, button, output, fieldset")
           .map do |n|
             el.document.wrap_node(n)
@@ -245,7 +251,7 @@ module Dommy
     # `submitter` (if given) must be a button inside this form.
     def request_submit(submitter = nil)
       if submitter
-        unless submitter.respond_to?(:__node__) && submitter.__node__.ancestors.include?(@__node__)
+        unless submitter.respond_to?(:__dommy_backend_node__) && submitter.__dommy_backend_node__.ancestors.include?(@__node__)
           raise DOMException::NotFoundError, "submitter is not a descendant of this form"
         end
 
@@ -346,6 +352,15 @@ module Dommy
 
   # `<input>` — covers the most-used form control surface.
   class HTMLInputElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[
+      select setSelectionRange setRangeText stepUp stepDown
+      checkValidity reportValidity setCustomValidity
+    ].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def type
       raw = @__node__["type"].to_s
       raw.empty? ? "text" : raw.downcase
@@ -422,14 +437,14 @@ module Dommy
     end
 
     # `files` — for `<input type="file">`. Browsers populate this via
-    # user interaction; in tests, code uses `__set_files__` to seed it.
+    # user interaction; in tests, code uses `__driver_set_files__` to seed it.
     def files
       @__files ||= FileList.new
     end
 
     # Test-only seam: set the input's file list directly.
     # Accepts an array (wrapped in a FileList) or a FileList itself.
-    def __set_files__(files_input)
+    def __driver_set_files__(files_input)
       @__files = files_input.is_a?(FileList) ? files_input : FileList.new(Array(files_input))
     end
 
@@ -1381,13 +1396,13 @@ module Dommy
     def host_attr_value(name)
       return "" unless @host
 
-      @host.__node__[name].to_s
+      @host.__dommy_backend_node__[name].to_s
     end
 
     def host_attr_present?(name)
       return false unless @host
 
-      @host.__node__.key?(name.to_s)
+      @host.__dommy_backend_node__.key?(name.to_s)
     end
 
     def host_type
@@ -1482,7 +1497,7 @@ module Dommy
       sel = closest("select")
       return 0 unless sel
 
-      sel.options.find_index { |o| o.__node__ == @__node__ } || 0
+      sel.options.find_index { |o| o.__dommy_backend_node__ == @__node__ } || 0
     end
 
     def __js_get__(key)
@@ -1569,6 +1584,14 @@ module Dommy
 
   # `<textarea>` — multi-line text input.
   class HTMLTextAreaElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[
+      select setSelectionRange setRangeText checkValidity reportValidity setCustomValidity
+    ].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def value
       @__node__["value"] || text_content
     end
@@ -1865,7 +1888,7 @@ module Dommy
       el = self
       HTMLCollection.new do
         el
-          .__node__
+          .__dommy_backend_node__
           .css("input, select, textarea, button, output, fieldset")
           .map do |n|
             el.document.wrap_node(n)
@@ -2031,6 +2054,12 @@ module Dommy
   # `slot` attribute go to the unnamed default slot. If nothing is
   # assigned, the slot's own children render as fallback content.
   class HTMLSlotElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[assignedNodes assignedElements assign].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def name
       reflected_string("name")
     end
@@ -2062,7 +2091,7 @@ module Dommy
     # call and fire `slotchange` in both modes; named mode simply
     # ignores the override.
     def assign(*nodes)
-      @__manual_assignment = nodes.flatten.select { |n| n.respond_to?(:__node__) }
+      @__manual_assignment = nodes.flatten.select { |n| n.respond_to?(:__dommy_backend_node__) }
       dispatch_event(Event.new("slotchange", "bubbles" => true))
       nil
     end
@@ -2105,7 +2134,7 @@ module Dommy
     private
 
     def matching_light_nodes
-      sr = @document.__shadow_root_containing__(@__node__)
+      sr = @document.__internal_shadow_root_containing__(@__node__)
       return [] unless sr
 
       host = sr.host
@@ -2118,7 +2147,7 @@ module Dommy
       end
 
       host
-        .__node__
+        .__dommy_backend_node__
         .children
         .map do |child|
           wrapped = @document.wrap_node(child)
@@ -2139,6 +2168,12 @@ module Dommy
   # `selectedIndex`, and dispatches change events. Minimal compared to
   # happy-dom's full HTMLSelectElement, but covers common test cases.
   class HTMLSelectElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[item add checkValidity reportValidity setCustomValidity].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def name
       reflected_string("name")
     end
@@ -2165,7 +2200,7 @@ module Dommy
     def options
       el = self
       HTMLOptionsCollection.new(self) do
-        el.__node__.css("option").map { |n| el.document.wrap_node(n) }.compact
+        el.__dommy_backend_node__.css("option").map { |n| el.document.wrap_node(n) }.compact
       end
     end
 
@@ -2175,8 +2210,8 @@ module Dommy
     def selected_options
       el = self
       HTMLCollection.new do
-        opts = el.__node__.css("option").map { |n| el.document.wrap_node(n) }.compact
-        chosen = opts.select { |o| o.__node__.key?("selected") }
+        opts = el.__dommy_backend_node__.css("option").map { |n| el.document.wrap_node(n) }.compact
+        chosen = opts.select { |o| o.__dommy_backend_node__.key?("selected") }
         next chosen unless chosen.empty?
         next [] if el.multiple
 
@@ -2196,7 +2231,7 @@ module Dommy
     # not multiple, or -1 if multiple and none.
     def selected_index
       opts = options
-      idx = opts.find_index { |o| o.__node__.key?("selected") }
+      idx = opts.find_index { |o| o.__dommy_backend_node__.key?("selected") }
       return idx if idx
 
       multiple ? -1 : (opts.empty? ? -1 : 0)
@@ -2207,7 +2242,7 @@ module Dommy
       opts.each_with_index do |o, idx|
         if idx == i.to_i
           o.set_attribute("selected", "")
-        elsif o.__node__.key?("selected")
+        elsif o.__dommy_backend_node__.key?("selected")
           o.remove_attribute("selected")
         end
       end
@@ -2216,15 +2251,15 @@ module Dommy
     # `value` of the select = value of the selected option, or "".
     def value
       opts = options
-      sel = opts.find { |o| o.__node__.key?("selected") } || opts.first
-      sel ? (sel.__node__["value"] || sel.text_content).to_s : ""
+      sel = opts.find { |o| o.__dommy_backend_node__.key?("selected") } || opts.first
+      sel ? (sel.__dommy_backend_node__["value"] || sel.text_content).to_s : ""
     end
 
     def value=(new_value)
-      target = options.find { |o| (o.__node__["value"] || o.text_content).to_s == new_value.to_s }
+      target = options.find { |o| (o.__dommy_backend_node__["value"] || o.text_content).to_s == new_value.to_s }
       return unless target
 
-      options.each { |o| o.remove_attribute("selected") if o.__node__.key?("selected") }
+      options.each { |o| o.remove_attribute("selected") if o.__dommy_backend_node__.key?("selected") }
       target.set_attribute("selected", "")
     end
 
@@ -2235,9 +2270,9 @@ module Dommy
 
     # `select.add(option, before)` — appends or inserts before `before`.
     def add(option, before = nil)
-      return nil unless option.respond_to?(:__node__)
+      return nil unless option.respond_to?(:__dommy_backend_node__)
 
-      if before.respond_to?(:__node__)
+      if before.respond_to?(:__dommy_backend_node__)
         insert_before(option, before)
       else
         append_child(option)
@@ -2367,6 +2402,12 @@ module Dommy
   # `close(returnValue?)`. Dommy has no modal stack, so showModal is
   # functionally identical to show (no backdrop, no escape-to-close).
   class HTMLDialogElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[show showModal close].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def open
       reflected_boolean("open")
     end
@@ -2652,7 +2693,7 @@ module Dommy
       row = closest("tr")
       return -1 unless row
 
-      row.cells.find_index { |c| c.__node__ == @__node__ } || -1
+      row.cells.find_index { |c| c.__dommy_backend_node__ == @__node__ } || -1
     end
 
     def col_span
@@ -2738,11 +2779,17 @@ module Dommy
   # `rowIndex` walks the enclosing table; `sectionRowIndex` walks
   # the enclosing thead/tbody/tfoot.
   class HTMLTableRowElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[insertCell deleteCell].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def cells
       el = self
       HTMLCollection.new do
         el
-          .__node__
+          .__dommy_backend_node__
           .element_children
           .select { |n| %w[td th].include?(n.name) }
           .map { |n| el.document.wrap_node(n) }
@@ -2754,7 +2801,7 @@ module Dommy
       table = closest("table")
       return -1 unless table
 
-      table.rows.find_index { |r| r.__node__ == @__node__ } || -1
+      table.rows.find_index { |r| r.__dommy_backend_node__ == @__node__ } || -1
     end
 
     def section_row_index
@@ -2812,11 +2859,17 @@ module Dommy
   # `<thead>` / `<tbody>` / `<tfoot>` — share section-level row
   # collection + insertRow / deleteRow.
   class HTMLTableSectionElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[insertRow deleteRow].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def rows
       el = self
       HTMLCollection.new do
         el
-          .__node__
+          .__dommy_backend_node__
           .element_children
           .select { |n| n.name == "tr" }
           .map { |n| el.document.wrap_node(n) }
@@ -2866,16 +2919,25 @@ module Dommy
   # tbody elements. `insertRow(-1)` appends to the last tbody (or
   # creates one); `deleteRow` works against the merged `rows` list.
   class HTMLTableElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[
+      insertRow deleteRow createCaption deleteCaption createTHead deleteTHead
+      createTFoot deleteTFoot createTBody
+    ].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     def caption
       @__node__.element_children.find { |n| n.name == "caption" }&.then { |n| @document.wrap_node(n) }
     end
 
     def caption=(new_caption)
       delete_caption
-      return unless new_caption.respond_to?(:__node__)
+      return unless new_caption.respond_to?(:__dommy_backend_node__)
 
       first = @__node__.children.first
-      first ? first.add_previous_sibling(new_caption.__node__) : @__node__.add_child(new_caption.__node__)
+      first ? first.add_previous_sibling(new_caption.__dommy_backend_node__) : @__node__.add_child(new_caption.__dommy_backend_node__)
     end
 
     def t_head
@@ -2890,7 +2952,7 @@ module Dommy
       el = self
       HTMLCollection.new do
         el
-          .__node__
+          .__dommy_backend_node__
           .element_children
           .select { |n| n.name == "tbody" }
           .map { |n| el.document.wrap_node(n) }
@@ -2902,10 +2964,10 @@ module Dommy
       el = self
       HTMLCollection.new do
         ordered = []
-        head = el.__node__.element_children.find { |n| n.name == "thead" }
-        bodies = el.__node__.element_children.select { |n| n.name == "tbody" }
-        direct = el.__node__.element_children.select { |n| n.name == "tr" }
-        foot = el.__node__.element_children.find { |n| n.name == "tfoot" }
+        head = el.__dommy_backend_node__.element_children.find { |n| n.name == "thead" }
+        bodies = el.__dommy_backend_node__.element_children.select { |n| n.name == "tbody" }
+        direct = el.__dommy_backend_node__.element_children.select { |n| n.name == "tr" }
+        foot = el.__dommy_backend_node__.element_children.find { |n| n.name == "tfoot" }
         [head, *bodies, foot].compact.each do |sec|
           sec.element_children.select { |n| n.name == "tr" }.each { |n| ordered << n }
         end
@@ -2921,7 +2983,7 @@ module Dommy
 
       cap = @document.create_element("caption")
       first = @__node__.children.first
-      first ? first.add_previous_sibling(cap.__node__) : @__node__.add_child(cap.__node__)
+      first ? first.add_previous_sibling(cap.__dommy_backend_node__) : @__node__.add_child(cap.__dommy_backend_node__)
       cap
     end
 
@@ -2938,10 +3000,10 @@ module Dommy
       head = @document.create_element("thead")
       cap = caption
       if cap
-        cap.__node__.add_next_sibling(head.__node__)
+        cap.__dommy_backend_node__.add_next_sibling(head.__dommy_backend_node__)
       else
         first = @__node__.children.first
-        first ? first.add_previous_sibling(head.__node__) : @__node__.add_child(head.__node__)
+        first ? first.add_previous_sibling(head.__dommy_backend_node__) : @__node__.add_child(head.__dommy_backend_node__)
       end
 
       head
@@ -2957,7 +3019,7 @@ module Dommy
       return existing if existing
 
       foot = @document.create_element("tfoot")
-      @__node__.add_child(foot.__node__)
+      @__node__.add_child(foot.__dommy_backend_node__)
       foot
     end
 
@@ -2970,9 +3032,9 @@ module Dommy
       tb = @document.create_element("tbody")
       last_tbody = t_bodies.last
       if last_tbody
-        last_tbody.__node__.add_next_sibling(tb.__node__)
+        last_tbody.__dommy_backend_node__.add_next_sibling(tb.__dommy_backend_node__)
       else
-        @__node__.add_child(tb.__node__)
+        @__node__.add_child(tb.__dommy_backend_node__)
       end
 
       tb
@@ -2995,10 +3057,10 @@ module Dommy
         target_section.append_child(tr)
       else
         anchor = list[idx]
-        section = anchor.__node__.parent
+        section = anchor.__dommy_backend_node__.parent
         if section
-          anchor.__node__.add_previous_sibling(tr.__node__)
-          @document.notify_child_list_mutation(target_node: section, added_nodes: [tr.__node__], removed_nodes: [])
+          anchor.__dommy_backend_node__.add_previous_sibling(tr.__dommy_backend_node__)
+          @document.notify_child_list_mutation(target_node: section, added_nodes: [tr.__dommy_backend_node__], removed_nodes: [])
         end
       end
 
@@ -3066,6 +3128,12 @@ module Dommy
   # absent in Dommy — getters return inert values, `play()` returns
   # a resolved Promise, and `pause()` flips `paused` back to true.
   class HTMLMediaElement < HTMLElement
+    # Own __js_call__ methods, on top of Element's.
+    JS_METHOD_NAMES = %w[play pause load canPlayType].freeze
+    def __js_method_names__
+      super + JS_METHOD_NAMES
+    end
+
     NETWORK_EMPTY = 0
     NETWORK_IDLE = 1
     NETWORK_LOADING = 2

data/lib/dommy/internal/css_pseudo_handlers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Custom Nokogiri pseudo-class handlers so CSS selectors like
+    # `:disabled` / `:enabled` / `:checked` work in query_selector(_all).
+    # Nokogiri calls the method named after the pseudo-class with the current
+    # node list and expects the filtered list back. Receives raw Nokogiri
+    # nodes (not Dommy wrappers).
+    class CSSPseudoHandlers < BasicObject
+      include ::Kernel
+
+      def disabled(list)
+        list.find_all { |node| node.has_attribute?("disabled") }
+      end
+
+      def enabled(list)
+        list.find_all { |node| !node.has_attribute?("disabled") }
+      end
+
+      def checked(list)
+        list.find_all { |node| node.has_attribute?("checked") }
+      end
+    end
+
+    CSS_PSEUDO_HANDLERS = CSSPseudoHandlers.new
+  end
+end

data/lib/dommy/internal/dom_matching.rb

@@ -57,7 +57,7 @@ module Dommy
       #
       # @param html [String]
       def normalize_html(html)
-        Nokogiri::HTML5.fragment(html.to_s).to_html.gsub(/\s+/, " ").strip
+        Backend.fragment(html.to_s, owner_doc: nil).to_html.gsub(/\s+/, " ").strip
       end
 
       # Get the text_content of a scope, handling Document (which has
@@ -91,9 +91,9 @@ module Dommy
       # ancestors (head/script/style/template), inline `display:none` /
       # `visibility:hidden` on element or any ancestor.
       def visible?(element)
-        return true unless element.respond_to?(:__node__)
+        return true unless element.respond_to?(:__dommy_backend_node__)
 
-        node = element.__node__
+        node = element.__dommy_backend_node__
         return false if node_invisible_self?(node)
 
         NodeTraversal.each_ancestor(node) do |ancestor|

data/lib/dommy/internal/node_traversal.rb

@@ -10,7 +10,7 @@ module Dommy
       # Stops at Nokogiri::XML::Document (the root).
       def self.each_ancestor(node)
         current = node.respond_to?(:parent) ? node.parent : nil
-        while current && !current.is_a?(Nokogiri::XML::Document)
+        while current && !current.is_a?(Backend.document_class)
           yield current
           current = current.respond_to?(:parent) ? current.parent : nil
         end

data/lib/dommy/internal/node_wrapper_cache.rb

@@ -33,15 +33,15 @@ module Dommy
         raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
         raise DOMException::InvalidCharacterError, "invalid element name: #{str.inspect}" unless str.match?(NAME_RE)
 
-        wrap_node(Nokogiri::XML::Node.new(str.downcase, @document.nokogiri_doc))
+        wrap_node(Backend.create_element(str.downcase, @document.nokogiri_doc))
       end
 
       def create_text_node(text)
-        wrap_node(Nokogiri::XML::Text.new(text.to_s, @document.nokogiri_doc))
+        wrap_node(Backend.create_text(text.to_s, @document.nokogiri_doc))
       end
 
       def create_comment(text)
-        wrap_node(Nokogiri::XML::Comment.new(@document.nokogiri_doc, text.to_s))
+        wrap_node(Backend.create_comment(text.to_s, @document.nokogiri_doc))
       end
 
       def create_document_fragment
@@ -69,8 +69,11 @@ module Dommy
         raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
         raise DOMException::InvalidCharacterError, "invalid qualified name: #{str.inspect}" unless str.match?(NAME_RE)
 
-        el = Nokogiri::XML::Node.new(str, @document.nokogiri_doc)
-        el.add_namespace_definition(nil, namespace_uri.to_s) if namespace_uri && !namespace_uri.to_s.empty?
+        el = Backend.create_element(str, @document.nokogiri_doc)
+        if namespace_uri && !namespace_uri.to_s.empty?
+          Backend.add_namespace_definition(el, nil, namespace_uri.to_s)
+        end
+
         wrap(el)
       end
 
@@ -79,13 +82,13 @@ module Dommy
       def query_selector(selector)
         return nil if selector.nil? || selector.to_s.empty?
 
-        wrap(@document.nokogiri_doc.at_css(selector.to_s))
+        wrap(@document.nokogiri_doc.at_css(selector.to_s, CSS_PSEUDO_HANDLERS))
       end
 
       def query_selector_all(selector)
         return NodeList.new if selector.nil? || selector.to_s.empty?
 
-        NodeList.new(@document.nokogiri_doc.css(selector.to_s).map { |node| wrap(node) }.compact)
+        NodeList.new(@document.nokogiri_doc.css(selector.to_s, CSS_PSEUDO_HANDLERS).map { |node| wrap(node) }.compact)
       end
 
       def get_element_by_id(id)
@@ -131,6 +134,14 @@ module Dommy
         @wrappers.delete(nokogiri_node.object_id)
       end
 
+      # Register an externally-built wrapper. Used by
+      # Document#adopt_node when migrating a wrapper from another
+      # document so the existing Ruby object survives the move
+      # rather than being replaced by a freshly-built one.
+      def register(nokogiri_node, wrapper)
+        @wrappers[nokogiri_node.object_id] = wrapper
+      end
+
       private
 
       def wrap_node(node)
@@ -139,20 +150,20 @@ module Dommy
 
       def build_wrapper_for(node)
         case node
-        when Nokogiri::XML::Element
+        when Backend.element_class
           build_element_wrapper(node)
-        when Nokogiri::XML::Text
+        when Backend.text_class
           TextNode.new(@document, node)
-        when Nokogiri::XML::Comment
+        when Backend.comment_class
           CommentNode.new(@document, node)
-        when Nokogiri::XML::DocumentFragment
+        when Backend.document_fragment_class
           Fragment.new(@document, node)
         end
       end
 
       def build_element_wrapper(node)
         custom_klass = custom_element_class_for(node.name)
-        klass = custom_klass || Dommy.element_class_for(node.name, node.namespace&.href)
+        klass = custom_klass || Dommy.element_class_for(node.name, Backend.namespace_of(node)&.href)
         instance = klass.new(@document, node)
 
         @wrappers[node.object_id] = instance

data/lib/dommy/internal/template_content_registry.rb

@@ -19,16 +19,16 @@ module Dommy
       # Parse HTML into a fragment and attach it as the template's content.
       # Drops any pre-existing direct children of the template element.
       def attach(template_element, html)
-        template_element.__node__.children.each(&:unlink)
+        template_element.__dommy_backend_node__.children.each(&:unlink)
         fragment = @document.nokogiri_doc.fragment(html.to_s)
-        @fragments[template_element.__node__.object_id] = fragment
+        @fragments[template_element.__dommy_backend_node__.object_id] = fragment
         fragment
       end
 
       # Get the wrapped Fragment for a template element, seeding from
       # the template's current children if not previously migrated.
       def fragment_for(template_element)
-        fragment = @fragments[template_element.__node__.object_id]
+        fragment = @fragments[template_element.__dommy_backend_node__.object_id]
         fragment ||= seed(template_element)
         @document.wrap_node(fragment)
       end
@@ -40,7 +40,7 @@ module Dommy
       end
 
       def inner_html_of(template_element)
-        fragment = @fragments[template_element.__node__.object_id]
+        fragment = @fragments[template_element.__dommy_backend_node__.object_id]
         return "" unless fragment
 
         fragment.children.map(&:to_html).join
@@ -79,8 +79,8 @@ module Dommy
       end
 
       def seed(template_element)
-        migrate_one(template_element.__node__)
-        @fragments[template_element.__node__.object_id]
+        migrate_one(template_element.__dommy_backend_node__)
+        @fragments[template_element.__dommy_backend_node__.object_id]
       end
 
       def migrate_one(template_node)

data/lib/dommy/intersection_observer.rb

@@ -3,7 +3,7 @@
 module Dommy
   # `IntersectionObserver` — stub for the viewport-intersection API.
   # Dommy has no layout engine, so callbacks never fire automatically.
-  # Tests can drive callbacks explicitly via `__trigger__(entries)`.
+  # Tests can drive callbacks explicitly via `__test_trigger__(entries)`.
   #
   # Spec: https://w3c.github.io/IntersectionObserver/
   class IntersectionObserver
@@ -51,7 +51,7 @@ module Dommy
 
     # Test seam: invoke the callback with a synthetic entries list.
     # Each entry is whatever shape the test wants (usually a Hash).
-    def __trigger__(entries)
+    def __test_trigger__(entries)
       invoke_callback(entries)
     end
 

data/lib/dommy/location.rb

@@ -5,7 +5,7 @@ require "uri"
 module Dommy
   # `window.location` polyfill. The Window owns one Location and one
   # History instance, and they share the same underlying state. Hash
-  # / pushState / replaceState all flow through `__set_url__`.
+  # / pushState / replaceState all flow through `__internal_set_url__`.
   class Location
     def initialize(window, origin: "http://localhost", pathname: "/", search: "", hash: "")
       @window = window
@@ -41,7 +41,7 @@ module Dommy
     def __js_set__(key, value)
       case key
       when "href"
-        __set_url__(value.to_s)
+        __internal_set_url__(value.to_s)
       when "hash"
         new_hash = value.to_s
         new_hash = "##{new_hash}" unless new_hash.empty? || new_hash.start_with?("#")
@@ -68,7 +68,7 @@ module Dommy
     def __js_call__(method, args)
       case method
       when "assign", "replace"
-        __set_url__(args[0].to_s)
+        __internal_set_url__(args[0].to_s)
       when "reload"
         nil
       when "toString"
@@ -83,12 +83,16 @@ module Dommy
     # Internal — accepts an absolute or relative URL string and
     # updates pathname / search / hash. Called by History pushState /
     # replaceState and by `location.href = ...`.
-    def __set_url__(raw)
+    def __internal_set_url__(raw)
       previous_hash = @hash
       if raw.start_with?("#")
         @hash = raw
       else
         uri = URI.join(@origin + @pathname + @search + @hash, raw) rescue URI(raw)
+        # An absolute URL (carrying scheme + host) navigates to a new
+        # origin; a relative URL inherits the current origin from the
+        # join base, so rebuilding with the same parts is a no-op.
+        rebuild_origin(scheme: uri.scheme, host: uri.host, port: uri.port) if uri.scheme && uri.host
         @pathname = uri.path.to_s == "" ? "/" : uri.path
         @search = uri.query ? "?#{uri.query}" : ""
         @hash = uri.fragment ? "##{uri.fragment}" : ""