parselly 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c245172165bcac6e4b24a355b6e26a4039960fb8654374587523c3041015bb96
-  data.tar.gz: 1897eee14cb66e216422815883375837168e8850d17e87a98ca7a05873d18d58
+  metadata.gz: e1e4e245059433130b385388d399fe29355a1c679a15327a02cb3b49e69ae23b
+  data.tar.gz: ceb1167e8a32c25543b96988f754f76eb01fe287fc279a6ceb8dd26ffc258ca9
 SHA512:
-  metadata.gz: 011ea12078d3311c28d00864167fa5cd7a5a9b1afd24feacccb4df2631b00e095aedf231793bd93bf7717b2bf99b7bfd28a6918d7b5d0f3e2794ac3d5f0faa6b
-  data.tar.gz: 261006f641a09ecea004423a68601b0a7c4941d35cf13ddd0acd74dfc530a1de19a2e4d5d370cef8a366271a2a713756ba6ce3f7fd1b1fe8fbe464e534a3549a
+  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,
@@ -62,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]
@@ -74,11 +80,11 @@ 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
 
@@ -145,7 +151,8 @@ module Parselly
       ident = @scanner.matched
       update_position(ident)
       # Remove backslashes from escaped characters
-      ident.gsub(ESCAPE_REGEX, '\1')
+      normalized = ident.gsub(ESCAPE_REGEX, '\1')
+      Identifier.new(normalized, ident)
     end
 
     def scan_number

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,31 @@ 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
 
@@ -92,6 +104,31 @@ module Parselly
       @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).
     #
     # @return [Array<Node>] array of sibling nodes, or empty array if no parent
@@ -230,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
@@ -316,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

data/lib/parselly/parser.rb

@@ -660,24 +660,102 @@ 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
+SUBCLASS_SELECTOR_END_TYPES = Set[:IDENT, :RBRACKET, :RPAREN].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', 272)
-def parse(input)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 279)
+def parse(input, tolerant: false)
+  @tolerant = tolerant
+  @errors = []
+  @error_index = nil
+  @suppress_errors = false
   @lexer = Parselly::Lexer.new(input)
-  @tokens = @lexer.tokenize
+  begin
+    @tokens = @lexer.tokenize
+  rescue RuntimeError => e
+    if tolerant
+      @errors << parse_error_from_exception(e)
+      return Parselly::ParseResult.new(nil, @errors)
+    end
+    raise
+  end
   preprocess_tokens!
   @index = 0
-  @current_position = { line: 1, column: 1 }
+  @current_position = { line: 1, column: 1, offset: 0 }
+
+  if tolerant
+    ast = parse_with_recovery
+    normalize_an_plus_b(ast) if ast
+    return Parselly::ParseResult.new(ast, @errors)
+  end
+
   ast = do_parse
   normalize_an_plus_b(ast)
   ast
 end
 
+def parse_with_recovery
+  do_parse
+rescue Parselly::ParseError, RuntimeError
+  parse_partial_ast
+end
+
+def parse_partial_ast
+  return nil unless @tokens && !@tokens.empty?
+
+  eof_token = @tokens.last if @tokens.last && @tokens.last[0] == false
+  tokens = @tokens.dup
+  tokens.pop if eof_token
+  limit = @error_index || tokens.length
+
+  while limit > 0
+    truncated = tokens[0...limit]
+    truncated << eof_token if eof_token
+    begin
+      return parse_from_tokens(truncated, suppress_errors: true)
+    rescue Parselly::ParseError, RuntimeError
+      limit -= 1
+    end
+  end
+  nil
+end
+
+def parse_from_tokens(tokens, suppress_errors: false)
+  @tokens = tokens
+  @index = 0
+  @current_position = { line: 1, column: 1, offset: 0 }
+  @suppress_errors = suppress_errors
+  do_parse
+ensure
+  @suppress_errors = false
+end
+
+def parse_error_from_exception(error)
+  line = nil
+  column = nil
+  offset = nil
+  if error.message =~ /at (\d+):(\d+)/
+    line = Regexp.last_match(1).to_i
+    column = Regexp.last_match(2).to_i
+  end
+  if error.message =~ /offset (\d+)/
+    offset = Regexp.last_match(1).to_i
+  end
+  { message: error.message, line: line, column: column, offset: offset }
+end
+
+def identifier_value(token)
+  token.respond_to?(:value) ? token.value : token
+end
+
+def identifier_raw(token)
+  token.respond_to?(:raw) ? token.raw : token
+end
+
 def preprocess_tokens!
   return if @tokens.size <= 1
 
@@ -692,7 +770,7 @@ def preprocess_tokens!
     if i < last_idx
       next_token = @tokens[i + 1]
       if needs_descendant?(token, next_token)
-        pos = { line: token[2][:line], column: token[2][:column] }
+        pos = { line: token[2][:line], column: token[2][:column], offset: token[2][:offset] }
         new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
         new_tokens_idx += 1
       end
@@ -712,8 +790,11 @@ def needs_descendant?(current, next_tok)
   next_type = next_tok[0]
 
   # Type selector followed by subclass selector = same compound
-  return false if TYPE_SELECTOR_TYPES.include?(current_type) &&
-                  SUBCLASS_SELECTOR_TYPES.include?(next_type)
+  # Subclass selector followed by subclass selector = same compound
+  if SUBCLASS_SELECTOR_TYPES.include?(next_type)
+    return false if TYPE_SELECTOR_TYPES.include?(current_type) ||
+                    SUBCLASS_SELECTOR_END_TYPES.include?(current_type)
+  end
 
   CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
 end
@@ -759,88 +840,101 @@ end
 def on_error(token_id, val, vstack)
   token_name = token_to_str(token_id) || '?'
   pos = @current_position || { line: '?', column: '?' }
-  raise "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[:column]}"
+  error = {
+    message: "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[:column]}",
+    line: pos[:line],
+    column: pos[:column],
+    offset: pos[:offset]
+  }
+  if @tolerant
+    @errors << error unless @suppress_errors
+    @error_index ||= [@index - 1, 0].max
+    raise Parselly::ParseError, error
+  end
+  raise error[:message]
 end
 ...end parser.y/module_eval...
 ##### State transition tables begin ###
 
 racc_action_table = [
-    55,    57,    60,    14,    15,     8,    16,    35,    18,    67,
-    17,    19,    25,    26,    27,    28,    32,    36,    68,    79,
-     7,    33,    61,    14,    15,     8,    16,    43,    80,    72,
-    17,    71,    25,    26,    27,    28,    45,    46,    47,    48,
-    49,    50,     7,    54,    53,    14,    15,     8,    16,    34,
-     7,    37,    17,    14,    15,     8,    16,    19,     7,    51,
-    17,    14,    15,     8,    16,    82,     7,    52,    17,    14,
-    15,     8,    16,    88,    83,    65,    17,    14,    15,    66,
-    16,    69,    89,    70,    17,    14,    15,    73,    16,    77,
-    78,    81,    17,    25,    26,    27,    28,    25,    26,    27,
-    28,    73,    86,    87,    90,    91,    92,    93 ]
+    45,    47,    50,    14,    15,     8,    16,    55,    18,    70,
+    17,    69,    25,    26,    27,    28,    57,    58,    59,    60,
+    61,    62,    51,    45,    47,    50,    14,    15,     8,    16,
+    37,    19,    80,    17,    33,    25,    26,    27,    28,    34,
+    38,    81,    83,     7,    35,    51,    14,    15,     8,    16,
+    36,    84,    92,    17,    33,    25,    26,    27,    28,    65,
+     7,    93,    39,    14,    15,     8,    16,    19,    66,    32,
+    17,    33,    14,    15,    63,    16,    64,     7,    67,    17,
+    14,    15,     8,    16,    68,     7,    71,    17,    14,    15,
+     8,    16,    78,    32,    79,    17,    14,    15,    82,    16,
+    71,     7,    87,    17,    14,    15,     8,    16,    76,    75,
+    88,    17,    25,    26,    27,    28,    25,    26,    27,    28,
+    89,    90,    91,    94,    95,    96,    97 ]
 
 racc_action_check = [
-    51,    51,    51,    51,    51,    51,    51,    17,     1,    55,
-    51,     2,    51,    51,    51,    51,    14,    17,    55,    70,
-    73,    15,    51,    73,    73,    73,    73,    34,    70,    61,
-    73,    61,    73,    73,    73,    73,    34,    34,    34,    34,
-    34,    34,     0,    44,    44,     0,     0,     0,     0,    16,
-    19,    18,     0,    19,    19,    19,    19,    20,    22,    35,
-    19,    22,    22,    22,    22,    72,    64,    36,    22,    64,
-    64,    64,    64,    81,    72,    53,    64,     4,     4,    54,
-     4,    56,    81,    60,     4,    30,    30,    62,    30,    67,
-    68,    71,    30,     3,     3,     3,     3,    23,    23,    23,
-    23,    74,    79,    80,    82,    83,    88,    89 ]
+    33,    33,    33,    33,    33,    33,    33,    36,     1,    51,
+    33,    51,    33,    33,    33,    33,    36,    36,    36,    36,
+    36,    36,    33,    63,    63,    63,    63,    63,    63,    63,
+    17,     2,    68,    63,     7,    63,    63,    63,    63,    14,
+    17,    68,    70,    71,    15,    63,    71,    71,    71,    71,
+    16,    70,    82,    71,    45,    71,    71,    71,    71,    45,
+     0,    82,    18,     0,     0,     0,     0,    20,    45,     4,
+     0,    32,     4,     4,    37,     4,    38,    19,    46,     4,
+    19,    19,    19,    19,    50,    22,    52,    19,    22,    22,
+    22,    22,    65,    30,    66,    22,    30,    30,    69,    30,
+    72,    54,    75,    30,    54,    54,    54,    54,    56,    56,
+    76,    54,     3,     3,     3,     3,    23,    23,    23,    23,
+    77,    80,    81,    83,    84,    92,    93 ]
 
 racc_action_pointer = [
-    40,     8,    -2,    79,    72,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    14,    19,    47,     5,    51,    48,
-    44,   nil,    56,    83,   nil,   nil,   nil,   nil,   nil,   nil,
-    80,   nil,   nil,   nil,    18,    49,    65,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    41,   nil,   nil,   nil,   nil,   nil,
-   nil,    -2,   nil,    66,    70,    -6,    70,   nil,   nil,   nil,
-    81,    27,    74,   nil,    64,   nil,   nil,    85,    86,   nil,
-     4,    89,    50,    18,    88,   nil,   nil,   nil,   nil,    98,
-    99,    58,   100,   101,   nil,   nil,   nil,   nil,   102,   103,
-   nil,   nil,   nil,   nil ]
+    58,     8,    18,    98,    67,   nil,   nil,    24,   nil,   nil,
+   nil,   nil,   nil,   nil,    37,    42,    48,    28,    62,    75,
+    54,   nil,    83,   102,   nil,   nil,   nil,   nil,   nil,   nil,
+    91,   nil,    61,    -2,   nil,   nil,    -2,    64,    74,   nil,
+   nil,   nil,   nil,   nil,   nil,    44,    67,   nil,   nil,   nil,
+    82,     7,    73,   nil,    99,   nil,   106,   nil,   nil,   nil,
+   nil,   nil,   nil,    21,   nil,    88,    90,   nil,    17,    96,
+    27,    41,    87,   nil,   nil,    93,   101,   109,   nil,   nil,
+   117,   118,    37,   119,   120,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   121,   122,   nil,   nil,   nil,   nil ]
 
 racc_action_default = [
-   -61,   -61,    -2,    -6,   -16,   -14,   -15,   -19,   -20,   -21,
-   -22,   -23,   -24,   -25,   -61,   -61,   -61,   -61,   -61,   -61,
-    -2,    -4,   -61,    -6,    -8,    -9,   -10,   -11,   -12,   -13,
-   -16,   -18,   -26,   -27,   -61,   -37,   -61,    94,    -1,    -3,
-    -5,    -7,   -17,   -28,   -61,   -31,   -32,   -33,   -34,   -35,
-   -36,   -61,   -39,   -61,   -61,   -19,   -61,   -40,   -41,   -42,
-   -54,   -61,   -56,   -59,   -61,   -29,   -30,   -61,   -61,   -38,
-   -45,   -61,   -53,   -61,   -56,   -58,   -60,   -46,   -47,   -61,
-   -61,   -50,   -61,   -61,   -55,   -57,   -43,   -44,   -61,   -61,
-   -51,   -52,   -48,   -49 ]
+   -62,   -62,    -2,    -6,   -16,   -14,   -15,   -19,   -20,   -21,
+   -22,   -23,   -24,   -25,   -62,   -62,   -62,   -62,   -62,   -62,
+    -2,    -4,   -62,    -6,    -8,    -9,   -10,   -11,   -12,   -13,
+   -16,   -18,   -62,   -62,   -26,   -27,   -62,   -37,   -62,    98,
+    -1,    -3,    -5,    -7,   -17,   -19,   -62,   -41,   -42,   -43,
+   -55,   -62,   -57,   -60,   -62,   -28,   -62,   -31,   -32,   -33,
+   -34,   -35,   -36,   -62,   -40,   -62,   -62,   -39,   -46,   -62,
+   -54,   -62,   -57,   -59,   -61,   -62,   -62,   -62,   -47,   -48,
+   -62,   -62,   -51,   -62,   -62,   -56,   -58,   -29,   -30,   -38,
+   -44,   -45,   -62,   -62,   -52,   -53,   -49,   -50 ]
 
 racc_goto_table = [
-     2,    30,    31,    64,    62,    21,    75,     1,    40,    24,
-    29,    44,    56,    58,    59,   nil,   nil,   nil,    85,    38,
-   nil,   nil,   nil,    39,   nil,    64,    84,    30,    42,    41,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     2,    46,    30,    31,    22,    24,    73,     1,    42,    21,
+    29,    56,    85,   nil,   nil,   nil,   nil,   nil,   nil,    40,
+   nil,   nil,   nil,   nil,    22,    43,    86,    41,    30,    44,
+   nil,    77,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    76 ]
+   nil,   nil,   nil,   nil,    74 ]
 
 racc_goto_check = [
-     2,    12,    13,     6,    23,     4,    25,     1,     5,     8,
-    10,    19,    20,    21,    22,   nil,   nil,   nil,    25,     2,
-   nil,   nil,   nil,     4,   nil,     6,    23,    12,    13,     8,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     2,    20,    12,    13,     6,     8,    25,     1,     5,     4,
+    10,    19,    23,   nil,   nil,   nil,   nil,   nil,   nil,     2,
+   nil,   nil,   nil,   nil,     6,     8,    25,     4,    12,    13,
+   nil,    20,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,     2 ]
 
 racc_goto_pointer = [
-   nil,     7,     0,   nil,     3,   -14,   -48,   nil,     6,   nil,
-     6,   nil,    -3,    -2,   nil,   nil,   nil,   nil,   nil,   -23,
-   -39,   -38,   -37,   -47,   nil,   -56 ]
+   nil,     7,     0,   nil,     7,   -14,     1,   nil,     2,   nil,
+     6,   nil,    -2,    -1,   nil,   nil,   nil,   nil,   nil,   -25,
+   -32,   nil,   nil,   -59,   nil,   -46 ]
 
 racc_goto_default = [
-   nil,   nil,    63,    20,   nil,     3,    22,    23,   nil,     4,
+   nil,   nil,    53,    20,   nil,     3,    54,    23,   nil,     4,
    nil,     5,     6,   nil,     9,    10,    11,    12,    13,   nil,
-   nil,   nil,   nil,   nil,    74,   nil ]
+   nil,    48,    49,    52,    72,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
@@ -882,32 +976,33 @@ racc_reduce_table = [
   1, 45, :_reduce_36,
   2, 43, :_reduce_37,
   5, 43, :_reduce_38,
-  3, 44, :_reduce_39,
-  1, 46, :_reduce_40,
+  4, 43, :_reduce_39,
+  3, 44, :_reduce_40,
   1, 46, :_reduce_41,
   1, 46, :_reduce_42,
-  4, 47, :_reduce_43,
+  1, 46, :_reduce_43,
   4, 47, :_reduce_44,
-  2, 47, :_reduce_45,
-  3, 47, :_reduce_46,
+  4, 47, :_reduce_45,
+  2, 47, :_reduce_46,
   3, 47, :_reduce_47,
-  5, 47, :_reduce_48,
+  3, 47, :_reduce_48,
   5, 47, :_reduce_49,
-  3, 47, :_reduce_50,
-  4, 47, :_reduce_51,
+  5, 47, :_reduce_50,
+  3, 47, :_reduce_51,
   4, 47, :_reduce_52,
-  2, 47, :_reduce_53,
-  1, 47, :_reduce_54,
-  2, 50, :_reduce_55,
-  0, 51, :_reduce_56,
-  2, 51, :_reduce_57,
-  2, 48, :_reduce_58,
-  1, 49, :_reduce_59,
-  2, 49, :_reduce_60 ]
+  4, 47, :_reduce_53,
+  2, 47, :_reduce_54,
+  1, 47, :_reduce_55,
+  2, 50, :_reduce_56,
+  0, 51, :_reduce_57,
+  2, 51, :_reduce_58,
+  2, 48, :_reduce_59,
+  1, 49, :_reduce_60,
+  2, 49, :_reduce_61 ]
 
-racc_reduce_n = 61
+racc_reduce_n = 62
 
-racc_shift_n = 94
+racc_shift_n = 98
 
 racc_token_table = {
   false => 0,
@@ -1165,7 +1260,7 @@ module_eval(<<'.,.,', 'parser.y', 79)
 
 module_eval(<<'.,.,', 'parser.y', 84)
   def _reduce_19(val, _values, result)
-     result = Node.new(:type_selector, val[0], @current_position)
+     result = Node.new(:type_selector, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
     result
   end
 .,.,
@@ -1214,21 +1309,21 @@ module_eval(<<'.,.,', 'parser.y', 99)
 
 module_eval(<<'.,.,', 'parser.y', 104)
   def _reduce_26(val, _values, result)
-     result = Node.new(:id_selector, val[1], @current_position)
+     result = Node.new(:id_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 109)
   def _reduce_27(val, _values, result)
-     result = Node.new(:class_selector, val[1], @current_position)
+     result = Node.new(:class_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 114)
   def _reduce_28(val, _values, result)
-     result = Node.new(:attribute_selector, val[1], @current_position)
+     result = Node.new(:attribute_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
@@ -1236,7 +1331,7 @@ module_eval(<<'.,.,', 'parser.y', 114)
 module_eval(<<'.,.,', 'parser.y', 117)
   def _reduce_29(val, _values, result)
             result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @current_position))
+        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
         result.add_child(val[2])
         result.add_child(Node.new(:value, val[3], @current_position))
 
@@ -1247,9 +1342,9 @@ module_eval(<<'.,.,', 'parser.y', 117)
 module_eval(<<'.,.,', 'parser.y', 124)
   def _reduce_30(val, _values, result)
             result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @current_position))
+        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
         result.add_child(val[2])
-        result.add_child(Node.new(:value, val[3], @current_position))
+        result.add_child(Node.new(:value, identifier_value(val[3]), @current_position, raw_value: identifier_raw(val[3])))
 
     result
   end
@@ -1299,14 +1394,14 @@ module_eval(<<'.,.,', 'parser.y', 143)
 
 module_eval(<<'.,.,', 'parser.y', 148)
   def _reduce_37(val, _values, result)
-     result = Node.new(:pseudo_class, val[1], @current_position)
+     result = Node.new(:pseudo_class, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 151)
   def _reduce_38(val, _values, result)
-            fn = Node.new(:pseudo_function, val[1], @current_position)
+            fn = Node.new(:pseudo_function, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
         fn.add_child(val[3])
         result = fn
 
@@ -1314,36 +1409,46 @@ module_eval(<<'.,.,', 'parser.y', 151)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 159)
+module_eval(<<'.,.,', 'parser.y', 157)
   def _reduce_39(val, _values, result)
-     result = Node.new(:pseudo_element, val[2], @current_position)
+            fn = Node.new(:pseudo_function, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
+        fn.add_child(val[2])
+        result = fn
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 164)
+module_eval(<<'.,.,', 'parser.y', 165)
   def _reduce_40(val, _values, result)
-     result = Node.new(:argument, val[0], @current_position)
+     result = Node.new(:pseudo_element, identifier_value(val[2]), @current_position, raw_value: identifier_raw(val[2]))
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 166)
+module_eval(<<'.,.,', 'parser.y', 170)
   def _reduce_41(val, _values, result)
-     result = val[0]
+     result = Node.new(:argument, val[0], @current_position)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 168)
+module_eval(<<'.,.,', 'parser.y', 172)
   def _reduce_42(val, _values, result)
      result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 175)
+module_eval(<<'.,.,', 'parser.y', 174)
   def _reduce_43(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 181)
+  def _reduce_44(val, _values, result)
             # Handle 'An+B' like '2n+1'
         result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}+#{val[3]}", @current_position)
 
@@ -1351,8 +1456,8 @@ module_eval(<<'.,.,', 'parser.y', 175)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 180)
-  def _reduce_44(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 186)
+  def _reduce_45(val, _values, result)
             # Handle 'An-B' like '2n-1'
         result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}-#{val[3]}", @current_position)
 
@@ -1360,8 +1465,8 @@ module_eval(<<'.,.,', 'parser.y', 180)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 185)
-  def _reduce_45(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 191)
+  def _reduce_46(val, _values, result)
             # Handle 'An' like '2n' or composite like '2n-1' (when '-1' is part of IDENT)
         result = Node.new(:an_plus_b, "#{val[0]}#{val[1]}", @current_position)
 
@@ -1369,8 +1474,8 @@ module_eval(<<'.,.,', 'parser.y', 185)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 190)
-  def _reduce_46(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 196)
+  def _reduce_47(val, _values, result)
             # Handle 'n+B' like 'n+5' or keywords followed by offset (rare but valid)
         result = Node.new(:an_plus_b, "#{val[0]}+#{val[2]}", @current_position)
 
@@ -1378,8 +1483,8 @@ module_eval(<<'.,.,', 'parser.y', 190)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 195)
-  def _reduce_47(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 201)
+  def _reduce_48(val, _values, result)
             # Handle 'n-B' like 'n-3'
         result = Node.new(:an_plus_b, "#{val[0]}-#{val[2]}", @current_position)
 
@@ -1387,8 +1492,8 @@ module_eval(<<'.,.,', 'parser.y', 195)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 201)
-  def _reduce_48(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 207)
+  def _reduce_49(val, _values, result)
             # Handle '-An+B' like '-2n+1'
         result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}+#{val[4]}", @current_position)
 
@@ -1396,8 +1501,8 @@ module_eval(<<'.,.,', 'parser.y', 201)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 206)
-  def _reduce_49(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 212)
+  def _reduce_50(val, _values, result)
             # Handle '-An-B' like '-2n-1'
         result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}-#{val[4]}", @current_position)
 
@@ -1405,8 +1510,8 @@ module_eval(<<'.,.,', 'parser.y', 206)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 211)
-  def _reduce_50(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 217)
+  def _reduce_51(val, _values, result)
             # Handle '-An' like '-2n' or composite like '-2n+1' (when '+1' is part of IDENT)
         result = Node.new(:an_plus_b, "-#{val[1]}#{val[2]}", @current_position)
 
@@ -1414,8 +1519,8 @@ module_eval(<<'.,.,', 'parser.y', 211)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 216)
-  def _reduce_51(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 222)
+  def _reduce_52(val, _values, result)
             # Handle '-n+B' like '-n+3'
         result = Node.new(:an_plus_b, "-#{val[1]}+#{val[3]}", @current_position)
 
@@ -1423,8 +1528,8 @@ module_eval(<<'.,.,', 'parser.y', 216)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 221)
-  def _reduce_52(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 227)
+  def _reduce_53(val, _values, result)
             # Handle '-n-B' like '-n-2'
         result = Node.new(:an_plus_b, "-#{val[1]}-#{val[3]}", @current_position)
 
@@ -1432,8 +1537,8 @@ module_eval(<<'.,.,', 'parser.y', 221)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 226)
-  def _reduce_53(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 232)
+  def _reduce_54(val, _values, result)
             # Handle '-n' or composite like '-n+3' (when '+3' is part of IDENT)
         result = Node.new(:an_plus_b, "-#{val[1]}", @current_position)
 
@@ -1441,8 +1546,8 @@ module_eval(<<'.,.,', 'parser.y', 226)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 232)
-  def _reduce_54(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 238)
+  def _reduce_55(val, _values, result)
             # Handle just a number like '3'
         result = Node.new(:an_plus_b, val[0].to_s, @current_position)
 
@@ -1450,29 +1555,29 @@ module_eval(<<'.,.,', 'parser.y', 232)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_55(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_56(val, _values, result)
     result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_56(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_57(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 245)
-  def _reduce_57(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_58(val, _values, result)
     result = val[1] ? val[1].unshift(val[0]) : val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 240)
-  def _reduce_58(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 246)
+  def _reduce_59(val, _values, result)
             result = Node.new(:selector_list, nil, @current_position)
         result.add_child(val[0])
         val[1].each { |pair| result.add_child(pair[1]) }
@@ -1481,15 +1586,15 @@ module_eval(<<'.,.,', 'parser.y', 240)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 248)
-  def _reduce_59(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 254)
+  def _reduce_60(val, _values, result)
      result = val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 251)
-  def _reduce_60(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 257)
+  def _reduce_61(val, _values, result)
             result = Node.new(:selector, nil, val[0].position)
         result.add_child(val[0])
         result.add_child(val[1])

data/lib/parselly/version.rb

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

data/lib/parselly.rb

@@ -8,6 +8,21 @@ require_relative 'parselly/parser'
 require_relative 'parselly/version'
 
 module Parselly
+  ParseResult = Struct.new(:ast, :errors)
+
+  class ParseError < StandardError
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+      super(error[:message])
+    end
+  end
+
+  def parse(selector, tolerant: false)
+    Parser.new.parse(selector, tolerant: tolerant)
+  end
+
   def sanitize(selector)
     scanner = StringScanner.new(selector)
     result = +''
@@ -46,5 +61,5 @@ module Parselly
     "\\#{char.ord.to_s(16)} "
   end
 
-  module_function :sanitize, :escaped_hex
+  module_function :parse, :sanitize, :escaped_hex
 end

data/parser.y

@@ -82,7 +82,7 @@ rule
 
   type_selector
     : IDENT
-      { result = Node.new(:type_selector, val[0], @current_position) }
+      { result = Node.new(:type_selector, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0])) }
     | STAR
       { result = Node.new(:universal_selector, '*', @current_position) }
     ;
@@ -102,30 +102,30 @@ rule
 
   id_selector
     : HASH IDENT
-      { result = Node.new(:id_selector, val[1], @current_position) }
+      { result = Node.new(:id_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])) }
     ;
 
   class_selector
     : DOT IDENT
-      { result = Node.new(:class_selector, val[1], @current_position) }
+      { result = Node.new(:class_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])) }
     ;
 
   attribute_selector
     : LBRACKET IDENT RBRACKET
-      { result = Node.new(:attribute_selector, val[1], @current_position) }
+      { result = Node.new(:attribute_selector, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])) }
     | LBRACKET IDENT attr_matcher STRING RBRACKET
       {
         result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @current_position))
+        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
         result.add_child(val[2])
         result.add_child(Node.new(:value, val[3], @current_position))
       }
     | LBRACKET IDENT attr_matcher IDENT RBRACKET
       {
         result = Node.new(:attribute_selector, nil, @current_position)
-        result.add_child(Node.new(:attribute, val[1], @current_position))
+        result.add_child(Node.new(:attribute, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])))
         result.add_child(val[2])
-        result.add_child(Node.new(:value, val[3], @current_position))
+        result.add_child(Node.new(:value, identifier_value(val[3]), @current_position, raw_value: identifier_raw(val[3])))
       }
     ;
 
@@ -146,18 +146,24 @@ rule
 
   pseudo_class_selector
     : COLON IDENT
-      { result = Node.new(:pseudo_class, val[1], @current_position) }
+      { result = Node.new(:pseudo_class, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1])) }
     | COLON IDENT LPAREN any_value RPAREN
       {
-        fn = Node.new(:pseudo_function, val[1], @current_position)
+        fn = Node.new(:pseudo_function, identifier_value(val[1]), @current_position, raw_value: identifier_raw(val[1]))
         fn.add_child(val[3])
         result = fn
       }
+    | IDENT LPAREN any_value RPAREN
+      {
+        fn = Node.new(:pseudo_function, identifier_value(val[0]), @current_position, raw_value: identifier_raw(val[0]))
+        fn.add_child(val[2])
+        result = fn
+      }
     ;
 
   pseudo_element_selector
     : COLON COLON IDENT
-      { result = Node.new(:pseudo_element, val[2], @current_position) }
+      { result = Node.new(:pseudo_element, identifier_value(val[2]), @current_position, raw_value: identifier_raw(val[2])) }
     ;
 
   any_value
@@ -265,21 +271,99 @@ 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
+SUBCLASS_SELECTOR_END_TYPES = Set[:IDENT, :RBRACKET, :RPAREN].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)
+def parse(input, tolerant: false)
+  @tolerant = tolerant
+  @errors = []
+  @error_index = nil
+  @suppress_errors = false
   @lexer = Parselly::Lexer.new(input)
-  @tokens = @lexer.tokenize
+  begin
+    @tokens = @lexer.tokenize
+  rescue RuntimeError => e
+    if tolerant
+      @errors << parse_error_from_exception(e)
+      return Parselly::ParseResult.new(nil, @errors)
+    end
+    raise
+  end
   preprocess_tokens!
   @index = 0
-  @current_position = { line: 1, column: 1 }
+  @current_position = { line: 1, column: 1, offset: 0 }
+
+  if tolerant
+    ast = parse_with_recovery
+    normalize_an_plus_b(ast) if ast
+    return Parselly::ParseResult.new(ast, @errors)
+  end
+
   ast = do_parse
   normalize_an_plus_b(ast)
   ast
 end
 
+def parse_with_recovery
+  do_parse
+rescue Parselly::ParseError, RuntimeError
+  parse_partial_ast
+end
+
+def parse_partial_ast
+  return nil unless @tokens && !@tokens.empty?
+
+  eof_token = @tokens.last if @tokens.last && @tokens.last[0] == false
+  tokens = @tokens.dup
+  tokens.pop if eof_token
+  limit = @error_index || tokens.length
+
+  while limit > 0
+    truncated = tokens[0...limit]
+    truncated << eof_token if eof_token
+    begin
+      return parse_from_tokens(truncated, suppress_errors: true)
+    rescue Parselly::ParseError, RuntimeError
+      limit -= 1
+    end
+  end
+  nil
+end
+
+def parse_from_tokens(tokens, suppress_errors: false)
+  @tokens = tokens
+  @index = 0
+  @current_position = { line: 1, column: 1, offset: 0 }
+  @suppress_errors = suppress_errors
+  do_parse
+ensure
+  @suppress_errors = false
+end
+
+def parse_error_from_exception(error)
+  line = nil
+  column = nil
+  offset = nil
+  if error.message =~ /at (\d+):(\d+)/
+    line = Regexp.last_match(1).to_i
+    column = Regexp.last_match(2).to_i
+  end
+  if error.message =~ /offset (\d+)/
+    offset = Regexp.last_match(1).to_i
+  end
+  { message: error.message, line: line, column: column, offset: offset }
+end
+
+def identifier_value(token)
+  token.respond_to?(:value) ? token.value : token
+end
+
+def identifier_raw(token)
+  token.respond_to?(:raw) ? token.raw : token
+end
+
 def preprocess_tokens!
   return if @tokens.size <= 1
 
@@ -294,7 +378,7 @@ def preprocess_tokens!
     if i < last_idx
       next_token = @tokens[i + 1]
       if needs_descendant?(token, next_token)
-        pos = { line: token[2][:line], column: token[2][:column] }
+        pos = { line: token[2][:line], column: token[2][:column], offset: token[2][:offset] }
         new_tokens[new_tokens_idx] = [:DESCENDANT, ' ', pos]
         new_tokens_idx += 1
       end
@@ -314,8 +398,11 @@ def needs_descendant?(current, next_tok)
   next_type = next_tok[0]
 
   # Type selector followed by subclass selector = same compound
-  return false if TYPE_SELECTOR_TYPES.include?(current_type) &&
-                  SUBCLASS_SELECTOR_TYPES.include?(next_type)
+  # Subclass selector followed by subclass selector = same compound
+  if SUBCLASS_SELECTOR_TYPES.include?(next_type)
+    return false if TYPE_SELECTOR_TYPES.include?(current_type) ||
+                    SUBCLASS_SELECTOR_END_TYPES.include?(current_type)
+  end
 
   CAN_END_COMPOUND.include?(current_type) && CAN_START_COMPOUND.include?(next_type)
 end
@@ -361,5 +448,16 @@ end
 def on_error(token_id, val, vstack)
   token_name = token_to_str(token_id) || '?'
   pos = @current_position || { line: '?', column: '?' }
-  raise "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[:column]}"
+  error = {
+    message: "Parse error: unexpected #{token_name} '#{val}' at #{pos[:line]}:#{pos[:column]}",
+    line: pos[:line],
+    column: pos[:column],
+    offset: pos[:offset]
+  }
+  if @tolerant
+    @errors << error unless @suppress_errors
+    @error_index ||= [@index - 1, 0].max
+    raise Parselly::ParseError, error
+  end
+  raise error[:message]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parselly
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -51,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.4
 specification_version: 4
 summary: Pure Ruby CSS selector parser.
 test_files: []