dommy 0.12.0 → 0.14.0

data/lib/dommy/internal/rendered_text/collector.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "../css/cascade"
+require_relative "../css/renderability"
+require_relative "../css/ua_stylesheet"
+require_relative "computed_box"
+require_relative "items"
+require_relative "whitespace_collapser"
+
+module Dommy
+  module Internal
+    module RenderedText
+      # The `innerText` / `outerText` getter: HTML's "rendered text collection
+      # steps", from
+      # https://html.spec.whatwg.org/multipage/dom.html#the-innertext-and-outertext-properties
+      #
+      # Dommy lays nothing out, so the layout-derived parts — soft line
+      # wrapping, `::first-line` / `::first-letter`, multicol — are out of
+      # reach. Everything that follows from the computed style and the tree is
+      # implemented: display:none / contents, visibility, white-space,
+      # text-transform, <br>, block and <p> line breaks, table cells and rows,
+      # and the select / optgroup / option box rules.
+      #
+      # Whether the element itself is rendered is asked once, up the tree.
+      # Below it the walk goes top-down and never looks up again: a subtree
+      # without a box is skipped where it starts (see #collect_element and
+      # #rendered_children).
+      class Collector
+        # Elements that render as a replaced box, whose children are not
+        # rendered at all.
+        REPLACED = %w[area audio canvas embed iframe img input object textarea video].freeze
+
+        # The elements the spec gives a special box for inside <select>.
+        OPTION_LIKE = %w[optgroup option].freeze
+
+        # Displays that make an atomic inline-level box: it establishes its own
+        # inline formatting context, so its leading/trailing whitespace is
+        # trimmed and the whitespace around it does not merge with its content.
+        ATOMIC_INLINE_DISPLAYS = %w[inline-block inline-flex inline-grid inline-table].freeze
+
+        def initialize(element)
+          @element = element
+          @boxes = {}.compare_by_identity
+        end
+
+        # HTML's "get the text steps": textContent for an element that is not
+        # being rendered, the rendered text otherwise.
+        def text
+          return @element.text_content.to_s unless being_rendered?(@element)
+
+          WhitespaceCollapser.collapse(collect_children(@element))
+        end
+
+        private
+
+        # Rendered by tree position (connected, in the flat tree, in a rendered
+        # frame), and reached from the root only through boxes that render it:
+        # no display:none on the way, and each step down one that
+        # #rendered_children keeps — which is what rules out a replaced
+        # ancestor and the hidden content of a closed <details>.
+        def being_rendered?(element)
+          return false if CSS::Renderability.not_rendered?(element, method(:style))
+
+          node = element
+          while node
+            return false if box(node).none?
+
+            parent = node.parent_element
+            return false if parent && rendered_children(parent).none? { |child| child.equal?(node) }
+
+            node = parent
+          end
+          true
+        end
+
+        # --- the rendered text collection steps -----------------------------
+
+        def collect(node)
+          case node
+          when TextNode then collect_text(node)
+          when Element then collect_element(node)
+          else [] # a Comment / ProcessingInstruction carries no rendered text
+          end
+        end
+
+        def collect_text(node)
+          box = box(node.parent_element)
+          return [] unless box.visible?
+
+          [TextRun.new(node.data.to_s, box.white_space, box.text_transform)]
+        end
+
+        def collect_element(element)
+          box = box(element)
+          # Nothing inside a display:none box is rendered.
+          return [] if box.none?
+
+          items = collect_children(element)
+          # Invisible, or no box of its own (display:contents): the children's
+          # items alone.
+          return items if !box.visible? || box.contents?
+          # An atomic inline renders as one unbreakable box: a replaced element
+          # contributes nothing, an inline-block contributes its own (already
+          # collapsed) text, and whitespace on either side does not merge with
+          # what is inside. Block-level replaced elements still get line breaks
+          # below.
+          return [Atomic.new("")] if replaced?(element) && box.inline_level?
+          return [Atomic.new(WhitespaceCollapser.collapse(items))] if atomic_inline?(element, box)
+
+          items << Literal.new("\n") if tag(element) == "br"
+          items << Literal.new("\t") if table_cell_not_last?(element, box)
+          items << Literal.new("\n") if table_row_not_last?(element, box)
+          breaks = required_breaks(element, box)
+          breaks ? [RequiredBreak.new(breaks), *items, RequiredBreak.new(breaks)] : items
+        end
+
+        def collect_children(element)
+          rendered_children(element).flat_map { |child| collect(child) }
+        end
+
+        # The child nodes that get a box, where the element restricts them: a
+        # replaced element renders none, a <select> only its optgroup / option
+        # children, a closed <details> only its first <summary>, and a shadow
+        # host only the children assigned to a slot.
+        def rendered_children(element)
+          children = element.child_nodes.to_a
+          if replaced?(element)
+            []
+          elsif tag(element) == "select"
+            children.select { |child| option_like?(child) }
+          elsif closed_details?(element)
+            summary = children.grep(Element).find { |child| tag(child) == "summary" }
+            summary ? [summary] : []
+          elsif element.shadow_root
+            children.select { |child| child.respond_to?(:assigned_slot) && child.assigned_slot }
+          else
+            children
+          end
+        end
+
+        # A <p> gets two required line breaks whatever its display, any other
+        # block-level box one.
+        def required_breaks(element, box)
+          if tag(element) == "p" then 2
+          elsif block_level?(element, box) then 1
+          end
+        end
+
+        # optgroup / option act as block-level boxes whatever their computed
+        # display; table cells and rows are separated by tabs and newlines
+        # instead. With no computed display, the UA-default box decides.
+        def block_level?(element, box)
+          return true if option_like?(element)
+          return CSS::UAStylesheet::BLOCK_LEVEL_TAGS.include?(tag(element)) if box.display.nil?
+          return false if box.display == "table-cell" || box.display == "table-row"
+
+          !box.inline_level?
+        end
+
+        # A <p> keeps its two line breaks whatever its display.
+        def atomic_inline?(element, box)
+          tag(element) != "p" && ATOMIC_INLINE_DISPLAYS.include?(box.display)
+        end
+
+        def table_cell_not_last?(element, box)
+          return false unless box.display == "table-cell"
+
+          row = element.parent_element
+          return false unless row
+
+          cells = element_children(row).select { |child| box(child).display == "table-cell" }
+          !cells.last.equal?(element)
+        end
+
+        def table_row_not_last?(element, box)
+          return false unless box.display == "table-row"
+
+          table = element.parent_element
+          table = table.parent_element while table && box(table).display == "table-row-group"
+          return false unless table
+
+          !table_rows(table).last.equal?(element)
+        end
+
+        # Every table-row box of a table, in tree order, descending through the
+        # row groups (tbody / thead / tfoot) but not into a nested table.
+        def table_rows(parent)
+          element_children(parent).flat_map do |child|
+            case box(child).display
+            when "table-row" then [child]
+            when "table-row-group" then table_rows(child)
+            else []
+            end
+          end
+        end
+
+        # --- element facts --------------------------------------------------
+
+        def tag(element) = element.local_name.to_s.downcase
+
+        def replaced?(element) = REPLACED.include?(tag(element))
+
+        def option_like?(node) = node.is_a?(Element) && OPTION_LIKE.include?(tag(node))
+
+        def closed_details?(element) = tag(element) == "details" && !element.has_attribute?("open")
+
+        def element_children(element) = element.child_nodes.to_a.grep(Element)
+
+        def box(element)
+          @boxes[element] ||= ComputedBox.from(style(element))
+        end
+
+        def style(element)
+          CSS::Cascade.computed_style(element)
+        rescue CSS::Parser::Unavailable
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/dommy/internal/rendered_text/computed_box.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    module RenderedText
+      # The computed properties the collection steps read from one element.
+      #
+      # An empty computed style (no CSS layer to ask) falls back to each
+      # property's initial value. `display` alone has no usable one — `inline`
+      # would make every <div> inline — so it is nil there, and the caller
+      # falls back to the element's UA-default box instead.
+      ComputedBox = Data.define(:display, :visibility, :white_space, :text_transform) do
+        def self.from(style)
+          new(
+            display: value_of(style, "display"),
+            visibility: value_of(style, "visibility") || "visible",
+            white_space: value_of(style, "white-space") || "normal",
+            text_transform: value_of(style, "text-transform") || "none"
+          )
+        end
+
+        def self.value_of(style, property)
+          value = style[property].to_s
+          value unless value.empty?
+        end
+        private_class_method :value_of
+
+        def visible? = visibility == "visible"
+
+        def none? = display == "none"
+
+        def contents? = display == "contents"
+
+        # Inline-level, counting an unknown display as the inline default.
+        def inline_level? = display.nil? || display.start_with?("inline")
+      end
+    end
+  end
+end

data/lib/dommy/internal/rendered_text/fragment.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    module RenderedText
+      # The `innerText` / `outerText` setters, both built on HTML's "rendered
+      # text fragment": the value split on line breaks, a Text node for each
+      # run of text between them and a <br> for each break (CRLF counts once).
+      module Fragment
+        module_function
+
+        # The innerText setter: "set the inner text steps".
+        def set_inner(element, value)
+          element.__internal_replace_all__(fragment(element.document, value.to_s).map(&:__dommy_backend_node__))
+          nil
+        end
+
+        # The outerText setter: the element is replaced by the fragment (an
+        # empty Text node when there is none), and the Text nodes it lands
+        # between merge with it.
+        def set_outer(element, value)
+          raise DOMException::NoModificationAllowedError, "outerText requires a parent" if element.parent_node.nil?
+
+          following = element.next_sibling
+          preceding = element.previous_sibling
+          nodes = fragment(element.document, value.to_s)
+          nodes = [element.document.create_text_node("")] if nodes.empty?
+          element.replace_with(*nodes)
+          merge_next_text_node(following)
+          merge_next_text_node(preceding) if preceding.is_a?(TextNode)
+          nil
+        end
+
+        def fragment(document, value)
+          value.scan(/[^\r\n]+|\r\n|\r|\n/).map do |piece|
+            piece.start_with?("\r", "\n") ? document.create_element("br") : document.create_text_node(piece)
+          end
+        end
+
+        def merge_next_text_node(node)
+          return unless node.is_a?(TextNode)
+
+          following = node.next_sibling
+          return unless following.is_a?(TextNode)
+
+          node.data = node.data + following.data
+          following.remove
+        end
+
+        # The two setters are the module; the rest is how.
+        private_class_method :fragment, :merge_next_text_node
+      end
+    end
+  end
+end

data/lib/dommy/internal/rendered_text/items.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    module RenderedText
+      # The white-space values under which a run's spaces, tabs and newlines
+      # collapse into one space.
+      COLLAPSIBLE_WHITE_SPACE = %w[normal nowrap pre-line].freeze
+      # The values under which a newline in the source stays a newline.
+      NEWLINE_PRESERVING_WHITE_SPACE = %w[pre pre-wrap pre-line break-spaces].freeze
+      # The values under which spaces and tabs stay as written.
+      SPACE_PRESERVING_WHITE_SPACE = %w[pre pre-wrap break-spaces].freeze
+
+      # The item list the collection steps produce holds four kinds of item.
+
+      # A run of text as it appears in the item list, before the block-wide
+      # white-space pass: the raw data plus the two computed properties that
+      # decide how it renders.
+      TextRun = Data.define(:text, :white_space, :text_transform) do
+        def empty? = text.empty?
+
+        def collapsible? = COLLAPSIBLE_WHITE_SPACE.include?(white_space)
+
+        def preserves_newlines? = NEWLINE_PRESERVING_WHITE_SPACE.include?(white_space)
+
+        def preserves_spaces? = SPACE_PRESERVING_WHITE_SPACE.include?(white_space)
+
+        # Collapsible whitespace and nothing else: beside a block break it
+        # neither shows nor separates anything.
+        def collapsible_whitespace_only? = collapsible? && text.match?(/\A[ \t\n\r\f]*\z/)
+
+        # The text with `text-transform` applied.
+        def transformed_text
+          case text_transform
+          when "uppercase" then text.upcase
+          when "lowercase" then text.downcase
+          when "capitalize" then text.gsub(/\b\p{L}/) { |c| c.upcase }
+          else text
+          end
+        end
+      end
+
+      # An atomic inline box (an inline-block or a replaced element): its own
+      # rendered text, already collapsed and trimmed, which the surrounding
+      # block treats as a single unbreakable unit.
+      Atomic = Data.define(:text)
+
+      # A string the collection steps append as is: "\n" for a <br>, "\t"
+      # between table cells, "\n" between table rows.
+      Literal = Data.define(:text)
+
+      # A required line break count: the breaks around a block-level box (1)
+      # or a <p> (2). Adjacent counts collapse to the largest.
+      RequiredBreak = Data.define(:count)
+    end
+  end
+end

data/lib/dommy/internal/rendered_text/whitespace_collapser.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "items"
+
+module Dommy
+  module Internal
+    module RenderedText
+      # The block-wide white-space pass: turns the item list into the final
+      # string. The list is first normalized (see #normalize), then each item
+      # is appended in turn. Its three pieces of state are the whole algorithm:
+      #   * `pending_space` — a collapsible space seen but not yet emitted (it is
+      #     dropped if nothing follows on the line);
+      #   * `line_start` — suppresses that space at the start of a line;
+      #   * `after_atomic` — makes the space following an atomic inline literal,
+      #     so whitespace on either side of an inline-block does not merge.
+      class WhitespaceCollapser
+        def self.collapse(items) = new.collapse(items)
+
+        def initialize
+          @out = +""
+          @pending_space = false
+          @line_start = true
+          @after_atomic = false
+        end
+
+        def collapse(items)
+          normalize(items).each { |item| append(item) }
+          @out
+        end
+
+        private
+
+        # Drop empty runs, drop a collapsible whitespace-only run beside a
+        # required break (the whitespace around a block box neither shows nor
+        # separates the two breaks), trim the leading/trailing required breaks,
+        # and collapse each run of them to the largest count.
+        def normalize(items)
+          items = items.reject { |item| item.is_a?(TextRun) && item.empty? }
+          items = items.reject.with_index do |item, i|
+            item.is_a?(TextRun) && item.collapsible_whitespace_only? &&
+              (required_break_at?(items, i - 1) || required_break_at?(items, i + 1))
+          end
+          items.shift while items.first.is_a?(RequiredBreak)
+          items.pop while items.last.is_a?(RequiredBreak)
+
+          items.chunk_while { |a, b| a.is_a?(RequiredBreak) && b.is_a?(RequiredBreak) }.map do |chunk|
+            chunk.first.is_a?(RequiredBreak) ? RequiredBreak.new(chunk.map(&:count).max) : chunk.first
+          end
+        end
+
+        def required_break_at?(items, index)
+          index >= 0 && items[index].is_a?(RequiredBreak)
+        end
+
+        def append(item)
+          case item
+          when RequiredBreak then append_breaks(item.count)
+          when Literal then append_literal(item.text)
+          when Atomic then append_atomic(item.text)
+          when TextRun then append_run(item)
+          end
+        end
+
+        # Emit that many newlines and start a line.
+        def append_breaks(count)
+          @out << ("\n" * count)
+          @pending_space = false
+          @line_start = true
+          @after_atomic = false
+        end
+
+        def append_literal(text)
+          @out << text
+          @pending_space = false
+          @line_start = text == "\n"
+          @after_atomic = false
+        end
+
+        def append_atomic(text)
+          @out << " " if @pending_space
+          @out << text
+          @pending_space = false
+          @line_start = false
+          @after_atomic = true
+        end
+
+        def append_run(run)
+          run.transformed_text.each_char do |char|
+            case char
+            when "\n", "\r" then append_newline(run)
+            when " ", "\t", "\f" then append_space(char, run)
+            else append_char(char)
+            end
+          end
+        end
+
+        def append_newline(run)
+          if run.preserves_newlines?
+            @out << "\n"
+            @pending_space = false
+            @line_start = true
+          elsif run.collapsible?
+            @pending_space = true
+          end
+        end
+
+        def append_space(char, run)
+          if run.preserves_spaces?
+            @out << char
+            @pending_space = false
+            @line_start = false
+          elsif @after_atomic
+            @out << " "
+            @after_atomic = false
+          else
+            @pending_space = true
+          end
+        end
+
+        def append_char(char)
+          if @pending_space && !@line_start && !@out.end_with?(" ", "\n", "\t")
+            @out << " "
+          end
+          @pending_space = false
+          @after_atomic = false
+          @out << char
+          @line_start = false
+        end
+      end
+    end
+  end
+end

data/lib/dommy/internal/selector_arguments.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # What every query method does with its selector argument before anything
+    # matches: coerce it per WebIDL, validate it against the grammar, and map
+    # the errors a backend raises onto the DOM ones.
+    #
+    # Matching itself is SelectorMatcher's, and the state pseudo-classes it
+    # cannot answer from the tree alone (`:checked`, `:target`) are here because
+    # they read live DOM state rather than the selector.
+
+    # The complete set of CSS pseudo-classes (+ the four legacy single-colon
+    # pseudo-elements). A `:identifier` outside this set is an unknown selector
+    # token → SyntaxError, whereas a known-but-unimplemented one (`:hover`) is a
+    # valid selector that simply matches nothing.
+    KNOWN_PSEUDOS = %w[
+      active any-link autofill blank checked current default defined disabled empty
+      enabled first first-child first-of-type focus focus-visible focus-within
+      fullscreen future has host hover in-range indeterminate invalid is lang
+      last-child last-of-type left link local-link modal not nth-child nth-col
+      nth-last-child nth-last-col nth-last-of-type nth-of-type only-child
+      only-of-type optional out-of-range past placeholder-shown playing paused
+      read-only read-write required right root scope target target-within
+      user-invalid user-valid valid visited where dir
+      before after first-line first-letter
+    ].to_set.freeze
+
+    # Validate a non-null CSS selector for `querySelector`/`matches`/`closest`,
+    # raising SyntaxError for syntactically invalid selectors. Delegates to the
+    # full grammar parser (SelectorParser), which catches the whole Selectors
+    # grammar — `[*=v]`, `..x`, `div % p`, unknown pseudo-elements, undeclared
+    # namespaces — not just the obvious cases.
+    def self.validate_selector!(selector)
+      SelectorParser.validate!(selector.to_s)
+    end
+
+    # Coerce the JS argument of a query method (querySelector/All) per WebIDL: the
+    # selector is a *non-nullable* DOMString, so JS `null` → "null" and
+    # `undefined` → "undefined" (which then match `<null>` / `<undefined>` typed
+    # elements rather than returning nothing), while a missing argument is a
+    # TypeError. Used at every JS dispatch site so the behaviour is uniform.
+    def self.css_query_arg!(args)
+      raise ::Dommy::Bridge::TypeError, "1 argument required, but only 0 present" if args.empty?
+
+      value = args[0]
+      return "null" if value.nil?
+      return "undefined" if defined?(::Dommy::Bridge::UNDEFINED) && value.equal?(::Dommy::Bridge::UNDEFINED)
+
+      value
+    end
+
+    # Map a backend's selector complaints onto the DOM's:
+    # - an "Unregistered function" means a valid pseudo the backend compiled
+    #   but can't evaluate (`:active`, `:invalid`, …) → degrade to no match
+    #   (returns []),
+    # - a backend syntax complaint becomes a DOMException::SyntaxError,
+    # - anything else propagates.
+    def self.with_selector_errors(selector)
+      yield
+    rescue ::StandardError => e
+      return [] if e.message.include?("Unregistered function")
+      raise DOMException::SyntaxError, "'#{selector}' is not a valid selector." if e.message.include?("unexpected")
+
+      raise
+    end
+
+    # `:checked`'s checkedness/selectedness is live state, not the attribute:
+    # checkbox/radio inputs match on the checked property (which defaults to
+    # the attribute), <option> on selectedness.
+    def self.checked_state?(element)
+      return false unless element
+
+      case element.tag_name
+      when "INPUT"
+        %w[checkbox radio].include?(element.respond_to?(:type) ? element.type.to_s : "") &&
+          element.respond_to?(:checked) && !!element.checked
+      when "OPTION"
+        element.respond_to?(:selected) && !!element.selected
+      else
+        false
+      end
+    end
+
+    # The id referenced by the document's URL fragment (`:target`), or nil when
+    # there is no fragment.
+    def self.target_id(document)
+      view = document.respond_to?(:default_view) ? document.default_view : nil
+      loc = view.respond_to?(:location) ? view.location : nil if view
+      hash = loc&.__js_get__("hash").to_s
+      hash.start_with?("#") && hash.length > 1 ? hash[1..] : nil
+    end
+  end
+end

data/lib/dommy/internal/selector_index.rb

@@ -141,7 +141,9 @@ module Dommy
       end
 
       def record(bnode, enter)
-        name = bnode.name
+        # By local name, as a type selector compares: a prefixed element parsed
+        # from XML (`cp:coreProperties`) is found by `coreProperties`.
+        name = bnode.local_name
         (@by_tag[name.downcase] ||= []) << [enter, bnode] if name && !name.empty?
 
         id = bnode["id"]