node_query 1.0.0 → 1.3.0

data/lib/node_query/compiler/expression_list.rb

@@ -13,12 +13,20 @@ module NodeQuery::Compiler
 
     # Query nodes by the current and the rest expression.
     # @param node [Node] node to match
+    # @params including_self [boolean] if query the current node.
     # @return [Array<Node>] matching nodes.
-    def query_nodes(node)
-      matching_nodes = @expression.query_nodes(node)
+    def query_nodes(node, including_self = true)
+      matching_nodes = @expression.query_nodes(node, including_self)
       return matching_nodes if @rest.nil?
 
-      matching_nodes + @rest.query_nodes(node)
+      matching_nodes + @rest.query_nodes(node, including_self)
+    end
+
+    # Check if the node matches the expression list.
+    # @param node [Node] the node
+    # @return [Boolean]
+    def match_node?(node)
+      !query_nodes(node).empty?
     end
 
     def to_s

data/lib/node_query/compiler/identifier.rb

@@ -19,8 +19,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 node.is_a?(::Parser::AST::Node)
-        NodeQuery.get_adapter.get_source(node)
+      if NodeQuery.adapter.is_node?(node)
+        NodeQuery.adapter.get_source(node)
       elsif node.is_a?(::Array)
         node.map { |n| actual_value(n) }
       else

data/lib/node_query/compiler/regexp.rb

@@ -13,16 +13,13 @@ module NodeQuery::Compiler
 
     # Check if the regexp value matches the node value.
     # @param node [Node] the node
-    # @param operator [String] the operator
-    # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
-    def match?(node, operator = '=~')
-      match =
-        if node.is_a?(::Parser::AST::Node)
-          @value.match(NodeQuery.get_adapter.get_source(node))
-        else
-          @value.match(node.to_s)
-        end
-      operator == '=~' ? match : !match
+    # @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
     end
 
     # Get valid operators.

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,9 @@ 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
+    # @params including_self [boolean] if query the current node.
     # @return [Array<Node>] matching nodes.
-    def query_nodes(node)
+    def query_nodes(node, including_self = true)
       return find_nodes_by_relationship(node) if @relationship
 
       if node.is_a?(::Array)
@@ -44,7 +45,9 @@ module NodeQuery::Compiler
       return find_nodes_by_goto_scope(node) if @goto_scope
 
       nodes = []
-      nodes << node if match?(node)
+      if including_self && match?(node)
+        nodes << node
+      end
       if @basic_selector
         NodeQuery::Helper.handle_recursive_child(node) do |child_node|
           nodes << child_node if match?(child_node)
@@ -86,7 +89,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,35 +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.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.get_adapter.get_children(node).each do |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

data/lib/node_query/node_rules.rb

@@ -0,0 +1,174 @@
+# 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
+  # @params including_self [boolean] if query the current node.
+  # @return [Array<Node>] matching nodes.
+  def query_nodes(node, including_self = true)
+    matching_nodes  = []
+    if (including_self && match_node?(node))
+      matching_nodes.push(node)
+    end
+    NodeQuery::Helper.handle_recursive_child(node) do |child_node|
+      if (match_node?(child_node))
+        matching_nodes.push(child_node)
+      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/parser_adapter.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class NodeQuery::ParserAdapter
+  def is_node?(node)
+    node.is_a?(Parser::AST::Node)
+  end
+
   def get_node_type(node)
     node.type
   end
@@ -10,11 +14,11 @@ class NodeQuery::ParserAdapter
   end
 
   def get_children(node)
-    node.is_a?(Parser::AST::Node) ? node.children : []
+    node.children
   end
 
   def get_siblings(node)
     index = node.parent.children.index(node)
     node.parent.children[index + 1..]
   end
-end
+end

data/lib/node_query/version.rb

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

data/lib/node_query.rb

@@ -3,13 +3,16 @@
 require 'active_support/core_ext/array'
 
 require_relative "node_query/version"
-require_relative "node_query/parser_adapter"
-require_relative "node_query/compiler"
-require_relative "node_query/helper"
 require_relative "./node_query_lexer.rex"
 require_relative "./node_query_parser.racc"
 
 class NodeQuery
+  autoload :Adapter, "node_query/adapter"
+  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
   # @option options [NodeQuery::Adapter] :adapter the adpater
@@ -19,20 +22,44 @@ class NodeQuery
 
   # Get the adapter
   # @return [NodeQuery::Adapter] current adapter, by default is {NodeQuery::ParserAdapter}
-  def self.get_adapter
+  def self.adapter
     @adapter ||= ParserAdapter.new
   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 including_self [boolean] if check the node itself
   # @return [Array<Node>] matching child nodes
-  def parse(node)
-    @expression.query_nodes(node)
+  def query_nodes(node, including_self = true)
+    if @expression
+      @expression.query_nodes(node, including_self)
+    elsif @rules
+      @rules.query_nodes(node, including_self)
+    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]+/
-  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] }