node_query 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86cae1819b055b5c50aa47879d3da1902805a24fa484f9697270e1591f4af73f
-  data.tar.gz: 59c4f42f81cd67758c0e3e6d237c3e23e3f35aec2175ae9d4798d93b3b4d11c6
+  metadata.gz: 061470a9033fb08485c03c44c3c41ca6ff0daf6a7db2fbe474d82384f9dd731b
+  data.tar.gz: 915e29f0a09147d3b7d06b0e81770b197cd743f4d44cd3da7b7f5ddee8a50a8c
 SHA512:
-  metadata.gz: 1b10e103621f14acc695c6b27c26d15a4751c804a907273b95056516697934d381aefdb8396aa90056385b90a741052bc9d5dc8a2a2c2afe05e69101d06af958
-  data.tar.gz: 36063af159d24d01bdf7e447aab58fc0800a95d3c764915635a31f2f26ae7ff401a8243287c3d1b01ca5cae1ddc6753ad952dee7c7f3ffa62c66834114bc572d
+  metadata.gz: b2184539cae7f69fdc3c53d993394fe4a5cb78bf2fb2e92a7183d61c6de4cab4e9117891859ddbd3c09d54f7905de2ea9c3059279e56d7b28c4f3a286f7247a6
+  data.tar.gz: e040f8691f7d51c07b6f9a7f7c03de42488a4f02815c683fd1a763eff6f985e4899a91c620d0bc37a4c9942e1c7e294c1e7220e9499a4ee573734cddeeb39acc

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 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`
+
 ## 1.6.0 (2022-09-16)
 
 * Rename `nodeType` to `node_type`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_query (1.6.0)
+    node_query (1.7.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/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.
@@ -93,10 +95,6 @@ module NodeQuery::Compiler
           nil
         when :array
           NodeQuery.adapter.get_children(node).map { |child_node| actual_value(child_node) }
-        when :irange
-          actual_value(NodeQuery.adapter.get_children(node).first)..actual_value(NodeQuery.adapter.get_children(node).last)
-        when :erange
-          actual_value(NodeQuery.adapter.get_children(node).first)...actual_value(NodeQuery.adapter.get_children(node).last)
         when :begin
           actual_value(NodeQuery.adapter.get_children(node).first)
         else
@@ -108,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

@@ -22,8 +22,9 @@ module NodeQuery::Compiler
 
     # 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,25 +50,25 @@ 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
@@ -106,25 +107,25 @@ 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

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/version.rb

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

metadata

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