dommy 0.9.0 → 0.10.0

data/lib/dommy/html_collection.rb

@@ -25,18 +25,77 @@ module Dommy
     # 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.
+    HTML_NAMESPACE = "http://www.w3.org/1999/xhtml"
+
+    # WHATWG `getElementsByTagName(qualifiedName)` — a live collection filtered
+    # by qualified name. "*" matches any. In an HTML document, HTML-namespace
+    # elements match case-insensitively (ASCII), while other-namespace elements
+    # (and everything in a non-HTML document) match case-sensitively.
+    def self.elements_by_tag_name(root, document, qualified_name)
+      qn = qualified_name.to_s
+      html_doc = document.respond_to?(:html_document?) ? document.html_document? : true
+      qn_lower = ascii_downcase(qn)
+      new do
+        root.css("*").filter_map do |node|
+          el = document.wrap_node(node)
+          next nil unless el
+          next el if qn == "*"
+
+          el_qn = qualified_name_of(el)
+          el_ns = el.respond_to?(:namespace_uri) ? el.namespace_uri : nil
+          # For an HTML-namespace element in an HTML document, only the QUERY is
+          # ASCII-lowercased — the element's own qualified name is compared as-is
+          # (so an uppercase-localName HTML element, e.g. createElementNS(html,
+          # "I"), never matches "i" or "I").
+          match =
+            if html_doc && el_ns == HTML_NAMESPACE
+              el_qn == qn_lower
+            else
+              el_qn == qn
+            end
+          match ? el : nil
+        end
+      end
+    end
+
+    # The element's qualified name (prefix:localName, or just localName). The
+    # backend node name can't be trusted — the HTML parser lowercases it — so
+    # rebuild it from the case-preserving local name and prefix.
+    def self.qualified_name_of(el)
+      local = el.respond_to?(:local_name) ? el.local_name.to_s : ""
+      prefix = el.respond_to?(:__js_get__) ? el.__js_get__("prefix") : nil
+      prefix = nil if prefix.nil? || prefix.to_s.empty? ||
+                      (defined?(Bridge::UNDEFINED) && prefix.equal?(Bridge::UNDEFINED))
+      prefix ? "#{prefix}:#{local}" : local
+    end
+
+    # ASCII-only lowercase (A-Z -> a-z), leaving non-ASCII code points intact,
+    # per the spec's "converted to ASCII lowercase".
+    def self.ascii_downcase(str)
+      str.gsub(/[A-Z]/) { |c| (c.ord + 32).chr }
+    end
+
     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
+      local_filter = local == "*" ? :any : local
       new do
-        nodes = local == "*" ? root.css("*") : root.css(local)
-        nodes.filter_map do |node|
+        # Match on the element's LOCAL NAME (case-sensitive, exact) and
+        # namespace — NOT a CSS type selector, which is case-insensitive in an
+        # HTML document and keys off the qualified name (so it misses a
+        # prefixed `test:body` and wrongly matches `BODY` for `body`).
+        root.css("*").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
+          next nil unless ns_filter == :any || el_ns == ns_filter
+
+          el_local = el.respond_to?(:local_name) ? el.local_name : nil
+          next nil unless local_filter == :any || el_local == local_filter
+
+          el
         end
       end
     end
@@ -69,7 +128,14 @@ module Dommy
       to_a.find do |el|
         next false unless el.respond_to?(:__dommy_backend_node__)
 
-        el.__dommy_backend_node__["id"].to_s == key || el.__dommy_backend_node__["name"].to_s == key
+        node = el.__dommy_backend_node__
+        # `id` matches any element; `name` matches only HTML-namespace elements
+        # (WebIDL supported property names), so a null-namespace element's
+        # `name` attribute isn't a supported name.
+        next true if node["id"].to_s == key
+
+        html_ns = !el.respond_to?(:namespace_uri) || el.namespace_uri == "http://www.w3.org/1999/xhtml"
+        html_ns && node["name"].to_s == key
       end
     end
 
@@ -112,9 +178,11 @@ module Dommy
         item(key)
       else
         s = key.to_s
-        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.
+        if s.match?(/\A\d+\z/) && s.to_i < 4_294_967_295 && s == s.to_i.to_s
+          # A valid array index is the CANONICAL decimal of 0 ≤ n < 2^32-1 (no
+          # leading zeros: "03" is NOT an index, it is a named key). A pure
+          # indexed lookup — out of range yields nil (→ undefined), no named
+          # fallback.
           item(s.to_i)
         else
           # Non-array-index strings (negative, ≥ 2^32-1, or names) use the named
@@ -157,6 +225,35 @@ module Dommy
     end
   end
 
+  # `HTMLFormControlsCollection` — a form's `elements`. Like HTMLCollection but
+  # its named getter returns a RadioNodeList when a name/id matches more than one
+  # control (e.g. a radio group), and the single control otherwise.
+  class HTMLFormControlsCollection < HTMLCollection
+    def named_item(name)
+      key = name.to_s
+      return nil if key.empty?
+
+      matches = controls_named(key)
+      return nil if matches.empty?
+      return matches.first if matches.length == 1
+
+      # A live RadioNodeList: a reference held across a DOM mutation reflects the
+      # updated group (per spec the named getter returns a live NodeList).
+      coll = self
+      RadioNodeList.new(matches) { coll.controls_named(key) }
+    end
+
+    # The controls in this collection whose id or name equals `key`, in order.
+    def controls_named(key)
+      to_a.select do |el|
+        next false unless el.respond_to?(:__dommy_backend_node__)
+
+        node = el.__dommy_backend_node__
+        node["id"].to_s == key || node["name"].to_s == key
+      end
+    end
+  end
+
   # `HTMLOptionsCollection` — specialized `<select>.options` collection.
   # Adds `add(option, before?)`, `remove(index)`, the `selectedIndex`
   # getter/setter, and a `length=` setter that truncates or extends.
@@ -169,24 +266,25 @@ module Dommy
       @owner = owner
     end
 
-    # Append (or insert before `before`) an option element. `before`
-    # accepts either another option (insert before that node) or an
-    # integer index. Strings/`null` append.
+    # Append (or insert before `before`) an option element. `before` accepts
+    # another element (insert before it) or an integer index. Strings/`null`
+    # append. The insertion happens in the REFERENCE's parent — which may be an
+    # `<optgroup>` — not always the select itself.
     def add(option, before = nil)
       return nil unless option.respond_to?(:__dommy_backend_node__)
 
-      case before
-      when nil
-        @owner.append_child(option)
-      when Integer
-        anchor = item(before)
-        anchor ? @owner.insert_before(option, anchor) : @owner.append_child(option)
-      else
-        if before.respond_to?(:__dommy_backend_node__)
-          @owner.insert_before(option, before)
-        else
-          @owner.append_child(option)
+      reference =
+        case before
+        when nil then nil
+        when Integer then item(before)
+        else before.respond_to?(:__dommy_backend_node__) ? before : nil
         end
+
+      parent = reference&.parent_node
+      if reference && parent.respond_to?(:insert_before)
+        parent.insert_before(option, reference)
+      else
+        @owner.append_child(option)
       end
 
       nil
@@ -198,6 +296,29 @@ module Dommy
       nil
     end
 
+    # WebIDL "set an indexed property" for HTMLOptionsCollection:
+    #   * a null value removes the option at `index`
+    #   * otherwise, an in-range index replaces that option; an index at or past
+    #     the end appends (padding with blank options for any gap).
+    def __set_indexed__(index, option)
+      i = index.to_i
+      if option.nil?
+        remove(i)
+        return nil
+      end
+      return nil unless option.respond_to?(:__dommy_backend_node__)
+
+      current = to_a
+      if i < current.length
+        @owner.insert_before(option, current[i])
+        current[i].remove
+      else
+        (i - current.length).times { @owner.append_child(@owner.document.create_element("option")) }
+        @owner.append_child(option)
+      end
+      nil
+    end
+
     def selected_index
       @owner.selected_index
     end
@@ -237,6 +358,9 @@ module Dommy
       when "length"
         self.length = value
       else
+        # Indexed property setter: `options[i] = option | null`.
+        return __set_indexed__(key.to_i, value) if key.is_a?(Integer) || (key.is_a?(String) && key.match?(/\A\d+\z/))
+
         return Bridge::UNHANDLED
       end