dommy 0.13.0 → 0.14.0

data/lib/dommy/internal/node_adopter.rb

@@ -15,8 +15,9 @@ module Dommy
     #   - every live wrapper in the subtree, so a reference page script is
     #     holding (an aria element reference, a queued MutationRecord's target)
     #     keeps pointing at a node in the right document;
-    #   - a `<template>`'s contents, which are not in its child list and so are
-    #     reachable only through the source document's registry.
+    #   - a `<template>`'s contents, which are not in its child list, and which
+    #     the import copies in a shape of its own between an HTML and an XML
+    #     document.
     #
     # Spec: https://dom.spec.whatwg.org/#concept-node-adopt
     class NodeAdopter
@@ -55,50 +56,10 @@ module Dommy
         return node if node.document == backend_doc
 
         adopted = Backend.adopt(node, backend_doc)
-        if source_document && !source_document.equal?(@document)
-          reseat_wrapper(node, adopted, source_document)
-          reseat_descendant_wrappers(node, adopted, source_document)
-          adopt_template_contents(node, adopted, source_document)
-        end
+        carry_over(node, adopted, source_document) if source_document && !source_document.equal?(@document)
         adopted
       end
 
-      # Move each live wrapper for a descendant of `src_root` onto the matching
-      # node in `dst_root` (the imported copy), pruning it from the source
-      # document. `include_root` also re-binds the root pair — #adopt re-binds
-      # its own root wrapper by hand, but a template's content fragment has no
-      # such caller.
-      def reseat_descendant_wrappers(src_root, dst_root, src_doc, include_root: false)
-        return unless src_doc.respond_to?(:__internal_peek_wrapper__)
-
-        each_node_pair(src_root, dst_root) do |orig, copy|
-          next if orig.equal?(src_root) && !include_root
-
-          reseat_wrapper(orig, copy, src_doc)
-        end
-      end
-
-      # HTML: adopting a `<template>` adopts its template contents
-      # DocumentFragment along with it — the SAME fragment object, so
-      # `template.content` keeps both its identity and its children across the
-      # move. The contents are not in the template's child list, so neither the
-      # backend's adopt nor the descendant walk above ever reaches them; without
-      # this the adopted template comes out empty. Recurses, since a template's
-      # contents can hold further templates.
-      # Spec: https://html.spec.whatwg.org/#the-template-element (adopting steps)
-      def adopt_template_contents(src_root, dst_root, src_doc)
-        return if src_doc.nil? || src_doc.equal?(@document)
-        return unless src_doc.respond_to?(:__internal_template_registry__)
-
-        src_registry = src_doc.__internal_template_registry__
-        each_node_pair(src_root, dst_root) do |orig, copy|
-          src_frag = src_registry.raw_fragment_for(orig)
-          next unless src_frag
-
-          adopt_one_template_content(src_frag, copy, src_doc)
-        end
-      end
-
       private
 
       def backend_doc = @document.backend_doc
@@ -108,15 +69,13 @@ module Dommy
       # publicId / systemId (as createDocument does), then re-bind the caller's
       # wrapper onto the new node so JS identity survives the move.
       def adopt_doctype(node, src)
-        adopted = begin
-          Backend.create_document_type(node.name, node.public_id, node.system_id, backend_doc)
-        rescue StandardError
-          nil
-        end
-        return node unless adopted
-
+        adopted = Backend.create_document_type(node.name, node.public_id, node.system_id, backend_doc)
         reseat_known_wrapper(node, src, adopted, node.document)
         node
+      rescue StandardError => e
+        # Returning the node unchanged would read as a successful adoption while
+        # its ownerDocument never moved, so the caller hears about it instead.
+        raise DOMException::NotSupportedError, "Cannot adopt this doctype: #{e.message}"
       end
 
       # Hand the detached source to the backend, which returns the node now
@@ -127,42 +86,90 @@ module Dommy
         adopted = Backend.adopt(src, backend_doc)
 
         reseat_known_wrapper(node, src, adopted, src_doc)
-        # A deep adopt imports a fresh copy of the whole subtree, so any live
-        # descendant wrapper must be re-bound onto its corresponding copy —
-        # otherwise it stays bound to the old document. Import preserves document
-        # order, so walk both subtrees in lockstep.
-        reseat_descendant_wrappers(src, adopted, src_doc)
-        adopt_template_contents(src, adopted, src_doc)
+        carry_over(src, adopted, src_doc)
         node
       end
 
-      def adopt_one_template_content(src_frag, template_copy, src_doc)
-        frag = Parser.fragment("", owner_doc: backend_doc)
-        # Snapshot before moving: the backend either relocates each node in place
-        # (Nokogiri) or hands back an imported copy (Makiri, which cannot move a
-        # node between arenas), and the pairs drive the wrapper re-bind either way.
-        src_frag.children.to_a.each do |child|
-          moved = Backend.adopt(child, backend_doc)
-          adopt_template_contents(child, moved, src_doc)
-          reseat_wrapper(child, moved, src_doc)
-          reseat_descendant_wrappers(child, moved, src_doc)
-          frag.add_child(moved)
+      # A deep adopt imports a fresh copy of the whole subtree, so each live
+      # wrapper in it must be re-bound onto its copy — otherwise it stays bound
+      # to the old document. Import preserves document order, so the two
+      # subtrees are walked together.
+      def carry_over(orig, copy, src_doc)
+        reseat_wrapper(orig, copy, src_doc)
+        if registry.template_node?(orig)
+          carry_over_template(orig, copy, src_doc)
+        elsif orig.respond_to?(:children)
+          carry_over_each(orig.children.to_a, copy.children.to_a, src_doc)
+        end
+      end
+
+      # A length mismatch means the copies are not the import of the originals,
+      # so nothing is paired at all rather than paired wrongly.
+      def carry_over_each(origs, copies, src_doc)
+        return unless origs.length == copies.length
+
+        origs.zip(copies).each { |orig, copy| carry_over(orig, copy, src_doc) }
+      end
+
+      # HTML: adopting a `<template>` adopts its template contents
+      # DocumentFragment along with it — the SAME fragment object, so
+      # `template.content` keeps both its identity and its children across the
+      # move. An HTML document's contents are the backend's own, which its
+      # import copies as contents into an HTML document and as the leading
+      # children into an XML one (which has no contents); an XML document's
+      # live apart from the tree and move here one by one. Whatever the import
+      # made of them, they end up as the destination keeps contents, and the
+      # template's own children as its children.
+      # Spec: https://html.spec.whatwg.org/#the-template-element (adopting steps)
+      def carry_over_template(orig, copy, src_doc)
+        src_registry = src_doc.__internal_template_registry__
+        src_frag = src_registry.existing_contents(orig)
+        contents = src_frag ? src_frag.children.to_a : []
+        children = orig.children.to_a
+        dst_frag = registry.contents(copy)
+        from_html = !Backend.template_contents(orig).nil?
+        to_html = !Backend.template_contents(copy).nil?
+
+        if from_html && to_html
+          carry_over_each(contents, dst_frag.children.to_a, src_doc)
+          carry_over_each(children, copy.children.to_a, src_doc)
+        elsif from_html
+          copied = copy.children.to_a
+          copied.first(contents.length).each { |node| move_node(node, dst_frag) }
+          carry_over_each(contents, copied.first(contents.length), src_doc)
+          carry_over_each(children, copied.drop(contents.length), src_doc)
+        else
+          if to_html
+            # The import made the XML template's own children the contents.
+            copied = dst_frag.children.to_a
+            copied.each { |node| move_node(node, copy) }
+          end
+          carry_over_each(children, copy.children.to_a, src_doc)
+          adopt_detached_contents(contents, dst_frag, src_doc)
+          src_registry.release(orig)
         end
-        @document.__internal_template_registry__.store(template_copy, frag)
-        reseat_wrapper(src_frag, frag, src_doc)
+        reseat_wrapper(src_frag, dst_frag, src_doc) if src_frag
       end
 
-      # Each (original, copy) pair of the two subtrees, in document order. A
-      # length mismatch means the copy is not the import of the original, so
-      # nothing is paired at all rather than paired wrongly.
-      def each_node_pair(src_root, dst_root)
-        src_nodes = NodeTraversal.subtree_nodes(src_root)
-        dst_nodes = NodeTraversal.subtree_nodes(dst_root)
-        return if src_nodes.length != dst_nodes.length
+      # An XML document's contents, which no import reached, moved one by one.
+      def adopt_detached_contents(nodes, dst_frag, src_doc)
+        nodes.each do |node|
+          moved = Backend.adopt(node, backend_doc)
+          carry_over(node, moved, src_doc)
+          dst_frag.add_child(moved)
+        end
+      end
 
-        src_nodes.zip(dst_nodes).each { |pair| yield(*pair) }
+      # Put a copy the import placed where the destination does not keep it
+      # into place. Not a DOM mutation — the node is where the adopt means it to
+      # be — so a raw unlink.
+      def move_node(node, parent)
+        node.unlink
+        parent.add_child(node)
       end
 
+      def registry = @document.__internal_template_registry__
+
       # Look up the live wrapper for `orig` in the source document, if it has
       # one, and move it onto `copy`.
       def reseat_wrapper(orig, copy, src_doc)

data/lib/dommy/internal/node_factory.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Document's createElement / createTextNode / createAttribute family: mint a
+    # backend node, then hand back the wrapper for it.
+    #
+    # A factory is not a cache. These lived in NodeWrapperCache, which made that
+    # class's name describe about a third of it; it keeps the identity table the
+    # wrappers come from, and this asks it for them.
+    class NodeFactory
+      def initialize(document, wrappers)
+        @document = document
+        @wrappers = wrappers
+      end
+
+      def create_element(name)
+        str = domstring(name)
+        raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
+        raise DOMException::InvalidCharacterError, "invalid element name: #{str.inspect}" unless Namespaces.valid_element_local_name?(str)
+
+        # WHATWG createElement: lowercase (ASCII) the name only in an HTML
+        # document; the namespace is the HTML namespace for HTML/XHTML documents
+        # and null for a non-XHTML XML document. Record the metadata so the
+        # element's localName/tagName/namespaceURI getters report it faithfully
+        # (in particular case preservation for XML/XHTML).
+        if @document.html_document?
+          local = str.downcase(:ascii)
+          namespace = Element::HTML_NAMESPACE
+        else
+          local = str
+          namespace = @document.content_type == "application/xhtml+xml" ? Element::HTML_NAMESPACE : nil
+        end
+
+        # createElement validates against the XML *Name* production, which is
+        # looser than the QName an XML backend insists on: ":", "foo:", "f::oo"
+        # and a local part with a combining char are all valid element names the
+        # backend would reject. The loose creator builds those verbatim; anything
+        # it (or the strict path) still refuses is an InvalidCharacterError.
+        node =
+          begin
+            Backend.create_element_loose(local, nil, local, namespace, @document.backend_doc) ||
+              Backend.create_element(local, @document.backend_doc)
+          rescue ArgumentError
+            raise DOMException::InvalidCharacterError, "invalid element name: #{str.inspect}"
+          end
+
+        wrapper = @wrappers.wrap(node)
+        wrapper.__internal_set_namespace__(namespace, nil, local, local)
+        @document.__internal_note_namespaced_element__(namespace, nil)
+        wrapper
+      end
+
+      def create_text_node(text)
+        @wrappers.wrap(Backend.create_text(text.to_s, @document.backend_doc))
+      end
+
+      def create_cdata_section(text)
+        @wrappers.wrap(Backend.create_cdata(text.to_s, @document.backend_doc))
+      end
+
+      def create_comment(text)
+        @wrappers.wrap(Backend.create_comment(text.to_s, @document.backend_doc))
+      end
+
+      # WHATWG Document.createProcessingInstruction: the target must be a valid
+      # XML Name and the data must not contain the PI close delimiter "?>", else
+      # InvalidCharacterError. The result is a real backend-backed PI node.
+      def create_processing_instruction(target, data)
+        t = domstring(target)
+        d = domstring(data)
+        raise DOMException::InvalidCharacterError, "invalid processing instruction target: #{t.inspect}" unless t.match?(Namespaces::NAME)
+        raise DOMException::InvalidCharacterError, "processing instruction data must not contain '?>'" if d.include?("?>")
+
+        @wrappers.wrap(Backend.create_processing_instruction(t, d, @document.backend_doc))
+      end
+
+      def create_document_fragment
+        @wrappers.wrap(Parser.fragment("", owner_doc: @document.backend_doc))
+      end
+
+      def create_attribute(name)
+        str = domstring(name)
+        raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
+        raise DOMException::InvalidCharacterError, "invalid attribute name: #{str.inspect}" unless Namespaces.valid_attribute_local_name?(str)
+
+        # WHATWG createAttribute: an HTML document lower-cases the name (an XML
+        # document preserves it). Attr.new no longer folds case, so do it here.
+        str = str.downcase if @document.html_document?
+        Attr.new(str, document: @document)
+      end
+
+      def create_attribute_ns(namespace_uri, qualified_name)
+        namespace_uri = nil if namespace_uri.equal?(Bridge::UNDEFINED)
+        qualified_name = domstring(qualified_name)
+        ns, prefix, local = Namespaces.validate_and_extract(namespace_uri, qualified_name)
+        Attr.new(qualified_name, namespace_uri: ns, prefix: prefix, local_name: local, document: @document)
+      end
+
+      def create_element_ns(namespace_uri, qualified_name)
+        # WHATWG "validate and extract": QName-validate the qualifiedName
+        # (InvalidCharacterError) and apply the prefix/namespace rules
+        # (NamespaceError), then build the element with its prefix bound.
+        # namespace is nullable (undefined → null); qualifiedName is a plain
+        # DOMString (undefined → "undefined", null → "null").
+        namespace_uri = nil if namespace_uri.equal?(Bridge::UNDEFINED)
+        qualified_name = domstring(qualified_name)
+        ns, prefix, local = Namespaces.validate_and_extract(namespace_uri, qualified_name, context: :element)
+
+        # An XML backend rejects some DOM-valid qualified names (an invalid char
+        # in the local part, which DOM permits): the loose creator builds them
+        # verbatim. An HTML backend builds the element in its namespace. A
+        # genuinely invalid name it (or the strict path) rejects with an
+        # ArgumentError becomes an InvalidCharacterError, per DOM.
+        el =
+          begin
+            Backend.create_element_loose(qualified_name, prefix, local, ns, @document.backend_doc) ||
+              Backend.create_element_ns(ns, qualified_name, @document.backend_doc) ||
+              Backend.create_element(qualified_name, @document.backend_doc)
+          rescue ArgumentError
+            raise DOMException::InvalidCharacterError, "'#{qualified_name}' is not a valid element name"
+          end
+        Backend.add_namespace_definition(el, prefix, ns) if ns
+
+        wrapper = @wrappers.build_element_wrapper(el, namespace: ns, local_name: local)
+        wrapper.__internal_set_namespace__(ns, prefix, local, qualified_name)
+        @document.__internal_note_namespaced_element__(ns, prefix)
+        wrapper
+      end
+
+      # Wrap a freshly-cloned backend element whose original was built via
+      # createElementNS: route the wrapper class by the known local name (the
+      # backend node name may be the full qualified name, e.g. "foo:div", which
+      # would otherwise resolve to HTMLUnknownElement) and reapply its namespace
+      # metadata (namespaceURI / prefix / localName / tagName).
+      def wrap_cloned_element_ns(node, namespace, prefix, local, qualified_name)
+        @wrappers.reset_wrapper(node)
+        wrapper = @wrappers.build_element_wrapper(node, namespace: namespace, local_name: local)
+        wrapper.__internal_set_namespace__(namespace, prefix, local, qualified_name)
+        wrapper
+      end
+
+      # Query methods
+
+      private
+
+      # WebIDL DOMString coercion for a name/qualifiedName argument: JS
+      # `undefined` → "undefined", JS `null` (Ruby nil) → "null", else #to_s.
+      def domstring(value)
+        return "undefined" if value.equal?(Bridge::UNDEFINED)
+        return "null" if value.nil?
+
+        value.to_s
+      end
+    end
+  end
+end

data/lib/dommy/internal/node_identity.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Whether two DOM references stand for the same node.
+    #
+    # Comparing the backend nodes with `==` is not it: a backend may mint a
+    # fresh wrapper per traversal, and one that frees nodes may hand the same
+    # pointer to a later node. Backend.identity_key is what each backend says
+    # its stable key is (see NodeWrapperCache#identity_key), so that is what
+    # this asks — in one place, because three callers used to answer it three
+    # ways.
+    module NodeIdentity
+      module_function
+
+      # `first` and `second` may be wrappers or backend nodes, in any mix.
+      def same_node?(first, second)
+        return false unless first && second
+
+        left = key_for(first)
+        right = key_for(second)
+        !left.nil? && left == right
+      end
+
+      def key_for(node)
+        backend = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__ : node
+        backend && Backend.identity_key(backend)
+      end
+    end
+  end
+end