synvert-core 1.0.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a19f84568d17d7d51bf4f4486a7f95a299261c25eacd5ff57faea07fd597bc26
-  data.tar.gz: 8dce2d09629733e239046581aa03433a7231cf8094ba0e1aec99f1df7ec0f867
+  metadata.gz: e5bf36b2f9e986dd2baf0bbddf53f4671a3bf98af0db830c270960eb583b47ce
+  data.tar.gz: 7e8693858d73d11c09652076ee03d49fe69662386caff67cbd0a3cc37e47d0a2
 SHA512:
-  metadata.gz: 2a731bae510193fccf6c5682ff7559e7610b7774af5e2d0a196bad1ed838f84c5700e9dfcb123d0314b2ac40034d6246cd676b9e60e01f148ed17e6c32f1bc90
-  data.tar.gz: 15fad0af1dce17af70f2b3a8ab1af3827f57892437076ddda86acdde19f7b24691b05c5c7b064ef33985815e0fdb0eb7fc4ad29924433c955067ee715f302138
+  metadata.gz: ad0eb6125d82241c60f7f0e229b9735f7c253280f1e56d586dfd24e8afb9c25b2cf574ca9c21e252c485f529b1bdf5f6b26c2b59805781cdefd3bc07a76072d8
+  data.tar.gz: 37bd754087a17d55577a10338fef9da3c60733d8634e9c394666a826fe205dc7f895121570f1e9cca4e7e1284f0b3b11c16e532e197afe2cd0ce61424c5d1557

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## 1.2.0 (2022-04-29)
+
+* Remove comma in NQL array value
+* Parse pseduo class without selector in NQL
+* Parse multiple goto scope in NQL
+* Parse `nil?` in NQL
+
+## 1.1.1 (2022-04-27)
+
+* Parse empty string properly in node query language
+* Parse `[]` and `[]=` properly in node query language
+
+## 1.1.0 (2022-04-26)
+
+* Dynamic define Node methods by `TYPE_CHILDREN` const
+* Add `Node#to_hash`
+* Parse empty string in node query language
+* Identifier value can contain `?`, `<`, `=`, `>` in node query language
+
 ## 1.0.0 (2022-04-25)
 
 * Introduce new node query language

data/lib/synvert/core/array_ext.rb

@@ -13,7 +13,7 @@ class Array
     return child_direct_child_node if child_direct_child_node
 
     raise Synvert::Core::MethodNotSupported,
-          "child_node_by_name is not handled for #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+          "child_node_by_name is not handled for #{debug_info}, child_name: #{child_name}"
   end
 
   # Get the source range of child node.
@@ -35,7 +35,14 @@ class Array
       )
     else
       raise Synvert::Core::MethodNotSupported,
-            "child_node_range is not handled for #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+            "child_node_range is not handled for #{debug_info}, child_name: #{child_name}"
     end
   end
+
+  # Return the debug info.
+  #
+  # @return [String] file, line, source and node.
+  def debug_info
+    map(&:debug_info).join("\n")
+  end
 end

data/lib/synvert/core/node_ext.rb

@@ -27,11 +27,41 @@ module Parser::AST
   # +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}
+  # {https://synvert-playground.xinminlabs.com/ruby}
   class Node
+    TYPE_CHILDREN = {
+      and: %i[left_value right_value],
+      arg: %i[name],
+      begin: %i[body],
+      block: %i[caller arguments body],
+      blockarg: %i[name],
+      const: %i[parent_const name],
+      class: %i[name parent_class body],
+      csend: %i[receiver message arguments],
+      cvasgn: %i[left_value right_value],
+      cvar: %i[name],
+      def: %i[name arguments body],
+      definded?: %i[arguments],
+      defs: %i[self name arguments body],
+      hash: %i[pairs],
+      ivasgn: %i[left_value right_value],
+      ivar: %i[name],
+      lvar: %i[name],
+      lvasgn: %i[left_value right_value],
+      masgn: %i[left_value right_value],
+      module: %i[name body],
+      or: %i[left_value right_value],
+      or_asgn: %i[left_value right_value],
+      pair: %i[key value],
+      restarg: %i[name],
+      send: %i[receiver message arguments],
+      super: %i[arguments],
+      zsuper: %i[]
+    }
+
     # Initialize a Node.
     #
-    # It extends Parser::AST::Node and set parent for its child nodes.
+    # It extends {Parser::AST::Node} and set parent for its child nodes.
     def initialize(type, children = [], properties = {})
       @mutable_attributes = {}
       super
@@ -62,88 +92,32 @@ module Parser::AST
       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
-      when :class, :module, :def, :arg, :blockarg, :restarg, :lvar, :ivar, :cvar
-        children[0]
-      when :defs, :const
-        children[1]
-      when :mlhs
-        self
-      else
-        raise Synvert::Core::MethodNotSupported, "name is not handled for #{debug_info}"
-      end
-    end
+    # Dyamically defined method
+    # caller, key, left_value, message, name, parent_class, parent_const, receivr, rgith_value and value.
+    # based on const TYPE_CHILDREN.
+    %i[caller key left_value message name parent_class parent_const receiver right_value value].each do |method_name|
+      define_method(method_name) do
+        index = TYPE_CHILDREN[type]&.index(method_name)
+        return children[index] if index
 
-    # 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
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "parent_class is not handled for #{debug_info}"
+        raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
       end
     end
 
-    # Get parent constant of node.
-    # It supports :const node.
+    # Return the left value of node.
+    # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
     # @example
-    #   node # s(:const, s(:const, nil, :Synvert), :Node)
-    #   node.parent_const # s(:const, nil, :Synvert)
-    # @return [Parser::AST::Node] parent const of node.
+    #   node # s(:or_asgn, s(:lvasgn, :a), s(:int, 1))
+    #   node.left_value # :a
+    # @return [Parser::AST::Node] left value of node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def parent_const
-      if :const == type
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "parent_const is not handled for #{debug_info}"
-      end
-    end
+    def left_value
+      return children[0].children[0] if type == :or_asgn
 
-    # 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)
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "receiver is not handled for #{debug_info}"
-      end
-    end
+      index = TYPE_CHILDREN[type]&.index(:left_value)
+      return children[index] if index
 
-    # 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
-      when :super, :zsuper
-        :super
-      when :send, :csend
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "message is not handled for #{debug_info}"
-      end
+      raise Synvert::Core::MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
     end
 
     # Get arguments of node.
@@ -168,21 +142,6 @@ module Parser::AST
       end
     end
 
-    # 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
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "caller is not handled for #{debug_info}"
-      end
-    end
-
     # Get body of node.
     # It supports :begin, :block, :class, :def, :defs and :module node.
     # @example
@@ -281,66 +240,6 @@ module Parser::AST
       end
     end
 
-    # Get key node of hash :pair 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
-        children.first
-      else
-        raise Synvert::Core::MethodNotSupported, "key is not handled for #{debug_info}"
-      end
-    end
-
-    # Get value node of hash :pair 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
-        children.last
-      else
-        raise Synvert::Core::MethodNotSupported, "value is not handled for #{debug_info}"
-      end
-    end
-
-    # 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
-        children[0]
-      elsif :or_asgn == type
-        children[0].children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "left_value is not handled for #{debug_info}"
-      end
-    end
-
-    # 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
-        children[1]
-      else
-        raise Synvert::Core::MethodNotSupported, "right_value is not handled for #{debug_info}"
-      end
-    end
-
     # Return the exact value of node.
     # It supports :array, :begin, :erange, :false, :float, :irange, :int, :str, :sym and :true nodes.
     # @example
@@ -717,6 +616,28 @@ module Parser::AST
       end
     end
 
+    # Convert node to a hash, so that it can be converted to a json.
+    def to_hash
+      result = { type: type }
+      if TYPE_CHILDREN[type]
+        TYPE_CHILDREN[type].each do |key|
+          value = send(key)
+          result[key] =
+            case value
+            when Array
+              value.map { |v| v.respond_to?(:to_hash) ? v.to_hash : v }
+            when Parser::AST::Node
+              value.to_hash
+            else
+              value
+            end
+        end
+      else
+        result[:children] = children.map { |c| c.respond_to?(:to_hash) ? c.to_hash : c }
+      end
+      result
+    end
+
     private
 
     # Compare actual value with expected value.

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

@@ -28,7 +28,7 @@ module Synvert::Core::NodeQuery::Compiler
     end
 
     def to_s
-      [@value, @rest].compact.join(', ')
+      [@value, @rest].compact.join(' ')
     end
   end
 end

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

@@ -5,10 +5,12 @@ module Synvert::Core::NodeQuery::Compiler
   class Expression
     # Initialize a Expression.
     # @param selector [Synvert::Core::NodeQuery::Compiler::Selector] the selector
+    # @param goto_scope [String] goto scope
     # @param rest [Synvert::Core::NodeQuery::Compiler::Expression] the rest expression
     # @param relationship [Symbol] the relationship between the selector and rest expression, it can be <code>:descendant</code>, <code>:child</code>, <code>:next_sibling</code>, <code>:subsequent_sibling</code> or <code>nil</code>.
-    def initialize(selector: nil, rest: nil, relationship: nil)
+    def initialize(selector: nil, goto_scope: nil, rest: nil, relationship: nil)
       @selector = selector
+      @goto_scope = goto_scope
       @rest = rest
       @relationship = relationship
     end
@@ -30,49 +32,85 @@ module Synvert::Core::NodeQuery::Compiler
     # @param node [Parser::AST::Node] node to match
     # @param descendant_match [Boolean] whether to match in descendant node
     # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node, descendant_match: true)
-      matching_nodes = find_nodes_without_relationship(node, descendant_match: descendant_match)
-      if @relationship.nil?
-        return matching_nodes
-      end
+    def query_nodes(node, descendant_match = true)
+      return find_nodes_by_goto_scope(node) if @goto_scope
 
-      expression_nodes = matching_nodes.map do |matching_node|
-        case @relationship
-        when :descendant
-          nodes = []
-          matching_node.recursive_children { |child_node|
-            nodes += @rest.query_nodes(child_node, descendant_match: false)
-          }
-          nodes
-        when :child
-          matching_node.children.map { |child_node| @rest.query_nodes(child_node, descendant_match: false) }
-                       .flatten
-        when :next_sibling
-          @rest.query_nodes(matching_node.siblings.first, descendant_match: false)
-        when :subsequent_sibling
-          matching_node.siblings.map { |sibling_node| @rest.query_nodes(sibling_node, descendant_match: false) }
-                       .flatten
-        end
-      end.flatten
+      return find_nodes_by_relationship(node) if @relationship
+
+      matching_nodes = find_nodes_without_relationship(node, descendant_match)
+      return matching_nodes if @rest.nil?
+
+      matching_nodes.map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
+                    .flatten
     end
 
     def to_s
       return @selector.to_s unless @rest
 
       result = []
-      result << @selector if @selector
+      result << @selector.to_s if @selector
+      result << "<#{@goto_scope}>" if @goto_scope
       case @relationship
-      when :child then result << '>'
-      when :subsequent_sibling then result << '~'
-      when :next_sibling then result << '+'
+      when :child then result << "> #{@rest}"
+      when :subsequent_sibling then result << "~ #{@rest}"
+      when :next_sibling then result << "+ #{@rest}"
+      when :has then result << ":has(#{@rest})"
+      when :not_has then result << ":not_has(#{@rest})"
+      else result << @rest.to_s
       end
-      result << @rest
-      result.map(&:to_s).join(' ')
+      result.join(' ')
     end
 
     private
 
-    def find_nodes_without_relationship(node, descendant_match: true)
+    # Find nodes by @goto_scope
+    # @param node [Parser::AST::Node] node to match
+    def find_nodes_by_goto_scope(node)
+      @goto_scope.split('.').each { |scope| node = node.send(scope) }
+      @rest.query_nodes(node, false)
+    end
+
+    # Find ndoes by @relationship
+    # @param node [Parser::AST::Node] node to match
+    def find_nodes_by_relationship(node)
+      case @relationship
+      when :child
+        if node.is_a?(::Array)
+          return node.map { |each_node| find_nodes_by_rest(each_node) }
+                     .flatten
+        else
+          return node.children.map { |each_node| find_nodes_by_rest(each_node) }
+                     .flatten
+        end
+      when :next_sibling
+        return find_nodes_by_rest(node.siblings.first)
+      when :subsequent_sibling
+        return node.siblings.map { |each_node| find_nodes_by_rest(each_node) }
+                   .flatten
+      when :has
+        return @rest.match?(node) ? [node] : []
+      when :not_has
+        return !@rest.match?(node) ? [node] : []
+      end
+    end
+
+    # Find nodes by @rest
+    # @param node [Parser::AST::Node] node to match
+    # @param descendant_match [Boolean] whether to match in descendant node
+    def find_nodes_by_rest(node, descendant_match = false)
+      @rest.query_nodes(node, descendant_match)
+    end
+
+    # Find nodes with nil relationship.
+    # @param node [Parser::AST::Node] node to match
+    # @param descendant_match [Boolean] whether to match in descendant node
+    def find_nodes_without_relationship(node, descendant_match = true)
+      if node.is_a?(::Array)
+        return node.map { |each_node|
+          find_nodes_without_relationship(each_node, descendant_match)
+        }.flatten
+      end
+
       return [node] unless @selector
 
       nodes = []

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

@@ -7,12 +7,14 @@ module Synvert::Core::NodeQuery::Compiler
     # @param node_type [String] the node type
     # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
     # @param index [Integer] the index
-    # @param has_expression [Synvert::Core::NodeQuery::Compiler::Expression] the has expression
-    def initialize(node_type: nil, attribute_list: nil, index: nil, has_expression: nil)
+    # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
+    # @param pseudo_expression [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo expression
+    def initialize(node_type: nil, attribute_list: nil, index: nil, pseudo_class: nil, pseudo_expression: nil)
       @node_type = node_type
       @attribute_list = attribute_list
       @index = index
-      @has_expression = has_expression
+      @pseudo_class = pseudo_class
+      @pseudo_expression = pseudo_expression
     end
 
     # Filter nodes by index.
@@ -27,25 +29,28 @@ module Synvert::Core::NodeQuery::Compiler
     def match?(node, _operator = :==)
       (!@node_type || (node.is_a?(::Parser::AST::Node) && @node_type.to_sym == node.type)) &&
         (!@attribute_list || @attribute_list.match?(node)) &&
-        (!@has_expression || @has_expression.match?(node))
+        (!@pseudo_class || (@pseudo_class == 'has' && @pseudo_expression.match?(node)) || (@pseudo_class == 'not_has' && !@pseudo_expression.match?(node)))
     end
 
     def to_s
-      str = ".#{@node_type}#{@attribute_list}"
-      return str if !@index && !@has_expression
-
-      return "#{str}:has(#{@has_expression})" if @has_expression
-
-      case @index
-      when 0
-        str + ':first-child'
-      when -1
-        str + ':last-child'
-      when (1..)
-        str + ":nth-child(#{@index + 1})"
-      else # ...-1
-        str + ":nth-last-child(#{-@index})"
+      result = []
+      result << ".#{@node_type}" if @node_type
+      result << @attribute_list.to_s if @attribute_list
+      result << ":#{@pseudo_class}(#{@pseudo_expression})" if @pseudo_class
+      if @index
+        result <<
+          case @index
+          when 0
+            ':first-child'
+          when -1
+            ':last-child'
+          when (1..)
+            ":nth-child(#{@index + 1})"
+          else # ...-1
+            ":nth-last-child(#{-@index})"
+          end
       end
+      result.join('')
     end
   end
 end

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

@@ -16,17 +16,6 @@ module Synvert::Core::NodeQuery::Compiler
       SIMPLE_VALID_OPERATORS
     end
 
-    # Get the actual value of a node.
-    # @param node [Parser::AST::Node] the node
-    # @return [String] if node is a Parser::AST::Node, return the node source code, otherwise, return the string value.
-    def actual_value(node)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_source
-      else
-        node.to_s
-      end
-    end
-
     def to_s
       "\"#{@value}\""
     end

data/lib/synvert/core/node_query/lexer.rex

@@ -7,6 +7,8 @@ macros
   CLOSE_ARRAY              /\)/
   OPEN_SELECTOR            /\(/
   CLOSE_SELECTOR           /\)/
+  OPEN_GOTO_SCOPE          /</
+  CLOSE_GOTO_SCOPE         />/
   OPEN_DYNAMIC_ATTRIBUTE   /{{/
   CLOSE_DYNAMIC_ATTRIBUTE  /}}/
   NODE_TYPE                /\.[a-z]+/
@@ -31,14 +33,19 @@ rules
                     /:last-child/                 { [:tINDEX, -1] }
                     /:nth-child\(\d+\)/           { [:tINDEX, text.sub(':nth-child(', '').to_i - 1] }
                     /:nth-last-child\(\d+\)/      { [:tINDEX, -text.sub(':nth-last-child(', '').to_i] }
-                    /:has/                        { [:tHAS, text[1..-1]] }
+                    /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
+                    /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
                     /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
                     />/                           { [:tCHILD, text] }
                     /~/                           { [:tSUBSEQUENT_SIBLING, text] }
                     /\+/                          { [:tNEXT_SIBLING, text] }
                     /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
                     /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
+                    /#{OPEN_GOTO_SCOPE}/          { @state = :GOTO_SCOPE; [:tOPEN_GOTO_SCOPE, text] }
                     /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+:GOTO_SCOPE         /\s+/
+:GOTO_SCOPE         /#{IDENTIFIER}/               { [:tIDENTIFIER, text] }
+:GOTO_SCOPE         /#{CLOSE_GOTO_SCOPE}/         { @state = nil; [:tCLOSE_GOTO_SCOPE, text] }
 :KEY                /\s+/
 :KEY                /!=/                          { @state = :VALUE; [:tNOT_EQUAL, text] }
 :KEY                /=~/                          { @state = :VALUE; [:tMATCH, text] }
@@ -53,9 +60,14 @@ rules
 :KEY                /in/i                         { @state = :VALUE; [:tIN, text] }
 :KEY                /#{IDENTIFIER}/               { [:tKEY, text] }
 :VALUE              /\s+/
+:VALUE              /\[\]=/                       { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /\[\]/                        { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /:\[\]=/                      { [:tSYMBOL, text[1..-1].to_sym] }
+:VALUE              /:\[\]/                       { [:tSYMBOL, text[1..-1].to_sym] }
 :VALUE              /#{OPEN_DYNAMIC_ATTRIBUTE}/   { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
 :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] }
 :VALUE              /#{NIL}/                      { [:tNIL, nil] }
 :VALUE              /#{TRUE}/                     { [:tBOOLEAN, true] }
 :VALUE              /#{FALSE}/                    { [:tBOOLEAN, false] }
@@ -71,8 +83,8 @@ rules
 :DYNAMIC_ATTRIBUTE  /#{CLOSE_DYNAMIC_ATTRIBUTE}/  { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
 :DYNAMIC_ATTRIBUTE  /#{IDENTIFIER}/               { [:tDYNAMIC_ATTRIBUTE, text] }
 :ARRAY_VALUE        /\s+/
-:ARRAY_VALUE        /,/                           { [:tCOMMA, text] }
 :ARRAY_VALUE        /#{CLOSE_ARRAY}/              { @state = :VALUE; [:tCLOSE_ARRAY, text] }
+:ARRAY_VALUE        /#{NIL}\?/                    { [:tIDENTIFIER_VALUE, text] }
 :ARRAY_VALUE        /#{NIL}/                      { [:tNIL, nil] }
 :ARRAY_VALUE        /#{TRUE}/                     { [:tBOOLEAN, true] }
 :ARRAY_VALUE        /#{FALSE}/                    { [:tBOOLEAN, false] }