dommy 0.14.0 → 0.16.0

data/lib/dommy/internal/document_generations.rb

@@ -9,14 +9,28 @@ module Dommy
     # the ones it can actually invalidate, which is the whole point — a text
     # edit inside a <p> must not throw away the rule index.
     #
-    # Host contract: @__css_style_cache__ and #__internal_style_sheet_elements__.
+    # Each is the sum of the document's own count, which its mutation paths
+    # move, and Makiri's count of the matching edits — tree_version for the
+    # child lists, attribute_version for the attributes — which moves however
+    # the backend was edited. Every term only grows, so the sum changes with
+    # any of them: an edit that reached Makiri without passing through the
+    # document's paths still retires what hangs on the counter. Makiri counts
+    # no character-data edit, so a text edit that flips nothing moves nothing
+    # here either; one that flips `:empty` is seen through the document's
+    # own path alone.
+    #
+    # Host contract: @backend_doc, @__internal_css_style_cache__,
+    # #__internal_style_sheet_elements__ and #quirks_mode?.
     module DocumentGenerations
+      # The attributes SelectorIndex records an element under.
+      INDEXED_ATTRIBUTES = %w[id class].freeze
+
       def style_generation
-        @style_generation || 0
+        (@style_generation || 0) + backend_tree_version
       end
 
       def dom_generation
-        @dom_generation || 0
+        (@dom_generation || 0) + backend_tree_version + backend_attribute_version
       end
 
       # Moves only on childList mutations — the coarsest epoch. Keys memos
@@ -24,23 +38,56 @@ module Dommy
       # exist, in what order), like the document's <style>/<link> list: an
       # attribute-triggered cascade rebuild can then skip re-walking for them.
       def tree_generation
-        @tree_generation || 0
+        (@tree_generation || 0) + backend_tree_version
+      end
+
+      # What the selector index (SelectorIndex) is built from: the element tree
+      # and each element's `id` and `class`. Nothing else it holds can go
+      # stale, so a value, focus or `data-*` change, which moves
+      # dom_generation, leaves it standing.
+      #
+      # An attribute edit the document saw and could name (see
+      # #__internal_note_attribute_mutation__) is accounted for: an `id` or
+      # `class` one moves the index's own counter, any other moves nothing.
+      # One Makiri counted that the document did not account for — edited
+      # around its mutation paths — moves the epoch, so the index is rebuilt
+      # rather than trusted.
+      def __internal_selector_index_generation__
+        version = backend_attribute_version
+        unless version == @__index_attribute_version
+          @__index_attribute_epoch = (@__index_attribute_epoch || 0) + 1
+          @__index_attribute_version = version
+        end
+        # The same frozen key while nothing moved: the matcher asks once per
+        # candidate, so this must not allocate.
+        tree = tree_generation
+        own = @__index_generation || 0
+        quirks = quirks_mode?
+        key = @__index_generation_key
+        unless key && key[0] == tree && key[1] == own && key[2] == @__index_attribute_epoch && key[3] == quirks
+          key = @__index_generation_key = [tree, own, @__index_attribute_epoch, quirks].freeze
+        end
+        key
       end
 
       def __internal_bump_style_generation__
-        @style_generation = style_generation + 1
+        @style_generation = (@style_generation || 0) + 1
+        # Whatever changed may have made the focused element unfocusable:
+        # the next rendering update's focus fixup checks.
+        __internal_schedule_rendering_update__ if @active_element
         nil
       end
 
       def __internal_bump_dom_generation__
-        @dom_generation = dom_generation + 1
+        @dom_generation = (@dom_generation || 0) + 1
+        __internal_schedule_rendering_update__ if @active_element
         nil
       end
 
       # A childList mutation: tree shape feeds both selector matching and the
       # rule -> element index, so everything is suspect.
       def __internal_note_tree_mutation__
-        @tree_generation = tree_generation + 1
+        @tree_generation = (@tree_generation || 0) + 1
         __internal_bump_dom_generation__
         __internal_bump_style_generation__
       end
@@ -51,6 +98,7 @@ module Dommy
       # <style>/<link>, whose media/disabled/rel gate whole sheets.
       def __internal_note_attribute_mutation__(name, target_node)
         __internal_bump_dom_generation__
+        __internal_note_index_attribute__(name)
         __internal_bump_style_generation__ if __internal_style_affected_by_attribute__(name, target_node)
       end
 
@@ -62,7 +110,7 @@ module Dommy
         # Only a Text node's data participates in :empty; a comment/PI edit
         # can't change any match. `target_node` is a backend node, so its data
         # reads through the Nokogiri-compatible #content.
-        text = target_node.respond_to?(:node_type) && target_node.node_type == 3
+        text = target_node.node_type == 3
         flipped = text && (old_value.to_s.empty? != target_node.content.to_s.empty?)
         __internal_bump_dom_generation__ if flipped
         if __internal_inside_style_element__(target_node) ||
@@ -95,7 +143,7 @@ module Dommy
       end
 
       def __internal_style_value_sensitive__
-        index = @__css_style_cache__&.index
+        index = @__internal_css_style_cache__&.index
         index ? index.value_sensitive? : true
       end
 
@@ -109,7 +157,7 @@ module Dommy
         return @__direction_sensitive[1] if @__direction_sensitive&.first == generation
 
         sensitive = @backend_doc.css("[dir], bdi").any? do |node|
-          Directionality.text_dependent?(node.name, node["dir"])
+          Directionality.text_dependent?(node.name, Backend.no_namespace_attribute_value(node, "dir"))
         end
         @__direction_sensitive = [generation, sensitive]
         sensitive
@@ -122,21 +170,27 @@ module Dommy
       def __internal_direction_sensitive_ancestor__(node)
         current = node
         while current
-          return true if current.respond_to?(:name) && Directionality.text_dependent?(current.name, current["dir"])
+          if current.element? &&
+             Directionality.text_dependent?(current.name, Backend.no_namespace_attribute_value(current, "dir"))
+            return true
+          end
 
-          current = current.respond_to?(:parent) ? current.parent : nil
+          current = current.parent
         end
         false
       end
 
       def __internal_style_affected_by_attribute__(name, target_node)
-        owner = target_node.respond_to?(:name) ? target_node.name.to_s.downcase : nil
+        owner = target_node.name.to_s.downcase
         return true if owner == "style" || owner == "link"
         # The `dir` attribute drives the computed `direction` (Directionality)
         # as well as `:dir()`, neither of which is a plain attribute selector.
         return true if name.to_s.casecmp?("dir")
+        # The UA rules for popovers and dialogs (UAStylesheet
+        # .top_layer_declarations) read these with no selector of their own.
+        return true if name.to_s.casecmp?("popover") || name.to_s.casecmp?("open")
 
-        index = @__css_style_cache__&.index
+        index = @__internal_css_style_cache__&.index
         # No RuleIndex yet: the bump is nearly free (at most it drops the
         # author_css?/counters memos), so stay conservative.
         return true unless index
@@ -145,7 +199,7 @@ module Dommy
       end
 
       def __internal_style_text_sensitive__
-        index = @__css_style_cache__&.index
+        index = @__internal_css_style_cache__&.index
         index ? index.text_sensitive? : true
       end
 
@@ -156,14 +210,33 @@ module Dommy
         # between childList mutations answers this without re-walking.
         return false unless __internal_style_sheet_elements__.any? { |el| el.local_name.to_s.casecmp?("style") }
 
-        current = node.respond_to?(:parent) ? node.parent : nil
+        current = node.parent
         while current
-          return true if current.respond_to?(:name) && current.name.to_s.downcase == "style"
+          return true if current.name.to_s.downcase == "style"
 
-          current = current.respond_to?(:parent) ? current.parent : nil
+          current = current.parent
         end
         false
       end
+
+      private
+
+      # The index-side accounting for one attribute edit, called after the
+      # backend took it. A non-indexed name is accounted only when it is the
+      # single backend edit since the last accounted one; anything else leaves
+      # the gap for #__internal_selector_index_generation__ to see.
+      def __internal_note_index_attribute__(name)
+        if INDEXED_ATTRIBUTES.any? { |indexed| name.casecmp?(indexed) }
+          @__index_generation = (@__index_generation || 0) + 1
+        else
+          version = backend_attribute_version
+          @__index_attribute_version = version if @__index_attribute_version == version - 1
+        end
+      end
+
+      def backend_tree_version = @backend_doc ? @backend_doc.tree_version : 0
+
+      def backend_attribute_version = @backend_doc ? @backend_doc.attribute_version : 0
     end
   end
 end

data/lib/dommy/internal/document_interaction_state.rb

@@ -6,29 +6,230 @@ module Dommy
     # They are not tree state, but :focus and :hover match on them, so a change
     # has to tell the selector caches.
     #
-    # Host contract: #body, and DocumentGenerations for the epoch bump a
-    # focus or hover change owes the selector caches.
+    # Host contract: #body, #document_element, #default_view, and
+    # DocumentGenerations for the epoch bump a focus or hover change owes the
+    # selector caches.
     module DocumentInteractionState
-      # Currently-focused element (or body if none). Updated via
-      # `el.focus()` / `el.blur()`.
+      # DocumentOrShadowRoot's `activeElement` for the document: the focused
+      # element retargeted against the document — the outermost shadow host,
+      # for an element inside a shadow tree — or, with the viewport focused,
+      # the body element, else the document element.
       def active_element
-        @active_element || body
+        focused = @active_element
+        if focused
+          candidate = Retargeting.retarget(focused, self)
+          return candidate if candidate.respond_to?(:get_root_node) && candidate.get_root_node.equal?(self)
+        end
+        body || document_element
       end
 
+      # Designate `el` (nil for the viewport) as the focused area, firing
+      # nothing — what the focus fixup does, and what the focus update steps
+      # do between their blur and focus events.
       def __internal_set_active_element__(el)
         # Focus is selector-observable state (:focus / :focus-within rules), so
         # a change invalidates cached query results and computed styles.
-        __internal_note_selector_state_change__ unless @active_element.equal?(el)
+        return if @active_element.equal?(el)
+
         @active_element = el
+        __internal_note_selector_state_change__
       end
 
-      # The explicitly focused element (nil when nothing holds focus) — what
-      # :focus matches. Distinct from #active_element, which falls back to
-      # <body> per spec.
+      # The explicitly focused element (nil when the viewport has the focus) —
+      # the focused area's DOM anchor when it is an element.
       def __internal_focused_element__
         @active_element
       end
 
+      # HTML's "focus update steps" from the focused area to `new_element`
+      # (nil, the viewport): blur and focusout at the element losing focus,
+      # then focus and focusin at the one gaining it, each a trusted
+      # FocusEvent whose relatedTarget is the other element.
+      #
+      # Whether the new focus is indicated (`:focus-visible`) is decided
+      # first, from how it moved (#__internal_with_focus_type__).
+      def __internal_focus_update__(new_element)
+        old = @active_element
+        type = @pending_focus_type || :script
+        explicit = @pending_focus_visible
+        # Focus moved by the handlers of the events below is script focus.
+        @pending_focus_type = nil
+        @pending_focus_visible = nil
+        return nil if old.equal?(new_element)
+
+        fire_focus_event(old, "blur", new_element) if old
+        fire_focus_event(old, "focusout", new_element) if old
+        if new_element
+          @focus_visible = focus_indicated?(new_element, type, explicit)
+          @last_focus_type = type unless type == :script
+          # Sequential navigation goes on from the newly focused element.
+          @__internal_sequential_focus_navigation_starting_point__ = new_element
+        else
+          @focus_visible = false
+        end
+        __internal_set_active_element__(new_element)
+        return nil unless new_element
+
+        fire_focus_event(new_element, "focus", old)
+        fire_focus_event(new_element, "focusin", old)
+        nil
+      end
+
+      # Run the block — focusing steps — as focus moved by `type`: :keyboard
+      # (sequential focus navigation), :mouse (a click) or :script, and with
+      # FocusOptions' `focusVisible` when the caller passed one.
+      def __internal_with_focus_type__(type, focus_visible: nil)
+        saved = [@pending_focus_type, @pending_focus_visible]
+        @pending_focus_type = type
+        @pending_focus_visible = focus_visible
+        yield
+      ensure
+        @pending_focus_type, @pending_focus_visible = saved
+      end
+
+      # Whether the user agent indicates the focus of the focused element:
+      # what `:focus-visible` matches on.
+      def __internal_focus_visible__? = @focus_visible && @active_element ? true : false
+
+      # `focus({focusVisible: true})` on the element already focused still
+      # indicates its focus.
+      def __internal_indicate_focus__
+        return nil if @focus_visible || @active_element.nil?
+
+        @focus_visible = true
+        __internal_note_selector_state_change__
+        nil
+      end
+
+      # The input modality the focus heuristics remember: a key press makes
+      # later script focus visible, a pointer press undoes that.
+      def __internal_note_keyboard_input__
+        @had_keyboard_event = true
+        nil
+      end
+
+      def __internal_note_pointer_input__
+        @had_keyboard_event = false
+        nil
+      end
+
+      # HTML's removing steps, for the focus: when the focused element, or
+      # a shadow-including ancestor of it, leaves the document, the viewport
+      # becomes the focused area. No blur fires (the "focus fixup").
+      def __internal_focused_subtree_removed__(element)
+        focused = @active_element
+        return nil unless focused
+        return nil unless Retargeting.shadow_including_inclusive_ancestor?(element, focused)
+
+        __internal_set_active_element__(nil)
+        nil
+      end
+
+      # The modal dialogs in the top layer, in the order they entered it.
+      # The last one blocks the document: everything outside it is inert.
+      def __internal_add_modal_dialog__(dialog)
+        (@modal_dialogs ||= []).reject! { |d| d.equal?(dialog) }
+        @modal_dialogs << dialog
+        __internal_note_selector_state_change__
+        nil
+      end
+
+      def __internal_remove_modal_dialog__(dialog)
+        return nil unless @modal_dialogs&.any? { |d| d.equal?(dialog) }
+
+        @modal_dialogs.reject! { |d| d.equal?(dialog) }
+        __internal_note_selector_state_change__
+        nil
+      end
+
+      # HTML "blocked by a modal dialog": the topmost dialog in the top layer.
+      def __internal_blocking_modal_dialog__ = @modal_dialogs&.last
+
+      # HTML's "open dialogs list": the open, connected dialogs, in the order
+      # their dialog setup steps ran (a copy).
+      def __internal_open_dialogs__ = (@open_dialogs ||= []).dup
+
+      def __internal_add_open_dialog__(dialog)
+        (@open_dialogs ||= []) << dialog unless @open_dialogs&.any? { |d| d.equal?(dialog) }
+        nil
+      end
+
+      def __internal_remove_open_dialog__(dialog)
+        @open_dialogs&.reject! { |d| d.equal?(dialog) }
+        nil
+      end
+
+      # HTML's "sequential focus navigation starting point": a node, or nil
+      # when unset (Internal::SequentialFocusNavigation).
+      attr_accessor :__internal_sequential_focus_navigation_starting_point__
+
+      # HTML's "popover pointerdown target" and "dialog pointerdown target",
+      # which light dismiss records on a press (Internal::LightDismiss).
+      attr_accessor :__internal_popover_pointerdown_target__, :__internal_dialog_pointerdown_target__
+
+      # HTML's steps for an element with an autofocus attribute inserted into
+      # a document: unless the top-level document has already processed its
+      # autofocus, the element joins (or moves to the end of) its autofocus
+      # candidates, which the next rendering update flushes.
+      def __internal_autofocus_inserted__(element)
+        return nil unless default_view.is_a?(Window)
+
+        top = __internal_top_document__
+        return nil if top.__internal_autofocus_processed__
+
+        top.__internal_add_autofocus_candidate__(element)
+        nil
+      end
+
+      def __internal_add_autofocus_candidate__(element)
+        candidates = (@autofocus_candidates ||= [])
+        candidates.reject! { |e| e.equal?(element) }
+        candidates << element
+        __internal_schedule_rendering_update__(:before)
+        nil
+      end
+
+      def __internal_autofocus_processed__ = @autofocus_processed ? true : false
+
+      # What the dialog and popover focusing steps do once they have focused
+      # something: the page's autofocus is settled.
+      def __internal_autofocus_done__
+        top = __internal_top_document__
+        top.instance_variable_set(:@autofocus_candidates, [])
+        top.instance_variable_set(:@autofocus_processed, true)
+        nil
+      end
+
+      # The active document of this document's top-level traversable: up
+      # through the frames that host it.
+      def __internal_top_document__
+        document = self
+        seen = 0
+        while (view = document.default_view).respond_to?(:frame_element) && (frame = view.frame_element) &&
+            (seen += 1) < 64
+          document = frame.owner_document
+        end
+        document
+      end
+
+      # Ask for the next rendering update (Scheduler#request_rendering_update),
+      # once per phase: before the frame's rAF callbacks it flushes the
+      # autofocus candidates, after them it runs the focus fixup.
+      def __internal_schedule_rendering_update__(phase = :after)
+        pending = (@rendering_update_pending ||= {})
+        return nil if pending[phase]
+
+        view = default_view
+        return nil unless view.is_a?(Window) && view.document.equal?(self)
+
+        pending[phase] = true
+        view.scheduler.request_rendering_update(lambda do
+          pending.delete(phase)
+          phase == :before ? flush_autofocus_candidates : focus_fixup
+        end, phase: phase)
+        nil
+      end
+
       # The element the (virtual) pointer hovers — :hover matches it and its
       # ancestors. Set from tests or capybara-dommy's Node#hover; nil clears.
       def __internal_hovered_element__
@@ -42,6 +243,89 @@ module Dommy
         __internal_note_selector_state_change__
         nil
       end
+
+      private
+
+      # Input types whose controls take keyboard input (they would bring up
+      # a virtual keyboard).
+      KEYBOARD_INPUT_TYPES = %w[text search url tel email password number date month week time
+                                datetime-local].freeze
+
+      # Selectors' suggested heuristics for when to indicate focus: an
+      # explicit `focusVisible` wins; keyboard focus is indicated; a click
+      # indicates it only on an element that takes keyboard input; script
+      # focus is indicated unless the last focus came from a pointer with no
+      # key pressed since — or the element takes keyboard input.
+      def focus_indicated?(element, type, explicit)
+        return explicit unless explicit.nil?
+
+        case type
+        when :keyboard then true
+        when :mouse then keyboard_input?(element)
+        else @last_focus_type != :mouse || @had_keyboard_event || keyboard_input?(element)
+        end
+      end
+
+      def keyboard_input?(element)
+        return true if Focusability.editing_host?(element)
+        return false unless element.namespace_uri == Namespaces::HTML
+
+        case element.local_name
+        when "textarea" then true
+        when "input" then KEYBOARD_INPUT_TYPES.include?(element.type.to_s)
+        else false
+        end
+      end
+
+      # HTML's focus fixup (in "update the rendering"): a focused element
+      # that stopped being a focusable area (disabled, hidden, made inert)
+      # gives the focus to the viewport, firing blur.
+      def focus_fixup
+        focused = @active_element
+        __internal_focus_update__(nil) if focused && !Focusability.focusable_area?(focused)
+      end
+
+      # HTML "flush autofocus candidates", for a top-level document: the
+      # first candidate that is (or delegates to) a focusable area takes the
+      # focus — unless something is focused already or the document has a
+      # target element, which settles the matter without focusing anything.
+      def flush_autofocus_candidates
+        return if @autofocus_processed
+
+        candidates = @autofocus_candidates
+        return if candidates.nil? || candidates.empty?
+
+        if @active_element || Internal.target_id(self)
+          candidates.clear
+          @autofocus_processed = true
+          return
+        end
+
+        until candidates.empty?
+          element = candidates.shift
+          doc = element.owner_document
+          next unless element.is_connected? && doc.__internal_top_document__.equal?(self)
+          next if Internal.target_id(doc)
+
+          target = Focusability.focusable_area?(element) ? element : Focusability.focusable_area_for(element)
+          next if target.nil?
+
+          candidates.clear
+          @autofocus_processed = true
+          target == :viewport ? __internal_focus_update__(nil) : Focusability.run_focusing_steps(target)
+        end
+      end
+
+      # HTML "fire a focus event": a FocusEvent with the related target, the
+      # window as its view, and the composed flag; focusin and focusout
+      # (UI Events) bubble.
+      def fire_focus_event(target, type, related)
+        bubbles = type == "focusin" || type == "focusout"
+        view = default_view
+        event = FocusEvent.new(type, "bubbles" => bubbles, "composed" => true, "relatedTarget" => related,
+          "view" => view.is_a?(Window) ? view : nil)
+        target.dispatch_event(event.__internal_mark_trusted__)
+      end
     end
   end
 end

data/lib/dommy/internal/dom_matching.rb

@@ -91,9 +91,9 @@ module Dommy
       # detected through the computed style as well. No layout: geometry-
       # dependent invisibility stays out of scope.
       def visible?(element)
-        return true unless element.respond_to?(:__dommy_backend_node__)
+        node = element.__dommy_backend_node__ if element.is_a?(Node)
+        return true unless node
 
-        node = element.__dommy_backend_node__
         return false if node_invisible_self?(node)
 
         NodeTraversal.each_ancestor(node) do |ancestor|
@@ -170,12 +170,12 @@ module Dommy
       # @api private (kept module-level only because visible? calls them)
 
       def node_invisible_self?(node)
-        return false unless node.respond_to?(:[])
+        return false unless node.element?
 
-        return true if node["hidden"]
-        return true if node.respond_to?(:name) && node.name == "input" && node["type"] == "hidden"
+        return true if Backend.no_namespace_attribute_value(node, "hidden")
+        return true if node.name == "input" && Backend.no_namespace_attribute_value(node, "type") == "hidden"
 
-        style = node["style"].to_s
+        style = Backend.no_namespace_attribute_value(node, "style").to_s
         style.match?(/display\s*:\s*none/i) ||
           style.match?(/visibility\s*:\s*hidden/i) ||
           # Inline zero opacity hides too — the same number grammar as the
@@ -189,7 +189,7 @@ module Dommy
       NON_RENDERED_TAGS = %w[head script style template noscript].freeze
 
       def non_rendering_tag?(node)
-        node.respond_to?(:name) && NON_RENDERED_TAGS.include?(node.name)
+        NON_RENDERED_TAGS.include?(node.name)
       end
 
       # Visible text of a node's subtree: like `text_content`, but excluding