parselly 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 117ef0c09557018d7129fa29c61565b90432dfeeec3a6b7b8bc9df6f06dcd06a
-  data.tar.gz: edfa4d22bbc8ffe26e9b6118993b0af67cbb4578471f8b2c62a807dcac554e95
+  metadata.gz: e1e4e245059433130b385388d399fe29355a1c679a15327a02cb3b49e69ae23b
+  data.tar.gz: ceb1167e8a32c25543b96988f754f76eb01fe287fc279a6ceb8dd26ffc258ca9
 SHA512:
-  metadata.gz: 72e2ffff39cc66e2fb68da3d8e69eba7e2435d380d6246f6deb2d2800e75ca64e459cd8e3a029a9f4c30f6548125fbcf7bbafd3ed2efd6e31766052de3aceebb
-  data.tar.gz: bf902d1d2cfcc2f88c5824b8448a8354dfffac62dcdd36e4c33bcff84f2e32f72b9120f674a581d22cab0bcb12e559691a3c507236f67786b94eb34430e255d6
+  metadata.gz: 33dab2f628019bbd51d482c53ae267f98914a5a561beb146ce57b3625f30535b661de168b2c6150faa79f16af8a49a8c15e7d6047a118577359fdd9334249a7f
+  data.tar.gz: 38803e8cc427a8eaa0b2a63f9446cf91334a368a7ea86908da80eb62cca3569a7b44f4c9536165a57f99048cf604dd948814b12dff25ac49c43ab637ec344324

data/lib/parselly/lexer.rb

@@ -4,6 +4,12 @@ require 'strscan'
 
 module Parselly
   class Lexer
+    Identifier = Struct.new(:value, :raw) do
+      def to_s
+        value
+      end
+    end
+
     TOKENS = {
       # Combinators
       '>' => :CHILD,
@@ -31,6 +37,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)
@@ -45,7 +68,7 @@ module Parselly
         skip_whitespace
         break if @scanner.eos?
 
-        pos = { line: @line, column: @column }
+        pos = { line: @line, column: @column, offset: @scanner.pos }
 
         if (token = scan_string)
           @tokens << [:STRING, token, pos]
@@ -57,35 +80,40 @@ module Parselly
           @tokens << [:IDENT, token, pos]
         else
           char = @scanner.getch
-          raise "Unexpected character: #{char} at #{pos[:line]}:#{pos[:column]}"
+          raise "Unexpected character: #{char} at #{pos[:line]}:#{pos[:column]} (offset #{pos[:offset]})"
         end
       end
 
-      @tokens << [false, nil, { line: @line, column: @column }]
+      @tokens << [false, nil, { line: @line, column: @column, offset: @scanner.pos }]
       @tokens
     end
 
     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 +127,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 +146,17 @@ 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')
+      normalized = ident.gsub(ESCAPE_REGEX, '\1')
+      Identifier.new(normalized, ident)
     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

@@ -8,7 +8,7 @@ module Parselly
   # child nodes, parent reference, and source position.
   #
   # @example Creating a simple AST node
-  #   node = Parselly::Node.new(:type_selector, 'div', { line: 1, column: 1 })
+  #   node = Parselly::Node.new(:type_selector, 'div', { line: 1, column: 1, offset: 0 })
   #   node.add_child(Parselly::Node.new(:class_selector, 'container'))
   #
   # @example Traversing the AST
@@ -16,19 +16,32 @@ module Parselly
   #   node.descendants  # Returns array of all descendant nodes
   #   node.siblings     # Returns array of sibling nodes
   class Node
-    attr_accessor :type, :value, :children, :parent, :position
+    attr_accessor :type, :value, :raw_value, :children, :parent, :position
 
     # Creates a new AST node.
     #
     # @param type [Symbol] the type of the node (e.g., :type_selector, :class_selector)
     # @param value [String, nil] optional value associated with the node
-    # @param position [Hash] source position with :line and :column keys
-    def initialize(type, value = nil, position = {})
+    # @param position [Hash] source position with :line, :column, and :offset keys
+    # @param line [Integer, nil] optional line number (keyword alternative)
+    # @param column [Integer, nil] optional column number (keyword alternative)
+    # @param offset [Integer, nil] optional offset (keyword alternative)
+    def initialize(type, value = nil, position = {}, raw_value: nil, line: nil, column: nil, offset: nil)
       @type = type
       @value = value
+      @raw_value = raw_value.nil? ? value : raw_value
       @children = []
       @parent = nil
-      @position = position
+      unless position.nil? || position.is_a?(Hash)
+        raise ArgumentError, 'position must be a Hash'
+      end
+
+      resolved_position = position ? position.dup : {}
+      resolved_position[:line] = line unless line.nil?
+      resolved_position[:column] = column unless column.nil?
+      resolved_position[:offset] = offset unless offset.nil?
+      @position = resolved_position
+      @descendants_cache = nil
     end
 
     # Adds a child node to this node.
@@ -40,9 +53,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 +92,41 @@ 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
+
+    # Depth-first traversal of this node and its descendants.
+    #
+    # @return [Enumerator, Node] enumerator if no block, otherwise self
+    def each
+      return enum_for(:each) unless block_given?
+
+      stack = [self]
+      until stack.empty?
+        node = stack.pop
+        yield node
+        children = node.children
+        stack.concat(children.reverse) if children && !children.empty?
+      end
+
+      self
+    end
+
+    # Finds all nodes of a given type in this subtree.
+    #
+    # @param type [Symbol] the node type to match
+    # @return [Array<Node>] array of matching nodes
+    def find_all(type)
+      each.with_object([]) { |node, acc| acc << node if node.type == type }
     end
 
     # Returns an array of sibling nodes (excluding self).
@@ -150,7 +211,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 +221,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 +243,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.
@@ -202,6 +267,24 @@ module Parselly
       result
     end
 
+    # Extracts detailed attribute selector nodes from this node and its descendants.
+    #
+    # @return [Array<Hash>] array of attribute selector detail hashes
+    #   Each hash contains :name, :operator (optional), and :value (optional) keys
+    def attribute_selectors
+      result = []
+
+      if type == :attribute_selector
+        result << extract_attribute_node(self)
+      end
+
+      descendants.each do |node|
+        result << extract_attribute_node(node) if node.type == :attribute_selector
+      end
+
+      result
+    end
+
     # Extracts all pseudo-classes and pseudo-elements from this node and its descendants.
     #
     # @return [Array<String>] array of pseudo-class and pseudo-element names
@@ -243,11 +326,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
@@ -277,6 +371,36 @@ module Parselly
       info
     end
 
+    # Helper method to extract detailed attribute selector data.
+    #
+    # @param node [Node] an attribute_selector node
+    # @return [Hash] attribute selector detail hash
+    def extract_attribute_node(node)
+      info = {}
+
+      if node.value
+        info[:name] = node.value
+        info[:raw_name] = node.raw_value
+        return info
+      end
+
+      node.children.each do |child|
+        case child.type
+        when :attribute
+          info[:name] = child.value
+          info[:raw_name] = child.raw_value
+        when :equal_operator, :includes_operator, :dashmatch_operator,
+             :prefixmatch_operator, :suffixmatch_operator, :substringmatch_operator
+          info[:operator] = child.value
+        when :value
+          info[:value] = child.value
+          info[:raw_value] = child.raw_value
+        end
+      end
+
+      info
+    end
+
     # Helper method to build an attribute selector string.
     #
     # @return [String] the attribute selector string