node_query 1.6.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 474136c42ade45282559b6e9700faffacdec002f75d8033f00d05639034a3245
-  data.tar.gz: 1be2a9b18e54c36605468ce8ca5e9ad78c05c698b6f9994c0d6ea18f2270e25c
+  metadata.gz: 3638d51ca40eb891535cc2320377e3492023439946460a1c0a81af02f211c3ce
+  data.tar.gz: 4919be334676677f9ad144db4358be354ca81f8244294e3ea1fbf07d6d0a9845
 SHA512:
-  metadata.gz: a0d40e1da75eb1a235398b5cddeae0e2378bbb2c92c03f8d7a9e5680b8a2512fa9f8230b713b70d3cc164497451157998520ee5d62e5637cef07e023a6033efb
-  data.tar.gz: e587ebfd379a4ff909583109ba42d16c572aeaab69bf2303efa5bd92325750c8cddb3a20dd8712e668233691a1cb3eba25250fbbdb936651fd15a9722514a12d
+  metadata.gz: af54774545d5b284e3d6bd1977094f108553526fc9613ceebe0c96e46be9ac26c5c66db2e4301cef483cf66e4c02f04f19e1e8180e8025d360e5c2b0437c2efa
+  data.tar.gz: ca74ee091e6ec5d603ce4efaed4927e4d08a123563f95f7e09807e7c8433447ef53390ba727f7500037d60fc74ea5fb1601dfeba52e2cc569e54bd25eea14fc9

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 1.8.0 (2022-10-14)
+
+* Support `:first-child` and `:last-child`
+
+## 1.7.0 (2022-10-01)
+
+* Better regexp to match evaluated value
+* Make `base_node` as the root matching node
+
 ## 1.6.1 (2022-09-28)
 
 * Do not handle `erange` and `irange` in `actual_value`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_query (1.6.1)
+    node_query (1.8.0)
       activesupport (< 7.0.0)
 
 GEM
@@ -78,7 +78,7 @@ GEM
     thor (1.2.1)
     tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.6.0)
+    zeitwerk (2.6.1)
 
 PLATFORMS
   x86_64-darwin-21

data/README.md

@@ -1,7 +1,6 @@
 # NodeQuery
 
-NodeQuery defines an AST node query language, which is a css like syntax for matching nodes,
-it supports other ast parser if it implements `NodeQuery::Adapter`.
+NodeQuery defines a NQL (node query language) and node rules to query AST nodes.
 
 ## Table of Contents
 
@@ -25,7 +24,8 @@ it supports other ast parser if it implements `NodeQuery::Adapter`.
       - [Adjacent sibling combinator](#adjacent-sibling-combinator)
       - [General sibling combinator](#general-sibling-combinator)
     - [nql matches goto scope](#nql-matches-goto-scope)
-    - [nql matches pseudo selector](#nql-matches-pseudo-selector)
+    - [nql matches :has and :not_has pseudo selector](#nql-matches-has-and-not_has-pseudo-selector)
+    - [nql matches :first-child and :last-child pseudo selector](#nql-matches-first-child-and-last-child-pseudo-selector)
     - [nql matches multiple expressions](#nql-matches-multiple-expressions)
   - [Node Rules](#node-rules)
     - [rules matches node type](#rules-matches-node-type)
@@ -61,7 +61,7 @@ Or install it yourself as:
 It provides two apis: `query_nodes` and `match_node?`
 
 ```ruby
-node_query = NodeQuery.new(nqlOrRules: String | Hash) # Initialize NodeQuery
+node_query = NodeQuery.new(nql_or_rules: String | Hash) # Initialize NodeQuery
 node_query.query_nodes(node: Node, options = { including_self: true, stop_at_first_match: false, recursive: true }): Node[] # Get the matching nodes.
 node_query.match_node?(node: Node): boolean # Check if the node matches nql or rules.
 ```
@@ -286,7 +286,7 @@ It matches send node only if it is follows the send node whose left value is @id
 
 It matches send node who is in the body of def node.
 
-### nql matches pseudo selector
+### nql matches :has and :not_has pseudo selector
 
 ```
 .class:has(.def[name=initialize])
@@ -300,6 +300,20 @@ It matches class node who has an initialize def node.
 
 It matches class node who does not have an initialize def node.
 
+### nql matches :first-child and :last-child pseudo selector
+
+```
+.def:first-child
+```
+
+It matches the first def node.
+
+```
+.def:last-child
+```
+
+It matches the last def node.
+
 ### nql matches multiple expressions
 
 ```

data/lib/node_query/compiler/array_value.rb

@@ -15,10 +15,10 @@ module NodeQuery::Compiler
 
     # Get the expected value.
     # @return [Array]
-    def expected_value
+    def expected_value(base_node)
       expected = []
       expected.push(@value) if @value
-      expected += @rest.expected_value if @rest
+      expected += @rest.expected_value(base_node) if @rest
       expected
     end
 

data/lib/node_query/compiler/attribute.rb

@@ -15,10 +15,10 @@ module NodeQuery::Compiler
 
     # Check if the node matches the attribute.
     # @param node [Node] the node
+    # @param base_node [Node] the bae node for evaluated value
     # @return [Boolean]
-    def match?(node)
-      @value.base_node = node if @value.is_a?(String)
-      node && @value.match?(NodeQuery::Helper.get_target_node(node, @key), @operator)
+    def match?(node, base_node)
+      node && @value.match?(NodeQuery::Helper.get_target_node(node, @key), base_node, @operator)
     end
 
     def to_s

data/lib/node_query/compiler/attribute_list.rb

@@ -13,9 +13,10 @@ module NodeQuery::Compiler
 
     # Check if the node matches the attribute list.
     # @param node [Node] the node
+    # @param base_node [Node] the base node for evaluated value
     # @return [Boolean]
-    def match?(node)
-      @attribute.match?(node) && (!@rest || @rest.match?(node))
+    def match?(node, base_node)
+      @attribute.match?(node, base_node) && (!@rest || @rest.match?(node, base_node))
     end
 
     def to_s

data/lib/node_query/compiler/basic_selector.rb

@@ -13,11 +13,12 @@ module NodeQuery::Compiler
 
     # Check if node matches the selector.
     # @param node [Node] the node
+    # @param base_node [Node] the base node for evaluated value
     # @return [Boolean]
-    def match?(node, _operator = '==')
+    def match?(node, base_node, _operator = '==')
       return false unless node
 
-      @node_type.to_sym == NodeQuery.adapter.get_node_type(node) && (!@attribute_list || @attribute_list.match?(node))
+      @node_type.to_sym == NodeQuery.adapter.get_node_type(node) && (!@attribute_list || @attribute_list.match?(node, base_node))
     end
 
     def to_s

data/lib/node_query/compiler/comparable.rb

@@ -12,69 +12,71 @@ module NodeQuery::Compiler
     # Check if the actual value matches the expected value.
     #
     # @param node [Node] node to calculate actual value
+    # @param base_node [Node] the base node for evaluated value
     # @param operator [String] operator to compare with expected value, operator can be <code>'=='</code>, <code>'!='</code>, <code>'>'</code>, <code>'>='</code>, <code>'<'</code>, <code>'<='</code>, <code>'includes'</code>, <code>'in'</code>, <code>'not_in'</code>, <code>'=~'</code>, <code>'!~'</code>
     # @return [Boolean] true if actual value matches the expected value
     # @raise [NodeQuery::Compiler::InvalidOperatorError] if operator is invalid
-    def match?(node, operator)
+    def match?(node, base_node, operator)
       raise InvalidOperatorError, "invalid operator #{operator}" unless valid_operator?(operator)
 
+      actual = actual_value(node)
+      expected = expected_value(base_node)
       case operator
       when '!='
-        if expected_value.is_a?(::Array)
-          actual = actual_value(node)
-          !actual.is_a?(::Array) || actual.size != expected_value.size ||
-            actual.zip(expected_value).any? { |actual_node, expected_node| expected_node.match?(actual_node, '!=') }
+        if expected.is_a?(::Array)
+          !actual.is_a?(::Array) || actual.size != expected.size ||
+            actual.zip(expected).any? { |actual_child, expected_child| expected_child.match?(actual_child, base_node, '!=') }
         else
-          !is_equal?(node)
+          !is_equal?(actual, expected)
         end
       when '=~'
-        actual_value(node) =~ expected_value
+        actual =~ expected
       when '!~'
-        actual_value(node) !~ expected_value
+        actual !~ expected
       when '^='
-        actual_value(node).start_with?(expected_value)
+        actual.start_with?(expected)
       when '$='
-        actual_value(node).end_with?(expected_value)
+        actual.end_with?(expected)
       when '*='
-        actual_value(node).include?(expected_value)
+        actual.include?(expected)
       when '>'
-        actual_value(node) > expected_value
+        actual > expected
       when '>='
-        actual_value(node) >= expected_value
+        actual >= expected
       when '<'
-        actual_value(node) < expected_value
+        actual < expected
       when '<='
-        actual_value(node) <= expected_value
+        actual <= expected
       when 'in'
         if node.is_a?(Array)
-          node.all? { |child| expected_value.any? { |expected| expected.match?(child, '==') } }
+          node.all? { |child| expected.any? { |expected_child| expected_child.match?(child, base_node, '==') } }
         else
-          expected_value.any? { |expected| expected.match?(node, '==') }
+          expected.any? { |expected_child| expected_child.match?(node, base_node, '==') }
         end
       when 'not_in'
         if node.is_a?(Array)
-          node.all? { |child| expected_value.all? { |expected| expected.match?(child, '!=') } }
+          node.all? { |child| expected.all? { |expected_child| expected_child.match?(child, base_node, '!=') } }
         else
-          expected_value.all? { |expected| expected.match?(node, '!=') }
+          expected.all? { |expected_child| expected_child.match?(node, base_node, '!=') }
         end
       when 'includes'
-        actual_value(node).any? { |actual| actual == expected_value }
+        actual.any? { |actual_child| actual_child == expected }
       else
-        if expected_value.is_a?(::Array)
-          actual = actual_value(node)
-          actual.is_a?(::Array) && actual.size == expected_value.size &&
-            actual.zip(expected_value).all? { |actual_node, expected_node| expected_node.match?(actual_node, '==') }
+        if expected.is_a?(::Array)
+          actual.is_a?(::Array) && actual.size == expected.size &&
+            actual.zip(expected).all? { |actual_child, expected_child| expected_child.match?(actual_child, base_node, '==') }
         else
-          is_equal?(node)
+          is_equal?(actual, expected)
         end
       end
     end
 
-    # Check if the actual value equals the node value.
-    # @param node [Node] the node
-    # @return [Boolean] true if the actual value equals the node value.
-    def is_equal?(node)
-      actual_value(node) == expected_value
+    # Check if the actual value equals the expected value.
+    # @param acutal
+    # @param expected
+    # @return [Boolean] true if the actual value equals the expected value.
+    def is_equal?(actual, expected)
+      actual == expected
     end
 
     # Get the actual value from ast node.
@@ -104,8 +106,9 @@ module NodeQuery::Compiler
     end
 
     # Get the expected value
+    # @param base_node [Node] the base node for evaluated value
     # @return expected value, could be integer, float, string, boolean, nil, range, and etc.
-    def expected_value
+    def expected_value(base_node)
       @value
     end
 

data/lib/node_query/compiler/regexp.rb

@@ -13,9 +13,10 @@ module NodeQuery::Compiler
 
     # Check if the regexp value matches the node value.
     # @param node [Node] the node
+    # @param _base_node [Node] the base node for evaluated value
     # @param operator [String] the operator
     # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
-    def match?(node, operator = '=~')
+    def match?(node, _base_node, operator = '=~')
       match =
         if NodeQuery.adapter.is_node?(node)
           @value.match(NodeQuery.adapter.get_source(node))

data/lib/node_query/compiler/selector.rb

@@ -8,22 +8,25 @@ module NodeQuery::Compiler
     # @param relationship [String] the relationship between the selectors, it can be descendant <code>nil</code>, child <code>></code>, next sibling <code>+</code> or subsequent sibing <code>~</code>.
     # @param rest [NodeQuery::Compiler::Selector] the rest selector
     # @param basic_selector [NodeQuery::Compiler::BasicSelector] the simple selector
+    # @param position [String] the position of the node
     # @param attribute_list [NodeQuery::Compiler::AttributeList] the attribute list
     # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
     # @param pseudo_selector [NodeQuery::Compiler::Expression] the pseudo selector
-    def initialize(goto_scope: nil, relationship: nil, rest: nil, basic_selector: nil, pseudo_class: nil, pseudo_selector: nil)
+    def initialize(goto_scope: nil, relationship: nil, rest: nil, basic_selector: nil, position: nil, pseudo_class: nil, pseudo_selector: nil)
       @goto_scope = goto_scope
       @relationship = relationship
       @rest = rest
       @basic_selector = basic_selector
+      @position = position
       @pseudo_class = pseudo_class
       @pseudo_selector = pseudo_selector
     end
 
     # Check if node matches the selector.
     # @param node [Parser::AST::Node] the node
-    def match?(node)
-      NodeQuery.adapter.is_node?(node) && (!@basic_selector || @basic_selector.match?(node)) && match_pseudo_class?(node)
+    # @param base_node [Parser::AST::Node] the base node for evaluated node
+    def match?(node, base_node)
+      NodeQuery.adapter.is_node?(node) && (!@basic_selector || @basic_selector.match?(node, base_node)) && match_pseudo_class?(node)
     end
 
     # Query nodes by the selector.
@@ -49,32 +52,32 @@ module NodeQuery::Compiler
       return find_nodes_by_goto_scope(node) if @goto_scope
 
       if options[:including_self] && !options[:recursive]
-        return match?(node) ? [node] : []
+        return match?(node, node) ? [node] : []
       end
 
       nodes = []
-      if options[:including_self] && match?(node)
+      if options[:including_self] && match?(node, node)
         nodes << node
         return nodes if options[:stop_at_first_match]
       end
       if @basic_selector
         if options[:recursive]
           NodeQuery::Helper.handle_recursive_child(node) do |child_node|
-            if match?(child_node)
+            if match?(child_node, child_node)
               nodes << child_node
               break if options[:stop_at_first_match]
             end
           end
         else
           NodeQuery.adapter.get_children(node).each do |child_node|
-            if match?(child_node)
+            if match?(child_node, child_node)
               nodes << child_node
               break if options[:stop_at_first_match]
             end
           end
         end
       end
-      nodes
+      filter_by_position(nodes)
     end
 
     def to_s
@@ -83,10 +86,29 @@ module NodeQuery::Compiler
       result << "#{@relationship} " if @relationship
       result << @rest.to_s if @rest
       result << @basic_selector.to_s if @basic_selector
+      result << ":#{@position}" if @position
       result << ":#{@pseudo_class}(#{@pseudo_selector})" if @pseudo_class
       result.join('')
     end
 
+    protected
+
+    # Filter nodes by position.
+    # @param nodes [Array<Node>] nodes to filter
+    # @return [Array<Node>|Node] first node or last node or nodes
+    def filter_by_position(nodes)
+      return nodes unless @position
+
+      case @position
+      when 'first-child'
+        [nodes.first]
+      when 'last-child'
+        [nodes.last]
+      else
+        nodes
+      end
+    end
+
     private
 
     # Find nodes by @goto_scope
@@ -106,28 +128,28 @@ module NodeQuery::Compiler
       when '>'
         if node.is_a?(::Array)
           node.each do |child_node|
-            nodes << child_node if @rest.match?(child_node)
+            nodes << child_node if @rest.match?(child_node, child_node)
           end
         else
           node.children.each do |child_node|
             if NodeQuery.adapter.is_node?(child_node) && :begin == NodeQuery.adapter.get_node_type(child_node)
               child_node.children.each do |child_child_node|
-                nodes << child_child_node if @rest.match?(child_child_node)
+                nodes << child_child_node if @rest.match?(child_child_node, child_child_node)
               end
-            elsif @rest.match?(child_node)
+            elsif @rest.match?(child_node, child_node)
               nodes << child_node
             end
           end
         end
       when '+'
         next_sibling = node.siblings.first
-        nodes << next_sibling if @rest.match?(next_sibling)
+        nodes << next_sibling if @rest.match?(next_sibling, next_sibling)
       when '~'
         node.siblings.each do |sibling_node|
-          nodes << sibling_node if @rest.match?(sibling_node)
+          nodes << sibling_node if @rest.match?(sibling_node, sibling_node)
         end
       end
-      nodes
+      @rest.filter_by_position(nodes)
     end
 
     # Check if it matches pseudo class.

data/lib/node_query/compiler/string.rb

@@ -5,8 +5,6 @@ module NodeQuery::Compiler
   class String
     include Comparable
 
-    attr_accessor :base_node
-
     # Initialize a String.
     # @param value [String] the string value
     def initialize(value:)
@@ -18,16 +16,18 @@ module NodeQuery::Compiler
     #     if the source code of the node is @id = id,
     #     and the @value is "@{{right_vaue}}",
     #     then it returns "@id".
+    # @param base_node [Node] the base node for evaluated value
     # @return [String] the expected string, if it contains evaluated value, evaluate the node value.
-    def expected_value
+    def expected_value(base_node)
       NodeQuery::Helper.evaluate_node_value(base_node, @value)
     end
 
     # Check if the actual value equals the node value.
     # @param node [Node] the node
+    # @param base_node [Node] the base node for evaluated value
     # @return [Boolean] true if the actual value equals the node value.
-    def is_equal?(node)
-      NodeQuery::Helper.to_string(actual_value(node)) == expected_value
+    def is_equal?(actual, expected)
+      NodeQuery::Helper.to_string(actual) == expected
     end
 
     # Get valid operators.

data/lib/node_query/helper.rb

@@ -48,7 +48,7 @@ class NodeQuery::Helper
     # @param str [String] string to be evaluated
     # @return [String] evaluated string
     def evaluate_node_value(node, str)
-      str.scan(/{{(.*?)}}/).each do |match_data|
+      str.scan(/{{(.+?)}}/).each do |match_data|
         target_node = NodeQuery::Helper.get_target_node(node, match_data.first)
         str = str.sub("{{#{match_data.first}}}", to_string(target_node))
       end

data/lib/node_query/node_rules.rb

@@ -144,8 +144,8 @@ class NodeQuery::NodeRules
   # Convert a hash to flat one.
   #
   # @example
-  #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
-  #     # {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
+  #   flat_hash(node_type: 'block', caller: { node_type: 'send', receiver: 'RSpec' })
+  #     # {[:node_type] => 'block', [:caller, :node_type] => 'send', [:caller, :receiver] => 'RSpec'}
   # @param h [Hash] original hash.
   # @return flatten hash.
   def flat_hash(h, k = [])
@@ -190,4 +190,4 @@ class NodeQuery::NodeRules
       string
     end
   end
-end
+end

data/lib/node_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class NodeQuery
-  VERSION = "1.6.1"
+  VERSION = "1.8.0"
 end

data/lib/node_query.rb

@@ -27,12 +27,12 @@ class NodeQuery
   end
 
   # Initialize a NodeQuery.
-  # @param nqlOrRules [String | Hash] node query language or node rules
-  def initialize(nqlOrRules)
-    if nqlOrRules.is_a?(String)
-      @expression = NodeQueryParser.new.parse(nqlOrRules)
+  # @param nql_or_ruls [String | Hash] node query language or node rules
+  def initialize(nql_or_ruls)
+    if nql_or_ruls.is_a?(String)
+      @expression = NodeQueryParser.new.parse(nql_or_ruls)
     else
-      @rules = NodeRules.new(nqlOrRules)
+      @rules = NodeRules.new(nql_or_ruls)
     end
   end
 

data/lib/node_query_lexer.rex

@@ -26,6 +26,8 @@ rules
 # [:state]          pattern                       [actions]
                     /\s+/
                     /,/                           { [:tCOMMA, text] }
+                    /:first-child/                { [:tPOSITION, text[1..-1]] }
+                    /:last-child/                 { [:tPOSITION, text[1..-1]] }
                     /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
                     /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
                     /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }

data/lib/node_query_lexer.rex.rb

@@ -125,6 +125,10 @@ class NodeQueryLexer
             # do nothing
           when text = ss.scan(/,/) then
             action { [:tCOMMA, text] }
+          when text = ss.scan(/:first-child/) then
+            action { [:tPOSITION, text[1..-1]] }
+          when text = ss.scan(/:last-child/) then
+            action { [:tPOSITION, text[1..-1]] }
           when text = ss.scan(/:has/) then
             action { [:tPSEUDO_CLASS, text[1..-1]] }
           when text = ss.scan(/:not_has/) then

data/lib/node_query_parser.racc.rb

@@ -22,85 +22,86 @@ class NodeQueryParser < Racc::Parser
 ##### State transition tables begin ###
 
 racc_action_table = [
-     8,     8,     7,     9,    10,    36,    12,     5,     6,    16,
-    27,    17,    21,    22,    23,    24,    29,    30,    31,    32,
-    33,    34,    35,     8,    16,     8,     7,    40,    36,   nil,
-     8,     5,     6,   nil,    37,    36,   nil,   nil,   nil,    29,
-    30,    31,    32,    33,    34,    35,    29,    30,    31,    32,
-    33,    34,    35,     8,     7,     8,     7,     8,     7,     5,
-     6,     5,     6,     5,     6,     8,     7,   nil,   nil,   nil,
-   nil,     5,     6 ]
+     8,     8,     7,     9,    10,    37,    12,     5,     6,    13,
+    28,    17,    18,    22,    23,    24,    25,    30,    31,    32,
+    33,    34,    35,    36,     8,    17,     8,     7,    41,    37,
+   nil,     8,     5,     6,   nil,    38,    37,   nil,   nil,   nil,
+   nil,    30,    31,    32,    33,    34,    35,    36,    30,    31,
+    32,    33,    34,    35,    36,     8,     7,     8,     7,     8,
+     7,     5,     6,     5,     6,     5,     6,     8,     7,   nil,
+   nil,   nil,   nil,     5,     6 ]
 
 racc_action_check = [
-    24,     0,     0,     1,     2,    24,     5,     0,     0,     8,
-    24,     9,    16,    19,    20,    21,    24,    24,    24,    24,
-    24,    24,    24,    27,    23,     3,     3,    38,    27,   nil,
-    39,     3,     3,   nil,    27,    39,   nil,   nil,   nil,    27,
-    27,    27,    27,    27,    27,    27,    39,    39,    39,    39,
-    39,    39,    39,     6,     6,     7,     7,    10,    10,     6,
-     6,     7,     7,    10,    10,    12,    12,   nil,   nil,   nil,
-   nil,    12,    12 ]
+    25,     0,     0,     1,     2,    25,     4,     0,     0,     5,
+    25,     8,     9,    17,    20,    21,    22,    25,    25,    25,
+    25,    25,    25,    25,    28,    24,     3,     3,    39,    28,
+   nil,    40,     3,     3,   nil,    28,    40,   nil,   nil,   nil,
+   nil,    28,    28,    28,    28,    28,    28,    28,    40,    40,
+    40,    40,    40,    40,    40,     6,     6,     7,     7,    10,
+    10,     6,     6,     7,     7,    10,    10,    13,    13,   nil,
+   nil,   nil,   nil,    13,    13 ]
 
 racc_action_pointer = [
-    -2,     3,     2,    22,   nil,    -9,    50,    52,    -2,    11,
-    54,   nil,    62,   nil,   nil,   nil,     6,   nil,   nil,    -3,
-     2,    -2,   nil,    13,    -3,   nil,   nil,    20,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    13,    27,
-   nil,   nil ]
+    -2,     3,     2,    23,   -11,    -6,    52,    54,     0,    12,
+    56,   nil,   nil,    64,   nil,   nil,   nil,     7,   nil,   nil,
+    -2,     3,    -2,   nil,    14,    -3,   nil,   nil,    21,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    14,
+    28,   nil,   nil ]
 
 racc_action_default = [
-   -27,   -27,    -2,    -4,    -5,   -27,   -27,   -27,    -9,   -27,
-   -27,    -3,   -27,    -7,    -8,   -10,   -27,    42,    -1,   -27,
-   -27,   -27,    -6,   -12,   -27,   -11,   -13,   -27,   -18,   -19,
-   -20,   -21,   -22,   -23,   -24,   -25,   -26,   -14,   -27,   -17,
-   -15,   -16 ]
+   -28,   -28,    -2,    -4,    -6,   -28,   -28,   -28,   -10,   -28,
+   -28,    -3,    -5,   -28,    -8,    -9,   -11,   -28,    43,    -1,
+   -28,   -28,   -28,    -7,   -13,   -28,   -12,   -14,   -28,   -19,
+   -20,   -21,   -22,   -23,   -24,   -25,   -26,   -27,   -15,   -28,
+   -18,   -16,   -17 ]
 
 racc_goto_table = [
-    28,    15,    38,    28,    13,    14,    11,     1,    20,    26,
-    19,   nil,   nil,   nil,    41,    28,    25,    18 ]
+    16,    39,    29,    11,     1,    29,    21,    27,    14,    15,
+   nil,   nil,   nil,    42,    19,    20,    26,    29 ]
 
 racc_goto_check = [
-     4,     5,     8,     4,     3,     3,     2,     1,     6,     7,
-     3,   nil,   nil,   nil,     8,     4,     5,     1 ]
+     5,     8,     4,     2,     1,     4,     6,     7,     3,     3,
+   nil,   nil,   nil,     8,     1,     3,     5,     4 ]
 
 racc_goto_pointer = [
-   nil,     7,     3,    -2,   -24,    -7,    -8,   -15,   -25 ]
+   nil,     4,     0,     2,   -23,    -8,   -11,   -18,   -27 ]
 
 racc_goto_default = [
-   nil,   nil,     2,     3,     4,   nil,   nil,    39,   nil ]
+   nil,   nil,     2,     3,     4,   nil,   nil,    40,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  3, 27, :_reduce_1,
-  1, 27, :_reduce_2,
-  2, 28, :_reduce_3,
-  1, 28, :_reduce_4,
-  1, 29, :_reduce_5,
-  4, 29, :_reduce_6,
-  2, 29, :_reduce_7,
-  2, 29, :_reduce_8,
-  1, 30, :_reduce_9,
-  2, 30, :_reduce_10,
-  4, 31, :_reduce_11,
-  3, 31, :_reduce_12,
+  3, 28, :_reduce_1,
+  1, 28, :_reduce_2,
+  2, 29, :_reduce_3,
+  1, 29, :_reduce_4,
+  2, 30, :_reduce_5,
+  1, 30, :_reduce_6,
+  4, 30, :_reduce_7,
+  2, 30, :_reduce_8,
+  2, 30, :_reduce_9,
+  1, 31, :_reduce_10,
+  2, 31, :_reduce_11,
+  4, 32, :_reduce_12,
   3, 32, :_reduce_13,
-  4, 32, :_reduce_14,
-  5, 32, :_reduce_15,
-  2, 34, :_reduce_16,
-  1, 34, :_reduce_17,
-  1, 33, :_reduce_none,
-  1, 33, :_reduce_19,
-  1, 33, :_reduce_20,
-  1, 33, :_reduce_21,
-  1, 33, :_reduce_22,
-  1, 33, :_reduce_23,
-  1, 33, :_reduce_24,
-  1, 33, :_reduce_25,
-  1, 33, :_reduce_26 ]
-
-racc_reduce_n = 27
-
-racc_shift_n = 42
+  3, 33, :_reduce_14,
+  4, 33, :_reduce_15,
+  5, 33, :_reduce_16,
+  2, 35, :_reduce_17,
+  1, 35, :_reduce_18,
+  1, 34, :_reduce_none,
+  1, 34, :_reduce_20,
+  1, 34, :_reduce_21,
+  1, 34, :_reduce_22,
+  1, 34, :_reduce_23,
+  1, 34, :_reduce_24,
+  1, 34, :_reduce_25,
+  1, 34, :_reduce_26,
+  1, 34, :_reduce_27 ]
+
+racc_reduce_n = 28
+
+racc_shift_n = 43
 
 racc_token_table = {
   false => 0,
@@ -120,17 +121,18 @@ racc_token_table = {
   :tCLOSE_ARRAY => 14,
   :tOPEN_SELECTOR => 15,
   :tCLOSE_SELECTOR => 16,
-  :tOPERATOR => 17,
-  :tARRAY_VALUE => 18,
-  :tBOOLEAN => 19,
-  :tFLOAT => 20,
-  :tINTEGER => 21,
-  :tNIL => 22,
-  :tREGEXP => 23,
-  :tSTRING => 24,
-  :tSYMBOL => 25 }
-
-racc_nt_base = 26
+  :tPOSITION => 17,
+  :tOPERATOR => 18,
+  :tARRAY_VALUE => 19,
+  :tBOOLEAN => 20,
+  :tFLOAT => 21,
+  :tINTEGER => 22,
+  :tNIL => 23,
+  :tREGEXP => 24,
+  :tSTRING => 25,
+  :tSYMBOL => 26 }
+
+racc_nt_base = 27
 
 racc_use_result_var = false
 
@@ -168,6 +170,7 @@ Racc_token_to_s_table = [
   "tCLOSE_ARRAY",
   "tOPEN_SELECTOR",
   "tCLOSE_SELECTOR",
+  "tPOSITION",
   "tOPERATOR",
   "tARRAY_VALUE",
   "tBOOLEAN",
@@ -210,88 +213,92 @@ def _reduce_4(val, _values)
 end
 
 def _reduce_5(val, _values)
- NodeQuery::Compiler::Selector.new(basic_selector: val[0])
+ NodeQuery::Compiler::Selector.new(basic_selector: val[0], position: val[1] )
 end
 
 def _reduce_6(val, _values)
- NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2])
+ NodeQuery::Compiler::Selector.new(basic_selector: val[0])
 end
 
 def _reduce_7(val, _values)
- NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1])
+ NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2])
 end
 
 def _reduce_8(val, _values)
- NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1])
+ NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1])
 end
 
 def _reduce_9(val, _values)
- NodeQuery::Compiler::BasicSelector.new(node_type: val[0])
+ NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1])
 end
 
 def _reduce_10(val, _values)
- NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1])
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0])
 end
 
 def _reduce_11(val, _values)
- NodeQuery::Compiler::AttributeList.new(attribute: val[1], rest: val[3])
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1])
 end
 
 def _reduce_12(val, _values)
- NodeQuery::Compiler::AttributeList.new(attribute: val[1])
+ NodeQuery::Compiler::AttributeList.new(attribute: val[1], rest: val[3])
 end
 
 def _reduce_13(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[0], value: val[2], operator: val[1])
+ NodeQuery::Compiler::AttributeList.new(attribute: val[1])
 end
 
 def _reduce_14(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[0], value: NodeQuery::Compiler::ArrayValue.new, operator: val[1])
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: val[2], operator: val[1])
 end
 
 def _reduce_15(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[0], value: val[3], operator: val[1])
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: NodeQuery::Compiler::ArrayValue.new, operator: val[1])
 end
 
 def _reduce_16(val, _values)
- NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1])
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: val[3], operator: val[1])
 end
 
 def _reduce_17(val, _values)
+ NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1])
+end
+
+def _reduce_18(val, _values)
  NodeQuery::Compiler::ArrayValue.new(value: val[0])
 end
 
-# reduce 18 omitted
+# reduce 19 omitted
 
-def _reduce_19(val, _values)
+def _reduce_20(val, _values)
  NodeQuery::Compiler::Boolean.new(value: val[0])
 end
 
-def _reduce_20(val, _values)
+def _reduce_21(val, _values)
  NodeQuery::Compiler::Float.new(value: val[0])
 end
 
-def _reduce_21(val, _values)
+def _reduce_22(val, _values)
  NodeQuery::Compiler::Integer.new(value: val[0])
 end
 
-def _reduce_22(val, _values)
+def _reduce_23(val, _values)
  NodeQuery::Compiler::Nil.new(value: val[0])
 end
 
-def _reduce_23(val, _values)
+def _reduce_24(val, _values)
  NodeQuery::Compiler::Regexp.new(value: val[0])
 end
 
-def _reduce_24(val, _values)
+def _reduce_25(val, _values)
  NodeQuery::Compiler::String.new(value: val[0])
 end
 
-def _reduce_25(val, _values)
+def _reduce_26(val, _values)
  NodeQuery::Compiler::Symbol.new(value: val[0])
 end
 
-def _reduce_26(val, _values)
+def _reduce_27(val, _values)
  NodeQuery::Compiler::Identifier.new(value: val[0])
 end
 

data/lib/node_query_parser.y

@@ -1,7 +1,7 @@
 class NodeQueryParser
 options no_result_var
 token tCOMMA tNODE_TYPE tGOTO_SCOPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tPSEUDO_CLASS tRELATIONSHIP
-      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR
+      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR tPOSITION
       tOPERATOR tARRAY_VALUE tBOOLEAN tFLOAT tINTEGER tNIL tREGEXP tSTRING tSYMBOL
 rule
   expression_list
@@ -13,7 +13,8 @@ rule
     | selector { NodeQuery::Compiler::Expression.new(selector: val[0]) }
 
   selector
-    : basic_selector { NodeQuery::Compiler::Selector.new(basic_selector: val[0]) }
+    : basic_selector tPOSITION { NodeQuery::Compiler::Selector.new(basic_selector: val[0], position: val[1] ) }
+    | basic_selector { NodeQuery::Compiler::Selector.new(basic_selector: val[0]) }
     | tPSEUDO_CLASS tOPEN_SELECTOR selector tCLOSE_SELECTOR { NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2]) }
     | tRELATIONSHIP selector { NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1]) }
     | tGOTO_SCOPE selector { NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1]) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_query
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.8.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-28 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.22
 signing_key:
 specification_version: 4
 summary: ast node query language