dommy 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccbe61a606e042968621f7fa81588634f2cdae566d96cef137bfefdfb6d38dd6
-  data.tar.gz: 4358d9b68082608b7e78971be2d2818fb35200b17bec1819ce21a520b3552d7c
+  metadata.gz: ae1783921d75a534741bfa2de3be6ddd7492f01a6d63d4a3102b85411518e64d
+  data.tar.gz: 3022f80e295f06db17782b034d252e8529435ccae9e7ce7283e936da2cea8804
 SHA512:
-  metadata.gz: a8c9a3b7bbfacb6f58440cbfec8884cc79c8690beda03225b229ca935f1b6d1ce0778c83a9253f2996198e46c8d8b85f9df53ccedb1ffa4e942a5b9841c051e4
-  data.tar.gz: f428a160a4c2f0180e7fa01f8cb1e6ec31dc9855f2bd7b43f1be6abd7a752a6b93926c1e57791a1c8b51a22e62631c997c4fbe8b55ea38fed5748f62cc874033
+  metadata.gz: c3ccc2658999f785bab29f01e94bca1d7c0505370256fb55687cca8822b0e4dcdd8efb1d64d172a3a7dced5a3a4224612bc38d8df48f943088d56bd81bc85cd9
+  data.tar.gz: dc65af8b414579d71d72601e1c1f3ac070ed6e4a67a7385cbc17222ed9b896687a494709f974f75af192d2441f12de3cc6be0f4eaaa263198f5bc868335193ab

data/lib/dommy/animation.rb

@@ -48,6 +48,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[getTiming updateTiming]
     def __js_call__(method, args)
       case method
       when "getTiming"
@@ -217,11 +219,17 @@ module Dommy
         @playback_rate = value.to_f
       when "id"
         @id = value.to_s
+      else
+        return Bridge::UNHANDLED
       end
 
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[
+      play pause cancel finish reverse addEventListener removeEventListener dispatchEvent
+    ]
     def __js_call__(method, args)
       case method
       when "play"
@@ -237,7 +245,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/attr.rb

@@ -13,12 +13,32 @@ module Dommy
   #     not yet attached. Value is stored locally; `setAttributeNode`
   #     transfers it to an element.
   class Attr
-    attr_reader :name
+    include Node
+    include EventTarget
 
-    def initialize(name, owner: nil, value: "")
-      @name = name.to_s.downcase
+    attr_reader :name, :namespace_uri, :prefix, :local_name
+
+    def __internal_event_parent__
+      nil
+    end
+
+    def initialize(name, owner: nil, value: "", namespace_uri: nil, prefix: nil, local_name: nil)
+      qname = name.to_s
       @owner = owner
       @detached_value = value.to_s
+      if namespace_uri && !namespace_uri.to_s.empty?
+        # Namespaced attributes preserve case and carry prefix / localName.
+        @name = qname
+        @namespace_uri = namespace_uri.to_s
+        @prefix = prefix
+        @local_name = (local_name || qname.split(":", 2).last).to_s
+      else
+        # Null-namespace (HTML) attributes are lower-cased, as before.
+        @name = qname.downcase
+        @namespace_uri = nil
+        @prefix = nil
+        @local_name = @name
+      end
     end
 
     # The Element this attr is on, or nil if detached.
@@ -28,7 +48,11 @@ module Dommy
 
     def value
       if @owner
-        @owner.__dommy_backend_node__[@name].to_s
+        if @namespace_uri
+          Backend.get_attribute_ns(@owner.__dommy_backend_node__, @namespace_uri, @local_name).to_s
+        else
+          @owner.__dommy_backend_node__[@name].to_s
+        end
       else
         @detached_value
       end
@@ -36,7 +60,11 @@ module Dommy
 
     def value=(new_value)
       if @owner
-        @owner.set_attribute(@name, new_value.to_s)
+        if @namespace_uri
+          @owner.set_attribute_ns(@namespace_uri, @name, new_value.to_s)
+        else
+          @owner.set_attribute(@name, new_value.to_s)
+        end
       else
         @detached_value = new_value.to_s
       end
@@ -52,36 +80,65 @@ module Dommy
         @name
       when "nodeValue"
         value
+      when "textContent"
+        # Node.textContent for an Attr returns its value (WHATWG DOM).
+        value
       when "ownerElement"
         @owner
       when "localName"
-        @name
+        @local_name
       when "namespaceURI"
-        nil
+        @namespace_uri
+      when "prefix"
+        @prefix
       when "nodeType"
         2
+      when "specified"
+        # Legacy/useless attribute — always true (WHATWG DOM).
+        true
       end
     end
 
     def __js_set__(key, val)
       case key
-      when "value", "nodeValue"
+      when "value", "nodeValue", "textContent"
         self.value = val
+      else
+        return Bridge::UNHANDLED
       end
 
       nil
     end
 
-    # Methods routed through __js_call__ (keep in sync with its when-arms).
-    JS_METHOD_NAMES = %w[cloneNode].freeze
-    def __js_method_names__
-      JS_METHOD_NAMES
-    end
-
-    def __js_call__(method, _args)
+    include Bridge::Methods
+    js_methods %w[cloneNode isSameNode getRootNode hasChildNodes normalize compareDocumentPosition
+      appendChild insertBefore removeChild replaceChild
+      addEventListener removeEventListener dispatchEvent]
+    def __js_call__(method, args)
       case method
       when "cloneNode"
-        Attr.new(@name, owner: nil, value: value)
+        Attr.new(@name, owner: nil, value: value,
+                        namespace_uri: @namespace_uri, prefix: @prefix, local_name: @local_name)
+      when "isSameNode"
+        is_same_node(args[0])
+      when "getRootNode"
+        get_root_node(args[0])
+      when "compareDocumentPosition"
+        compare_document_position(args[0])
+      when "appendChild", "insertBefore"
+        raise DOMException::HierarchyRequestError, "an Attr may not have children"
+      when "removeChild", "replaceChild"
+        raise DOMException::NotFoundError, "the node to be removed is not a child of this node"
+      when "hasChildNodes"
+        false
+      when "normalize"
+        nil
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1], args[2])
+      when "dispatchEvent"
+        dispatch_event(args[0])
       end
     end
 
@@ -112,49 +169,134 @@ module Dommy
 
     def initialize(element)
       @element = element
+      # Attr-node identity cache, keyed by [namespace_or_nil, localName].
+      # Every accessor (item / index / getNamedItem(NS)) returns the SAME
+      # Attr object for a given underlying attribute, per the DOM.
+      @attrs = {}
     end
 
     def length
-      @element.__dommy_backend_node__.attribute_nodes.size
+      Backend.attribute_nodes(@element.__dommy_backend_node__).size
     end
 
     alias size length
 
     def item(index)
-      name = @element.__dommy_backend_node__.attribute_nodes[index.to_i]&.name
-      name && Attr.new(name, owner: @element)
+      node = Backend.attribute_nodes(@element.__dommy_backend_node__)[index.to_i]
+      node && attr_for(node)
+    end
+
+    # Return the cached Attr for a backend attribute node, creating (and
+    # caching) one on first access so DOM node identity holds.
+    def attr_for(attr_node)
+      info = Backend.attribute_ns_info(attr_node)
+      key = [info[:namespace_uri], info[:local_name]]
+      cached = @attrs[key]
+      return cached if cached && cached.owner_element.equal?(@element)
+
+      attr = Attr.new(info[:qualified_name], owner: @element,
+                                             namespace_uri: info[:namespace_uri],
+                                             prefix: info[:prefix],
+                                             local_name: info[:local_name])
+      @attrs[key] = attr
+      attr
     end
 
     def get_named_item(name)
       key = name.to_s.downcase
-      return nil unless @element.__dommy_backend_node__.key?(key)
-
-      Attr.new(key, owner: @element)
+      node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
+        Backend.attribute_ns_info(a)[:qualified_name] == key
+      end
+      node && attr_for(node)
     end
 
     def set_named_item(attr)
-      return nil unless attr.is_a?(Attr)
-
-      key = attr.name
-      val = attr.value
-      attr.__internal_attach__(@element)
-      @element.set_attribute(key, val)
-      attr
+      set_attribute_node(attr)
     end
 
     def remove_named_item(name)
       key = name.to_s.downcase
-      return nil unless @element.__dommy_backend_node__.key?(key)
+      node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
+        Backend.attribute_ns_info(a)[:qualified_name] == key
+      end
+      return nil unless node
 
-      attr = Attr.new(key, owner: nil, value: @element.__dommy_backend_node__[key].to_s)
+      removed = attr_for(node)
       @element.remove_attribute(key)
-      attr
+      removed
     end
 
-    def each(&blk)
-      @element.__dommy_backend_node__.attribute_nodes.each do |a|
-        yield Attr.new(a.name, owner: @element)
+    def each
+      Backend.attribute_nodes(@element.__dommy_backend_node__).each do |a|
+        yield attr_for(a)
+      end
+    end
+
+    # WHATWG "set an attribute" / "set attribute node". Adopts `attr` (the
+    # exact object — identity is preserved), replacing any attribute with the
+    # same (namespace, localName) and returning the previous Attr (detached),
+    # or nil. Throws InUseAttributeError if `attr` is bound to another element.
+    def set_attribute_node(attr)
+      return nil unless attr.is_a?(Attr)
+
+      owner = attr.owner_element
+      if owner && !owner.equal?(@element)
+        raise DOMException::InUseAttributeError, "attribute is in use by another element"
+      end
+
+      ns = attr.namespace_uri
+      local = attr.local_name
+      old = get_named_item_ns(ns, local)
+      return attr if old && old.equal?(attr)
+
+      value = attr.value
+      key = [ns, local]
+      if old
+        old.__internal_detach__
+        @attrs.delete(key)
+      end
+      attr.__internal_attach__(@element)
+      if ns
+        @element.set_attribute_ns(ns, attr.name, value)
+      else
+        @element.set_attribute(attr.name, value)
       end
+      @attrs[key] = attr
+      old
+    end
+
+    # Detach and evict the cached Attr for (namespace, localName), if any —
+    # called by Element after the underlying attribute is removed so a held
+    # reference reports `ownerElement === null`.
+    def __internal_evict__(namespace, local_name)
+      key = [namespace.to_s.empty? ? nil : namespace.to_s, local_name.to_s]
+      attr = @attrs.delete(key)
+      attr&.__internal_detach__
+      nil
+    end
+
+    # ----- Namespaced named-item access (getNamedItemNS etc.) -----
+
+    def get_named_item_ns(namespace, local_name)
+      node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
+        info = Backend.attribute_ns_info(a)
+        info[:local_name] == local_name.to_s &&
+          (info[:namespace_uri] || nil) == (namespace.to_s.empty? ? nil : namespace.to_s)
+      end
+      node && attr_for(node)
+    end
+
+    # setNamedItemNS shares the "set an attribute" algorithm with setNamedItem.
+    def set_named_item_ns(attr)
+      set_attribute_node(attr)
+    end
+
+    def remove_named_item_ns(namespace, local_name)
+      existing = get_named_item_ns(namespace, local_name)
+      return nil unless existing
+
+      @element.remove_attribute_ns(namespace, local_name)
+      existing
     end
 
     # Property-style access — `el.attributes.id`, `el.attributes["class"]`.
@@ -181,12 +323,17 @@ module Dommy
       end
     end
 
-    # Methods routed through __js_call__ (keep in sync with its when-arms).
-    JS_METHOD_NAMES = %w[item getNamedItem setNamedItem removeNamedItem].freeze
-    def __js_method_names__
-      JS_METHOD_NAMES
+    # WebIDL "supported property names" for NamedNodeMap: the qualified name of
+    # each attribute, in order (the indexed names are reflected separately).
+    def __js_named_props__
+      Backend.attribute_nodes(@element.__dommy_backend_node__).map do |a|
+        Backend.attribute_ns_info(a)[:qualified_name]
+      end
     end
 
+    include Bridge::Methods
+    js_methods %w[item getNamedItem setNamedItem removeNamedItem
+                  getNamedItemNS setNamedItemNS removeNamedItemNS]
     def __js_call__(method, args)
       case method
       when "item"
@@ -197,6 +344,12 @@ module Dommy
         set_named_item(args[0])
       when "removeNamedItem"
         remove_named_item(args[0])
+      when "getNamedItemNS"
+        get_named_item_ns(args[0], args[1])
+      when "setNamedItemNS"
+        set_named_item_ns(args[0])
+      when "removeNamedItemNS"
+        remove_named_item_ns(args[0], args[1])
       end
     end
 

data/lib/dommy/backend/nokogiri_adapter.rb

@@ -21,6 +21,11 @@ module Dommy
         ::Nokogiri::HTML5(html.to_s, max_errors: 0)
       end
 
+      # Parse an XML string into an XML document (DOMParser "text/xml" etc.).
+      def parse_xml(xml)
+        ::Nokogiri::XML(xml.to_s)
+      end
+
       def fragment(html, owner_doc:)
         # owner_doc is unused by Nokogiri — the fragment carries its
         # own document. The Parser layer copies nodes into the target.
@@ -39,6 +44,12 @@ module Dommy
         ::Nokogiri::XML::Comment.new(doc, content)
       end
 
+      def create_cdata(content, doc)
+        ::Nokogiri::XML::CDATA.new(doc, content.to_s)
+      end
+
+      def cdata_class = ::Nokogiri::XML::CDATA
+
       def namespace_of(node)
         node.namespace
       end
@@ -46,6 +57,71 @@ module Dommy
       def add_namespace_definition(node, prefix, href)
         node.add_namespace_definition(prefix, href)
       end
+
+      # ----- Namespaced attributes -----
+
+      def get_attribute_ns(node, namespace, local_name)
+        find_attr_ns(node, namespace, local_name)&.value
+      end
+
+      def has_attribute_ns?(node, namespace, local_name)
+        !find_attr_ns(node, namespace, local_name).nil?
+      end
+
+      def set_attribute_ns(node, namespace, prefix, local_name, qualified_name, value)
+        # WHATWG "set an attribute value": when an attribute with this
+        # (namespace, localName) already exists, only its value changes —
+        # the existing prefix/qualified name is preserved, not replaced by
+        # the one in this call.
+        existing = find_attr_ns(node, namespace, local_name)
+        if existing
+          existing.value = value.to_s
+          return value.to_s
+        end
+
+        if namespace.nil? || namespace.to_s.empty?
+          node[qualified_name] = value.to_s
+          return value.to_s
+        end
+
+        # Defining the namespace before the qualified-name assignment lets
+        # libxml2 bind the prefix to it (verified behavior). Reuse an existing
+        # matching definition so repeated sets don't pile up declarations.
+        node.namespace_definitions.find { |d| d.href == namespace.to_s && d.prefix == prefix } ||
+          node.add_namespace_definition(prefix, namespace.to_s)
+        node[qualified_name] = value.to_s
+        value.to_s
+      end
+
+      def remove_attribute_ns(node, namespace, local_name)
+        find_attr_ns(node, namespace, local_name)&.remove
+        nil
+      end
+
+      def attribute_ns_info(attr_node)
+        ns = attr_node.namespace
+        {
+          namespace_uri: ns&.href,
+          prefix: ns&.prefix,
+          local_name: attr_node.name,
+          qualified_name: ns&.prefix ? "#{ns.prefix}:#{attr_node.name}" : attr_node.name,
+          value: attr_node.value,
+        }
+      end
+
+      def attribute_nodes(node)
+        node.attribute_nodes
+      end
+
+      # Finds the attribute node matching (namespace, localName). A null
+      # namespace matches only the un-namespaced attribute of that local name.
+      def find_attr_ns(node, namespace, local_name)
+        if namespace.nil? || namespace.to_s.empty?
+          node.attribute_nodes.find { |a| a.namespace.nil? && a.name == local_name.to_s }
+        else
+          node.attribute_with_ns(local_name.to_s, namespace.to_s)
+        end
+      end
     end
   end
 end

data/lib/dommy/backend/nokolexbor_adapter.rb

@@ -63,6 +63,43 @@ module Dommy
         # No-op: Nokolexbor doesn't support XML namespaces.
       end
 
+      # ----- Namespaced attributes (degraded) -----
+      # Nokolexbor has no namespace model, so *AttributeNS collapses to the
+      # qualified name in the null namespace. Fine for HTML (all attributes are
+      # null-namespace); foreign-content (SVG/MathML) fidelity is lost.
+
+      def get_attribute_ns(node, _namespace, local_name)
+        node[local_name.to_s]
+      end
+
+      def has_attribute_ns?(node, _namespace, local_name)
+        node.key?(local_name.to_s)
+      end
+
+      def set_attribute_ns(node, _namespace, _prefix, _local_name, qualified_name, value)
+        node[qualified_name] = value.to_s
+        value.to_s
+      end
+
+      def remove_attribute_ns(node, _namespace, local_name)
+        node.remove_attribute(local_name.to_s) if node.key?(local_name.to_s)
+        nil
+      end
+
+      def attribute_ns_info(attr_node)
+        {
+          namespace_uri: nil,
+          prefix: nil,
+          local_name: attr_node.name,
+          qualified_name: attr_node.name,
+          value: attr_node.value,
+        }
+      end
+
+      def attribute_nodes(node)
+        node.attribute_nodes
+      end
+
       # Internal helper — visible to allow testing.
       def in_svg_subtree?(node)
         return true if node.name.to_s.downcase == "svg"

data/lib/dommy/backend.rb

@@ -49,6 +49,12 @@ module Dommy
         current.parse(html)
       end
 
+      # Parse XML input into an XML document. Backends without a real XML parser
+      # (HTML-only, e.g. Nokolexbor) fall back to the HTML parser.
+      def parse_xml(xml)
+        current.respond_to?(:parse_xml) ? current.parse_xml(xml) : current.parse(xml)
+      end
+
       def fragment(html, owner_doc:)
         current.fragment(html, owner_doc: owner_doc)
       end
@@ -65,6 +71,16 @@ module Dommy
         current.create_comment(content, doc)
       end
 
+      # CDATA section node (XML documents). Backends without CDATA fall back to a
+      # text node.
+      def create_cdata(content, doc)
+        current.respond_to?(:create_cdata) ? current.create_cdata(content, doc) : current.create_text(content, doc)
+      end
+
+      def cdata_class
+        current.respond_to?(:cdata_class) ? current.cdata_class : nil
+      end
+
       def namespace_of(node)
         current.namespace_of(node)
       end
@@ -73,6 +89,36 @@ module Dommy
         current.add_namespace_definition(node, prefix, href)
       end
 
+      # Namespaced attribute access (DOM *AttributeNS). `namespace` is an href
+      # String or nil. Nokolexbor degrades to qualified-name (null-namespace).
+      def get_attribute_ns(node, namespace, local_name)
+        current.get_attribute_ns(node, namespace, local_name)
+      end
+
+      def set_attribute_ns(node, namespace, prefix, local_name, qualified_name, value)
+        current.set_attribute_ns(node, namespace, prefix, local_name, qualified_name, value)
+      end
+
+      def remove_attribute_ns(node, namespace, local_name)
+        current.remove_attribute_ns(node, namespace, local_name)
+      end
+
+      def has_attribute_ns?(node, namespace, local_name)
+        current.has_attribute_ns?(node, namespace, local_name)
+      end
+
+      # Reads a backend attribute node into {namespace_uri:, prefix:,
+      # local_name:, qualified_name:, value:} (namespace-aware).
+      def attribute_ns_info(attr_node)
+        current.attribute_ns_info(attr_node)
+      end
+
+      # The element's attribute nodes (each readable via attribute_ns_info).
+      # The single choke point so DOM code doesn't touch parser internals.
+      def attribute_nodes(node)
+        current.attribute_nodes(node)
+      end
+
       # Type constants — proxy through to the current backend so
       # `node.is_a?(Backend::Element)` resolves dynamically.
       def element_class

data/lib/dommy/blob.rb

@@ -17,12 +17,16 @@ module Dommy
     #   - anything else: coerced via to_s
     #
     # `options["type"]` sets the MIME type (lowercased per spec).
-    def initialize(parts = [], options = {})
+    # `window` (optional) lets the JS-facing `text()`/`arrayBuffer()` return real
+    # Promises (they need a scheduler). A window-less Blob falls back to a
+    # synchronous result, which `await` still handles.
+    def initialize(parts = [], options = {}, window = nil)
       parts = [parts] unless parts.is_a?(Array)
       @data = collect_bytes(parts)
       @size = @data.bytesize
       raw_type = options["type"] || options[:type] || ""
       @type = raw_type.to_s.downcase
+      @window = window
     end
 
     # Return a new Blob over a byte range of this one.
@@ -31,7 +35,7 @@ module Dommy
       s = clamp_index(start.to_i, @size)
       e = clamp_index(last.to_i, @size)
       e = s if e < s
-      Blob.new([@data.byteslice(s, e - s) || ""], "type" => content_type.to_s)
+      Blob.new([@data.byteslice(s, e - s) || ""], {"type" => content_type.to_s}, @window)
     end
 
     # Read the bytes as UTF-8 text. The DOM spec returns a Promise,
@@ -40,10 +44,11 @@ module Dommy
       @data.dup.force_encoding(Encoding::UTF_8)
     end
 
-    # Read the bytes as an Array<Integer>. The DOM spec returns a
-    # Promise<ArrayBuffer>; Dommy is synchronous.
+    # Read the bytes as a real ArrayBuffer (the spec return type, wrapped so it
+    # crosses the JS boundary as a bare ArrayBuffer rather than an Array/typed
+    # array). The DOM spec returns a Promise<ArrayBuffer>; Dommy is synchronous.
     def array_buffer
-      @data.bytes
+      Bridge::ArrayBuffer.new(@data.bytes)
     end
 
     # Raw binary bytes (Ruby ASCII-8BIT string). Used by FormData /
@@ -61,19 +66,31 @@ module Dommy
       end
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    # File < Blob inherits these (it adds only properties).
+    include Bridge::Methods
+    js_methods %w[slice text arrayBuffer]
     def __js_call__(method, args)
       case method
       when "slice"
         slice(args[0] || 0, args[1] || @size, args[2] || "")
       when "text"
-        text
+        # WHATWG: Blob.text() returns a Promise<string>.
+        promise_or_value(text)
       when "arrayBuffer"
-        array_buffer
+        # WHATWG: Blob.arrayBuffer() returns a Promise<ArrayBuffer>.
+        promise_or_value(array_buffer)
       end
     end
 
     private
 
+    # Wrap a consumed value in a resolved Promise when a window is available;
+    # otherwise return it directly (a window-less Blob — `await` copes either way).
+    def promise_or_value(value)
+      @window ? PromiseValue.resolve(@window, value) : value
+    end
+
     def collect_bytes(parts)
       buf = String.new(encoding: Encoding::ASCII_8BIT)
       parts.each do |part|
@@ -106,8 +123,8 @@ module Dommy
   class File < Blob
     attr_reader :name, :last_modified
 
-    def initialize(parts, name, options = {})
-      super(parts, options)
+    def initialize(parts, name, options = {}, window = nil)
+      super(parts, options, window)
       @name = name.to_s
       raw_lm = options["lastModified"] || options[:lastModified]
       @last_modified = (raw_lm || (Time.now.to_f * 1000)).to_i
@@ -172,6 +189,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[item]
     def __js_call__(method, args)
       case method
       when "item"