node_query 1.2.0 → 1.4.0

data/lib/node_query/compiler/selector.rb

@@ -23,7 +23,7 @@ module NodeQuery::Compiler
     # Check if node matches the selector.
     # @param node [Parser::AST::Node] the node
     def match?(node)
-      node.is_a?(::Parser::AST::Node) && (!@basic_selector || @basic_selector.match?(node)) && match_pseudo_class?(node)
+      NodeQuery.adapter.is_node?(node) && (!@basic_selector || @basic_selector.match?(node)) && match_pseudo_class?(node)
     end
 
     # Query nodes by the selector.
@@ -33,8 +33,13 @@ module NodeQuery::Compiler
     # * If relationship is next sibling, it try to match next sibling node.
     # * If relationship is subsequent sibling, it will match in all sibling nodes.
     # @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
     # @return [Array<Node>] matching nodes.
-    def query_nodes(node)
+    def query_nodes(node, options = {})
+      options = { including_self: true, stop_on_match: false, recursive: true }.merge(options)
       return find_nodes_by_relationship(node) if @relationship
 
       if node.is_a?(::Array)
@@ -44,10 +49,25 @@ module NodeQuery::Compiler
       return find_nodes_by_goto_scope(node) if @goto_scope
 
       nodes = []
-      nodes << node if match?(node)
+      if options[:including_self] && match?(node)
+        nodes << node
+        return matching_nodes if options[:stop_on_match]
+      end
       if @basic_selector
-        NodeQuery::Helper.handle_recursive_child(node) do |child_node|
-          nodes << child_node if match?(child_node)
+        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]
+            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]
+            end
+          end
         end
       end
       nodes
@@ -86,7 +106,13 @@ module NodeQuery::Compiler
           end
         else
           node.children.each do |child_node|
-            nodes << child_node if @rest.match?(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)
+              end
+            elsif @rest.match?(child_node)
+              nodes << child_node
+            end
           end
         end
       when '+'

data/lib/node_query/compiler/string.rb

@@ -5,12 +5,31 @@ module NodeQuery::Compiler
   class String
     include Comparable
 
+    attr_accessor :base_node
+
     # Initialize a String.
     # @param value [String] the string value
     def initialize(value:)
       @value = value
     end
 
+    # Get the expected value.
+    # @example
+    #     if the source code of the node is @id = id,
+    #     and the @value is "@{{right_vaue}}",
+    #     then it returns "@id".
+    # @return [String] the expected string, if it contains evaluated value, evaluate the node value.
+    def expected_value
+      NodeQuery::Helper.evaluate_node_value(base_node, @value)
+    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).to_s == expected_value
+    end
+
     # Get valid operators.
     # @return [Array] valid operators
     def valid_operators

data/lib/node_query/compiler.rb

@@ -15,7 +15,6 @@ module NodeQuery::Compiler
 
   autoload :ArrayValue, 'node_query/compiler/array_value'
   autoload :Boolean, 'node_query/compiler/boolean'
-  autoload :EvaluatedValue, 'node_query/compiler/evaluated_value'
   autoload :Float, 'node_query/compiler/float'
   autoload :Identifier, 'node_query/compiler/identifier'
   autoload :Integer, 'node_query/compiler/integer'

data/lib/node_query/helper.rb

@@ -1,40 +1,58 @@
 # frozen_string_literal: true
 
 class NodeQuery::Helper
-  # Get target node by the keys.
-  # @param node [Node] ast node
-  # @param keys [String] keys of child node.
-  # @return [Node|] the target node.
-  def self.get_target_node(node, keys)
-    return unless node
+  class <<self
+    # Get target node by the keys.
+    # @param node [Node] ast node
+    # @param keys [String|Array] keys of child node.
+    # @return [Node|] the target node.
+    def get_target_node(node, keys)
+      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) }
-    end
+      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) }
+      end
 
-    if node.is_a?(Array) && first_key =~ /\d+/
-      child_node = node[first_key.to_i]
-    end
-    if node.respond_to?(first_key)
-      child_node = node.send(first_key)
-    end
+      if node.is_a?(Array) && first_key =~ /\d+/
+        child_node = node[first_key.to_i]
+      elsif node.respond_to?(first_key)
+        child_node = node.send(first_key)
+      elsif first_key == "nodeType"
+        child_node = NodeQuery.adapter.get_node_type(node)
+      end
 
-    return child_node unless rest_keys
+      return child_node unless rest_keys
 
-    return get_target_node(child_node, rest_keys)
-  end
+      return get_target_node(child_node, rest_keys)
+    end
+
+    # Recursively handle child nodes.
+    # @param node [Node] ast node
+    # @yield [child] Gives a child node.
+    # @yieldparam child [Parser::AST::Node] child node
+    def handle_recursive_child(node, &block)
+      NodeQuery.adapter.get_children(node).each do |child|
+        if NodeQuery.adapter.is_node?(child)
+          block.call(child)
+          handle_recursive_child(child, &block)
+        end
+      end
+    end
 
-  # Recursively handle child nodes.
-  # @param node [Node] ast node
-  # @yield [child] Gives a child node.
-  # @yieldparam child [Parser::AST::Node] child node
-  def self.handle_recursive_child(node, &block)
-    NodeQuery.adapter.get_children(node).each do |child|
-      if NodeQuery.adapter.is_node?(child)
-        block.call(child)
-        handle_recursive_child(child, &block)
+    # Evaluate node value.
+    # @example
+    #     source code of the node is @id = id
+    #     evaluated_node_value(node, "@{{right_value}}") # => @id
+    # @param node [Node] ast node
+    # @param str [String] string to be evaluated
+    # @return [String] evaluated string
+    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))
       end
+      str
     end
   end
-end
+end

data/lib/node_query/node_rules.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+class NodeQuery::NodeRules
+  KEYWORDS = %i[any includes not in not_in gt gte lt lte]
+
+  # Initialize a NodeRules.
+  # @param rules [Hash] the nod rules
+  def initialize(rules)
+    @rules = rules
+  end
+
+  # Query nodes by the rules.
+  # @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
+  # @return [Array<Node>] matching nodes.
+  def query_nodes(node, options = {})
+    options = { including_self: true, stop_on_match: false, recursive: true }.merge(options)
+    matching_nodes  = []
+    if options[:including_self] && match_node?(node)
+      matching_nodes.push(node)
+      return matching_nodes if options[:stop_on_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]
+        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]
+        end
+      end
+    end
+    matching_nodes
+  end
+
+  # Check if the node matches the rules.
+  # @param node [Node] the node
+  # @return [Boolean]
+  def match_node?(node)
+    flat_hash(@rules).keys.all? do |multi_keys|
+      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('.'))
+      expected = expected_value(@rules, multi_keys)
+      expected = NodeQuery::Helper.evaluate_node_value(node, expected) if expected.is_a?(String)
+      case last_key
+      when :any, :includes
+        actual.any? { |actual_value| match_value?(actual_value, expected) }
+      when :not
+        !match_value?(actual, expected)
+      when :in
+        expected.any? { |expected_value| match_value?(actual, expected_value) }
+      when :not_in
+        expected.all? { |expected_value| !match_value?(actual, expected_value) }
+      when :gt
+        actual > expected
+      when :gte
+        actual >= expected
+      when :lt
+        actual < expected
+      when :lte
+        actual <= expected
+      else
+        match_value?(actual, expected)
+      end
+    end
+  end
+
+  private
+
+  # Compare actual value with expected value.
+  #
+  # @param actual [Object] actual value.
+  # @param expected [Object] expected value.
+  # @return [Boolean]
+  # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
+  def match_value?(actual, expected)
+    return true if actual == expected
+
+    case expected
+    when Symbol
+      if actual.is_a?(Parser::AST::Node)
+        actual_source = NodeQuery.adapter.get_source(actual)
+        actual_source == ":#{expected}" || actual_source == expected.to_s
+      else
+        actual.to_sym == expected
+      end
+    when String
+      if actual.is_a?(Parser::AST::Node)
+        actual_source = NodeQuery.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 actual.is_a?(Parser::AST::Node)
+        actual.to_source =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+      else
+        actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
+      end
+    when Array
+      return false unless expected.length == actual.length
+
+      actual.zip(expected).all? { |a, e| match_value?(a, e) }
+    when NilClass
+      if actual.is_a?(Parser::AST::Node)
+        :nil == actual.type
+      else
+        actual.nil?
+      end
+    when Numeric
+      if actual.is_a?(Parser::AST::Node)
+        actual.children[0] == expected
+      else
+        actual == expected
+      end
+    when TrueClass
+      :true == actual.type
+    when FalseClass
+      :false == actual.type
+    when Parser::AST::Node
+      actual == expected
+    when Synvert::Core::Rewriter::AnyValue
+      !actual.nil?
+    else
+      raise Synvert::Core::MethodNotSupported, "#{expected.class} is not handled for match_value?"
+    end
+  end
+
+  # Convert a hash to flat one.
+  #
+  # @example
+  #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
+  #     # {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
+  # @param h [Hash] original hash.
+  # @return flatten hash.
+  def flat_hash(h, k = [])
+    new_hash = {}
+    h.each_pair do |key, val|
+      if val.is_a?(Hash)
+        new_hash.merge!(flat_hash(val, k + [key]))
+      else
+        new_hash[k + [key]] = val
+      end
+    end
+    new_hash
+  end
+
+  # Get expected value from rules.
+  #
+  # @param rules [Hash]
+  # @param multi_keys [Array<Symbol>]
+  # @return [Object] expected value.
+  def expected_value(rules, multi_keys)
+    multi_keys.inject(rules) { |o, key| o[key] }
+  end
+
+  # Wrap the string with single or double quote.
+  # @param string [String]
+  # @return [String]
+  def wrap_quote(string)
+    if string.include?("'")
+      "\"#{string}\""
+    else
+      "'#{string}'"
+    end
+  end
+
+  # Unwrap the quote from the string.
+  # @param string [String]
+  # @return [String]
+  def unwrap_quote(string)
+    if (string[0] == '"' && string[-1] == '"') || (string[0] == "'" && string[-1] == "'")
+      string[1...-1]
+    else
+      string
+    end
+  end
+end

data/lib/node_query/version.rb

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

data/lib/node_query.rb

@@ -11,6 +11,7 @@ class NodeQuery
   autoload :ParserAdapter, "node_query/parser_adapter"
   autoload :Compiler, "node_query/compiler"
   autoload :Helper, "node_query/helper"
+  autoload :NodeRules, "node_query/node_rules"
 
   # Configure NodeQuery
   # @param [Hash] options options to configure
@@ -26,15 +27,42 @@ class NodeQuery
   end
 
   # Initialize a NodeQuery.
-  # @param nql [String] node query language
-  def initialize(nql)
-    @expression = NodeQueryParser.new.parse(nql)
+  # @param nqlOrRules [String | Hash] node query language or node rules
+  def initialize(nqlOrRules)
+    if nqlOrRules.is_a?(String)
+      @expression = NodeQueryParser.new.parse(nqlOrRules)
+    else
+      @rules = NodeRules.new(nqlOrRules)
+    end
   end
 
-  # Parse ast node.
+  # Query matching nodes.
   # @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
   # @return [Array<Node>] matching child nodes
-  def parse(node)
-    @expression.query_nodes(node)
+  def query_nodes(node, options = {})
+    if @expression
+      @expression.query_nodes(node, options)
+    elsif @rules
+      @rules.query_nodes(node, options)
+    else
+      []
+    end
+  end
+
+  # Check if the node matches the nql or rules.
+  # @param node [Node] the node
+  # @return [Boolean]
+  def match_node?(node)
+    if @expression
+      @expression.match_node?(node)
+    elsif @rules
+      @rules.match_node?(node)
+    else
+      false
+    end
   end
 end

data/lib/node_query_lexer.rex

@@ -7,11 +7,9 @@ macros
   CLOSE_ARRAY              /\)/
   OPEN_SELECTOR            /\(/
   CLOSE_SELECTOR           /\)/
-  OPEN_DYNAMIC_ATTRIBUTE   /{{/
-  CLOSE_DYNAMIC_ATTRIBUTE  /}}/
   NODE_TYPE                /\.[a-z]+/
-  IDENTIFIER               /[\*\.\w]*\w/
-  IDENTIFIER_VALUE         /[\.\w!&:\?<>=]+/
+  IDENTIFIER               /[@\*\.\w]*\w/
+  IDENTIFIER_VALUE         /[@\.\w!&:\?<>=]+/
   FALSE                    /false/
   FLOAT                    /\d+\.\d+/
   INTEGER                  /\d+/
@@ -59,7 +57,6 @@ rules
 :VALUE              /\[\]/                        { [:tIDENTIFIER_VALUE, text] }
 :VALUE              /:\[\]=/                      { [:tSYMBOL, text[1..-1].to_sym] }
 :VALUE              /:\[\]/                       { [:tSYMBOL, text[1..-1].to_sym] }
-:VALUE              /{{#{IDENTIFIER}}}/           { [:tDYNAMIC_ATTRIBUTE, text[2..-3]] }
 :VALUE              /#{OPEN_ARRAY}/               { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
 :VALUE              /#{CLOSE_ATTRIBUTE}/          { @nested_count -= 1; @state = @nested_count == 0 ? nil : :VALUE; [:tCLOSE_ATTRIBUTE, text] }
 :VALUE              /#{NIL}\?/                    { [:tIDENTIFIER_VALUE, text] }

data/lib/node_query_lexer.rex.rb

@@ -14,27 +14,25 @@ class NodeQueryLexer
   require 'strscan'
 
   # :stopdoc:
-  OPEN_ATTRIBUTE          = /\[/
-  CLOSE_ATTRIBUTE         = /\]/
-  OPEN_ARRAY              = /\(/
-  CLOSE_ARRAY             = /\)/
-  OPEN_SELECTOR           = /\(/
-  CLOSE_SELECTOR          = /\)/
-  OPEN_DYNAMIC_ATTRIBUTE  = /{{/
-  CLOSE_DYNAMIC_ATTRIBUTE = /}}/
-  NODE_TYPE               = /\.[a-z]+/
-  IDENTIFIER              = /[\*\.\w]*\w/
-  IDENTIFIER_VALUE        = /[\.\w!&:\?<>=]+/
-  FALSE                   = /false/
-  FLOAT                   = /\d+\.\d+/
-  INTEGER                 = /\d+/
-  NIL                     = /nil/
-  REGEXP_BODY             = /(?:[^\/]|\\\/)*/
-  REGEXP                  = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
-  SYMBOL                  = /:[\w!\?<>=]+/
-  TRUE                    = /true/
-  SINGLE_QUOTE_STRING     = /'.*?'/
-  DOUBLE_QUOTE_STRING     = /".*?"/
+  OPEN_ATTRIBUTE      = /\[/
+  CLOSE_ATTRIBUTE     = /\]/
+  OPEN_ARRAY          = /\(/
+  CLOSE_ARRAY         = /\)/
+  OPEN_SELECTOR       = /\(/
+  CLOSE_SELECTOR      = /\)/
+  NODE_TYPE           = /\.[a-z]+/
+  IDENTIFIER          = /[@\*\.\w]*\w/
+  IDENTIFIER_VALUE    = /[@\.\w!&:\?<>=]+/
+  FALSE               = /false/
+  FLOAT               = /\d+\.\d+/
+  INTEGER             = /\d+/
+  NIL                 = /nil/
+  REGEXP_BODY         = /(?:[^\/]|\\\/)*/
+  REGEXP              = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
+  SYMBOL              = /:[\w!\?<>=]+/
+  TRUE                = /true/
+  SINGLE_QUOTE_STRING = /'.*?'/
+  DOUBLE_QUOTE_STRING = /".*?"/
   # :startdoc:
   # :stopdoc:
   class LexerError < StandardError ; end
@@ -201,8 +199,6 @@ class NodeQueryLexer
             action { [:tSYMBOL, text[1..-1].to_sym] }
           when text = ss.scan(/:\[\]/) then
             action { [:tSYMBOL, text[1..-1].to_sym] }
-          when text = ss.scan(/{{#{IDENTIFIER}}}/) then
-            action { [:tDYNAMIC_ATTRIBUTE, text[2..-3]] }
           when text = ss.scan(/#{OPEN_ARRAY}/) then
             action { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
           when text = ss.scan(/#{CLOSE_ATTRIBUTE}/) then