p_css 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df1cd693075fe04da6a0c9ce4c65c9c4ef5f85c5b84bb82bd0136cf62fe52552
-  data.tar.gz: 9a9fc875c3872c49396c5b6c753a099ba3cc344efa7aa97745958d277630c7cb
+  metadata.gz: 965047de25f5fe1719b2d2b4c59d2fa2d74550249e2ffa23d4175ae88dc09ba9
+  data.tar.gz: ab8078d7209427b3f23cd774492fae69543bd8910b812a1a87fc7da38b8df89c
 SHA512:
-  metadata.gz: 28c76784dac592aa39cfaa5100b69e4765861ec2ab1ed536fb95dfb963481de2bd64d6b6b954f71b14b17ea4a328cc65af6f7a63df662f2083c2ef5ec623e892
-  data.tar.gz: 291d12b999205c032e7cebaa5da4b69aff717cb9f7b9743c3c54ce99539b59ec49612b87e9bcf105d374cc79871d8955fc57f18200b8ba76c396894db14f349f
+  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/code_points.rb

@@ -1,36 +1,59 @@
 module CSS
   # Character class predicates from CSS Syntax §4.2 Definitions, plus the
   # U+FFFD replacement character used both during tokenization and
-  # serialization. Implemented with char comparisons rather than regex to
-  # avoid pattern-match overhead in the tokenizer's inner loop.
+  # serialization.
+  #
+  # ASCII bytes are looked up in a precomputed boolean table (one Array
+  # access + one branch); non-ASCII code points (>= 0x80) are always
+  # ident-cp / ident-start per spec, so the helpers fall back to a single
+  # `c.ord >= 0x80` check. Avoids the chain of `String#<=>` calls a
+  # range-style predicate would dispatch.
   module CodePoints
     REPLACEMENT = "�".freeze
 
+    def self.build_table(*ranges_or_ints)
+      Array.new(128, false).tap {|a|
+        ranges_or_ints.each {|r|
+          if r.is_a?(Range) then r.each { a[it] = true }
+          else                   a[r] = true
+          end
+        }
+      }.freeze
+    end
+
+    DIGIT_TABLE       = build_table(0x30..0x39)
+    HEX_DIGIT_TABLE   = build_table(0x30..0x39, 0x41..0x46, 0x61..0x66)
+    IDENT_START_TABLE = build_table(0x41..0x5A, 0x61..0x7A, 0x5F)
+    IDENT_CP_TABLE    = build_table(0x30..0x39, 0x41..0x5A, 0x61..0x7A, 0x5F, 0x2D)
+
     module_function
 
     def digit?(c)
-      !c.nil? && c >= '0' && c <= '9'
+      return false if c.nil?
+
+      o = c.ord
+      o < 128 && DIGIT_TABLE[o]
     end
 
     def hex_digit?(c)
       return false if c.nil?
 
-      (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')
+      o = c.ord
+      o < 128 && HEX_DIGIT_TABLE[o]
     end
 
     def ident_start_code_point?(c)
       return false if c.nil?
-      return true  if c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
 
-      c.ord >= 0x80
+      o = c.ord
+      o >= 128 || IDENT_START_TABLE[o]
     end
 
     def ident_code_point?(c)
       return false if c.nil?
-      return true  if c == '_' || c == '-' || (c >= '0' && c <= '9')
-      return true  if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
 
-      c.ord >= 0x80
+      o = c.ord
+      o >= 128 || IDENT_CP_TABLE[o]
     end
   end
 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/token.rb

@@ -17,7 +17,7 @@ module CSS
       eof
     ].freeze
 
-    attr_reader :type, :value, :flag, :unit, :position
+    attr_reader :type, :value, :flag, :unit
 
     def initialize(type, value = nil, flag: nil, unit: nil, position: nil)
       raise ArgumentError, "unknown token type: #{type.inspect}" unless TYPES.include?(type)
@@ -58,21 +58,50 @@ module CSS
       type == :whitespace || type == :comment
     end
 
-    # Mutating: assigns the token's source position and returns self. Used
-    # by the tokenizer so each token requires only a single allocation.
-    def assign_position!(pos)
-      @position = pos
+    # Most tokens never have their `position` read after parsing, so the
+    # tokenizer plants raw offsets + a shared `@newlines` reference here
+    # via this method, and `Token#position` materializes the `Position`
+    # Data on first read.
+    def assign_source!(start_offset, end_offset, newlines)
+      @start_offset = start_offset
+      @end_offset   = end_offset
+      @newlines     = newlines
       self
     end
 
+    # Returns nil for tokens built without source info (i.e. tokens
+    # constructed by hand or via `Token.new(:eof)`).
+    def position
+      return @position if @position
+      return nil unless instance_variable_defined?(:@start_offset)
+
+      @position = compute_position
+    end
+
+    # Reads `@position` directly so debug-style introspection doesn't
+    # materialize a `Position` as a side effect.
     def inspect
       parts = ["type=#{type.inspect}"]
       parts << "value=#{value.inspect}" unless value.nil?
       parts << "flag=#{flag.inspect}"   unless flag.nil?
       parts << "unit=#{unit.inspect}"   unless unit.nil?
-      parts << "@#{position}"           unless position.nil?
+      parts << "@#{@position}"          if @position
 
       "#<CSS::Token #{parts.join(' ')}>"
     end
+
+    private
+
+    def compute_position
+      idx     = @newlines.bsearch_index { it >= @start_offset } || @newlines.size
+      prev_nl = idx.zero? ? -1 : @newlines[idx - 1]
+
+      Position.new(
+        line:       idx + 1,
+        column:     @start_offset - prev_nl,
+        offset:     @start_offset,
+        end_offset: @end_offset
+      )
+    end
   end
 end

data/lib/css/tokenizer.rb

@@ -2,9 +2,8 @@ module CSS
   # Tokenizer based on CSS Syntax Module Level 3/4 §4.
   # https://www.w3.org/TR/css-syntax-3/#tokenization
   #
-  # Not thread-safe: an instance carries mutable cursors (`@pos`,
-  # `@newline_cursor`) that advance over the input. Allocate one
-  # tokenizer per thread.
+  # Not thread-safe: an instance carries a mutable cursor (`@pos`) that
+  # advances over the input. Allocate one tokenizer per thread.
   class Tokenizer
     include CodePoints
 
@@ -26,9 +25,9 @@ module CSS
 
     def initialize(input, preserve_comments: false)
       @chars             = preprocess(input)
+      @length            = @chars.length
       @pos               = 0
       @newlines          = collect_newline_offsets(@chars)
-      @newline_cursor    = 0
       @preserve_comments = preserve_comments
     end
 
@@ -48,13 +47,12 @@ module CSS
     def next_token
       consume_comments unless @preserve_comments
 
-      return Token.new(:eof) if @pos >= @chars.length
+      return Token.new(:eof) if @pos >= @length
 
       start_offset = @pos
       tok          = consume_one_token
-      line, column = line_column_at(start_offset)
 
-      tok.assign_position!(Position.new(line:, column:, offset: start_offset, end_offset: @pos))
+      tok.assign_source!(start_offset, @pos, @newlines)
     end
 
     private
@@ -174,23 +172,6 @@ module CSS
       offsets
     end
 
-    # Newline characters themselves are reported as belonging to the
-    # line they terminate (col = offset + 1 on line 1, etc).
-    #
-    # Tokens are emitted in order, so the offsets passed in are
-    # monotonically non-decreasing. We keep a running cursor into
-    # `@newlines` and advance linearly — amortized O(1) per call,
-    # vs. O(log n) per call with a fresh `bsearch`.
-    def line_column_at(offset)
-      while @newline_cursor < @newlines.size && @newlines[@newline_cursor] < offset
-        @newline_cursor += 1
-      end
-
-      prev_nl = @newline_cursor.zero? ? -1 : @newlines[@newline_cursor - 1]
-
-      [@newline_cursor + 1, offset - prev_nl]
-    end
-
     def whitespace?(c)
       c == ' ' || c == "\n" || c == "\t"
     end
@@ -267,7 +248,7 @@ module CSS
     end
 
     def eof?
-      @pos >= @chars.length
+      @pos >= @length
     end
 
     def consume_whitespace

data/lib/css/version.rb

@@ -1,3 +1,3 @@
 module CSS
-  VERSION = '0.1.3'
+  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/token.rbs

@@ -22,7 +22,7 @@ module CSS
     def comment?: () -> bool
     def trivia?: () -> bool
 
-    def assign_position!: (Position pos) -> self
+    def assign_source!: (Integer start_offset, Integer end_offset, Array[Integer] newlines) -> self
 
     def ==: (untyped other) -> bool
     def eql?: (untyped other) -> bool

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.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Keita Urashima