dommy 0.15.0 → 0.17.0

data/lib/dommy/internal/css_source.rb

@@ -36,8 +36,6 @@ module Dommy
       # Where a call of the function #next_function is asked for may start, or
       # an atom: one pattern per function name, built on its first use.
       FUNCTION_STOP = Hash.new { |stops, name| stops[name] = Regexp.union(ATOM_START, /#{Regexp.escape(name[0])}/i) }
-      # The bracket that closes a block each opening one starts.
-      CLOSER = {"(" => ")", "[" => "]", "{" => "}"}.freeze
 
       # `bytes:` is a binary String this CssSource may keep as its copy, in
       # place of `text` — a reader handing on what it has already made.
@@ -195,7 +193,7 @@ module Dommy
       # closing bracket closes the innermost only when it is that block's own
       # kind (:closed); any other closing bracket is a token like any other.
       def step_block(blocks, c)
-        if (closer = CLOSER[c])
+        if (closer = CssSyntax::CLOSER[c])
           blocks.push(closer)
           :opened
         elsif !blocks.empty? && blocks.last == c

data/lib/dommy/internal/css_syntax.rb

@@ -19,6 +19,8 @@ module Dommy
     module CssSyntax
       OPENING_BRACKETS = "([{"
       CLOSING_BRACKETS = ")]}"
+      # The mirror each opening bracket's block (or function) closes at.
+      CLOSER = {"(" => ")", "[" => "]", "{" => "}"}.freeze
       # css-syntax-3's whitespace (§4.2) — before §3.3's preprocessing folds CR
       # and FF into LF, the same set as Infra's ASCII whitespace.
       WHITESPACE = Infra::ASCII_WHITESPACE_CHARS
@@ -35,119 +37,182 @@ module Dommy
       STRING_STOP = {'"' => /["\\\n]/, "'" => /['\\\n]/}.freeze
       # What can end an unquoted url, or must be stepped over in one.
       URL_STOP = /[)\\]/
+      # What makes an unquoted url bad (§4.3.6), whitespace and escapes aside:
+      # a quote, a `(`, or a non-printable code point (§4.2).
+      BAD_URL_CODE_POINT = /["'(\u0000-\u0008\u000B\u000E-\u001F\u007F]/
       # css-syntax-3 §3.3: the newline forms and NULL the tokenizer never sees.
       NEEDS_FILTERING = /[\r\f\u0000]/
 
-      module_function
+      class << self
+        # css-syntax-3 §3.3 "filter code points", the pass that runs before the
+        # tokenizer sees anything: the three newline forms become U+000A, and
+        # U+0000 becomes U+FFFD. Without it, a backslash before a CRLF escapes
+        # the CR and leaves the LF to end the string, as no browser reads it.
+        # The replacement character is itself an ident code point, so `.a<NUL>b`
+        # names the class `a<U+FFFD>b` rather than being a syntax error.
+        def preprocess(text)
+          return text unless text.match?(NEEDS_FILTERING)
+
+          text.gsub(/\r\n|[\r\f]/, "\n").gsub("\u0000", "\uFFFD")
+        end
 
-      # css-syntax-3 §3.3 "filter code points", the pass that runs before the
-      # tokenizer sees anything: the three newline forms become U+000A, and
-      # U+0000 becomes U+FFFD. Without it, a backslash before a CRLF escapes
-      # the CR and leaves the LF to end the string, as no browser reads it.
-      # The replacement character is itself an ident code point, so `.a<NUL>b`
-      # names the class `a<U+FFFD>b` rather than being a syntax error.
-      def preprocess(text)
-        return text unless text.match?(NEEDS_FILTERING)
+        # §4.3.8: a backslash at `j` starts a valid escape unless a newline
+        # follows it. Every other pair counts, the end of the input included.
+        def valid_escape_at?(source, j)
+          source[j] == "\\" && source[j + 1] != "\n"
+        end
 
-        text.gsub(/\r\n|[\r\f]/, "\n").gsub("\u0000", "\uFFFD")
-      end
+        # §4.2 ident-start code point: a letter, an underscore, or a non-ASCII
+        # ident code point. nil (past the end) is none.
+        def ident_start_code_point?(c)
+          return false if c.nil?
 
-      # §4.3.8: a backslash at `j` starts a valid escape unless a newline
-      # follows it. Every other pair counts, the end of the input included.
-      def valid_escape_at?(source, j)
-        source[j] == "\\" && source[j + 1] != "\n"
-      end
+          c.match?(/[A-Za-z_]/) || non_ascii_ident_code_point?(c)
+        end
 
-      # §4.2 ident-start code point: a letter, an underscore, or a non-ASCII
-      # ident code point. nil (past the end) is none.
-      def ident_start_code_point?(c)
-        return false if c.nil?
+        # §4.2 ident code point: an ident-start one, a digit, or U+002D.
+        def name_code_point?(c)
+          return false if c.nil?
 
-        c.match?(/[A-Za-z_]/) || non_ascii_ident_code_point?(c)
-      end
+          c.match?(/[A-Za-z0-9_\-]/) || non_ascii_ident_code_point?(c)
+        end
 
-      # §4.2 ident code point: an ident-start one, a digit, or U+002D.
-      def name_code_point?(c)
-        return false if c.nil?
+        # Index just past the escape, string, unquoted url or comment starting
+        # at `j`, or nil if none starts there. A string ends at its closing
+        # quote, or before a newline or the end of the input; a url at its `)`
+        # or the end of the input; a comment at its `*/` or the end of the input.
+        def atom_end(source, j)
+          c = source[j]
+          if (c == "u" || c == "U") && (k = url_contents_start(source, j))
+            url_end(source, k)
+          elsif c == "\\"
+            return nil unless valid_escape_at?(source, j)
+
+            [j + 2, source.length].min
+          elsif c == '"' || c == "'"
+            string_end(source, j + 1, c)
+          elsif c == "/" && source[j + 1] == "*"
+            close = source.index("*/", j + 2)
+            close ? close + 2 : source.length
+          end
+        end
 
-        c.match?(/[A-Za-z0-9_\-]/) || non_ascii_ident_code_point?(c)
-      end
+        # Whether the string or unquoted url starting at `j` is a bad one: a
+        # <bad-string-token>, which a newline ends unclosed (§4.3.5), or a
+        # <bad-url-token> (§4.3.6). No grammar takes either, not even
+        # <any-value>.
+        def bad_token_at?(source, j)
+          c = source[j]
+          if (c == "u" || c == "U") && (k = url_contents_start(source, j))
+            bad_url?(source, k)
+          elsif c == '"' || c == "'"
+            k = string_stop(source, j + 1, c)
+            !k.nil? && source[k] == "\n"
+          else
+            false
+          end
+        end
 
-      # A single byte of a binary String at or above 0x80 is part of a
-      # non-ASCII character that a byte-level reader cannot see whole; it is
-      # taken for a name code point, which only decides whether a `url(` or
-      # `var(` after it is the tail of a longer name.
-      def non_ascii_ident_code_point?(c)
-        codepoint = c.ord
-        return false if codepoint < 0x80
-        return true if c.bytesize == 1 || codepoint >= 0x10000
+        private
 
-        NON_ASCII_IDENT_RANGES.any? { |range| range.cover?(codepoint) }
-      end
+        # A single byte of a binary String at or above 0x80 is part of a
+        # non-ASCII character that a byte-level reader cannot see whole; it is
+        # taken for a name code point, which only decides whether a `url(` or
+        # `var(` after it is the tail of a longer name.
+        def non_ascii_ident_code_point?(c)
+          codepoint = c.ord
+          return false if codepoint < 0x80
+          return true if c.bytesize == 1 || codepoint >= 0x10000
 
-      # Index just past the escape, string, unquoted url or comment starting
-      # at `j`, or nil if none starts there. A string ends at its closing
-      # quote, or before a newline or the end of the input; a url at its `)`
-      # or the end of the input; a comment at its `*/` or the end of the input.
-      def atom_end(source, j)
-        c = source[j]
-        if (c == "u" || c == "U") && (k = url_contents_start(source, j))
-          url_end(source, k)
-        elsif c == "\\"
-          return nil unless valid_escape_at?(source, j)
-
-          [j + 2, source.length].min
-        elsif c == '"' || c == "'"
-          string_end(source, j + 1, c)
-        elsif c == "/" && source[j + 1] == "*"
-          close = source.index("*/", j + 2)
-          close ? close + 2 : source.length
+          NON_ASCII_IDENT_RANGES.any? { |range| range.cover?(codepoint) }
         end
-      end
 
-      # Index just past the `quote` closing a string whose contents start at
-      # `k`, or of the newline that ends it unclosed, or the end of the input.
-      # A backslash takes the code point after it (§4.3.5).
-      def string_end(source, k, quote)
-        stop = STRING_STOP[quote]
-        while (k = source.index(stop, k))
-          d = source[k]
-          return k + 1 if d == quote
-          return k if d == "\n"
-
-          k += 2
+        # Index just past the `quote` closing a string whose contents start at
+        # `k`, or of the newline that ends it unclosed, or the end of the input.
+        # A backslash takes the code point after it (§4.3.5).
+        def string_end(source, k, quote)
+          k = string_stop(source, k, quote)
+          return source.length if k.nil?
+
+          source[k] == quote ? k + 1 : k
         end
-        source.length
-      end
 
-      # Where an unquoted url token's contents start, if the ident `url`
-      # (ASCII case-insensitive, not the tail of a longer name) followed by
-      # `(` starts at `j` — after the whitespace the url skips. A quote there
-      # makes it a `url(` function holding a string instead (§4.3.4).
-      def url_contents_start(source, j)
-        return nil unless source[j, 4]&.casecmp?("url(")
-        return nil if j.positive? && name_code_point?(source[j - 1])
-
-        k = j + 4
-        k += 1 while k < source.length && WHITESPACE.include?(source[k])
-        q = source[k]
-        q == '"' || q == "'" ? nil : k
-      end
+        # Index of the `quote` closing a string whose contents start at `k`, or
+        # of the newline that ends it unclosed; nil if the input ends first.
+        def string_stop(source, k, quote)
+          stop = STRING_STOP[quote]
+          while (k = source.index(stop, k))
+            return k unless source[k] == "\\"
 
-      # Index just past the `)` closing an unquoted url whose contents start
-      # at `k`, or the end of the input. An escape is stepped over; whatever
-      # else would make the url bad (§4.3.6's consume the remnants of a bad
-      # url) still ends at the same `)`.
-      def url_end(source, k)
-        while (k = source.index(URL_STOP, k))
-          return k + 1 if source[k] == ")"
+            k += 2
+          end
+          nil
+        end
 
-          k += valid_escape_at?(source, k) ? 2 : 1
+        # Where an unquoted url token's contents start, if the ident `url`
+        # (ASCII case-insensitive, not the tail of a longer name) followed by
+        # `(` starts at `j` — after the whitespace the url skips. A quote there
+        # makes it a `url(` function holding a string instead (§4.3.4).
+        def url_contents_start(source, j)
+          return nil unless source[j, 4]&.casecmp?("url(")
+          return nil if j.positive? && name_code_point?(source[j - 1])
+
+          k = j + 4
+          k += 1 while k < source.length && WHITESPACE.include?(source[k])
+          q = source[k]
+          q == '"' || q == "'" ? nil : k
+        end
+
+        # Index just past the `)` closing an unquoted url whose contents start
+        # at `k`, or the end of the input. An escape is stepped over; whatever
+        # else would make the url bad (§4.3.6's consume the remnants of a bad
+        # url) still ends at the same `)`.
+        def url_end(source, k)
+          while (k = source.index(URL_STOP, k))
+            return k + 1 if source[k] == ")"
+
+            k += valid_escape_at?(source, k) ? 2 : 1
+          end
+          source.length
+        end
+
+        # Whether the unquoted url whose contents start at `k` is bad (§4.3.6):
+        # whitespace before anything but its `)` or the end of the input, a
+        # BAD_URL_CODE_POINT, or a backslash that starts no valid escape.
+        def bad_url?(source, k)
+          while k < source.length
+            c = source[k]
+            return false if c == ")"
+
+            if WHITESPACE.include?(c)
+              k += 1 while k < source.length && WHITESPACE.include?(source[k])
+              return k < source.length && source[k] != ")"
+            end
+            return true if c.match?(BAD_URL_CODE_POINT)
+
+            if c == "\\"
+              return true unless valid_escape_at?(source, k)
+
+              k = escape_end(source, k)
+            else
+              k += 1
+            end
+          end
+          false
         end
-        source.length
-      end
 
-      private_class_method :non_ascii_ident_code_point?, :string_end, :url_contents_start, :url_end
+        # Index just past the valid escape whose backslash is at `j` (§4.3.7):
+        # up to six hex digits and one whitespace after them, or else the one
+        # code point after the backslash.
+        def escape_end(source, j)
+          hex = source[j + 1, 6].to_s[/\A\h+/]
+          return [j + 2, source.length].min if hex.nil?
+
+          k = j + 1 + hex.length
+          k += 1 if k < source.length && WHITESPACE.include?(source[k])
+          k
+        end
+      end
     end
   end
 end

data/lib/dommy/internal/declarative_shadow_roots.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Declarative shadow roots, as a pass over what the parser built.
+    #
+    # The backend's HTML parser has no declarative shadow DOM: it parses a
+    # `<template shadowrootmode>` as an ordinary template, with its children
+    # in the template contents. HTML's tree builder, when its "allow
+    # declarative shadow roots" is on, does instead — at the template start
+    # tag ("in head" insertion mode) — attach a shadow root to the adjusted
+    # current node and parse the template's children into it, never
+    # inserting the template. This pass reproduces that result: it walks the
+    # parsed nodes in tree order, which is the order the parser met the start
+    # tags, and for each such template
+    #
+    #   - takes its parent as the declarative shadow host (the adjusted
+    #     current node the template was inserted under). A template whose
+    #     parent is not an element — the top of template contents (the
+    #     adjusted current node was the enclosing template), or of a fragment
+    #     parse (see below) — is left alone;
+    #   - leaves the template in place when the host is already a shadow host
+    #     (the first declarative template wins), or when attaching a shadow
+    #     root throws (not a valid shadow host, a definition that disables
+    #     shadow);
+    #   - otherwise attaches one with the template's shadowrootmode,
+    #     shadowrootdelegatesfocus, shadowrootserializable,
+    #     shadowrootslotassignment and shadowrootclonable, and a null registry
+    #     with shadowrootcustomelementregistry (else the host's document's);
+    #     sets it declarative and available to element internals (and keep
+    #     custom element registry null with that attribute), moves the template
+    #     contents into it and drops the template.
+    #
+    # Template contents, and the shadow trees the pass makes, are walked too:
+    # the parser attaches declarative shadow roots wherever it meets one.
+    #
+    # The fragment case: HTML's fragment parsing algorithm puts only its own
+    # `html` root on the stack of open elements, so for a top-level template
+    # the adjusted current node is the context element, and the spec text
+    # would attach a shadow root to it. Browsers (and the WPT expectations)
+    # leave such a template in place, and so does this pass, unless the
+    # caller names a `top_host` — document.write, whose parser is the
+    # document's own, where the template's adjusted current node really is
+    # the element the markup goes into.
+    #
+    # Moving the contents is a representation fix-up, not a DOM mutation: in
+    # the parser's tree they were never anywhere else. So it uses raw backend
+    # moves, and queues no mutation records. What the parser does at the
+    # time — a script's access mid-parse, the moment a MutationObserver sees
+    # the host — cannot be reproduced by a pass that runs once parsing ends.
+    #
+    # Spec: https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inhead
+    class DeclarativeShadowRoots
+      MODES = %w[open closed].freeze
+
+      # Run the pass over `root_bn`'s subtree (an element, a fragment, a
+      # document). Returns the shadow roots it attached, in tree order.
+      def self.attach(document, root_bn, top_host: nil)
+        new(document).run(root_bn, top_host)
+      end
+
+      def initialize(document)
+        @document = document
+        @templates = document.__internal_template_registry__
+        @attached = []
+      end
+
+      def run(root_bn, top_host)
+        walk(root_bn, top_host) if candidate?(root_bn)
+        @attached
+      end
+
+      private
+
+      # Whether a `<template shadowrootmode>` is anywhere in the subtree,
+      # template contents included — found by native queries, so a page with
+      # none (most) is not walked.
+      def candidate?(root_bn)
+        return false unless root_bn.respond_to?(:css)
+        return true if root_bn.element? && declarative_mode(root_bn)
+        return true unless root_bn.css("template[shadowrootmode]").empty?
+
+        templates = root_bn.css("template").to_a
+        templates.unshift(root_bn) if root_bn.element? && @templates.template_node?(root_bn)
+        templates.any? do |template|
+          contents = @templates.existing_contents(template)
+          contents && candidate?(contents)
+        end
+      end
+
+      def walk(parent, host_for_children = nil)
+        host_for_children ||= parent if parent.element?
+        parent.children.to_a.each do |child|
+          next unless child.element?
+
+          if host_for_children && (mode = declarative_mode(child))
+            shadow = attach(host_for_children, child, mode)
+            if shadow
+              walk(shadow.__dommy_backend_node__)
+              next
+            end
+          end
+          walk(child)
+          next unless @templates.template_node?(child)
+
+          contents = @templates.existing_contents(child)
+          walk(contents) if contents
+        end
+      end
+
+      # The template's shadowrootmode state, when it is open or closed.
+      def declarative_mode(node)
+        return nil unless @templates.template_node?(node)
+
+        value = Backend.no_namespace_attribute_value(node, "shadowrootmode")
+        return nil unless value
+
+        mode = value.downcase(:ascii)
+        mode if MODES.include?(mode)
+      end
+
+      def attach(host_bn, template, mode)
+        host = @document.wrap_node(host_bn)
+        return nil unless host.respond_to?(:__internal_attach_shadow_root__)
+        return nil if host.__internal_shadow_root__
+
+        keep_null = attribute?(template, "shadowrootcustomelementregistry")
+        slot = Backend.no_namespace_attribute_value(template, "shadowrootslotassignment")
+        begin
+          shadow = host.__internal_attach_shadow_root__(
+            mode: mode,
+            delegates_focus: attribute?(template, "shadowrootdelegatesfocus"),
+            serializable: attribute?(template, "shadowrootserializable"),
+            slot_assignment: slot&.downcase(:ascii) == "manual" ? "manual" : "named",
+            clonable: attribute?(template, "shadowrootclonable"),
+            registry: keep_null ? nil : :document
+          )
+        rescue DOMException
+          return nil
+        end
+        return nil unless shadow
+
+        shadow.__internal_available_to_internals__ = true
+        shadow.__internal_declarative__ = true
+        shadow.__internal_keep_registry_null__ = keep_null
+        shadow.__internal_parsed_before__ = template.next_sibling
+        # Where the merge below leaves the text that followed the template.
+        shadow.__internal_parsed_before__ = template.previous_sibling if text?(template.previous_sibling) && text?(template.next_sibling)
+        move_contents(template, shadow.__dommy_backend_node__)
+        shadow.__internal_first_slots__ = SlotAssignment.first_slots_by_name(shadow)
+        drop_template(template)
+        @attached << shadow
+        shadow
+      end
+
+      # The template was never in the tree, so the parser appended the text
+      # on either side of it to one Text node.
+      def drop_template(template)
+        before = template.previous_sibling
+        after = template.next_sibling
+        template.unlink
+        return unless text?(before) && text?(after)
+
+        before.content = before.content + after.content
+        after.unlink
+      end
+
+      def text?(node) = node.is_a?(Backend.text_class) && !node.is_a?(Backend.cdata_class)
+
+      def attribute?(node, name) = !Backend.no_namespace_attribute_value(node, name).nil?
+
+      def move_contents(template, fragment)
+        contents = @templates.existing_contents(template)
+        return unless contents
+
+        contents.children.to_a.each do |child|
+          child.unlink
+          fragment.add_child(child)
+        end
+      end
+    end
+  end
+end