synvert-core 0.63.1 → 1.0.2

data/lib/synvert/core/node_ext.rb

@@ -1,11 +1,74 @@
 # frozen_string_literal: true
 
 module Parser::AST
-  # Parser::AST::Node monkey patch.
+  # Extend Parser::AST::Node.
+  # {https://github.com/whitequark/parser/blob/master/lib/parser/ast/node.rb}
+  #
+  # Rules
+  #
+  # Synvert compares ast nodes with key / value pairs, each ast node has
+  # multiple attributes, e.g. +receiver+, +message+ and +arguments+, it
+  # matches only when all of key / value pairs match.
+  #
+  # +type: 'send', message: :include, arguments: ['FactoryGirl::Syntax::Methods']+
+  #
+  # Synvert does comparison based on the value type
+  #
+  # 1. if value is a symbol, then compares ast node value as symbol, e.g. +message: :include+
+  # 2. if value is a string, then compares ast node original source code, e.g. +name: 'Synvert::Application'+
+  # 3. if value is a regexp, then compares ast node original source code, e.g. +message: /find_all_by_/+
+  # 4. if value is an array, then compares each ast node, e.g. +arguments: ['FactoryGirl::Syntax::Methods']+
+  # 5. if value is nil, then check if ast node is nil, e.g. +arguments: [nil]+
+  # 6. if value is true or false, then check if ast node is :true or :false, e.g. +arguments: [false]+
+  # 7. if value is ast, then compare ast node directly, e.g. +to_ast: Parser::CurrentRuby.parse("self.class.serialized_attributes")+
+  #
+  # It can also compare nested key / value pairs, like
+  #
+  # +type: 'send', receiver: { type: 'send', receiver: { type: 'send', message: 'config' }, message: 'active_record' }, message: 'identity_map='+
+  #
+  # Source Code to Ast Node
+  # {https://synvert-playground.xinminlabs.com?language=ruby}
   class Node
-    # Get name node of :class, :module, :const, :mlhs, :def and :defs node.
+    # Initialize a Node.
     #
-    # @return [Parser::AST::Node] name node.
+    # It extends Parser::AST::Node and set parent for its child nodes.
+    def initialize(type, children = [], properties = {})
+      @mutable_attributes = {}
+      super
+      # children could be nil for s(:array)
+      Array(children).each do |child_node|
+        if child_node.is_a?(Parser::AST::Node)
+          child_node.parent = self
+        end
+      end
+    end
+
+    # Get the parent node.
+    # @return [Parser::AST::Node] parent node.
+    def parent
+      @mutable_attributes[:parent]
+    end
+
+    # Set the parent node.
+    # @param node [Parser::AST::Node] parent node.
+    def parent=(node)
+      @mutable_attributes[:parent] = node
+    end
+
+    # Get the sibling nodes.
+    # @return [Array<Parser::AST::Node>] sibling nodes.
+    def siblings
+      index = parent.children.index(self)
+      parent.children[index + 1..]
+    end
+
+    # Get the name of node.
+    # It supports :arg, :blockarg, :class, :const, :cvar, :def, :defs, :ivar,
+    # :lvar, :mlhs, :module and :restarg nodes.
+    # @example
+    #   node # => s(:class, s(:const, nil, :Synvert), nil, nil)
+    #   node.name # => s(:const, nil, :Synvert)
+    # @return [Parser::AST::Node] name of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def name
       case type
@@ -20,9 +83,12 @@ module Parser::AST
       end
     end
 
-    # Get parent_class node of :class node.
-    #
-    # @return [Parser::AST::Node] parent_class node.
+    # Get parent_class of node.
+    # It supports :class node.
+    # @example
+    #   node # s(:class, s(:const, nil, :Post), s(:const, s(:const, nil, :ActiveRecord), :Base), nil)
+    #   node.parent_class # s(:const, s(:const, nil, :ActiveRecord), :Base)
+    # @return [Parser::AST::Node] parent_class of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def parent_class
       if :class == type
@@ -32,9 +98,12 @@ module Parser::AST
       end
     end
 
-    # Get parent constant node of :const node.
-    #
-    # @return [Parser::AST::Node] parent const node.
+    # Get parent constant of node.
+    # It supports :const node.
+    # @example
+    #   node # s(:const, s(:const, nil, :Synvert), :Node)
+    #   node.parent_const # s(:const, nil, :Synvert)
+    # @return [Parser::AST::Node] parent const of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def parent_const
       if :const == type
@@ -44,9 +113,12 @@ module Parser::AST
       end
     end
 
-    # Get receiver node of :send node.
-    #
-    # @return [Parser::AST::Node] receiver node.
+    # Get receiver of node.
+    # It support :csend and :send nodes.
+    # @example
+    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post))
+    #   node.receiver # s(:const, nil, :FactoryGirl)
+    # @return [Parser::AST::Node] receiver of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def receiver
       if %i[csend send].include?(type)
@@ -56,9 +128,12 @@ module Parser::AST
       end
     end
 
-    # Get message node of :super or :send node.
-    #
-    # @return [Parser::AST::Node] mesage node.
+    # Get message of node.
+    # It support :csend, :send, :super and :zsuper nodes.
+    # @example
+    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post))
+    #   node.message # :create
+    # @return [Symbol] mesage of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def message
       case type
@@ -71,16 +146,19 @@ module Parser::AST
       end
     end
 
-    # Get arguments node of :send, :block or :defined? node.
-    #
-    # @return [Array<Parser::AST::Node>] arguments node.
+    # Get arguments of node.
+    # It supports :block, :csend, :def, :defined?, :defs and :send nodes.
+    # @example
+    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post"))))
+    #   node.arguments # [s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post")))]
+    # @return [Array<Parser::AST::Node>] arguments of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def arguments
       case type
       when :def, :block
-        children[1]
+        children[1].children
       when :defs
-        children[2]
+        children[2].children
       when :send, :csend
         children[2..-1]
       when :defined?
@@ -90,9 +168,12 @@ module Parser::AST
       end
     end
 
-    # Get caller node of :block node.
-    #
-    # @return [Parser::AST::Node] caller node.
+    # Get caller of node.
+    # It support :block node.
+    # @example
+    #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), nil)
+    #   node.caller # s(:send, s(:const, nil, :RSpec), :configure)
+    # @return [Parser::AST::Node] caller of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def caller
       if :block == type
@@ -102,9 +183,12 @@ module Parser::AST
       end
     end
 
-    # Get body node of :begin or :block node.
-    #
-    # @return [Array<Parser::AST::Node>] body node.
+    # Get body of node.
+    # It supports :begin, :block, :class, :def, :defs and :module node.
+    # @example
+    #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers)))
+    #   node.body # [s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers))]
+    # @return [Array<Parser::AST::Node>] body of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def body
       case type
@@ -123,9 +207,12 @@ module Parser::AST
       end
     end
 
-    # Get condition node of :if node.
-    #
-    # @return [Parser::AST::Node] condition node.
+    # Get condition of node.
+    # It supports :if node.
+    # @example
+    #   node # s(:if, s(:defined?, s(:const, nil, :Bundler)), nil, nil)
+    #   node.condition # s(:defined?, s(:const, nil, :Bundler))
+    # @return [Parser::AST::Node] condition of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def condition
       if :if == type
@@ -135,9 +222,11 @@ module Parser::AST
       end
     end
 
-    # Get keys node of :hash node.
-    #
-    # @return [Array<Parser::AST::Node>] keys node.
+    # Get keys of :hash node.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
+    #   node.keys # [s(:sym, :foo), s(:str, "foo")]
+    # @return [Array<Parser::AST::Node>] keys of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def keys
       if :hash == type
@@ -147,9 +236,11 @@ module Parser::AST
       end
     end
 
-    # Get values node of :hash node.
-    #
-    # @return [Array<Parser::AST::Node>] values node.
+    # Get values of :hash node.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
+    #   node.values # [s(:sym, :bar), s(:str, "bar")]
+    # @return [Array<Parser::AST::Node>] values of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def values
       if :hash == type
@@ -159,9 +250,11 @@ module Parser::AST
       end
     end
 
-    # Test if hash node contains specified key.
-    #
-    # @param [Object] key value.
+    # Check if :hash node contains specified key.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+    #   node.key?(:foo) # true
+    # @param [Symbol, String] key value.
     # @return [Boolean] true if specified key exists.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def key?(key)
@@ -172,10 +265,12 @@ module Parser::AST
       end
     end
 
-    # Get hash value node according to specified key.
-    #
-    # @param [Object] key value.
-    # @return [Parser::AST::Node] value node.
+    # Get :hash value node according to specified key.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+    #   node.hash_value(:foo) # s(:sym, :bar)
+    # @param [Symbol, String] key value.
+    # @return [Parser::AST::Node] hash value of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def hash_value(key)
       if :hash == type
@@ -187,8 +282,10 @@ module Parser::AST
     end
 
     # Get key node of hash :pair node.
-    #
-    # @return [Parser::AST::Node] key node.
+    # @example
+    #   node # s(:pair, s(:sym, :foo), s(:str, "bar"))
+    #   node.key # s(:sym, :foo)
+    # @return [Parser::AST::Node] key of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def key
       if :pair == type
@@ -199,8 +296,10 @@ module Parser::AST
     end
 
     # Get value node of hash :pair node.
-    #
-    # @return [Parser::AST::Node] value node.
+    # @example
+    #   node # s(:pair, s(:sym, :foo), s(:str, "bar"))
+    #   node.value # s(:str, "bar")
+    # @return [Parser::AST::Node] value of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def value
       if :pair == type
@@ -210,9 +309,12 @@ module Parser::AST
       end
     end
 
-    # Return the left value.
-    #
-    # @return [Parser::AST::Node] variable nodes.
+    # Return the left value of node.
+    # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
+    # @example
+    #   node # s(:masgn, s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)), s(:array, s(:int, 1), s(:int, 2)))
+    #   node.left_value # s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b))
+    # @return [Parser::AST::Node] left value of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def left_value
       if %i[masgn lvasgn ivasgn cvasgn and or].include? type
@@ -224,9 +326,12 @@ module Parser::AST
       end
     end
 
-    # Return the right value.
-    #
-    # @return [Array<Parser::AST::Node>] variable nodes.
+    # Return the right value of node.
+    # It supports :cvasgn, :ivasgn, :lvasgn, :masgn, :or and :or_asgn nodes.
+    # @example
+    #   node # s(:masgn, s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)), s(:array, s(:int, 1), s(:int, 2)))
+    #   node.right_value # s(:array, s(:int, 1), s(:int, 2))
+    # @return [Array<Parser::AST::Node>] right value of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def right_value
       if %i[masgn lvasgn ivasgn cvasgn or_asgn and or].include? type
@@ -236,8 +341,11 @@ module Parser::AST
       end
     end
 
-    # Return the exact value.
-    #
+    # Return the exact value of node.
+    # It supports :array, :begin, :erange, :false, :float, :irange, :int, :str, :sym and :true nodes.
+    # @example
+    #   node # s(:array, s(:str, "str"), s(:sym, :str))
+    #   node.to_value # ['str', :str]
     # @return [Object] exact value.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def to_value
@@ -248,6 +356,8 @@ module Parser::AST
         true
       when :false
         false
+      when :nil
+        nil
       when :array
         children.map(&:to_value)
       when :irange
@@ -261,10 +371,11 @@ module Parser::AST
       end
     end
 
-    # Respond key value for hash node, e.g.
-    #
-    # Current node is s(:hash, s(:pair, s(:sym, :number), s(:int, 10)))
-    # node.number_value is 10
+    # Respond key value and source for hash node, e.g.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
+    #   node.foo_value # :bar
+    #   node.foo_source # ":bar"
     def method_missing(method_name, *args, &block)
       if :args == type && children.respond_to?(method_name)
         return children.send(method_name, *args, &block)
@@ -299,12 +410,9 @@ module Parser::AST
       super
     end
 
-    def to_s
-      if :mlhs == type
-        "(#{children.map(&:name).join(', ')})"
-      end
-    end
-
+    # Return the debug info.
+    #
+    # @return [String] file, line, source and node.
     def debug_info
       "\n" +
         [
@@ -315,64 +423,49 @@ module Parser::AST
         ].join("\n")
     end
 
-    # Get the file name of the current node.
+    # Get the file name of node.
     #
     # @return [String] file name.
     def filename
       loc.expression&.source_buffer.name
     end
 
-    # Get the source code of current node.
+    # Get the source code of node.
     #
     # @return [String] source code.
     def to_source
       loc.expression&.source
     end
 
-    # Get the column of current node.
+    # Get the column of node.
     #
     # @return [Integer] column.
     def column
       loc.expression.column
     end
 
-    # Get the line of current node.
+    # Get the line of node.
     #
     # @return [Integer] line.
     def line
       loc.expression.line
     end
 
-    # Get child node by child name.
+    # Get child node by the name.
     #
-    # @param [String] name of child node.
+    # @param child_name [String] name of child node.
     # @return [Parser::AST::Node] the child node.
     def child_node_by_name(child_name)
       direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
       if respond_to?(direct_child_name)
         child_node = send(direct_child_name)
 
-        if nested_child_name
-          if child_node.is_a?(Array)
-            child_direct_child_name, child_nested_child_name = nested_child_name.split('.', 2)
-            child_direct_child_node = child_direct_child_name =~ /\A\d+\z/ ? child_node[child_direct_child_name.to_i - 1] : child_node.send(child_direct_child_name)
-            return child_direct_child_node.child_node_by_name(child_nested_child_name) if child_nested_child_name
-            return child_direct_child_node if child_direct_child_node
-
-            raise Synvert::Core::MethodNotSupported,
-                  "child_node_by_name is not handled for #{debug_info}, child_name: #{child_name}"
-          end
-
-          return child_node.child_node_by_name(nested_child_name)
-        end
+        return child_node.child_node_by_name(nested_child_name) if nested_child_name
 
         return nil if child_node.nil?
 
         return child_node if child_node.is_a?(Parser::AST::Node)
 
-        # arguments
-        return nil if child_node.empty?
-
         return child_node
       end
 
@@ -382,12 +475,16 @@ module Parser::AST
 
     # Get the source range of child node.
     #
-    # @param [String] name of child node.
+    # @param child_name [String] name of child node.
     # @return [Parser::Source::Range] source range of child node.
     def child_node_range(child_name)
       case [type, child_name.to_sym]
       when %i[block pipes], %i[def parentheses], %i[defs parentheses]
-        Parser::Source::Range.new('(string)', arguments.loc.expression.begin_pos, arguments.loc.expression.end_pos)
+        Parser::Source::Range.new(
+          '(string)',
+          arguments.first.loc.expression.begin_pos - 1,
+          arguments.last.loc.expression.end_pos + 1
+        )
       when %i[block arguments], %i[def arguments], %i[defs arguments]
         Parser::Source::Range.new(
           '(string)',
@@ -417,28 +514,7 @@ module Parser::AST
         if respond_to?(direct_child_name)
           child_node = send(direct_child_name)
 
-          if nested_child_name
-            if child_node.is_a?(Array)
-              child_direct_child_name, child_nested_child_name = nested_child_name.split('.', 2)
-              child_direct_child_node = child_direct_child_name =~ /\A\d+\z/ ? child_node[child_direct_child_name.to_i - 1] : child_node.send(child_direct_child_name)
-              if child_nested_child_name
-                return child_direct_child_node.child_node_range(child_nested_child_name)
-              elsif child_direct_child_node
-                return (
-                  Parser::Source::Range.new(
-                    '(string)',
-                    child_direct_child_node.loc.expression.begin_pos,
-                    child_direct_child_node.loc.expression.end_pos
-                  )
-                )
-              else
-                raise Synvert::Core::MethodNotSupported,
-                      "child_node_range is not handled for #{debug_info}, child_name: #{child_name}"
-              end
-            end
-
-            return child_node.child_node_range(nested_child_name)
-          end
+          return child_node.child_node_range(nested_child_name) if nested_child_name
 
           return nil if child_node.nil?
 
@@ -469,7 +545,7 @@ module Parser::AST
       end
     end
 
-    # Recursively iterate all child nodes of current node.
+    # Recursively iterate all child nodes of node.
     #
     # @yield [child] Gives a child node.
     # @yieldparam child [Parser::AST::Node] child node
@@ -482,8 +558,12 @@ module Parser::AST
       end
     end
 
-    # Match current node with rules.
-    #
+    # Match node with rules.
+    # It provides some additional keywords to match rules, +any+, +contain+, +not+, +in+, +not_in+, +gt+, +gte+, +lt+, +lte+.
+    # @example
+    #   type: 'send', arguments: { any: 'Lifo::ShowExceptions' }
+    #   type: { in: ['send', 'csend'] }
+    #   type: :send, arguments: { length: { gt: 2 } }
     # @param rules [Hash] rules to match.
     # @return true if matches.
     def match?(rules)
@@ -517,11 +597,10 @@ module Parser::AST
 
     # Get rewritten source code.
     # @example
-    #   node.rewritten_source("create({{arguments}})") #=> "create(:post)"
-    #
+    #   node.rewritten_source("create({{arguments}})") # "create(:post)"
     # @param code [String] raw code.
-    # @return [String] rewritten code, replace string in block {{ }} in raw code.
-    # @raise [Synvert::Core::MethodNotSupported] if string in block {{ }} does not support.
+    # @return [String] rewritten code, replace string in block !{{ }} in raw code.
+    # @raise [Synvert::Core::MethodNotSupported] if string in block !{{ }} does not support.
     def rewritten_source(code)
       code.gsub(/{{(.*?)}}/m) do
         old_code = Regexp.last_match(1)
@@ -563,47 +642,71 @@ module Parser::AST
       end
     end
 
-    # strip curly braces for hash
+    # Strip curly braces for hash.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:str, "bar")))
+    #   node.strip_curly_braces # "foo: 'bar'"
+    # @return [String]
     def strip_curly_braces
       return to_source unless type == :hash
 
       to_source.sub(/^{(.*)}$/) { Regexp.last_match(1).strip }
     end
 
-    # wrap curly braces for hash
+    # Wrap curly braces for hash.
+    # @example
+    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:str, "bar")))
+    #   node.wrap_curly_braces # "{ foo: 'bar' }"
+    # @return [String]
     def wrap_curly_braces
       return to_source unless type == :hash
 
       "{ #{to_source} }"
     end
 
-    # get single quote string
+    # Get single quote string.
+    # @example
+    #   node # s(:str, "foobar")
+    #   node.to_single_quote # "'foobar'"
+    # @return [String]
     def to_single_quote
       return to_source unless type == :str
 
       "'#{to_value}'"
     end
 
-    # convert string to symbol
+    # Convert string to symbol.
+    # @example
+    #   node # s(:str, "foobar")
+    #   node.to_symbol # ":foobar"
+    # @return [String]
     def to_symbol
       return to_source unless type == :str
 
       ":#{to_value}"
     end
 
-    # convert symbol to string
+    # Convert symbol to string.
+    # @example
+    #   node # s(:sym, :foobar)
+    #   node.to_string # "foobar"
+    # @return [String]
     def to_string
       return to_source unless type == :sym
 
       to_value.to_s
     end
 
-    # convert lambda {} to -> {}
+    # Convert lambda {} to -> {}
+    # @example
+    #   node # s(:block, s(:send, nil, :lambda), s(:args), s(:send, nil, :foobar))
+    #   node.to_lambda_literal # "-> { foobar }"
+    # @return [String]
     def to_lambda_literal
       if type == :block && caller.type == :send && caller.receiver.nil? && caller.message == :lambda
         new_source = to_source
         if arguments.size > 1
-          new_source = new_source[0...arguments.loc.begin.to_range.begin - 1] + new_source[arguments.loc.end.to_range.end..-1]
+          new_source = new_source[0...arguments.first.loc.expression.begin_pos - 2] + new_source[arguments.last.loc.expression.end_pos + 1..-1]
           new_source = new_source.sub('lambda', "->(#{arguments.map(&:to_source).join(', ')})")
         else
           new_source = new_source.sub('lambda', '->')
@@ -620,7 +723,7 @@ module Parser::AST
     #
     # @param actual [Object] actual value.
     # @param expected [Object] expected value.
-    # @return [Integer] -1, 0 or 1.
+    # @return [Boolean]
     # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
     def match_value?(actual, expected)
       return true if actual == expected
@@ -678,7 +781,7 @@ module Parser::AST
     #
     # @example
     #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
-    #     #=> {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
+    #     # {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
     # @param h [Hash] original hash.
     # @return flatten hash.
     def flat_hash(h, k = [])
@@ -695,8 +798,7 @@ module Parser::AST
 
     # Get actual value from the node.
     #
-    # @param node [Parser::AST::Node]
-    # @param multi_keys [Array<Symbol>]
+    # @param multi_keys [Array<Symbol, String>]
     # @return [Object] actual value.
     def actual_value(multi_keys)
       multi_keys.inject(self) { |n, key| n.send(key) if n }
@@ -711,6 +813,7 @@ module Parser::AST
       multi_keys.inject(rules) { |o, key| o[key] }
     end
 
+    # Wrap the string with single or double quote.
     def wrap_quote(string)
       if string.include?("'")
         "\"#{string}\""
@@ -719,6 +822,7 @@ module Parser::AST
       end
     end
 
+    # Unwrap the quote from the string.
     def unwrap_quote(string)
       if (string[0] == '"' && string[-1] == '"') || (string[0] == "'" && string[-1] == "'")
         string[1...-1]

data/lib/synvert/core/node_query/compiler/array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Array represents a ruby array value.
+  class Array
+    include Comparable
+
+    # 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)
+      @value = value
+      @rest = rest
+    end
+
+    # Get the expected value.
+    # @return [Array]
+    def expected_value
+      expected = []
+      expected.push(@value) if @value
+      expected += @rest.expected_value if @rest
+      expected
+    end
+
+    # Get valid operators.
+    def valid_operators
+      ARRAY_VALID_OPERATORS
+    end
+
+    def to_s
+      [@value, @rest].compact.join(', ')
+    end
+  end
+end