p_css 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc053cb635310340632520bdf6ef0771e1003b5d2f8582434078667cc9aeb7b4
-  data.tar.gz: b5e3c26f959dfb92e86126aab069b293796e762fb5388baef6be7c98b7b7499e
+  metadata.gz: 9e5c2f5073fa34e7847e6ce57005acbd33a912c544b6ea6971f8c50fc6f9f416
+  data.tar.gz: 4b6de8fb7d7919fafdc4e4ba249024d022c628675c0ecc66d65cba85f6132b51
 SHA512:
-  metadata.gz: 6803cd828b9d6b2ffeaf7c3c82e75345e7b1165dff0e93e4390ebf9eb4ea7a74bcd45453582562f44bcdb45cc614389c41e60bfc94ba2865421c1cc2ea9399b6
-  data.tar.gz: e6acedb22e9a43e81014dfff4d65378d88eda70f515936fd9f0962778e2c3aa4786cf608c8713fc0d3985e10dfb6919d77fcfe61cdd85b1263603b290fcbadb2
+  metadata.gz: ee478932c614e644236fe532663bf781c72397795db988ea34c92ff02a7659da0e076a2f547397f94b6500168b4fafa9071b728d0dd38b05075dfcf5589201fa
+  data.tar.gz: 9b87600e33a0500fd61c0b919e4709795a0cea47755eded8f343adb5341ee4c47a49b5197429cd443102adc88b0ebbcfdb2ee26a7e2a3133387c3650daae44fe

data/lib/css/cascade.rb

@@ -8,9 +8,11 @@ module CSS
   #   - cascade sort: `!important` > origin / inline > specificity > source order
   #
   # The Stylesheet is compiled once on construction (selectors are
-  # pre-parsed, specificities pre-computed, and `@media` chains are
-  # evaluated against the supplied context up-front so non-matching rules
-  # are dropped). `resolve(element)` is then cheap to call per node.
+  # pre-parsed, specificities pre-computed, `@media` chains are
+  # evaluated against the supplied context up-front, and rules are
+  # indexed by the rightmost compound's strongest anchor — id > class >
+  # tag > universal). `resolve(element)` then visits only the rules whose
+  # anchor could match the element.
   #
   # Cascade layers, `@scope` proximity, and Shadow DOM encapsulation are
   # not modeled — `@layer`, `@supports`, `@container`, `@scope`, and
@@ -25,15 +27,20 @@ module CSS
     def initialize(stylesheet, context: MediaQueries::Context.default)
       @context = context
       @entries = compile(stylesheet)
+      @index   = build_index(@entries)
     end
 
     # Returns Hash<String, Declaration> of winning declarations.
     def resolve(element, inline_style: nil)
-      order   = 0
-      matches = []
+      cache       = {}
+      candidates  = collect_candidate_indexes(element, cache)
+      order       = 0
+      matches     = []
+
+      candidates.each do |idx|
+        entry = @entries[idx]
+        spec  = best_matching_specificity(element, entry.selector_pairs, cache)
 
-      @entries.each do |entry|
-        spec = best_matching_specificity(element, entry.selector_pairs)
         next if spec.nil?
 
         entry.declarations.each do |decl|
@@ -54,6 +61,9 @@ module CSS
 
     private
 
+    # Compile
+    # ----------------------------------------------------------------
+
     def compile(stylesheet)
       out = []
       walk(stylesheet.rules, [], out)
@@ -77,7 +87,7 @@ module CSS
     def register_qualified_rule(rule, media_chain, out)
       return unless media_chain.all? { MediaQueries::Evaluator.evaluate(it, @context) }
 
-      sl = Selectors::Parser.parse_selector_list(rule.prelude)
+      sl    = Selectors::Parser.parse_selector_list(rule.prelude)
       pairs = sl.selectors.map { [it, Selectors::SpecificityCalculator.calculate(it)] }
       decls = rule.block.items.select { it.is_a?(Nodes::Declaration) }
 
@@ -102,11 +112,97 @@ module CSS
       # remain unaffected.
     end
 
-    def best_matching_specificity(element, selector_pairs)
+    # Index
+    # ----------------------------------------------------------------
+
+    Index = Data.define(:by_id, :by_class, :by_tag, :universal)
+
+    EMPTY_INDEXES = [].freeze
+
+    def build_index(entries)
+      by_id     = {}
+      by_class  = {}
+      by_tag    = {}
+      universal = []
+
+      entries.each_with_index do |entry, idx|
+        keys = Set.new
+
+        entry.selector_pairs.each do |sel, _spec|
+          key = anchor_key(sel)
+
+          next if keys.include?(key)
+
+          keys << key
+
+          case key.first
+          when :id        then (by_id[key.last]    ||= []) << idx
+          when :class     then (by_class[key.last] ||= []) << idx
+          when :tag       then (by_tag[key.last]   ||= []) << idx
+          when :universal then universal                   << idx
+          end
+        end
+      end
+
+      Index.new(
+        by_id:     by_id.freeze,
+        by_class:  by_class.freeze,
+        by_tag:    by_tag.freeze,
+        universal: universal.freeze
+      )
+    end
+
+    # Picks the strongest anchor in the rightmost compound: id > class >
+    # tag > universal. Compounds whose only simple selectors are pseudos
+    # (e.g. `:hover`) or attribute matchers fall through to universal —
+    # they will be tested against every element, but real-world
+    # stylesheets rarely have many such rules.
+    def anchor_key(complex_selector)
+      compound = complex_selector.compounds.last
+
+      compound.components.each do |c|
+        return [:id, c.name] if c.is_a?(Selectors::IdSelector)
+      end
+      compound.components.each do |c|
+        return [:class, c.name] if c.is_a?(Selectors::ClassSelector)
+      end
+      compound.components.each do |c|
+        return [:tag, c.name.downcase] if c.is_a?(Selectors::TypeSelector)
+      end
+
+      [:universal]
+    end
+
+    # Resolve helpers
+    # ----------------------------------------------------------------
+
+    def collect_candidate_indexes(element, cache)
+      seen = Set.new
+
+      el_id = Selectors::Matcher.id_of(element, cache)
+
+      if el_id && (bucket = @index.by_id[el_id])
+        seen.merge(bucket)
+      end
+
+      Selectors::Matcher.classes_of(element, cache).each do |cls|
+        bucket = @index.by_class[cls]
+        seen.merge(bucket) if bucket
+      end
+
+      tag_bucket = @index.by_tag[Selectors::Matcher.tag_of(element, cache)]
+      seen.merge(tag_bucket) if tag_bucket
+
+      seen.merge(@index.universal)
+
+      seen.to_a.sort!
+    end
+
+    def best_matching_specificity(element, selector_pairs, cache)
       best = nil
 
       selector_pairs.each do |sel, spec|
-        next unless Selectors::Matcher.matches?(element, sel)
+        next unless Selectors::Matcher.matches?(element, sel, cache: cache)
 
         best = spec if best.nil? || spec > best
       end
@@ -114,24 +210,20 @@ module CSS
       best
     end
 
-    # Single-pass: keep the running winner per property name. Cheaper than
-    # group_by + max_by, and more importantly avoids allocating a fresh
-    # comparison key per declaration.
+    # Single-pass running max per property name. Cheaper than group_by +
+    # max_by, and avoids allocating a fresh comparison key per
+    # declaration.
     def pick_winners(matches)
-      winners       = {}
-      winner_matches = {}
+      best = {}
 
       matches.each do |m|
         name      = m.declaration.name
-        incumbent = winner_matches[name]
+        incumbent = best[name]
 
-        if incumbent.nil? || better?(m, incumbent)
-          winners[name]        = m.declaration
-          winner_matches[name] = m
-        end
+        best[name] = m if incumbent.nil? || better?(m, incumbent)
       end
 
-      winners
+      best.transform_values(&:declaration)
     end
 
     # `m` outranks `incumbent` when its priority class is higher, or — at

data/lib/css/selectors/matcher.rb

@@ -26,16 +26,24 @@ module CSS
       LINK_TAGS        = %w[a area link].freeze
       RO_INPUT_TYPES   = %w[hidden range color checkbox radio file submit image reset button].freeze
 
-      def matches?(element, selector)
+      # 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
+      # the duration of a single matcher invocation.
+      Context = Struct.new(:tag, :id, :classes, keyword_init: true)
+
+      EMPTY_CLASS_SET = Set.new.freeze
+
+      def matches?(element, selector, cache: nil)
         sel = selector.is_a?(String) ? Parser.parse_selector_list(selector) : selector
 
         case sel
         when SelectorList
-          sel.selectors.any? { match_complex(element, it) }
+          sel.selectors.any? { match_complex(element, it, cache) }
         when ComplexSelector
-          match_complex(element, sel)
+          match_complex(element, sel, cache)
         when CompoundSelector
-          match_compound(element, sel)
+          match_compound(element, sel, cache)
         else
           raise ArgumentError, "expected a selector node or string, got #{sel.class}"
         end
@@ -46,32 +54,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)
-        match_at(element, complex, complex.compounds.size - 1)
+      def match_complex(element, complex, cache)
+        match_at(element, complex, complex.compounds.size - 1, cache)
       end
 
-      def match_at(element, complex, index)
+      def match_at(element, complex, index, cache)
         return false if element.nil?
-        return false unless match_compound(element, complex.compounds[index])
+        return false unless match_compound(element, complex.compounds[index], cache)
         return true  if index.zero?
 
         prev = index - 1
 
         case complex.combinators[prev]
-        when :descendant         then walk_until_match(element, complex, prev, :parent_element)
-        when :child              then match_at(parent_element(element), complex, prev)
-        when :next_sibling       then match_at(previous_element(element), complex, prev)
-        when :subsequent_sibling then walk_until_match(element, complex, prev, :previous_element)
+        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)
         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)
+      def walk_until_match(element, complex, index, direction, cache)
         candidate = send(direction, element)
 
         while candidate
-          return true if match_at(candidate, complex, index)
+          return true if match_at(candidate, complex, index, cache)
 
           candidate = send(direction, candidate)
         end
@@ -79,24 +87,63 @@ module CSS
         false
       end
 
-      def match_compound(element, compound)
-        compound.components.all? { match_simple(element, it) }
+      def match_compound(element, compound, cache)
+        compound.components.all? { match_simple(element, it, cache) }
       end
 
-      def match_simple(element, simple)
+      def match_simple(element, simple, cache)
         case simple
-        when TypeSelector      then tag(element).casecmp?(simple.name)
+        when TypeSelector      then tag_of(element, cache).casecmp?(simple.name)
         when UniversalSelector then true
-        when IdSelector        then attr(element, 'id') == simple.name
-        when ClassSelector     then class_list(element).include?(simple.name)
+        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)
+        when PseudoClass       then match_pseudo_class(element, simple, cache)
         when PseudoElement     then false
         when NestingSelector   then false
         else                        false
         end
       end
 
+      # Public — used by `Cascade` for both rule indexing and matching;
+      # callers can share a `cache` Hash with `matches?(cache: cache)`
+      # so each element pays for its tag / id / class set at most once.
+      public
+
+      def tag_of(element, cache = nil)
+        ctx = context_for(element, cache)
+        ctx ? ctx.tag : tag(element)
+      end
+
+      def id_of(element, cache = nil)
+        ctx = context_for(element, cache)
+        ctx ? ctx.id : attr(element, 'id')
+      end
+
+      def classes_of(element, cache = nil)
+        ctx = context_for(element, cache)
+        ctx ? ctx.classes : build_class_set(element)
+      end
+
+      private
+
+      def context_for(element, cache)
+        return nil if cache.nil?
+
+        cache[element.object_id] ||= Context.new(
+          tag:     tag(element),
+          id:      attr(element, 'id'),
+          classes: build_class_set(element)
+        )
+      end
+
+      def build_class_set(element)
+        v = attr(element, 'class')
+        return EMPTY_CLASS_SET if v.nil? || v.empty?
+
+        v.to_s.split(/\s+/).to_set
+      end
+
       # Attribute matching ----------------------------------------------
 
       def match_attribute(element, attr_sel)
@@ -125,10 +172,10 @@ module CSS
 
       # Pseudo-class matching -------------------------------------------
 
-      def match_pseudo_class(element, pc)
+      def match_pseudo_class(element, pc, cache)
         case pc.name.downcase
-        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument)
-        when 'not'                       then negate_selector_list_arg(element, pc.argument)
+        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument, cache)
+        when 'not'                       then negate_selector_list_arg(element, pc.argument, cache)
         when 'has'                       then false
         when 'root'                      then parent_element(element).nil?
         when 'scope'                     then parent_element(element).nil?
@@ -159,12 +206,12 @@ module CSS
         end
       end
 
-      def match_selector_list_arg(element, arg)
-        arg.is_a?(SelectorList) && matches?(element, arg)
+      def match_selector_list_arg(element, arg, cache)
+        arg.is_a?(SelectorList) && matches?(element, arg, cache: cache)
       end
 
-      def negate_selector_list_arg(element, arg)
-        arg.is_a?(SelectorList) && !matches?(element, arg)
+      def negate_selector_list_arg(element, arg, cache)
+        arg.is_a?(SelectorList) && !matches?(element, arg, cache: cache)
       end
 
       def match_nth(element, anb, of_type:, from_end:)

data/lib/css/version.rb

@@ -1,3 +1,3 @@
 module CSS
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

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