node_query 1.13.12 → 1.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdd226c05ade3d2dde453af11182b02cabe7111f27ab7eaa5677b5b48d3ac247
-  data.tar.gz: 06bde0578a6e5e113cd1675207f8bef58a77b07761e13bee0c9fdfc2d00cf8e5
+  metadata.gz: 7ca6c90b61fc096a8827b28f96e8af9c2f3bf114e09a0bc6f4fa4c2b6b0a5dcb
+  data.tar.gz: 14f2604eb60f8482d0c9182e2aa0054bbec3130c49504f519936d95d03a7611c
 SHA512:
-  metadata.gz: 3f2cd0d797d7c212481a481754aca0a448e6bafbee7a4b93b53c6c17255a40e066df5368cdae8304a9da99f3059042ff5798916519aeb25fea1c06c84282c620
-  data.tar.gz: 7249a00c56a7d527dee321375d6b3f05115fe3666ea8a126b7994935974e7dd7ec1d767296e2cd43d2987189c8c964eec5b065c42d7c7dd27d92c83f3b5d1b29
+  metadata.gz: 7d40bbebba507b8bf52b9c6981c060a07c827f01a30c78cf5dec7a916fb085f0377e1b3ca19a5ed8cef8117c3850cb1ff5055fcb48599522648bd22340d8397d
+  data.tar.gz: a9c3edcb83f845e350f5004a21278735e67c6357d28096011b8acd1908290bf1fa2e44d4f0223c0fcd4ace273bbdfc317043b509c160d6ea7bfd4f79fbe542fd

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 1.14.1 (2023-11-27)
+
+* Fix `ArrayValue` with `adapter` parameter
+
+## 1.14.0 (2023-11-27)
+
+* Add `adapter` parameter to `NodeQuery`
+* Do not allow to configure an `adapter` globally
+
 ## 1.13.12 (2023-09-29)
 
 * `NODE_TYPE` can contain `_`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_query (1.13.12)
+    node_query (1.14.1)
 
 GEM
   remote: https://rubygems.org/
@@ -38,9 +38,10 @@ GEM
       nenv (~> 0.1)
       shellany (~> 0.0)
     oedipus_lex (2.6.0)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
-    parser_node_ext (1.1.0)
+      racc
+    parser_node_ext (1.2.1)
       parser
     prettier_print (1.2.1)
     pry (0.14.1)

data/README.md

@@ -61,7 +61,7 @@ Or install it yourself as:
 It provides two apis: `query_nodes` and `match_node?`
 
 ```ruby
-node_query = NodeQuery.new(nql_or_rules: String | Hash) # Initialize NodeQuery
+node_query = NodeQuery.new(nql_or_rules: String | Hash, adapter: Symbol) # 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.
 ```
@@ -82,8 +82,8 @@ source = `
 node = Parser::CurrentRuby.parse(source)
 
 # It will get the node of initialize.
-NodeQuery.new('.def[name=initialize]').query_nodes(node)
-NodeQuery.new({ node_type: 'def', name: 'initialize' }).query_nodes(node)
+NodeQuery.new('.def[name=initialize]', adapter: :parser).query_nodes(node)
+NodeQuery.new({ node_type: 'def', name: 'initialize' }, adapter: :parser).query_nodes(node)
 ```
 
 ## Node Query Language
@@ -483,10 +483,6 @@ It provides 2 adapters
 1. `ParserAdapter`
 2. `SyntaxTreeAdapter`
 
-```ruby
-NodeQuery.configure(adapter: SyntaxTreeAdapter.new) # default is ParserAdapter
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/node_query/compiler/array_value.rb

@@ -8,9 +8,11 @@ module NodeQuery::Compiler
     # Initialize an Array.
     # @param value the first value of the array
     # @param rest the rest value of the array
-    def initialize(value: nil, rest: nil)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value: nil, rest: nil, adapter:)
       @value = value
       @rest = rest
+      @adapter = adapter
     end
 
     # Get the expected value.

data/lib/node_query/compiler/attribute.rb

@@ -7,10 +7,12 @@ module NodeQuery::Compiler
     # @param key [String] the key
     # @param value the value can be any class implement {NodeQuery::Compiler::Comparable}
     # @param operator [String] the operator
-    def initialize(key:, value:, operator: '=')
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(key:, value:, operator: '=', adapter:)
       @key = key
       @value = value
       @operator = operator
+      @adapter = adapter
     end
 
     # Check if the node matches the attribute.
@@ -18,7 +20,7 @@ module NodeQuery::Compiler
     # @param base_node [Node] the bae node for evaluated value
     # @return [Boolean]
     def match?(node, base_node)
-      node && @value.match?(NodeQuery::Helper.get_target_node(node, @key), base_node, @operator)
+      node && @value.match?(NodeQuery::Helper.get_target_node(node, @key, @adapter), base_node, @operator)
     end
 
     def to_s

data/lib/node_query/compiler/basic_selector.rb

@@ -6,9 +6,11 @@ module NodeQuery::Compiler
     # Initialize a BasicSelector.
     # @param node_type [String] the node type
     # @param attribute_list [NodeQuery::Compiler::AttributeList] the attribute list
-    def initialize(node_type:, attribute_list: nil)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(node_type:, attribute_list: nil, adapter:)
       @node_type = node_type
       @attribute_list = attribute_list
+      @adapter = adapter
     end
 
     # Check if node matches the selector.
@@ -18,7 +20,7 @@ module NodeQuery::Compiler
     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_type.to_sym == @adapter.get_node_type(node) && (!@attribute_list || @attribute_list.match?(
         node,
         base_node
       ))

data/lib/node_query/compiler/boolean.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a Boolean.
     # @param value [Boolean] the boolean value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get valid operators.

data/lib/node_query/compiler/comparable.rb

@@ -16,6 +16,7 @@ module NodeQuery::Compiler
     # @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
+    # @param adapter [NodeQuery::Adapter]
     def match?(node, base_node, operator)
       raise InvalidOperatorError, "invalid operator #{operator}" unless valid_operator?(operator)
 
@@ -89,7 +90,7 @@ module NodeQuery::Compiler
     # @param node [Node] ast node
     # @return the node value, could be integer, float, string, boolean, nil, range, and etc.
     def actual_value(node)
-      if NodeQuery.adapter.is_node?(node)
+      if @adapter.is_node?(node)
         node.to_value
       else
         node

data/lib/node_query/compiler/float.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a Float.
     # @param value [Float] the float value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get valid operators.

data/lib/node_query/compiler/identifier.rb

@@ -8,8 +8,10 @@ module NodeQuery::Compiler
 
     # Initialize an Identifier.
     # @param value [String] the identifier value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get the actual value.
@@ -19,8 +21,8 @@ module NodeQuery::Compiler
     # if the node is an Array, return the array of each element's actual value,
     # otherwise, return the String value.
     def actual_value(node)
-      if NodeQuery.adapter.is_node?(node)
-        NodeQuery.adapter.get_source(node)
+      if @adapter.is_node?(node)
+        @adapter.get_source(node)
       elsif node.is_a?(::Array)
         node.map { |n| actual_value(n) }
       else

data/lib/node_query/compiler/integer.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a Integer.
     # @param value [Integer] the integer value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get valid operators.

data/lib/node_query/compiler/nil.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a Nil.
     # @param value [nil] the nil value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get valid operators.

data/lib/node_query/compiler/regexp.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a Regexp.
     # @param value [Regexp] the regexp value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Check if the regexp value matches the node value.
@@ -18,8 +20,8 @@ module NodeQuery::Compiler
     # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
     def match?(node, _base_node, operator = '=~')
       match =
-        if NodeQuery.adapter.is_node?(node)
-          @value.match(NodeQuery.adapter.get_source(node))
+        if @adapter.is_node?(node)
+          @value.match(@adapter.get_source(node))
         else
           @value.match(node.to_s)
         end

data/lib/node_query/compiler/selector.rb

@@ -12,6 +12,7 @@ module NodeQuery::Compiler
     # @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
+    # @param adapter [NodeQuery::Adapter]
     def initialize(
       goto_scope: nil,
       relationship: nil,
@@ -19,7 +20,8 @@ module NodeQuery::Compiler
       basic_selector: nil,
       position: nil,
       pseudo_class: nil,
-      pseudo_selector: nil
+      pseudo_selector: nil,
+      adapter:
     )
       @goto_scope = goto_scope
       @relationship = relationship
@@ -28,6 +30,7 @@ module NodeQuery::Compiler
       @position = position
       @pseudo_class = pseudo_class
       @pseudo_selector = pseudo_selector
+      @adapter = adapter
     end
 
     # Check if node matches the selector.
@@ -44,7 +47,7 @@ module NodeQuery::Compiler
           return false
         end
       end
-      NodeQuery.adapter.is_node?(node) && (!@basic_selector || (operator == "!=" ? !@basic_selector.match?(
+      @adapter.is_node?(node) && (!@basic_selector || (operator == "!=" ? !@basic_selector.match?(
         node,
         base_node
       ) : @basic_selector.match?(node, base_node))) && match_pseudo_class?(node)
@@ -83,7 +86,7 @@ module NodeQuery::Compiler
       end
       if @basic_selector
         if options[:recursive]
-          NodeQuery::Helper.handle_recursive_child(node) do |child_node|
+          NodeQuery::Helper.handle_recursive_child(node, @adapter) do |child_node|
             if match?(child_node, child_node)
               nodes << child_node
               break if options[:stop_at_first_match]
@@ -153,13 +156,13 @@ module NodeQuery::Compiler
             nodes << child_node if @rest.match?(child_node, child_node)
           end
         else
-          NodeQuery.adapter.get_children(node).each do |child_node|
+          @adapter.get_children(node).each do |child_node|
             if child_node.is_a?(Array) # SyntaxTree may return an array in child node.
               child_node.each do |child_child_node|
                 nodes << child_child_node if @rest.match?(child_child_node, child_child_node)
               end
-            elsif NodeQuery.adapter.is_node?(child_node) && :begin == NodeQuery.adapter.get_node_type(child_node)
-              NodeQuery.adapter.get_children(child_node).each do |child_child_node|
+            elsif @adapter.is_node?(child_node) && :begin == @adapter.get_node_type(child_node)
+              @adapter.get_children(child_node).each do |child_child_node|
                 nodes << child_child_node if @rest.match?(child_child_node, child_child_node)
               end
             elsif @rest.match?(child_node, child_node)

data/lib/node_query/compiler/string.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initialize a String.
     # @param value [String] the string value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get the expected value.
@@ -19,7 +21,7 @@ module NodeQuery::Compiler
     # @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(base_node)
-      NodeQuery::Helper.evaluate_node_value(base_node, @value)
+      NodeQuery::Helper.evaluate_node_value(base_node, @value, @adapter)
     end
 
     # Check if the actual value equals the node value.
@@ -27,7 +29,7 @@ module NodeQuery::Compiler
     # @param base_node [Node] the base node for evaluated value
     # @return [Boolean] true if the actual value equals the node value.
     def is_equal?(actual, expected)
-      NodeQuery::Helper.to_string(actual) == expected
+      NodeQuery::Helper.to_string(actual, @adapter) == expected
     end
 
     # Get valid operators.

data/lib/node_query/compiler/symbol.rb

@@ -7,8 +7,10 @@ module NodeQuery::Compiler
 
     # Initliaze a Symobol.
     # @param value [Symbol] the symbol value
-    def initialize(value:)
+    # @param adapter [NodeQuery::Adapter]
+    def initialize(value:, adapter:)
       @value = value
+      @adapter = adapter
     end
 
     # Get valid operators.

data/lib/node_query/helper.rb

@@ -5,13 +5,14 @@ class NodeQuery::Helper
     # Get target node by the keys.
     # @param node [Node] ast node
     # @param keys [String|Array] keys of child node.
+    # @param adapter [NodeQuery::Adapter]
     # @return [Node|] the target node.
-    def get_target_node(node, keys)
+    def get_target_node(node, keys, adapter)
       return unless node
 
       first_key, rest_keys = keys.to_s.split('.', 2)
       if node.is_a?(Array) && first_key === "*"
-        return node.map { |child_node| get_target_node(child_node, rest_keys) }
+        return node.map { |child_node| get_target_node(child_node, rest_keys, adapter) }
       end
 
       if node.is_a?(Array) && first_key =~ /\d+/
@@ -19,21 +20,22 @@ class NodeQuery::Helper
       elsif node.respond_to?(first_key)
         child_node = node.send(first_key)
       elsif first_key == "node_type"
-        child_node = NodeQuery.adapter.get_node_type(node)
+        child_node = adapter.get_node_type(node)
       end
 
       return child_node unless rest_keys
 
-      return get_target_node(child_node, rest_keys)
+      return get_target_node(child_node, rest_keys, adapter)
     end
 
     # Recursively handle child nodes.
     # @param node [Node] ast node
+    # @param adapter [NodeQuery::Adapter] adapter
     # @yield [child] Gives a child node.
     # @yieldparam child [Node] child node
-    def handle_recursive_child(node, &block)
-      NodeQuery.adapter.get_children(node).each do |child|
-        handle_child(child, &block)
+    def handle_recursive_child(node, adapter, &block)
+      adapter.get_children(node).each do |child|
+        handle_child(child, adapter, &block)
       end
     end
 
@@ -43,18 +45,19 @@ class NodeQuery::Helper
     #     evaluated_node_value(node, "@{{value}}") # => @id
     # @param node [Node] ast node
     # @param str [String] string to be evaluated
+    # @param adapter [NodeQuery::Adapter] adapter
     # @return [String] evaluated string
-    def evaluate_node_value(node, str)
+    def evaluate_node_value(node, str, adapter)
       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))
+        target_node = NodeQuery::Helper.get_target_node(node, match_data.first, adapter)
+        str = str.sub("{{#{match_data.first}}}", to_string(target_node, adapter))
       end
       str
     end
 
-    def to_string(node)
-      if NodeQuery.adapter.is_node?(node)
-        return NodeQuery.adapter.get_source(node)
+    def to_string(node, adapter)
+      if adapter.is_node?(node)
+        return adapter.get_source(node)
       end
 
       node.to_s
@@ -62,13 +65,13 @@ class NodeQuery::Helper
 
     private
 
-    def handle_child(node, &block)
-      if NodeQuery.adapter.is_node?(node)
+    def handle_child(node, adapter, &block)
+      if adapter.is_node?(node)
         block.call(node)
-        handle_recursive_child(node, &block)
+        handle_recursive_child(node, adapter, &block)
       elsif node.is_a?(Array)
         node.each do |child_node|
-          handle_child(child_node, &block) unless child_node.nil?
+          handle_child(child_node, adapter, &block) unless child_node.nil?
         end
       end
     end

data/lib/node_query/node_rules.rb

@@ -5,8 +5,10 @@ class NodeQuery::NodeRules
 
   # Initialize a NodeRules.
   # @param rules [Hash] the nod rules
-  def initialize(rules)
+  # @param adapter [NodeQuery::Adapter]
+  def initialize(rules, adapter:)
     @rules = rules
+    @adapter = adapter
   end
 
   # Query nodes by the rules.
@@ -28,14 +30,14 @@ class NodeQuery::NodeRules
       return matching_nodes if options[:stop_at_first_match]
     end
     if options[:recursive]
-      NodeQuery::Helper.handle_recursive_child(node) do |child_node|
+      NodeQuery::Helper.handle_recursive_child(node, @adapter) do |child_node|
         if match_node?(child_node)
           matching_nodes.push(child_node)
           break if options[:stop_at_first_match]
         end
       end
     else
-      NodeQuery.adapter.get_children(node).each do |child_node|
+      @adapter.get_children(node).each do |child_node|
         if match_node?(child_node)
           matching_nodes.push(child_node)
           break if options[:stop_at_first_match]
@@ -53,10 +55,10 @@ class NodeQuery::NodeRules
       last_key = multi_keys.last
       actual =
         KEYWORDS.include?(last_key) ?
-               NodeQuery::Helper.get_target_node(node, multi_keys[0...-1].join('.')) :
-               NodeQuery::Helper.get_target_node(node, multi_keys.join('.'))
+               NodeQuery::Helper.get_target_node(node, multi_keys[0...-1].join('.'), @adapter) :
+               NodeQuery::Helper.get_target_node(node, multi_keys.join('.'), @adapter)
       expected = expected_value(@rules, multi_keys)
-      expected = NodeQuery::Helper.evaluate_node_value(node, expected) if expected.is_a?(String)
+      expected = NodeQuery::Helper.evaluate_node_value(node, expected, @adapter) if expected.is_a?(String)
       case last_key
       when :includes
         actual.any? { |actual_value| match_value?(actual_value, expected) }
@@ -95,22 +97,22 @@ class NodeQuery::NodeRules
 
     case expected
     when Symbol
-      if NodeQuery.adapter.is_node?(actual)
-        actual_source = NodeQuery.adapter.get_source(actual)
+      if @adapter.is_node?(actual)
+        actual_source = @adapter.get_source(actual)
         actual_source == ":#{expected}" || actual_source == expected.to_s
       else
         actual.to_sym == expected
       end
     when String
-      if NodeQuery.adapter.is_node?(actual)
-        actual_source = NodeQuery.adapter.get_source(actual)
+      if @adapter.is_node?(actual)
+        actual_source = @adapter.get_source(actual)
         actual_source == expected || actual_source == unwrap_quote(expected) ||
           unwrap_quote(actual_source) == expected || unwrap_quote(actual_source) == unwrap_quote(expected)
       else
         actual.to_s == expected || wrap_quote(actual.to_s) == expected
       end
     when Regexp
-      if NodeQuery.adapter.is_node?(actual)
+      if @adapter.is_node?(actual)
         actual.to_source =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
       else
         actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
@@ -120,13 +122,13 @@ class NodeQuery::NodeRules
 
       actual.zip(expected).all? { |a, e| match_value?(a, e) }
     when NilClass
-      if NodeQuery.adapter.is_node?(actual)
+      if @adapter.is_node?(actual)
         actual.to_value.nil?
       else
         actual.nil?
       end
     when Numeric
-      if NodeQuery.adapter.is_node?(actual)
+      if @adapter.is_node?(actual)
         actual.children[0] == expected
       else
         actual == expected
@@ -136,7 +138,7 @@ class NodeQuery::NodeRules
     when FalseClass
       false == actual&.to_value
     else
-      if NodeQuery.adapter.is_node?(expected)
+      if @adapter.is_node?(expected)
         actual == expected
       else
         raise NodeQuery::MethodNotSupported, "#{expected} is not supported"

data/lib/node_query/version.rb

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

data/lib/node_query.rb

@@ -6,6 +6,7 @@ require_relative "./node_query_parser.racc"
 
 class NodeQuery
   class MethodNotSupported < StandardError; end
+  class InvalidAdapterError < StandardError; end
 
   autoload :Adapter, "node_query/adapter"
   autoload :ParserAdapter, "node_query/adapter/parser"
@@ -14,26 +15,15 @@ class NodeQuery
   autoload :Helper, "node_query/helper"
   autoload :NodeRules, "node_query/node_rules"
 
-  # Configure NodeQuery
-  # @param [Hash] options options to configure
-  # @option options [NodeQuery::Adapter] :adapter the adpater
-  def self.configure(options)
-    @adapter = options[:adapter]
-  end
-
-  # Get the adapter
-  # @return [NodeQuery::Adapter] current adapter, by default is {NodeQuery::ParserAdapter}
-  def self.adapter
-    @adapter ||= ParserAdapter.new
-  end
-
   # Initialize a NodeQuery.
   # @param nql_or_ruls [String | Hash] node query language or node rules
-  def initialize(nql_or_ruls)
+  # @param adapter [Symbol] :parser or :syntax_tree
+  def initialize(nql_or_ruls, adapter: :parser)
+    adapter_instance = get_adapter_instance(adapter)
     if nql_or_ruls.is_a?(String)
-      @expression = NodeQueryParser.new.parse(nql_or_ruls)
+      @expression = NodeQueryParser.new(adapter: adapter_instance).parse(nql_or_ruls)
     else
-      @rules = NodeRules.new(nql_or_ruls)
+      @rules = NodeRules.new(nql_or_ruls, adapter: adapter_instance)
     end
   end
 
@@ -66,4 +56,17 @@ class NodeQuery
       false
     end
   end
+
+  private
+
+  def get_adapter_instance(adapter)
+    case adapter.to_sym
+    when :parser
+      ParserAdapter.new
+    when :syntax_tree
+      SyntaxTreeAdapter.new
+    else
+      raise InvalidAdapterError, "adapter #{adapter} is not supported"
+    end
+  end
 end

data/lib/node_query_parser.racc.rb

@@ -7,18 +7,19 @@
 require 'racc/parser.rb'
 class NodeQueryParser < Racc::Parser
 
-  def initialize
-    @lexer = NodeQueryLexer.new
-  end
-
-  def parse string
-    @lexer.parse string
-    do_parse
-  end
-
-  def next_token
-    @lexer.next_token
-  end
+    def initialize(adapter:)
+      @lexer = NodeQueryLexer.new
+      @adapter = adapter
+    end
+
+    def parse string
+      @lexer.parse string
+      do_parse
+    end
+
+    def next_token
+      @lexer.next_token
+    end
 ##### State transition tables begin ###
 
 racc_action_table = [
@@ -213,31 +214,31 @@ def _reduce_4(val, _values)
 end
 
 def _reduce_5(val, _values)
- NodeQuery::Compiler::Selector.new(basic_selector: val[0], position: val[1] )
+ NodeQuery::Compiler::Selector.new(basic_selector: val[0], position: val[1], adapter: @adapter )
 end
 
 def _reduce_6(val, _values)
- NodeQuery::Compiler::Selector.new(basic_selector: val[0])
+ NodeQuery::Compiler::Selector.new(basic_selector: val[0], adapter: @adapter)
 end
 
 def _reduce_7(val, _values)
- NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2])
+ NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2], adapter: @adapter)
 end
 
 def _reduce_8(val, _values)
- NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1])
+ NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1], adapter: @adapter)
 end
 
 def _reduce_9(val, _values)
- NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1])
+ NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1], adapter: @adapter)
 end
 
 def _reduce_10(val, _values)
- NodeQuery::Compiler::BasicSelector.new(node_type: val[0])
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0], adapter: @adapter)
 end
 
 def _reduce_11(val, _values)
- NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1])
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1], adapter: @adapter)
 end
 
 def _reduce_12(val, _values)
@@ -249,57 +250,57 @@ def _reduce_13(val, _values)
 end
 
 def _reduce_14(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[1], value: val[3], operator: val[2])
+ NodeQuery::Compiler::Attribute.new(key: val[1], value: val[3], operator: val[2], adapter: @adapter)
 end
 
 def _reduce_15(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[1], value: NodeQuery::Compiler::ArrayValue.new, operator: val[2])
+ NodeQuery::Compiler::Attribute.new(key: val[1], value: NodeQuery::Compiler::ArrayValue.new(adapter: @adapter), operator: val[2], adapter: @adapter)
 end
 
 def _reduce_16(val, _values)
- NodeQuery::Compiler::Attribute.new(key: val[1], value: val[4], operator: val[2])
+ NodeQuery::Compiler::Attribute.new(key: val[1], value: val[4], operator: val[2], adapter: @adapter)
 end
 
 def _reduce_17(val, _values)
- NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1])
+ NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1], adapter: @adapter)
 end
 
 def _reduce_18(val, _values)
- NodeQuery::Compiler::ArrayValue.new(value: val[0])
+ NodeQuery::Compiler::ArrayValue.new(value: val[0], adapter: @adapter)
 end
 
 # reduce 19 omitted
 
 def _reduce_20(val, _values)
- NodeQuery::Compiler::Boolean.new(value: val[0])
+ NodeQuery::Compiler::Boolean.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_21(val, _values)
- NodeQuery::Compiler::Float.new(value: val[0])
+ NodeQuery::Compiler::Float.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_22(val, _values)
- NodeQuery::Compiler::Integer.new(value: val[0])
+ NodeQuery::Compiler::Integer.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_23(val, _values)
- NodeQuery::Compiler::Nil.new(value: val[0])
+ NodeQuery::Compiler::Nil.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_24(val, _values)
- NodeQuery::Compiler::Regexp.new(value: val[0])
+ NodeQuery::Compiler::Regexp.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_25(val, _values)
- NodeQuery::Compiler::String.new(value: val[0])
+ NodeQuery::Compiler::String.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_26(val, _values)
- NodeQuery::Compiler::Symbol.new(value: val[0])
+ NodeQuery::Compiler::Symbol.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_27(val, _values)
- NodeQuery::Compiler::Identifier.new(value: val[0])
+ NodeQuery::Compiler::Identifier.new(value: val[0], adapter: @adapter)
 end
 
 def _reduce_none(val, _values)

data/lib/node_query_parser.y

@@ -13,44 +13,45 @@ rule
     | selector { NodeQuery::Compiler::Expression.new(selector: val[0]) }
 
   selector
-    : 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]) }
+    : basic_selector tPOSITION { NodeQuery::Compiler::Selector.new(basic_selector: val[0], position: val[1], adapter: @adapter ) }
+    | basic_selector { NodeQuery::Compiler::Selector.new(basic_selector: val[0], adapter: @adapter) }
+    | tPSEUDO_CLASS tOPEN_SELECTOR selector tCLOSE_SELECTOR { NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2], adapter: @adapter) }
+    | tRELATIONSHIP selector { NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1], adapter: @adapter) }
+    | tGOTO_SCOPE selector { NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1], adapter: @adapter) }
 
   basic_selector
-    : tNODE_TYPE { NodeQuery::Compiler::BasicSelector.new(node_type: val[0]) }
-    | tNODE_TYPE attribute_list { NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1]) }
+    : tNODE_TYPE { NodeQuery::Compiler::BasicSelector.new(node_type: val[0], adapter: @adapter) }
+    | tNODE_TYPE attribute_list { NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1], adapter: @adapter) }
 
   attribute_list
     : attribute attribute_list { NodeQuery::Compiler::AttributeList.new(attribute: val[0], rest: val[1]) }
     | attribute { NodeQuery::Compiler::AttributeList.new(attribute: val[0]) }
 
   attribute
-    : tOPEN_ATTRIBUTE tKEY tOPERATOR value tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: val[3], operator: val[2]) }
-    | tOPEN_ATTRIBUTE tKEY tOPERATOR tOPEN_ARRAY tCLOSE_ARRAY tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: NodeQuery::Compiler::ArrayValue.new, operator: val[2]) }
-    | tOPEN_ATTRIBUTE tKEY tOPERATOR tOPEN_ARRAY array_value tCLOSE_ARRAY tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: val[4], operator: val[2]) }
+    : tOPEN_ATTRIBUTE tKEY tOPERATOR value tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: val[3], operator: val[2], adapter: @adapter) }
+    | tOPEN_ATTRIBUTE tKEY tOPERATOR tOPEN_ARRAY tCLOSE_ARRAY tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: NodeQuery::Compiler::ArrayValue.new(adapter: @adapter), operator: val[2], adapter: @adapter) }
+    | tOPEN_ATTRIBUTE tKEY tOPERATOR tOPEN_ARRAY array_value tCLOSE_ARRAY tCLOSE_ATTRIBUTE { NodeQuery::Compiler::Attribute.new(key: val[1], value: val[4], operator: val[2], adapter: @adapter) }
 
   array_value
-    : value array_value { NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1]) }
-    | value { NodeQuery::Compiler::ArrayValue.new(value: val[0]) }
+    : value array_value { NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1], adapter: @adapter) }
+    | value { NodeQuery::Compiler::ArrayValue.new(value: val[0], adapter: @adapter) }
 
   value
     : selector
-    | tBOOLEAN { NodeQuery::Compiler::Boolean.new(value: val[0]) }
-    | tFLOAT { NodeQuery::Compiler::Float.new(value: val[0]) }
-    | tINTEGER { NodeQuery::Compiler::Integer.new(value: val[0])}
-    | tNIL { NodeQuery::Compiler::Nil.new(value: val[0]) }
-    | tREGEXP { NodeQuery::Compiler::Regexp.new(value: val[0]) }
-    | tSTRING { NodeQuery::Compiler::String.new(value: val[0]) }
-    | tSYMBOL { NodeQuery::Compiler::Symbol.new(value: val[0]) }
-    | tIDENTIFIER_VALUE { NodeQuery::Compiler::Identifier.new(value: val[0]) }
+    | tBOOLEAN { NodeQuery::Compiler::Boolean.new(value: val[0], adapter: @adapter) }
+    | tFLOAT { NodeQuery::Compiler::Float.new(value: val[0], adapter: @adapter) }
+    | tINTEGER { NodeQuery::Compiler::Integer.new(value: val[0], adapter: @adapter) }
+    | tNIL { NodeQuery::Compiler::Nil.new(value: val[0], adapter: @adapter) }
+    | tREGEXP { NodeQuery::Compiler::Regexp.new(value: val[0], adapter: @adapter) }
+    | tSTRING { NodeQuery::Compiler::String.new(value: val[0], adapter: @adapter) }
+    | tSYMBOL { NodeQuery::Compiler::Symbol.new(value: val[0], adapter: @adapter) }
+    | tIDENTIFIER_VALUE { NodeQuery::Compiler::Identifier.new(value: val[0], adapter: @adapter) }
 end
 
 ---- inner
-    def initialize
+    def initialize(adapter:)
       @lexer = NodeQueryLexer.new
+      @adapter = adapter
     end
 
     def parse string

data/sig/node_query.rbs

@@ -1,11 +1,7 @@
 class NodeQuery[T]
   VERSION: String
 
-  def self.configure: (options: { adapter: NodeQuery::Adapter }) -> void
-
-  def self.adapter: () -> NodeQuery::Adapter
-
-  def initialize: (nqlOrRues: String | Hash) -> NodeQuery
+  def initialize: (nqlOrRues: String | Hash, adapter: Symbol) -> NodeQuery
 
   def query_nodes: (node: T, options: Hash) -> Array[T]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_query
 version: !ruby/object:Gem::Version
-  version: 1.13.12
+  version: 1.14.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-29 00:00:00.000000000 Z
+date: 2023-11-27 00:00:00.000000000 Z
 dependencies: []
 description: ast node query language
 email:
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: ast node query language