p_css 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20afa2206ed855fdd796f19179d06a8dc8b76231c223560d59e664cb43ddf897
-  data.tar.gz: e951f89d04ff6db6f68151ad05a414e4f0f7d05f2dfc48580b22ef31b6f949de
+  metadata.gz: 965047de25f5fe1719b2d2b4c59d2fa2d74550249e2ffa23d4175ae88dc09ba9
+  data.tar.gz: ab8078d7209427b3f23cd774492fae69543bd8910b812a1a87fc7da38b8df89c
 SHA512:
-  metadata.gz: dc533dd2a146654d7a622b3206568168bea1e404b163ef6b24ae1c841ef4cd5ff3a4621bc6794f64178ffd5c87a0c4e6a46f70fd6c7999a52539091849ae2941
-  data.tar.gz: 67d08837559466bc5713aa6a40d8e67030ff9389228527b4ed8b4bb5e1121965fa90a31e6cf5aae40167151e535ae83b9f6073068e72d495a5098559b331698d
+  metadata.gz: '069d1c89de282155ee708b19aee7cc61226a68bd7ad662a869536b823bb99d58c6b8b1dae2567fa9f27d337fda392ea52f62592a718580aead69e1ded17cbf47'
+  data.tar.gz: 2d0ec3fd003f145859790f3140ec808e5ba1d1273dc2e78e379d7ef5eec3dd44c9c031cd8e5db22f5b1b63b27d52f9973cc18f19b0f184ebd6a882d73b24ac36

data/lib/css/cascade.rb

@@ -31,7 +31,11 @@ module CSS
     end
 
     # Returns Hash<String, Declaration> of winning declarations.
-    def resolve(element, inline_style: nil)
+    #
+    # `state:` opts into stateful-pseudo matching — see
+    # `Selectors::Matcher#matches?` for the shape. Defaults to the
+    # stateless behavior (`:hover`, `:focus`, etc. never match).
+    def resolve(element, inline_style: nil, state: nil)
       cache       = {}
       candidates  = collect_candidate_indexes(element, cache)
       order       = 0
@@ -39,7 +43,7 @@ module CSS
 
       candidates.each do |idx|
         entry = @entries[idx]
-        spec  = best_matching_specificity(element, entry.selector_pairs, cache)
+        spec  = best_matching_specificity(element, entry.selector_pairs, cache, state)
 
         next if spec.nil?
 
@@ -204,11 +208,11 @@ module CSS
       out
     end
 
-    def best_matching_specificity(element, selector_pairs, cache)
+    def best_matching_specificity(element, selector_pairs, cache, state)
       best = nil
 
       selector_pairs.each do |sel, spec|
-        next unless Selectors::Matcher.matches?(element, sel, cache: cache)
+        next unless Selectors::Matcher.matches?(element, sel, cache: cache, state: state)
 
         best = spec if best.nil? || spec > best
       end

data/lib/css/selectors/matcher.rb

@@ -16,8 +16,9 @@ module CSS
     # protocol out of the box.
     #
     # Pseudo-classes that depend on user-agent state (`:hover`, `:focus`,
-    # `:visited`, validity-API states, `:fullscreen`, etc.) always return
-    # false; this matcher is intended for stateless analysis.
+    # `:visited`, etc.) return false by default; pass an explicit `state:`
+    # mapping to opt into stateful matching. Validity-API and viewport-
+    # only states (`:fullscreen`, `:valid`, …) are not exposed.
     module Matcher
       extend self
 
@@ -26,6 +27,16 @@ module CSS
       LINK_TAGS        = %w[a area link].freeze
       RO_INPUT_TYPES   = %w[hidden range color checkbox radio file submit image reset button].freeze
 
+      # User-agent state pseudos. The matcher returns `false` for these
+      # unless the caller passes a `state:` Hash describing which
+      # elements (or "all") should match.
+      STATEFUL_PSEUDOS = %w[hover focus focus-within focus-visible active visited target].to_set.freeze
+
+      # Per spec these states propagate up the ancestor chain — if a
+      # descendant is hovered/active/contains-focus, the ancestors
+      # share the state for selector-matching purposes.
+      PROPAGATING_STATEFUL_PSEUDOS = %w[hover active focus-within].to_set.freeze
+
       # Per-element cache used to avoid recomputing tag / id / class set
       # for every selector in a hot loop (e.g. `Cascade#resolve` against
       # hundreds of rules). Keyed by `Object#object_id`; only valid for
@@ -34,16 +45,16 @@ module CSS
 
       EMPTY_CLASS_SET = Set.new.freeze
 
-      def matches?(element, selector, cache: nil)
+      def matches?(element, selector, cache: nil, state: nil)
         sel = selector.is_a?(String) ? Parser.parse_selector_list(selector) : selector
 
         case sel
         when SelectorList
-          sel.selectors.any? { match_complex(element, it, cache) }
+          sel.selectors.any? { match_complex(element, it, cache, state) }
         when ComplexSelector
-          match_complex(element, sel, cache)
+          match_complex(element, sel, cache, state)
         when CompoundSelector
-          match_compound(element, sel, cache)
+          match_compound(element, sel, cache, state)
         else
           raise ArgumentError, "expected a selector node or string, got #{sel.class}"
         end
@@ -54,32 +65,32 @@ module CSS
       # Walks the complex selector right-to-left starting at the rightmost
       # compound. Each combinator either succeeds against ancestors /
       # siblings of the current candidate or fails the whole match.
-      def match_complex(element, complex, cache)
-        match_at(element, complex, complex.compounds.size - 1, cache)
+      def match_complex(element, complex, cache, state)
+        match_at(element, complex, complex.compounds.size - 1, cache, state)
       end
 
-      def match_at(element, complex, index, cache)
+      def match_at(element, complex, index, cache, state)
         return false if element.nil?
-        return false unless match_compound(element, complex.compounds[index], cache)
+        return false unless match_compound(element, complex.compounds[index], cache, state)
         return true  if index.zero?
 
         prev = index - 1
 
         case complex.combinators[prev]
-        when :descendant         then walk_until_match(element, complex, prev, :parent_element, cache)
-        when :child              then match_at(parent_element(element), complex, prev, cache)
-        when :next_sibling       then match_at(previous_element(element), complex, prev, cache)
-        when :subsequent_sibling then walk_until_match(element, complex, prev, :previous_element, cache)
+        when :descendant         then walk_until_match(element, complex, prev, :parent_element,   cache, state)
+        when :child              then match_at(parent_element(element), complex, prev, cache, state)
+        when :next_sibling       then match_at(previous_element(element), complex, prev, cache, state)
+        when :subsequent_sibling then walk_until_match(element, complex, prev, :previous_element, cache, state)
         end
       end
 
       # Steps along the DOM via `direction` until a candidate matches the
       # remaining complex selector or the chain runs out.
-      def walk_until_match(element, complex, index, direction, cache)
+      def walk_until_match(element, complex, index, direction, cache, state)
         candidate = send(direction, element)
 
         while candidate
-          return true if match_at(candidate, complex, index, cache)
+          return true if match_at(candidate, complex, index, cache, state)
 
           candidate = send(direction, candidate)
         end
@@ -87,18 +98,18 @@ module CSS
         false
       end
 
-      def match_compound(element, compound, cache)
-        compound.components.all? { match_simple(element, it, cache) }
+      def match_compound(element, compound, cache, state)
+        compound.components.all? { match_simple(element, it, cache, state) }
       end
 
-      def match_simple(element, simple, cache)
+      def match_simple(element, simple, cache, state)
         case simple
         when TypeSelector      then tag_of(element, cache).casecmp?(simple.name)
         when UniversalSelector then true
         when IdSelector        then id_of(element, cache) == simple.name
         when ClassSelector     then classes_of(element, cache).include?(simple.name)
         when AttributeSelector then match_attribute(element, simple)
-        when PseudoClass       then match_pseudo_class(element, simple, cache)
+        when PseudoClass       then match_pseudo_class(element, simple, cache, state)
         when PseudoElement     then false
         when NestingSelector   then false
         else                        false
@@ -172,10 +183,14 @@ module CSS
 
       # Pseudo-class matching -------------------------------------------
 
-      def match_pseudo_class(element, pc, cache)
-        case pc.name.downcase
-        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument, cache)
-        when 'not'                       then negate_selector_list_arg(element, pc.argument, cache)
+      def match_pseudo_class(element, pc, cache, state)
+        name = pc.name.downcase
+
+        return match_stateful_pseudo?(name, element, state) if STATEFUL_PSEUDOS.include?(name)
+
+        case name
+        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument, cache, state)
+        when 'not'                       then negate_selector_list_arg(element, pc.argument, cache, state)
         when 'has'                       then false
         when 'root'                      then parent_element(element).nil?
         when 'scope'                     then parent_element(element).nil?
@@ -206,12 +221,40 @@ module CSS
         end
       end
 
-      def match_selector_list_arg(element, arg, cache)
-        arg.is_a?(SelectorList) && matches?(element, arg, cache: cache)
+      # `:hover` / `:active` / `:focus-within` propagate up the ancestor
+      # chain per Selectors §10 — the Set members are the *source* nodes
+      # (e.g. the deepest hovered element) and any of their ancestors
+      # also matches. Other stateful pseudos match only the explicit
+      # elements in the Set.
+      def match_stateful_pseudo?(name, element, state)
+        return false if state.nil?
+
+        value = state[name.to_sym] || state[name]
+
+        return false   if value.nil? || value == false
+        return true    if value == true
+
+        return value.include?(element) unless PROPAGATING_STATEFUL_PSEUDOS.include?(name)
+
+        value.each do |source|
+          cur = source
+
+          while cur
+            return true if cur == element
+
+            cur = parent_element(cur)
+          end
+        end
+
+        false
+      end
+
+      def match_selector_list_arg(element, arg, cache, state)
+        arg.is_a?(SelectorList) && matches?(element, arg, cache: cache, state: state)
       end
 
-      def negate_selector_list_arg(element, arg, cache)
-        arg.is_a?(SelectorList) && !matches?(element, arg, cache: cache)
+      def negate_selector_list_arg(element, arg, cache, state)
+        arg.is_a?(SelectorList) && !matches?(element, arg, cache: cache, state: state)
       end
 
       def match_nth(element, anb, of_type:, from_end:)

data/lib/css/version.rb

@@ -1,3 +1,3 @@
 module CSS
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

data/lib/css.rb

@@ -50,7 +50,7 @@ module CSS
 
     def specificity(selector) = Selectors::SpecificityCalculator.calculate(selector)
 
-    def matches?(element, selector) = Selectors::Matcher.matches?(element, selector)
+    def matches?(element, selector, state: nil) = Selectors::Matcher.matches?(element, selector, state: state)
 
     def parse_media_query_list(input) = MediaQueries::Parser.parse(input)
 

data/sig/css/cascade.rbs

@@ -17,6 +17,6 @@ module CSS
     # Returns Hash<String, Declaration> of winning declarations after
     # !important > inline > stylesheet > specificity > source-order
     # sorting.
-    def resolve: (untyped element, ?inline_style: inline_style?) -> Hash[String, Nodes::Declaration]
+    def resolve: (untyped element, ?inline_style: inline_style?, ?state: matcher_state?) -> Hash[String, Nodes::Declaration]
   end
 end

data/sig/css/selectors.rbs

@@ -151,7 +151,10 @@ module CSS
     end
 
     module Matcher
-      def self.matches?: (untyped element, untyped selector, ?cache: Hash[Integer, untyped]) -> bool
+      STATEFUL_PSEUDOS: Set[String]
+      PROPAGATING_STATEFUL_PSEUDOS: Set[String]
+
+      def self.matches?: (untyped element, untyped selector, ?cache: Hash[Integer, untyped], ?state: matcher_state?) -> bool
 
       def self.tag_of: (untyped element, ?Hash[Integer, untyped]?) -> String
       def self.id_of: (untyped element, ?Hash[Integer, untyped]?) -> String?

data/sig/css.rbs

@@ -68,7 +68,12 @@ module CSS
 
   type selector = Selectors::SelectorList | Selectors::ComplexSelector | Selectors::CompoundSelector
 
-  def self.matches?: (untyped element, String | selector selector, ?cache: Hash[Integer, untyped]) -> bool
+  # Per-pseudo state. Keys are pseudo-class names (Symbol or String);
+  # values are `true` (match every element), a `Set` / `Array` of the
+  # specific elements in that state, or falsy (no match).
+  type matcher_state = Hash[Symbol | String, bool | Set[untyped] | Array[untyped]]
+
+  def self.matches?: (untyped element, String | selector selector, ?cache: Hash[Integer, untyped], ?state: matcher_state?) -> bool
 
   # Media queries (Media Queries 4)
   # ---------------------------------------------------------------

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p_css
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Keita Urashima