synvert-core 1.4.0 → 1.5.0

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Compare acutal value with expected value.
-  module Comparable
-    SIMPLE_VALID_OPERATORS = ['==', '!=', 'includes']
-    STRING_VALID_OPERATORS = ['==', '!=', '^=', '$=', '*=', 'includes']
-    NUMBER_VALID_OPERATORS = ['==', '!=', '>', '>=', '<', '<=', 'includes']
-    ARRAY_VALID_OPERATORS = ['==', '!=', 'in', 'not_in']
-    REGEXP_VALID_OPERATORS = ['=~', '!~']
-
-    # Check if the actual value matches the expected value.
-    #
-    # @param node [Parser::AST::Node] node to calculate actual value
-    # @param operator [Symbol] 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 [Synvert::Core::NodeQuery::Compiler::InvalidOperatorError] if operator is invalid
-    def match?(node, operator)
-      raise InvalidOperatorError, "invalid operator #{operator}" unless valid_operator?(operator)
-
-      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, '!=') }
-        else
-          actual_value(node) != expected_value
-        end
-      when '=~'
-        actual_value(node) =~ expected_value
-      when '!~'
-        actual_value(node) !~ expected_value
-      when '^='
-        actual_value(node).start_with?(expected_value)
-      when '$='
-        actual_value(node).end_with?(expected_value)
-      when '*='
-        actual_value(node).include?(expected_value)
-      when '>'
-        actual_value(node) > expected_value
-      when '>='
-        actual_value(node) >= expected_value
-      when '<'
-        actual_value(node) < expected_value
-      when '<='
-        actual_value(node) <= expected_value
-      when 'in'
-        expected_value.any? { |expected| expected.match?(node, '==') }
-      when 'not_in'
-        expected_value.all? { |expected| expected.match?(node, '!=') }
-      when 'includes'
-        actual_value(node).any? { |actual| actual == expected_value }
-      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, '==') }
-        else
-          actual_value(node) == expected_value
-        end
-      end
-    end
-
-    # Get the actual value from ast node.
-    # @return if node is a {Parser::AST::Node}, return the node value, otherwise, return the node itself.
-    def actual_value(node)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_value
-      else
-        node
-      end
-    end
-
-    # Get the expected value
-    def expected_value
-      @value
-    end
-
-    # Check if the operator is valid.
-    # @return [Boolean] true if the operator is valid
-    def valid_operator?(operator)
-      valid_operators.include?(operator)
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # DynamicAttribute represents a ruby dynamic attribute.
-  # e.g. code is <code>{ a: a }</code>, query is <code>'.hash > .pair[key={{value}}]'</code>,
-  # <code>{{value}}</code> is the dynamic attribute.
-  class DynamicAttribute
-    include Comparable
-
-    attr_accessor :base_node
-
-    # Initialize a DynamicAttribute.
-    # @param value [String] the dynamic attribute value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get the actual value of a node.
-    #
-    # @param node the node
-    # @return [String] if node is a {Parser::AST::Node}, return the node source code, otherwise return the node itself.
-    def actual_value(node)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_source
-      else
-        node
-      end
-    end
-
-    # Get the expected value.
-    #
-    # @return [String] Query the node by @valud from base_node, if the node is a {Parser::AST::Node}, return the node source code, otherwise return the node itself.
-    def expected_value
-      node = base_node.child_node_by_name(@value)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_source
-      else
-        node
-      end
-    end
-
-    # Get valid operators.
-    def valid_operators
-      SIMPLE_VALID_OPERATORS
-    end
-
-    def to_s
-      "{{#{@value}}}"
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Expression represents a node query expression.
-  class Expression
-    # Initialize a Expression.
-    # @param selector [Synvert::Core::NodeQuery::Compiler::Selector] the selector
-    # @param rest [Synvert::Core::NodeQuery::Compiler::Expression] the rest expression
-    def initialize(selector: nil, rest: nil)
-      @selector = selector
-      @rest = rest
-    end
-
-    # Check if the node matches the expression.
-    # @param node [Parser::AST::Node] the node
-    # @return [Boolean]
-    def match?(node)
-      !query_nodes(node).empty?
-    end
-
-    # Query nodes by the selector and the rest expression.
-    #
-    # @param node [Parser::AST::Node] node to match
-    # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node)
-      matching_nodes = @selector.query_nodes(node)
-      return matching_nodes if @rest.nil?
-
-      matching_nodes.flat_map do |matching_node|
-        @rest.query_nodes(matching_node)
-      end
-    end
-
-    def to_s
-      result = []
-      result << @selector.to_s if @selector
-      result << @rest.to_s if @rest
-      result.join(' ')
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Float represents a ruby float value.
-  class Float
-    include Comparable
-
-    # Initialize a Float.
-    # @param value [Float] the float value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get valid operators.
-    def valid_operators
-      NUMBER_VALID_OPERATORS
-    end
-
-    def to_s
-      @value.to_s
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Identifier represents a ruby identifier value.
-  # e.g. code is `class Synvert; end`, `Synvert` is an identifier.
-  class Identifier
-    include Comparable
-
-    # Initialize an Identifier.
-    # @param value [String] the identifier value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get the actual value.
-    #
-    # @param node the node
-    # @return [String|Array]
-    # If the node is a {Parser::AST::Node}, return the node source code,
-    # 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)
-        node.to_source
-      elsif node.is_a?(::Array)
-        node.map { |n| actual_value(n) }
-      else
-        node.to_s
-      end
-    end
-
-    # Get valid operators.
-    def valid_operators
-      STRING_VALID_OPERATORS
-    end
-
-    def to_s
-      @value
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Integer represents a ruby integer value.
-  class Integer
-    include Comparable
-
-    # Initialize a Integer.
-    # @param value [Integer] the integer value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get valid operators.
-    def valid_operators
-      NUMBER_VALID_OPERATORS
-    end
-
-    def to_s
-      @value.to_s
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Operator is invalid error.
-  class InvalidOperatorError < StandardError
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Nil represents a ruby nil value.
-  class Nil
-    include Comparable
-
-    # Initialize a Nil.
-    # @param value [nil] the nil value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get valid operators.
-    def valid_operators
-      SIMPLE_VALID_OPERATORS
-    end
-
-    def to_s
-      'nil'
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # The parser error.
-  class ParseError < StandardError
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Regexp represents a ruby regexp value.
-  class Regexp
-    include Comparable
-
-    # Initialize a Regexp.
-    # @param value [Regexp] the regexp value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Check if the regexp value matches the node value.
-    # @param node [Parser::AST::Node] the node
-    # @param operator [Symbol] 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(node.to_source)
-        else
-          @value.match(node.to_s)
-        end
-      operator == '=~' ? match : !match
-    end
-
-    # Get valid operators.
-    def valid_operators
-      REGEXP_VALID_OPERATORS
-    end
-
-    def to_s
-      @value.to_s
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Selector used to match nodes, it combines by node type and/or attribute list, plus index or has expression.
-  class Selector
-    # Initialize a Selector.
-    # @param goto_scope [String] goto scope
-    # @param relationship [Symbol] the relationship between the selectors, it can be descendant <code>nil</code>, child <code>></code>, next sibling <code>+</code> or subsequent sibing <code>~</code>.
-    # @param rest [Synvert::Core::NodeQuery::Compiler::Selector] the rest selector
-    # @param basic_selector [Synvert::Core::NodeQuery::Compiler::BasicSelector] the simple selector
-    # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
-    # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
-    # @param pseudo_selector [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo selector
-    def initialize(goto_scope: nil, relationship: nil, rest: nil, basic_selector: nil, pseudo_class: nil, pseudo_selector: nil)
-      @goto_scope = goto_scope
-      @relationship = relationship
-      @rest = rest
-      @basic_selector = basic_selector
-      @pseudo_class = pseudo_class
-      @pseudo_selector = pseudo_selector
-    end
-
-    # 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)
-    end
-
-    # Query nodes by the selector.
-    #
-    # * If relationship is nil, it will match in all recursive child nodes and return matching nodes.
-    # * If relationship is decendant, it will match in all recursive child nodes.
-    # * If relationship is child, it will match in direct child nodes.
-    # * 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 [Parser::AST::Node] node to match
-    # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node)
-      return find_nodes_by_relationship(node) if @relationship
-
-      if node.is_a?(::Array)
-        return node.flat_map { |child_node| query_nodes(child_node) }
-      end
-
-      return find_nodes_by_goto_scope(node) if @goto_scope
-
-      nodes = []
-      nodes << node if match?(node)
-      if @basic_selector
-        node.recursive_children do |child_node|
-          nodes << child_node if match?(child_node)
-        end
-      end
-      nodes
-    end
-
-    def to_s
-      result = []
-      result << "#{@goto_scope} " if @goto_scope
-      result << "#{@relationship} " if @relationship
-      result << @rest.to_s if @rest
-      result << @basic_selector.to_s if @basic_selector
-      result << ":#{@pseudo_class}(#{@pseudo_selector})" if @pseudo_class
-      result.join('')
-    end
-
-    private
-
-    # 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)
-    end
-
-    # Find ndoes by @relationship
-    # @param node [Parser::AST::Node] node to match
-    def find_nodes_by_relationship(node)
-      nodes = []
-      case @relationship
-      when '>'
-        if node.is_a?(::Array)
-          node.each do |child_node|
-            nodes << child_node if @rest.match?(child_node)
-          end
-        else
-          node.children.each do |child_node|
-            nodes << child_node if @rest.match?(child_node)
-          end
-        end
-      when '+'
-        next_sibling = node.siblings.first
-        nodes << next_sibling if @rest.match?(next_sibling)
-      when '~'
-        node.siblings.each do |sibling_node|
-          nodes << sibling_node if @rest.match?(sibling_node)
-        end
-      end
-      nodes
-    end
-
-    def match_pseudo_class?(node)
-      case @pseudo_class
-      when 'has'
-        !@pseudo_selector.query_nodes(node).empty?
-      when 'not_has'
-        @pseudo_selector.query_nodes(node).empty?
-      else
-        true
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # String represents a ruby string value.
-  class String
-    include Comparable
-
-    # Initialize a String.
-    # @param value [String] the string value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get valid operators.
-    def valid_operators
-      STRING_VALID_OPERATORS
-    end
-
-    def to_s
-      "\"#{@value}\""
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Symbol represents a ruby symbol value.
-  class Symbol
-    include Comparable
-
-    # Initliaze a Symobol.
-    # @param value [Symbol] the symbol value
-    def initialize(value:)
-      @value = value
-    end
-
-    # Get valid operators.
-    def valid_operators
-      SIMPLE_VALID_OPERATORS
-    end
-
-    def to_s
-      ":#{@value}"
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  autoload :InvalidOperatorError, 'synvert/core/node_query/compiler/invalid_operator_error'
-  autoload :ParseError, 'synvert/core/node_query/compiler/parse_error'
-
-  autoload :Comparable, 'synvert/core/node_query/compiler/comparable'
-
-  autoload :Expression, 'synvert/core/node_query/compiler/expression'
-  autoload :Selector, 'synvert/core/node_query/compiler/selector'
-  autoload :BasicSelector, 'synvert/core/node_query/compiler/basic_selector'
-  autoload :AttributeList, 'synvert/core/node_query/compiler/attribute_list'
-  autoload :Attribute, 'synvert/core/node_query/compiler/attribute'
-
-  autoload :Array, 'synvert/core/node_query/compiler/array'
-  autoload :Boolean, 'synvert/core/node_query/compiler/boolean'
-  autoload :DynamicAttribute, 'synvert/core/node_query/compiler/dynamic_attribute'
-  autoload :Float, 'synvert/core/node_query/compiler/float'
-  autoload :Identifier, 'synvert/core/node_query/compiler/identifier'
-  autoload :Integer, 'synvert/core/node_query/compiler/integer'
-  autoload :Nil, 'synvert/core/node_query/compiler/nil'
-  autoload :Regexp, 'synvert/core/node_query/compiler/regexp'
-  autoload :String, 'synvert/core/node_query/compiler/string'
-  autoload :Symbol, 'synvert/core/node_query/compiler/symbol'
-end

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

@@ -1,99 +0,0 @@
-class Synvert::Core::NodeQuery::Lexer
-
-macros
-  OPEN_ATTRIBUTE           /\[/
-  CLOSE_ATTRIBUTE          /\]/
-  OPEN_ARRAY               /\(/
-  CLOSE_ARRAY              /\)/
-  OPEN_SELECTOR            /\(/
-  CLOSE_SELECTOR           /\)/
-  OPEN_DYNAMIC_ATTRIBUTE   /{{/
-  CLOSE_DYNAMIC_ATTRIBUTE  /}}/
-  NODE_TYPE                /\.[a-z]+/
-  IDENTIFIER               /[\.\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      /".*?"/
-
-rules
-
-# [:state]          pattern                       [actions]
-                    /\s+/
-                    /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
-                    /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
-                    /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-                    /#{IDENTIFIER}/               { [:tGOTO_SCOPE, text] }
-                    />/                           { [:tRELATIONSHIP, text] }
-                    /~/                           { [:tRELATIONSHIP, text] }
-                    /\+/                          { [:tRELATIONSHIP, text] }
-                    /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
-                    /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
-                    /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
-:KEY                /\s+/
-:KEY                /\^=/                         { @state = :VALUE; [:tOPERATOR, '^='] }
-:KEY                /\$=/                         { @state = :VALUE; [:tOPERATOR, '$='] }
-:KEY                /\*=/                         { @state = :VALUE; [:tOPERATOR, '*='] }
-:KEY                /!=/                          { @state = :VALUE; [:tOPERATOR, '!='] }
-:KEY                /=~/                          { @state = :VALUE; [:tOPERATOR, '=~'] }
-:KEY                /!~/                          { @state = :VALUE; [:tOPERATOR, '!~'] }
-:KEY                />=/                          { @state = :VALUE; [:tOPERATOR, '>='] }
-:KEY                /<=/                          { @state = :VALUE; [:tOPERATOR, '<='] }
-:KEY                />/                           { @state = :VALUE; [:tOPERATOR, '>'] }
-:KEY                /</                           { @state = :VALUE; [:tOPERATOR, '<'] }
-:KEY                /=/                           { @state = :VALUE; [:tOPERATOR, '=='] }
-:KEY                /includes/i                   { @state = :VALUE; [:tOPERATOR, 'includes'] }
-:KEY                /not in/i                     { @state = :VALUE; [:tOPERATOR, 'not_in'] }
-:KEY                /in/i                         { @state = :VALUE; [:tOPERATOR, 'in'] }
-: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] }
-:VALUE              /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
-:VALUE              /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
-:VALUE              /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
-:VALUE              /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
-:VALUE              /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:VALUE              /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:VALUE              /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-:VALUE              /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
-:VALUE              /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
-:DYNAMIC_ATTRIBUTE  /#{CLOSE_DYNAMIC_ATTRIBUTE}/  { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
-:DYNAMIC_ATTRIBUTE  /#{IDENTIFIER}/               { [:tDYNAMIC_ATTRIBUTE, text] }
-:ARRAY_VALUE        /\s+/
-: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] }
-:ARRAY_VALUE        /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
-:ARRAY_VALUE        /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
-:ARRAY_VALUE        /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
-:ARRAY_VALUE        /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
-:ARRAY_VALUE        /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:ARRAY_VALUE        /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:ARRAY_VALUE        /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
-
-inner
-  def initialize
-    @nested_count = 0
-  end
-
-  def do_parse; end
-end