parselly 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 117ef0c09557018d7129fa29c61565b90432dfeeec3a6b7b8bc9df6f06dcd06a
-  data.tar.gz: edfa4d22bbc8ffe26e9b6118993b0af67cbb4578471f8b2c62a807dcac554e95
+  metadata.gz: c245172165bcac6e4b24a355b6e26a4039960fb8654374587523c3041015bb96
+  data.tar.gz: 1897eee14cb66e216422815883375837168e8850d17e87a98ca7a05873d18d58
 SHA512:
-  metadata.gz: 72e2ffff39cc66e2fb68da3d8e69eba7e2435d380d6246f6deb2d2800e75ca64e459cd8e3a029a9f4c30f6548125fbcf7bbafd3ed2efd6e31766052de3aceebb
-  data.tar.gz: bf902d1d2cfcc2f88c5824b8448a8354dfffac62dcdd36e4c33bcff84f2e32f72b9120f674a581d22cab0bcb12e559691a3c507236f67786b94eb34430e255d6
+  metadata.gz: 011ea12078d3311c28d00864167fa5cd7a5a9b1afd24feacccb4df2631b00e095aedf231793bd93bf7717b2bf99b7bfd28a6918d7b5d0f3e2794ac3d5f0faa6b
+  data.tar.gz: 261006f641a09ecea004423a68601b0a7c4941d35cf13ddd0acd74dfc530a1de19a2e4d5d370cef8a366271a2a713756ba6ce3f7fd1b1fe8fbe464e534a3549a

data/lib/parselly/lexer.rb

@@ -31,6 +31,23 @@ module Parselly
       '*=' => :SUBSTRINGMATCH
     }.freeze
 
+    # Pre-compiled regular expressions for better performance
+    MULTI_CHAR_OPERATORS = [
+      [/~=/, :INCLUDES],
+      [/\|=/, :DASHMATCH],
+      [/\^=/, :PREFIXMATCH],
+      [/\$=/, :SUFFIXMATCH],
+      [/\*=/, :SUBSTRINGMATCH]
+    ].freeze
+
+    SINGLE_CHAR_OPERATOR_REGEX = /[>+~\[\]():,.#*=-]/.freeze
+    WHITESPACE_REGEX = /[ \t\n\r]+/.freeze
+    STRING_DOUBLE_REGEX = /"([^"\\]|\\.)*"/.freeze
+    STRING_SINGLE_REGEX = /'([^'\\]|\\.)*'/.freeze
+    IDENTIFIER_REGEX = /(?:--|-?[a-zA-Z_])(?:[\w-]|\\[^\n\r\f])*/.freeze
+    NUMBER_REGEX = /\d+(\.\d+)?/.freeze
+    ESCAPE_REGEX = /\\(.)/.freeze
+
     attr_reader :line, :column
 
     def initialize(input)
@@ -68,24 +85,29 @@ module Parselly
     private
 
     def skip_whitespace
-      while @scanner.scan(/[ \t\n\r]+/)
-        @scanner.matched.each_char do |char|
-          update_position(char)
+      while @scanner.scan(WHITESPACE_REGEX)
+        matched = @scanner.matched
+        newline_count = matched.count("\n")
+        if newline_count > 0
+          @line += newline_count
+          @column = matched.size - matched.rindex("\n")
+        else
+          @column += matched.size
         end
       end
     end
 
     def scan_operator
       # Check multi-character operators first
-      ['~=', '|=', '^=', '$=', '*='].each do |op|
-        if @scanner.scan(/#{Regexp.escape(op)}/)
+      MULTI_CHAR_OPERATORS.each do |regex, token|
+        if @scanner.scan(regex)
           update_position(@scanner.matched)
-          return TOKENS[op]
+          return token
         end
       end
 
       # Single character operators
-      return unless @scanner.scan(/[>+~\[\]():,.#*=-]/)
+      return unless @scanner.scan(SINGLE_CHAR_OPERATOR_REGEX)
 
       char = @scanner.matched
       update_position(char)
@@ -99,11 +121,11 @@ module Parselly
     # as raw text for simplicity. Identifiers process escapes to support patterns
     # like .hover\:bg-blue-500, but strings in attributes don't require this.
     def scan_string
-      if @scanner.scan(/"([^"\\]|\\.)*"/)
+      if @scanner.scan(STRING_DOUBLE_REGEX)
         str = @scanner.matched
         update_position(str)
         str[1..-2] # Remove quotes
-      elsif @scanner.scan(/'([^'\\]|\\.)*'/)
+      elsif @scanner.scan(STRING_SINGLE_REGEX)
         str = @scanner.matched
         update_position(str)
         str[1..-2] # Remove quotes
@@ -118,16 +140,16 @@ module Parselly
       # While custom properties are technically only valid in property contexts (not selectors),
       # this parser accepts them as a superset of valid CSS for flexibility. In practice,
       # selectors like .--invalid-class would parse but aren't valid CSS selectors.
-      return unless @scanner.scan(/(?:--|-?[a-zA-Z_])(?:[\w-]|\\[^\n\r\f])*/)
+      return unless @scanner.scan(IDENTIFIER_REGEX)
 
       ident = @scanner.matched
       update_position(ident)
       # Remove backslashes from escaped characters
-      ident.gsub(/\\(.)/, '\1')
+      ident.gsub(ESCAPE_REGEX, '\1')
     end
 
     def scan_number
-      return unless @scanner.scan(/\d+(\.\d+)?/)
+      return unless @scanner.scan(NUMBER_REGEX)
 
       num = @scanner.matched
       update_position(num)

data/lib/parselly/node.rb

@@ -29,6 +29,7 @@ module Parselly
       @children = []
       @parent = nil
       @position = position
+      @descendants_cache = nil
     end
 
     # Adds a child node to this node.
@@ -40,9 +41,28 @@ module Parselly
 
       node.parent = self
       @children << node
+      invalidate_cache
       node
     end
 
+    # Replaces a child node at the specified index.
+    #
+    # @param index [Integer] the index of the child to replace
+    # @param new_node [Node] the new child node
+    # @return [Node, nil] the new node, or nil if invalid parameters
+    def replace_child(index, new_node)
+      return nil if new_node.nil?
+      return nil if index < 0 || index >= @children.size
+
+      old_node = @children[index]
+      old_node.parent = nil if old_node
+
+      @children[index] = new_node
+      new_node.parent = self
+      invalidate_cache
+      new_node
+    end
+
     # Returns an array of all ancestor nodes from parent to root.
     #
     # @return [Array<Node>] array of ancestor nodes
@@ -60,12 +80,16 @@ module Parselly
     #
     # @return [Array<Node>] array of all descendant nodes
     def descendants
-      result = []
-      @children.each do |child|
-        result << child
-        result.concat(child.descendants)
+      return @descendants_cache if @descendants_cache
+
+      @descendants_cache = []
+      queue = @children.dup
+      until queue.empty?
+        node = queue.shift
+        @descendants_cache << node
+        queue.concat(node.children) unless node.children.empty?
       end
-      result
+      @descendants_cache
     end
 
     # Returns an array of sibling nodes (excluding self).
@@ -150,7 +174,8 @@ module Parselly
     #
     # @return [Boolean] true if an ID selector is present
     def id?
-      type == :id_selector || descendants.any? { |node| node.type == :id_selector }
+      return true if type == :id_selector
+      descendants.any? { |node| node.type == :id_selector }
     end
 
     # Extracts the ID value from this node or its descendants.
@@ -159,8 +184,10 @@ module Parselly
     def id
       return value if type == :id_selector
 
-      id_node = descendants.find { |node| node.type == :id_selector }
-      id_node&.value
+      descendants.each do |node|
+        return node.value if node.type == :id_selector
+      end
+      nil
     end
 
     # Extracts all class names from this node and its descendants.
@@ -179,7 +206,8 @@ module Parselly
     #
     # @return [Boolean] true if an attribute selector is present
     def attribute?
-      type == :attribute_selector || descendants.any? { |node| node.type == :attribute_selector }
+      return true if type == :attribute_selector
+      descendants.any? { |node| node.type == :attribute_selector }
     end
 
     # Extracts all attribute selectors from this node and its descendants.
@@ -243,11 +271,22 @@ module Parselly
     #
     # @return [Boolean] true if a type selector is present
     def type_selector?
-      type == :type_selector || descendants.any? { |node| node.type == :type_selector }
+      return true if type == :type_selector
+      descendants.any? { |node| node.type == :type_selector }
     end
 
     private
 
+    # Invalidates the descendants cache for this node and all ancestors.
+    # This ensures that cached descendants are cleared when the tree structure changes.
+    def invalidate_cache
+      node = self
+      while node
+        node.instance_variable_set(:@descendants_cache, nil)
+        node = node.parent
+      end
+    end
+
     # Helper method to extract attribute information from an attribute_selector node.
     #
     # @param node [Node] an attribute_selector node

data/lib/parselly/parser.rb

@@ -653,11 +653,20 @@ end
 end
 ###### racc/parser.rb end
 
+require 'set'
+
+# Pre-computed sets for faster lookup
+CAN_END_COMPOUND = Set[:IDENT, :STAR, :RPAREN, :RBRACKET].freeze
+CAN_START_COMPOUND = Set[:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].freeze
+TYPE_SELECTOR_TYPES = Set[:IDENT, :STAR].freeze
+SUBCLASS_SELECTOR_TYPES = Set[:DOT, :HASH, :LBRACKET, :COLON].freeze
+NTH_PSEUDO_NAMES = Set['nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type', 'nth-col', 'nth-last-col'].freeze
+AN_PLUS_B_REGEX = /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/.freeze
 
 module Parselly
   class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 263)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 272)
 def parse(input)
   @lexer = Parselly::Lexer.new(input)
   @tokens = @lexer.tokenize
@@ -670,20 +679,27 @@ def parse(input)
 end
 
 def preprocess_tokens!
-  new_tokens = []
-  i = 0
-  while i < @tokens.size
-    token = @tokens[i]
-    next_token = @tokens[i + 1]
-    new_tokens << token
-    if next_token && needs_descendant?(token, next_token)
-      pos = { line: token[2][:line], column: token[2][:column] }
-      new_tokens << [:DESCENDANT, ' ', pos]
+  return if @tokens.size <= 1
+
+  new_tokens = Array.new(@tokens.size + (@tokens.size / 2)) # Pre-allocate with conservative estimate
+  new_tokens_idx = 0
+
+  last_idx = @tokens.size - 1
+  @tokens.each_with_index do |token, i|
+    new_tokens[new_tokens_idx] = token
+    new_tokens_idx += 1
+
+    if i < last_idx
+      next_token = @tokens[i + 1]
+      if needs_descendant?(token, next_token)
+        pos = { line: token[2][:line], column: token[2][:column] }
+        new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
+        new_tokens_idx += 1
+      end
     end
-    i += 1
   end
 
-  @tokens = new_tokens
+  @tokens = new_tokens.first(new_tokens_idx)
 end
 
 # Insert DESCENDANT combinator if:
@@ -695,62 +711,39 @@ def needs_descendant?(current, next_tok)
   current_type = current[0]
   next_type = next_tok[0]
 
-  can_end = can_end_compound?(current_type)
-  can_start = can_start_compound?(next_type)
-
   # Type selector followed by subclass selector = same compound
-  if [:IDENT, :STAR].include?(current_type) &&
-     [:DOT, :HASH, :LBRACKET, :COLON].include?(next_type)
-    return false
-  end
-
-  can_end && can_start
-end
+  return false if TYPE_SELECTOR_TYPES.include?(current_type) &&
+                  SUBCLASS_SELECTOR_TYPES.include?(next_type)
 
-def can_end_compound?(token_type)
-  [:IDENT, :STAR, :RPAREN, :RBRACKET].include?(token_type)
-end
-
-def can_start_compound?(token_type)
-  # Type selectors and subclass selectors can start a compound selector
-  [:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].include?(token_type)
+  CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
 end
 
 def normalize_an_plus_b(node)
   return unless node.respond_to?(:children) && node.children
 
-  if node.type == :pseudo_function && nth_pseudo?(node.value)
+  if node.type == :pseudo_function && NTH_PSEUDO_NAMES.include?(node.value)
     child = node.children.first
-    if child && child.type == :selector_list
+    if child&.type == :selector_list
       an_plus_b_value = extract_an_plus_b_value(child)
       if an_plus_b_value
-        node.children[0] = Node.new(:an_plus_b, an_plus_b_value, child.position)
+        node.replace_child(0, Node.new(:an_plus_b, an_plus_b_value, child.position))
       end
     end
   end
   node.children.compact.each { |child| normalize_an_plus_b(child) }
 end
 
-def nth_pseudo?(name)
-  %w[nth-child nth-last-child nth-of-type nth-last-of-type nth-col nth-last-col].include?(name)
-end
-
 def extract_an_plus_b_value(selector_list_node)
   return nil unless selector_list_node.children.size == 1
 
   seq = selector_list_node.children.first
-  return nil unless seq.type == :simple_selector_sequence
-  return nil unless seq.children.size == 1
+  return nil unless seq.type == :simple_selector_sequence && seq.children.size == 1
 
   type_sel = seq.children.first
   return nil unless type_sel.type == :type_selector
 
   value = type_sel.value
-  if value =~ /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/
-    value
-  else
-    nil
-  end
+  value if value =~ AN_PLUS_B_REGEX
 end
 
 def next_token

data/lib/parselly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parselly
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/parser.y

@@ -258,6 +258,15 @@ rule
 end
 
 ---- header
+require 'set'
+
+# Pre-computed sets for faster lookup
+CAN_END_COMPOUND = Set[:IDENT, :STAR, :RPAREN, :RBRACKET].freeze
+CAN_START_COMPOUND = Set[:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].freeze
+TYPE_SELECTOR_TYPES = Set[:IDENT, :STAR].freeze
+SUBCLASS_SELECTOR_TYPES = Set[:DOT, :HASH, :LBRACKET, :COLON].freeze
+NTH_PSEUDO_NAMES = Set['nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type', 'nth-col', 'nth-last-col'].freeze
+AN_PLUS_B_REGEX = /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/.freeze
 
 ---- inner
 def parse(input)
@@ -272,20 +281,27 @@ def parse(input)
 end
 
 def preprocess_tokens!
-  new_tokens = []
-  i = 0
-  while i < @tokens.size
-    token = @tokens[i]
-    next_token = @tokens[i + 1]
-    new_tokens << token
-    if next_token && needs_descendant?(token, next_token)
-      pos = { line: token[2][:line], column: token[2][:column] }
-      new_tokens << [:DESCENDANT, ' ', pos]
+  return if @tokens.size <= 1
+
+  new_tokens = Array.new(@tokens.size + (@tokens.size / 2)) # Pre-allocate with conservative estimate
+  new_tokens_idx = 0
+
+  last_idx = @tokens.size - 1
+  @tokens.each_with_index do |token, i|
+    new_tokens[new_tokens_idx] = token
+    new_tokens_idx += 1
+
+    if i < last_idx
+      next_token = @tokens[i + 1]
+      if needs_descendant?(token, next_token)
+        pos = { line: token[2][:line], column: token[2][:column] }
+        new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
+        new_tokens_idx += 1
+      end
     end
-    i += 1
   end
 
-  @tokens = new_tokens
+  @tokens = new_tokens.first(new_tokens_idx)
 end
 
 # Insert DESCENDANT combinator if:
@@ -297,62 +313,39 @@ def needs_descendant?(current, next_tok)
   current_type = current[0]
   next_type = next_tok[0]
 
-  can_end = can_end_compound?(current_type)
-  can_start = can_start_compound?(next_type)
-
   # Type selector followed by subclass selector = same compound
-  if [:IDENT, :STAR].include?(current_type) &&
-     [:DOT, :HASH, :LBRACKET, :COLON].include?(next_type)
-    return false
-  end
-
-  can_end && can_start
-end
+  return false if TYPE_SELECTOR_TYPES.include?(current_type) &&
+                  SUBCLASS_SELECTOR_TYPES.include?(next_type)
 
-def can_end_compound?(token_type)
-  [:IDENT, :STAR, :RPAREN, :RBRACKET].include?(token_type)
-end
-
-def can_start_compound?(token_type)
-  # Type selectors and subclass selectors can start a compound selector
-  [:IDENT, :STAR, :DOT, :HASH, :LBRACKET, :COLON].include?(token_type)
+  CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
 end
 
 def normalize_an_plus_b(node)
   return unless node.respond_to?(:children) && node.children
 
-  if node.type == :pseudo_function && nth_pseudo?(node.value)
+  if node.type == :pseudo_function && NTH_PSEUDO_NAMES.include?(node.value)
     child = node.children.first
-    if child && child.type == :selector_list
+    if child&.type == :selector_list
       an_plus_b_value = extract_an_plus_b_value(child)
       if an_plus_b_value
-        node.children[0] = Node.new(:an_plus_b, an_plus_b_value, child.position)
+        node.replace_child(0, Node.new(:an_plus_b, an_plus_b_value, child.position))
       end
     end
   end
   node.children.compact.each { |child| normalize_an_plus_b(child) }
 end
 
-def nth_pseudo?(name)
-  %w[nth-child nth-last-child nth-of-type nth-last-of-type nth-col nth-last-col].include?(name)
-end
-
 def extract_an_plus_b_value(selector_list_node)
   return nil unless selector_list_node.children.size == 1
 
   seq = selector_list_node.children.first
-  return nil unless seq.type == :simple_selector_sequence
-  return nil unless seq.children.size == 1
+  return nil unless seq.type == :simple_selector_sequence && seq.children.size == 1
 
   type_sel = seq.children.first
   return nil unless type_sel.type == :type_selector
 
   value = type_sel.value
-  if value =~ /^(even|odd|[+-]?\d*n(?:[+-]\d+)?|[+-]?n(?:[+-]\d+)?|\d+)$/
-    value
-  else
-    nil
-  end
+  value if value =~ AN_PLUS_B_REGEX
 end
 
 def next_token

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parselly
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yudai Takada