dommy 0.5.0 → 0.7.0

data/lib/dommy/html_elements.rb

@@ -1,30 +1,19 @@
 # frozen_string_literal: true
 
 module Dommy
-  # Base for specialized HTMLElement subclasses. Adds the reflected
-  # IDL boolean / string attribute helpers each subclass uses.
+  # Base for specialized HTMLElement subclasses. Inherits reflection
+  # helpers from Internal::ReflectedAttributes (also shared with
+  # SVGElement).
   class HTMLElement < Element
-    private
-
-    def reflected_boolean(name)
-      @__node__.key?(name.to_s.downcase)
-    end
-
-    def set_reflected_boolean(name, value)
-      key = name.to_s.downcase
-      if value
-        set_attribute(key, "")
-      elsif @__node__.key?(key)
-        remove_attribute(key)
-      end
-    end
-
-    def reflected_string(name)
-      @__node__[name.to_s.downcase].to_s
-    end
-
-    def set_reflected_string(name, value)
-      set_attribute(name.to_s.downcase, value.to_s)
+    include Internal::ReflectedAttributes
+
+    # HTML attribute names are case-insensitive — the browser DOM
+    # lowercases everything. Override to make this explicit at the
+    # HTMLElement level (Element's default would already pick this up
+    # via namespace inspection, but spelling it out shortcuts the
+    # namespace check for HTML's hot path).
+    def case_sensitive_attribute_names?
+      false
     end
   end
 
@@ -165,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
@@ -222,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)
@@ -256,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
 
@@ -357,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
@@ -433,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
 
@@ -1392,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
@@ -1493,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)
@@ -1580,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
@@ -1876,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)
@@ -2042,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
@@ -2073,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
@@ -2116,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
@@ -2129,7 +2147,7 @@ module Dommy
       end
 
       host
-        .__node__
+        .__dommy_backend_node__
         .children
         .map do |child|
           wrapped = @document.wrap_node(child)
@@ -2150,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
@@ -2176,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
 
@@ -2186,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
 
@@ -2207,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)
@@ -2218,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
@@ -2227,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
 
@@ -2246,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)
@@ -2378,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
@@ -2663,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
@@ -2749,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) }
@@ -2765,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
@@ -2823,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) }
@@ -2877,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
@@ -2901,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) }
@@ -2913,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
@@ -2932,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
 
@@ -2949,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
@@ -2968,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
 
@@ -2981,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
@@ -3006,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
 
@@ -3077,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
@@ -4449,7 +4506,13 @@ module Dommy
     "html" => HTMLHtmlElement
   }.freeze
 
-  def self.element_class_for(tag_name)
-    HTML_ELEMENT_CLASSES[tag_name.to_s.downcase] || Element
+  SVG_NAMESPACE_URI = "http://www.w3.org/2000/svg"
+
+  def self.element_class_for(tag_name, namespace_uri = nil)
+    if namespace_uri == SVG_NAMESPACE_URI
+      SVG_ELEMENT_CLASSES[tag_name.to_s.downcase] || SVGElement
+    else
+      HTML_ELEMENT_CLASSES[tag_name.to_s.downcase] || Element
+    end
   end
 end

data/lib/dommy/internal/cookie_jar.rb

@@ -5,6 +5,8 @@ module Dommy
     # Manages document cookie storage (in-memory, not persisted).
     # Implements the simple document.cookie key=value; key=value interface.
     class CookieJar
+      attr_reader :cookies
+
       def initialize
         @cookies = {}
       end

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

@@ -44,7 +44,7 @@ module Dommy
           actual.positive?
         when Integer
           actual == expected
-        when Range
+        when ::Range
           expected.cover?(actual)
         else
           false
@@ -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|