node_query 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95dcf07d501c704e59bb792454be0bae1ddfafb915c77b6a062c6331d654564b
-  data.tar.gz: 7b835b8479ff5239ea77dcb5ed09f4868b1a09cbdf5edc2f4ab9413d352030be
+  metadata.gz: 86cae1819b055b5c50aa47879d3da1902805a24fa484f9697270e1591f4af73f
+  data.tar.gz: 59c4f42f81cd67758c0e3e6d237c3e23e3f35aec2175ae9d4798d93b3b4d11c6
 SHA512:
-  metadata.gz: e2dbea64418363ad059ea2b6e9d93b3c2d010bdba59317327904b6a48411517a511ab6737fe40bdf4847b2833ec4d81eb5d474be7db7d831a6119c89fe904fea
-  data.tar.gz: c2cf0bfec6edfa28b644a38957dce1276cc287507c3c3034a39e0ce018f25e420faded6ad0c7c3c3838757df5107082c30d05fcf9f4323c5d5d3f32bc68337f1
+  metadata.gz: 1b10e103621f14acc695c6b27c26d15a4751c804a907273b95056516697934d381aefdb8396aa90056385b90a741052bc9d5dc8a2a2c2afe05e69101d06af958
+  data.tar.gz: 36063af159d24d01bdf7e447aab58fc0800a95d3c764915635a31f2f26ae7ff401a8243287c3d1b01ca5cae1ddc6753ad952dee7c7f3ffa62c66834114bc572d

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+## 1.6.0 (2022-09-16)
+
+* Rename `nodeType` to `node_type`
+
+## 1.5.0 (2022-09-15)
+
+* Add `Helper.to_string`
+* Only check the current node if `including_self` is true and `recursive` is false
+* Fix `Regexp#match?` and `String#match?`
+* Rename `stop_on_match` to `stop_at_first_match`
+
 ## 1.4.0 (2022-09-14)
 
 * Add options `including_self`, `stop_on_match` and `recursive`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_query (1.4.0)
+    node_query (1.6.0)
       activesupport (< 7.0.0)
 
 GEM

data/README.md

@@ -62,7 +62,7 @@ It provides two apis: `query_nodes` and `match_node?`
 
 ```ruby
 node_query = NodeQuery.new(nqlOrRules: String | Hash) # Initialize NodeQuery
-node_query.query_nodes(node: Node, options = { including_self: true, stop_on_match: false, recursive: true }): Node[] # Get the matching nodes.
+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.
 ```
 
@@ -83,7 +83,7 @@ node = Parser::CurrentRuby.parse(source)
 
 # It will get the node of initialize.
 NodeQuery.new('.def[name=initialize]').query_nodes(node)
-NodeQuery.new({ nodeType: 'def', name: 'initialize' }).query_nodes(node)
+NodeQuery.new({ node_type: 'def', name: 'initialize' }).query_nodes(node)
 ```
 
 ## Node Query Language
@@ -313,7 +313,7 @@ It matches ivasgn node whose left value is either @id or @name.
 ### rules matches node type
 
 ```
-{ nodeType: 'class' }
+{ node_type: 'class' }
 ```
 
 It matches class node
@@ -321,13 +321,13 @@ It matches class node
 ### rules matches attribute
 
 ```
-{ nodeType: 'def', name: 'initialize' }
+{ node_type: 'def', name: 'initialize' }
 ```
 
 It matches def node whose name is initialize
 
 ```
-{ nodeType: 'def', arguments: { "0": 1, "1": "Murphy" } }
+{ node_type: 'def', arguments: { "0": 1, "1": "Murphy" } }
 ```
 
 It matches def node whose arguments are 1 and Murphy.
@@ -335,7 +335,7 @@ It matches def node whose arguments are 1 and Murphy.
 ### rules matches nested attribute
 
 ```
-{ nodeType: 'class', parent_class: { name: 'Base' } }
+{ node_type: 'class', parent_class: { name: 'Base' } }
 ```
 
 It matches class node whose parent class name is Base
@@ -343,7 +343,7 @@ It matches class node whose parent class name is Base
 ### rules matches evaluated value
 
 ```
-{ nodeType: 'ivasgn', left_value: '@{{right_value}}' }
+{ node_type: 'ivasgn', left_value: '@{{right_value}}' }
 ```
 
 It matches ivasgn node whose left value equals '@' plus the evaluated value of right value.
@@ -351,7 +351,7 @@ It matches ivasgn node whose left value equals '@' plus the evaluated value of r
 ### rules matches nested selector
 
 ```
-{ nodeType: 'def', body: { "0": { nodeType: 'ivasgn' } } }
+{ node_type: 'def', body: { "0": { node_type: 'ivasgn' } } }
 ```
 
 It matches def node whose first child node is an ivasgn node.
@@ -359,7 +359,7 @@ It matches def node whose first child node is an ivasgn node.
 ### rules matches method result
 
 ```
-{ nodeType: 'def', arguments: { size: 2 } }
+{ node_type: 'def', arguments: { size: 2 } }
 ```
 
 It matches def node whose arguments size is 2.
@@ -367,73 +367,73 @@ It matches def node whose arguments size is 2.
 ### rules matches operators
 
 ```
-{ nodeType: 'class', name: 'User' }
+{ node_type: 'class', name: 'User' }
 ```
 
 Value of name is equal to User
 
 ```
-{ nodeType: 'def', arguments: { size { not: 2 } }
+{ node_type: 'def', arguments: { size { not: 2 } }
 ```
 
 Size of arguments is not equal to 2
 
 ```
-{ nodeType: 'def', arguments: { size { gte: 2 } }
+{ node_type: 'def', arguments: { size { gte: 2 } }
 ```
 
 Size of arguments is greater than or equal to 2
 
 ```
-{ nodeType: 'def', arguments: { size { gt: 2 } }
+{ node_type: 'def', arguments: { size { gt: 2 } }
 ```
 
 Size of arguments is greater than 2
 
 ```
-{ nodeType: 'def', arguments: { size { lte: 2 } }
+{ node_type: 'def', arguments: { size { lte: 2 } }
 ```
 
 Size of arguments is less than or equal to 2
 
 ```
-{ nodeType: 'def', arguments: { size { lt: 2 } }
+{ node_type: 'def', arguments: { size { lt: 2 } }
 ```
 
 Size of arguments is less than 2
 
 ```
-{ nodeType: 'class', name: { in: ['User', 'Account'] } }
+{ node_type: 'class', name: { in: ['User', 'Account'] } }
 ```
 
 Value of name is either User or Account
 
 ```
-{ nodeType: 'class', name: { not_in: ['User', 'Account'] } }
+{ node_type: 'class', name: { not_in: ['User', 'Account'] } }
 ```
 
 Value of name is neither User nor Account
 
 ```
-{ nodeType: 'def', arguments: { includes: 'id' } }
+{ node_type: 'def', arguments: { includes: 'id' } }
 ```
 
 Value of arguments includes id
 
 ```
-{ nodeType: 'class', name: /User/ }
+{ node_type: 'class', name: /User/ }
 ```
 
 Value of name matches User
 
 ```
-{ nodeType: 'class', name: { not: /User/ } }
+{ node_type: 'class', name: { not: /User/ } }
 ```
 
 Value of name does not match User
 
 ```
-{ nodeType: 'class', name: { in: [/User/, /Account/] } }
+{ node_type: 'class', name: { in: [/User/, /Account/] } }
 ```
 
 Value of name matches either /User/ or /Account/
@@ -441,7 +441,7 @@ Value of name matches either /User/ or /Account/
 ### rules matches array nodes attribute
 
 ```
-{ nodeType: 'def', arguments: ['id', 'name'] }
+{ node_type: 'def', arguments: ['id', 'name'] }
 ```
 
 It matches def node whose arguments are id and name.

data/lib/node_query/compiler/expression.rb

@@ -15,8 +15,8 @@ module NodeQuery::Compiler
     # @param node [Node] node to match
     # @param options [Hash] if query the current node
     # @option options [boolean] :including_self if query the current node, default is ture
-    # @option options [boolean] :stop_on_match if stop on first match, default is false
-    # @option options [boolean] :recursive if stop on first match, default is true
+    # @option options [boolean] :stop_at_first_match if stop at first match, default is false
+    # @option options [boolean] :recursive if recursively query child nodes, default is true
     # @return [Array<Node>] matching nodes.
     def query_nodes(node, options = {})
       matching_nodes = @selector.query_nodes(node, options)

data/lib/node_query/compiler/expression_list.rb

@@ -15,8 +15,8 @@ module NodeQuery::Compiler
     # @param node [Node] node to match
     # @param options [Hash] if query the current node
     # @option options [boolean] :including_self if query the current node, default is ture
-    # @option options [boolean] :stop_on_match if stop on first match, default is false
-    # @option options [boolean] :recursive if stop on first match, default is true
+    # @option options [boolean] :stop_at_first_match if stop at first match, default is false
+    # @option options [boolean] :recursive if recursively query child nodes, default is true
     # @return [Array<Node>] matching nodes.
     def query_nodes(node, options = {})
       matching_nodes = @expression.query_nodes(node, options)

data/lib/node_query/compiler/regexp.rb

@@ -13,13 +13,16 @@ module NodeQuery::Compiler
 
     # Check if the regexp value matches the node value.
     # @param node [Node] the node
-    # @return [Boolean] true if the regexp value matches the node value.
-    def is_equal?(node)
-      if NodeQuery.adapter.is_node?(node)
-        @value.match(NodeQuery.adapter.get_source(node))
-      else
-        @value.match(node.to_s)
-      end
+    # @param operator [String] the operator
+    # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
+    def match?(node, operator = '=~')
+      match =
+        if NodeQuery.adapter.is_node?(node)
+          @value.match(NodeQuery.adapter.get_source(node))
+        else
+          @value.match(node.to_s)
+        end
+      operator == '=~' ? match : !match
     end
 
     # Get valid operators.

data/lib/node_query/compiler/selector.rb

@@ -35,11 +35,11 @@ module NodeQuery::Compiler
     # @param node [Node] node to match
     # @param options [Hash] if query the current node
     # @option options [boolean] :including_self if query the current node, default is ture
-    # @option options [boolean] :stop_on_match if stop on first match, default is false
-    # @option options [boolean] :recursive if stop on first match, default is true
+    # @option options [boolean] :stop_at_first_match if stop at first match, default is false
+    # @option options [boolean] :recursive if recursively query child nodes, default is true
     # @return [Array<Node>] matching nodes.
     def query_nodes(node, options = {})
-      options = { including_self: true, stop_on_match: false, recursive: true }.merge(options)
+      options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
       return find_nodes_by_relationship(node) if @relationship
 
       if node.is_a?(::Array)
@@ -48,24 +48,28 @@ module NodeQuery::Compiler
 
       return find_nodes_by_goto_scope(node) if @goto_scope
 
+      if options[:including_self] && !options[:recursive]
+        return match?(node) ? [node] : []
+      end
+
       nodes = []
       if options[:including_self] && match?(node)
         nodes << node
-        return matching_nodes if options[:stop_on_match]
+        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)
               nodes << child_node
-              break if options[:stop_on_match]
+              break if options[:stop_at_first_match]
             end
           end
         else
           NodeQuery.adapter.get_children(node).each do |child_node|
             if match?(child_node)
               nodes << child_node
-              break if options[:stop_on_match]
+              break if options[:stop_at_first_match]
             end
           end
         end

data/lib/node_query/compiler/string.rb

@@ -27,7 +27,7 @@ module NodeQuery::Compiler
     # @param node [Node] the node
     # @return [Boolean] true if the actual value equals the node value.
     def is_equal?(node)
-      actual_value(node).to_s == expected_value
+      NodeQuery::Helper.to_string(actual_value(node)) == expected_value
     end
 
     # Get valid operators.

data/lib/node_query/helper.rb

@@ -18,7 +18,7 @@ class NodeQuery::Helper
         child_node = node[first_key.to_i]
       elsif node.respond_to?(first_key)
         child_node = node.send(first_key)
-      elsif first_key == "nodeType"
+      elsif first_key == "node_type"
         child_node = NodeQuery.adapter.get_node_type(node)
       end
 
@@ -50,9 +50,17 @@ class NodeQuery::Helper
     def evaluate_node_value(node, str)
       str.scan(/{{(.*?)}}/).each do |match_data|
         target_node = NodeQuery::Helper.get_target_node(node, match_data.first)
-        str = str.sub("{{#{match_data.first}}}", NodeQuery.adapter.get_source(target_node))
+        str = str.sub("{{#{match_data.first}}}", to_string(target_node))
       end
       str
     end
+
+    def to_string(node)
+      if NodeQuery.adapter.is_node?(node)
+        return NodeQuery.adapter.get_source(node)
+      end
+
+      node.to_s
+    end
   end
 end

data/lib/node_query/node_rules.rb

@@ -13,28 +13,32 @@ class NodeQuery::NodeRules
   # @param node [Node] node to query
   # @param options [Hash] if query the current node
   # @option options [boolean] :including_self if query the current node, default is ture
-  # @option options [boolean] :stop_on_match if stop on first match, default is false
-  # @option options [boolean] :recursive if stop on first match, default is true
+  # @option options [boolean] :stop_at_first_match if stop at first match, default is false
+  # @option options [boolean] :recursive if recursively query child nodes, default is true
   # @return [Array<Node>] matching nodes.
   def query_nodes(node, options = {})
-    options = { including_self: true, stop_on_match: false, recursive: true }.merge(options)
+    options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
+    if options[:including_self] && !options[:recursive]
+      return match_node?(node) ? [node] : []
+    end
+
     matching_nodes  = []
     if options[:including_self] && match_node?(node)
       matching_nodes.push(node)
-      return matching_nodes if options[:stop_on_match]
+      return matching_nodes if options[:stop_at_first_match]
     end
     if options[:recursive]
       NodeQuery::Helper.handle_recursive_child(node) do |child_node|
         if match_node?(child_node)
           matching_nodes.push(child_node)
-          break if options[:stop_on_match]
+          break if options[:stop_at_first_match]
         end
       end
     else
       NodeQuery.adapter.get_children(node).each do |child_node|
         if match_node?(child_node)
           matching_nodes.push(child_node)
-          break if options[:stop_on_match]
+          break if options[:stop_at_first_match]
         end
       end
     end

data/lib/node_query/version.rb

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

data/lib/node_query.rb

@@ -40,8 +40,8 @@ class NodeQuery
   # @param node [Node] ast node
   # @param options [Hash] if query the current node
   # @option options [boolean] :including_self if query the current node, default is ture
-  # @option options [boolean] :stop_on_match if stop on first match, default is false
-  # @option options [boolean] :recursive if stop on first match, default is true
+  # @option options [boolean] :stop_at_first_match if stop at first match, default is false
+  # @option options [boolean] :recursive if recursively query child nodes, default is true
   # @return [Array<Node>] matching child nodes
   def query_nodes(node, options = {})
     if @expression

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_query
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-14 00:00:00.000000000 Z
+date: 2022-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport