dommy 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64a22d9ba17102a03881baedbda66b5236b8c4499140d779e4c4acba86583241
-  data.tar.gz: e111a114c5a7ae9485a3e99af339e70a59dce6b9a83a837639ac6564873a8d4e
+  metadata.gz: b0d28c900db6681f80910f285f05e95985648e6bf824990f23d4f4b4b47bdaf9
+  data.tar.gz: 509faf8cfe617d13f1ff69507254c3ef7987d77a9bdf796fa7ce44836d63c798
 SHA512:
-  metadata.gz: 67c651bd499d2cd0d6cf1fb862b11a9f0f6b68ba1814abe40732b990e5b66b9b5f0494fd33cb989e4b7a5f64faa3a8a152e8979231f4c082f32187999188030a
-  data.tar.gz: e7e8ee9194687b9fe6be28646e9f80d32631f3cf78e5b9fefbab5fd913b9a1d6116ab819bae3a54030f2fefc6e4fa8e478c8ab2667cc086e009c5ebb1a7c9481
+  metadata.gz: d52a0dec8dca36a172c0ff93e89ab75126049a6b85eeea2a7527c99a162cc087b98cdf11afa7a98d0cd5024bce642ac612f955babf15a3b02af63cbddc336981
+  data.tar.gz: f8de49a82844eee7f75e5b5db13a798b7210b70a9bc1e902b85c37819fc79e98c71a2dd8d60abeeaa4f16de9a2679c15f27d48d57f7005b2345ac5a1e0fce7b5

data/README.md

@@ -79,7 +79,7 @@ file = Dommy::File.new(["pdf body"], "doc.pdf", "type" => "application/pdf")
 
 # Seed a file input for tests
 input = win.document.query_selector("input[type='file']")
-input.__driver_set_files__([file])
+input.files = [file]
 
 # FormData picks it up
 fd = Dommy::FormData.new(win.document.query_selector("form"))
@@ -106,6 +106,20 @@ response = win.__js_call__("fetch", ["/api"]).await
 > [!WARNING]
 > Most Dommy accessors (`Blob#text`, `localStorage.get_item`) return synchronous Ruby values — not Promises. `.await` is only for the JS-bridged async surface (e.g., `fetch()`, `window.__js_call__`). Methods like `Response#text()` are Promise-returning and require `.await`.
 
+### Preloading ES modules across page loads
+
+With JavaScript on (dommy-js-quickjs), a test suite boots the same bundles — Turbo, Stimulus, an app's vendored libraries — page after page, and parsing them is most of what booting costs. Turn preloading on, and a page's ES modules of 10 KB or more are compiled to bytecode once per process and read as bytecode by every later page of the same origin:
+
+```ruby
+# spec/rails_helper.rb or test/test_helper.rb
+Dommy::Js::ModulePreload.enabled = true
+```
+
+With Turbo served as an ES module (importmap-rails), a page boots in about 11 ms instead of 24 ms from the third load on: the first registers the module, the second compiles it.
+
+> [!NOTE]
+> A preloaded module is not fetched again for the rest of the process. Turn it on when your module URLs carry a digest (importmap-rails, Propshaft, jsbundling with digested assets); a URL whose content changes without its name changing would keep running what it served first.
+
 ## Test helpers
 
 Dommy ships test-side modules you can `include` into RSpec / Minitest. Matchers accept a `Dommy::Document` / element or a raw HTML string (auto-parsed), matching Capybara's `expect(rendered).to ...` ergonomics.

data/lib/dommy/attr.rb

@@ -9,9 +9,13 @@ module Dommy
   # We represent two states:
   #   - "owned" — the Attr is attached to an Element. value reads/writes
   #     go through the element's Makiri attribute slot.
-  #   - "detached" — created via `document.createAttribute(name)` but
-  #     not yet attached. Value is stored locally; `setAttributeNode`
+  #   - "detached" — created via `document.createAttribute(name)` or removed
+  #     from its element. Value is stored locally; `setAttributeNode`
   #     transfers it to an element.
+  #
+  # Its node document is its own in either state, as the DOM has it: set
+  # when it is created, appended or adopted (with its element or by itself),
+  # and kept when it is removed.
   class Attr
     include Node
     include EventTarget
@@ -25,9 +29,7 @@ module Dommy
     def initialize(name, owner: nil, value: "", namespace_uri: nil, prefix: nil, local_name: nil, document: nil)
       qname = name.to_s
       @owner = owner
-      # The node document (for baseURI/ownerDocument when detached from an
-      # element). Owned attrs derive it from their owner instead.
-      @document = document
+      @document = document || owner&.document
       @detached_value = value.to_s
       if namespace_uri && !namespace_uri.to_s.empty?
         # Namespaced attributes preserve case and carry prefix / localName.
@@ -53,19 +55,13 @@ module Dommy
       @owner
     end
 
-    # Node.baseURI — the node document's base URL. Derived from the owner
-    # element when attached, else the document the attr was created in.
+    # Node.baseURI — the node document's base URL.
     def base_uri
-      return @owner.base_uri if @owner.respond_to?(:base_uri)
-
       @document&.base_uri
     end
 
-    # Node.ownerDocument — the owner element's current document when attached (so
-    # it follows the element across adoptNode), else the creation document.
+    # Node.ownerDocument — the node document.
     def owner_document
-      return @owner.document if @owner.respond_to?(:document)
-
       @document
     end
 
@@ -85,7 +81,9 @@ module Dommy
         if @namespace_uri
           @owner.set_attribute_ns(@namespace_uri, @name, new_value.to_s)
         else
-          @owner.set_attribute(@name, new_value.to_s)
+          # This attribute, in no namespace — not the first with its
+          # qualified name, which may be another namespace's.
+          @owner.__internal_set_attribute_value__(@local_name, new_value.to_s)
         end
       else
         @detached_value = new_value.to_s
@@ -122,6 +120,15 @@ module Dommy
       when "specified"
         # Legacy/useless attribute — always true (WHATWG DOM).
         true
+      when "parentNode", "parentElement", "firstChild", "lastChild", "previousSibling", "nextSibling"
+        # An Attr is no part of a tree: it has no parent, children or
+        # siblings, and its element is no parent of it.
+        nil
+      when "childNodes"
+        NodeList.new
+      when "isConnected"
+        # Its root is itself, never a document.
+        false
       else
         Bridge::ABSENT
       end
@@ -139,8 +146,8 @@ module Dommy
     end
 
     include Bridge::Methods
-    js_methods %w[cloneNode isSameNode getRootNode hasChildNodes normalize compareDocumentPosition
-      appendChild insertBefore removeChild replaceChild
+    js_methods %w[cloneNode isSameNode isEqualNode contains getRootNode hasChildNodes normalize
+      compareDocumentPosition appendChild insertBefore removeChild replaceChild
       lookupNamespaceURI lookupPrefix isDefaultNamespace
       addEventListener removeEventListener dispatchEvent]
     def __js_call__(method, args)
@@ -154,9 +161,13 @@ module Dommy
       when "cloneNode"
         Attr.new(@name, owner: nil, value: value,
                         namespace_uri: @namespace_uri, prefix: @prefix, local_name: @local_name,
-                        document: @document || (@owner.respond_to?(:document) ? @owner.document : nil))
+                        document: @document)
       when "isSameNode"
         is_same_node(args[0])
+      when "isEqualNode"
+        is_equal_node(args[0])
+      when "contains"
+        contains?(args[0])
       when "getRootNode"
         get_root_node(args[0])
       when "compareDocumentPosition"
@@ -178,14 +189,29 @@ module Dommy
       end
     end
 
+    # Node.contains — an Attr has no descendants, so only itself.
+    def contains?(other)
+      equal?(other)
+    end
+
     # Internal: called by Element when the attr is being transferred
-    # to (or detached from) an Element.
+    # to (or detached from) an Element. Appending it sets its node document
+    # to the element's; removing it leaves the node document as it is.
     def __internal_attach__(element)
       @owner = element
+      @document = element.document
       @detached_value = ""
       nil
     end
 
+    # Internal: "adopt" (DOM §4.5) sets the node document — of the Attr
+    # adopted by itself, which stays on its element, or of each attribute of
+    # an adopted element.
+    def __internal_adopt__(document)
+      @document = document
+      self
+    end
+
     def __internal_detach__
       cached = value
       @owner = nil
@@ -238,13 +264,17 @@ module Dommy
       attr
     end
 
+    # The element was adopted into `document`, and its attributes with it.
+    def __internal_adopt__(document)
+      @attrs.each_value { |attr| attr.__internal_adopt__(document) if attr.owner_element.equal?(@element) }
+      nil
+    end
+
     def get_named_item(name)
       # getNamedItem / getAttribute lowercase the qualified name only for an HTML
       # element in an HTML document; other elements match case-sensitively.
       key = @element.__internal_normalize_attr_key__(name)
-      node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
-        Backend.attribute_ns_info(a)[:qualified_name] == key
-      end
+      node = Backend.attr_by_qualified_name(@element.__dommy_backend_node__, key)
       node && attr_for(node)
     end
 
@@ -254,10 +284,8 @@ module Dommy
 
     def remove_named_item(name)
       key = @element.__internal_normalize_attr_key__(name)
-      node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
-        Backend.attribute_ns_info(a)[:qualified_name] == key
-      end
-      return nil unless node
+      node = Backend.attr_by_qualified_name(@element.__dommy_backend_node__, key)
+      raise DOMException::NotFoundError, "no attribute named #{key.inspect}" unless node
 
       removed = attr_for(node)
       @element.remove_attribute(key)
@@ -297,7 +325,7 @@ module Dommy
       if ns
         @element.set_attribute_ns(ns, attr.name, value)
       else
-        @element.set_attribute(attr.name, value)
+        @element.__internal_set_attribute_value__(local, value)
       end
       @attrs[key] = attr
       old
@@ -316,11 +344,7 @@ module Dommy
     # ----- 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 = Backend.attr_by_ns(@element.__dommy_backend_node__, namespace, local_name)
       node && attr_for(node)
     end
 
@@ -331,7 +355,7 @@ module Dommy
 
     def remove_named_item_ns(namespace, local_name)
       existing = get_named_item_ns(namespace, local_name)
-      return nil unless existing
+      raise DOMException::NotFoundError, "no attribute #{local_name.inspect} in that namespace" unless existing
 
       @element.remove_attribute_ns(namespace, local_name)
       existing