dommy 0.8.0 → 0.9.0

data/lib/dommy/internal/element_matching.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "dom_matching"
+
+module Dommy
+  module Internal
+    # Element-type-specific finders for links, forms, selects, and
+    # checkable fields.  Lives in dommy core so that companion gems
+    # (currently dommy-rails) share a single finder implementation
+    # instead of re-implementing the selector / filter logic per gem.
+    #
+    # Attribute criteria (`href:`, `action:`, `name:`) accept a String
+    # (exact match), a Regexp, or any object responding to `matches?` —
+    # the extension point dommy-rails uses to inject URL normalization.
+    module ElementMatching
+      module_function
+
+      # Find <a> elements matching the given criteria.
+      def find_links(scope, text: nil, href: nil)
+        links = scope.query_selector_all("a[href]").to_a
+        links = links.select { |el| DomMatching.text_matches?(el.text_content, text) } if text
+        links = links.select { |el| attribute_matches?(el, "href", href) } if href
+        links
+      end
+
+      # Find <form> elements matching the given criteria.  `method:` is
+      # matched against the effective method, honoring a hidden
+      # `_method` override field inside POST forms.
+      def find_forms(scope, action: nil, method: nil)
+        forms = scope.query_selector_all("form").to_a
+        forms = forms.select { |el| attribute_matches?(el, "action", action) } if action
+        forms = forms.select { |el| form_method_matches?(el, method) } if method
+        forms
+      end
+
+      # Find <select> elements matching the given criteria.
+      def find_selects(scope, name: nil, label: nil)
+        selects = scope.query_selector_all("select").to_a
+        selects = selects.select { |el| attribute_matches?(el, "name", name) } if name
+        selects = selects.select { |el| field_label_matches?(el, label) } if label
+        selects
+      end
+
+      # Find checkable fields (input[type=checkbox|radio]) matching the
+      # given criteria.
+      def find_checkable_fields(scope, name: nil, checked: nil)
+        fields = scope.query_selector_all("input[type='checkbox'], input[type='radio']").to_a
+        fields = fields.select { |el| attribute_matches?(el, "name", name) } if name
+        fields = fields.select { |el| el.get_attribute("checked") } if checked == true
+        fields = fields.reject { |el| el.get_attribute("checked") } if checked == false
+        fields
+      end
+
+      def attribute_matches?(element, attr_name, expected)
+        actual = element.get_attribute(attr_name).to_s
+        case expected
+        when Regexp
+          actual.match?(expected)
+        else
+          if expected.respond_to?(:matches?)
+            expected.matches?(actual)
+          else
+            actual == expected.to_s
+          end
+        end
+      end
+
+      # Labels associated with a field: a <label for=...> pointing at
+      # its id, and/or the nearest <label> ancestor wrapping it.
+      # Scans label elements instead of interpolating the id into a
+      # selector, so ids containing quotes cannot break the query.
+      def field_labels(field)
+        labels = []
+
+        id = field.get_attribute("id").to_s
+        unless id.empty?
+          for_label = field.owner_document.query_selector_all("label").to_a.find do |label|
+            label.get_attribute("for") == id
+          end
+          labels << for_label if for_label
+        end
+
+        parent = field.parent_node
+        while parent
+          if parent.respond_to?(:tag_name) && parent.tag_name == "LABEL"
+            labels << parent
+            break
+          end
+          parent = parent.respond_to?(:parent_node) ? parent.parent_node : nil
+        end
+
+        labels
+      end
+
+      def field_label_matches?(field, expected_label)
+        field_labels(field).any? { |label| DomMatching.text_matches?(label.text_content, expected_label) }
+      end
+
+      def form_method_matches?(form, expected_method)
+        actual_method = form.get_attribute("method").to_s.downcase
+        if actual_method == "post"
+          hidden_method = form.query_selector("input[type='hidden'][name='_method']")
+          actual_method = hidden_method.get_attribute("value").to_s.downcase if hidden_method
+        end
+        actual_method == expected_method.to_s.downcase
+      end
+    end
+  end
+end

data/lib/dommy/internal/global_functions.rb

@@ -2,6 +2,7 @@
 
 require "cgi"
 require "erb"
+require "base64"
 
 module Dommy
   module Internal
@@ -21,6 +22,38 @@ module Dommy
       def decode_uri_component(value)
         CGI.unescape(value.to_s)
       end
+
+      # JS `btoa`: base64-encode a binary (Latin1) string. Each code unit must be
+      # 0..255; anything beyond Latin1 is an InvalidCharacterError (per spec).
+      def btoa(value)
+        codepoints = value.to_s.codepoints
+        if codepoints.any? { |c| c > 0xFF }
+          raise DOMException::InvalidCharacterError.new(
+            "Failed to execute 'btoa': characters outside the Latin1 range cannot be base64-encoded."
+          )
+        end
+
+        Base64.strict_encode64(codepoints.pack("C*"))
+      end
+
+      # JS `atob`: decode base64 to a binary (Latin1) string. ASCII whitespace is
+      # ignored; an invalid alphabet/length is an InvalidCharacterError. The
+      # decoded bytes are returned as a string whose code units equal the bytes.
+      def atob(value)
+        data = value.to_s.gsub(/[\t\n\f\r ]/, "")
+        invalid_atob! if data.length % 4 == 1 || !data.match?(%r{\A[A-Za-z0-9+/]*={0,2}\z})
+
+        padded = data + ("=" * ((-data.length) % 4))
+        Base64.strict_decode64(padded).bytes.map { |byte| byte.chr(Encoding::UTF_8) }.join
+      rescue ArgumentError
+        invalid_atob!
+      end
+
+      def invalid_atob!
+        raise DOMException::InvalidCharacterError.new(
+          "Failed to execute 'atob': the string to be decoded is not correctly base64-encoded."
+        )
+      end
     end
   end
 end

data/lib/dommy/internal/mutation_coordinator.rb

@@ -43,12 +43,96 @@ module Dommy
 
         if nk.element?
           wrapped = @document.wrap_node(nk)
-          notify_connected(wrapped) if wrapped
+          if wrapped
+            notify_connected(wrapped)
+            run_connected_script(wrapped)
+            fire_blank_iframe_load(wrapped)
+          end
         end
 
         nk.children.each { |c| notify_connected_subtree(c) } if nk.respond_to?(:children)
       end
 
+      # A srcless ("blank"/about:blank) `<iframe>` connected to the document gets
+      # an empty nested browsing context (a real, complete content document) and
+      # fires its `load` event ASYNCHRONOUSLY (a microtask), like a real browser —
+      # handlers are commonly attached after insertion (`appendChild(f); f.onload
+      # = …`). Without this, code that awaits a blank iframe's load and then reads
+      # `iframe.contentWindow.document` hangs: FingerprintJS's `withIframe` (its
+      # font sources) does exactly that, which hung note.com's tracking plugin and
+      # its whole Nuxt hydration. A `src` iframe is left to the integration layer.
+      BLANK_IFRAME_SRCS = ["", "about:blank"].freeze
+
+      def fire_blank_iframe_load(element)
+        return unless element.respond_to?(:local_name) && element.local_name == "iframe"
+        return unless element.respond_to?(:is_connected?) && element.is_connected?
+        return unless element.respond_to?(:src) && BLANK_IFRAME_SRCS.include?(element.src.to_s.strip)
+
+        ensure_blank_content_document(element)
+        fire = proc { element.dispatch_event(Event.new("load")) rescue nil }
+        scheduler = (@document.default_view&.scheduler if @document.respond_to?(:default_view))
+        scheduler ? scheduler.queue_microtask(fire) : fire.call
+      rescue StandardError
+        nil
+      end
+
+      # Give a blank iframe a fresh empty document (or its `srcdoc`) so
+      # `contentWindow` / `contentDocument` resolve and DOM ops + measurement
+      # inside it work (readyState defaults to "complete"). No-op if it already
+      # has one.
+      def ensure_blank_content_document(element)
+        return unless element.respond_to?(:__internal_set_content_document__)
+        return if element.respond_to?(:content_document) && element.content_document
+
+        srcdoc = (element.srcdoc.to_s if element.respond_to?(:srcdoc))
+        html = srcdoc.nil? || srcdoc.empty? ? "<html><head></head><body></body></html>" : srcdoc
+        win = Dommy::Window.new(backend_doc: Dommy::Backend.parse(html))
+        element.__internal_set_content_document__(win.document)
+      end
+
+      # A classic <script> that's now genuinely connected to this document runs:
+      # an inline body through the document's script_runner (wired by the JS
+      # bridge), an external `src` through external_script_runner (wired by the
+      # integration layer, which fetches + runs it — webpack/Vite load on-demand
+      # chunks by injecting `<script src>` this way). Gated on is_connected?
+      # because this walk also fires for additions to a still-detached subtree.
+      def run_connected_script(element)
+        return unless element.respond_to?(:__internal_take_pending_script__) # a <script>
+        return unless element.respond_to?(:is_connected?) && element.is_connected?
+
+        if (runner = @document.script_runner) && (source = element.__internal_take_pending_script__)
+          # A script-inserted INLINE classic script runs synchronously on insertion.
+          runner.call(source)
+        elsif @document.external_script_runner &&
+              element.respond_to?(:__internal_take_pending_src__) &&
+              (src = element.__internal_take_pending_src__)
+          run_external_connected_script(element, src)
+        end
+      rescue StandardError
+        nil
+      end
+
+      # A script-inserted EXTERNAL `<script src>` loads and runs ASYNCHRONOUSLY
+      # (per HTML spec), unlike an inline one. Running it synchronously inside the
+      # insertion steps would (a) execute it mid-render and, worse, (b) make the
+      # engine drain its microtask queue while JS is still on the stack — running
+      # an unrelated queued microtask (e.g. Vue's `nextTick` scheduler flush)
+      # re-entrantly and patching a half-built component tree (note.com's
+      # RecommendTemplate crashed Vue's `isPatchable` this way). Defer to a
+      # microtask so it runs at a proper checkpoint, after the current task
+      # unwinds. Re-check connectedness then (the node may have been removed).
+      def run_external_connected_script(element, src)
+        run = proc do
+          next unless element.respond_to?(:is_connected?) && element.is_connected?
+
+          @document.external_script_runner.call(element, src)
+        rescue StandardError
+          nil
+        end
+        scheduler = (@document.default_view&.scheduler if @document.respond_to?(:default_view))
+        scheduler ? scheduler.queue_microtask(run) : run.call
+      end
+
       def notify_disconnected_subtree(nk)
         return unless nk.respond_to?(:element?)
 
@@ -80,6 +164,7 @@ module Dommy
         previous_sibling: nil,
         next_sibling: nil
       )
+        @document.__internal_bump_style_generation__
         target = @document.wrap_node(target_node)
         return nil unless target
         return nil if added_nodes.empty? && removed_nodes.empty?
@@ -111,12 +196,16 @@ module Dommy
         )
         # Only observers whose matching registration requested childList get the
         # record (an `attributes`/`characterData`-only observer must not — e.g.
-        # `observe(t, {childList: false, attributes: true})`).
+        # `observe(t, {childList: false, attributes: true})`). A subtree
+        # registration that matched ALSO gains a transient registered observer
+        # for each removed node, so mutations within the just-removed subtree
+        # (before the next microtask checkpoint) are still observed.
         @observer_manager.observers_matching(target).each do |observer|
           entry = observer.find_matching_entry(target)
-          next unless entry && entry[:child_list]
+          next unless entry
 
-          observer.enqueue(record)
+          observer.enqueue(record) if entry[:child_list]
+          wrapped_removed.each { |removed| observer.add_transient(removed, entry) } if entry[:subtree]
         end
 
         nil
@@ -124,6 +213,7 @@ module Dommy
 
       # Fire MutationObserver attribute records
       def notify_attribute_mutation(target_node:, attribute_name:, old_value:, namespace: nil)
+        @document.__internal_bump_style_generation__
         target = @document.wrap_node(target_node)
         return nil unless target
 
@@ -158,6 +248,7 @@ module Dommy
 
       # Fire MutationObserver characterData records
       def notify_character_data_mutation(target_node:, old_value:)
+        @document.__internal_bump_style_generation__
         target = @document.wrap_node(target_node)
         return nil unless target
 

data/lib/dommy/internal/namespaces.rb

@@ -25,31 +25,75 @@ module Dommy
 
       # The full Name production (NameStartChar additionally includes ":").
       NAME  = Regexp.new("\\A[:#{NC_START}][:#{NC_START}#{NC_EXTRA}]*\\z")
+      # `createElement` / `setAttribute` name validation. Browsers (and the WPT
+      # tests that pin web reality) are far more lenient than the XML Name
+      # production: any non-empty string with no ASCII whitespace or ">", whose
+      # first character is not a digit, ".", "-", "<", ">", or "}". (Names like
+      # "f}oo", "f<oo" or a leading combining mark are valid here but not under
+      # the strict QName production the *AttributeNS family still uses.)
+      HTML_NAME = /\A(?![\s0-9.\-<>}])[^\s>]+\z/
       # PrefixedName | UnprefixedName.
       QNAME = Regexp.new(
         "(?:\\A#{NCSTART}#{NCCHAR}*:#{NCSTART}#{NCCHAR}*\\z)|(?:\\A#{NCSTART}#{NCCHAR}*\\z)"
       )
 
+      # Code points forbidden anywhere in a "valid local name" / "valid namespace
+      # prefix" per the modern WHATWG algorithm: ASCII whitespace (TAB, LF, FF,
+      # CR, SPACE), NULL, U+002F (/), U+003E (>).
+      LOCAL_FORBIDDEN = Regexp.new("[\\u0000\\u0009\\u000A\\u000C\\u000D\\u0020/>]")
+      # Valid first code point of an element local name: ASCII alpha, U+003A (:),
+      # U+005F (_), or any code point U+0080 and above.
+      ELEMENT_LOCAL_START = Regexp.new("\\A[A-Za-z:_\\u0080-\\u{10FFFF}]")
+
       module_function
 
+      def valid_namespace_prefix?(str)
+        !str.empty? && !str.match?(LOCAL_FORBIDDEN)
+      end
+
+      def valid_element_local_name?(str)
+        return false if str.empty?
+        return false unless str.match?(ELEMENT_LOCAL_START)
+
+        rest = str[1..]
+        rest.nil? || rest.empty? || !rest.match?(LOCAL_FORBIDDEN)
+      end
+
       # https://dom.spec.whatwg.org/#validate-and-extract
       # Returns [namespace_or_nil, prefix_or_nil, local_name]. Raises
       # DOMException (InvalidCharacterError / NamespaceError) on bad input.
-      def validate_and_extract(namespace, qualified_name)
+      #
+      # `context: :element` applies the modern WHATWG "validate" character rules
+      # (lenient: a restricted first code point then any non-forbidden code
+      # points, multiple colons allowed when namespaced). `context: :attribute`
+      # (the default) keeps the strict XML QName production used historically by
+      # the *AttributeNS family.
+      def validate_and_extract(namespace, qualified_name, context: :attribute)
         ns = namespace.to_s
         ns = nil if ns.empty?
         qname = qualified_name.to_s
 
-        unless qname.match?(QNAME)
-          raise DOMException::InvalidCharacterError, "invalid qualified name: #{qname.inspect}"
-        end
-
         prefix = nil
         local = qname
         if qname.include?(":")
+          # Split on the FIRST colon: any further colons stay in the local part
+          # (e.g. "f:o:o" → prefix "f", local "o:o").
           prefix, local = qname.split(":", 2)
         end
 
+        if context == :element
+          if prefix && !valid_namespace_prefix?(prefix)
+            raise DOMException::InvalidCharacterError, "invalid namespace prefix: #{prefix.inspect}"
+          end
+          unless valid_element_local_name?(local)
+            raise DOMException::InvalidCharacterError, "invalid local name: #{local.inspect}"
+          end
+        else
+          unless qname.match?(QNAME)
+            raise DOMException::InvalidCharacterError, "invalid qualified name: #{qname.inspect}"
+          end
+        end
+
         if prefix && ns.nil?
           raise DOMException::NamespaceError, "prefix #{prefix.inspect} with null namespace"
         end