synvert-core 0.64.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea27da2bceb8ec0f2dd837e5aa80135860a2539c7e49170b2bd46af227d1043e
-  data.tar.gz: a901be4a294000eecfbbbf407416015cd9b38499ebc24c744147aebdeba5388f
+  metadata.gz: 2e678636827f8ffcad275fe7c6e6bcbee9d278a954bf33a80822ff7235944469
+  data.tar.gz: fa6c7ad36ed9fa50901f4b6f9f373190aa3ad0cbba4bdea539daf66376bc6e0c
 SHA512:
-  metadata.gz: b9d0451d59718fe04e23d48a90e7e705fb455592d2636055064d9c5d7f6a1db20980ff1a38b147d77b16fdc8b059b95a8a95848c183a4115ddb1730541bf0757
-  data.tar.gz: 63246572cc0d9c3d44d7bb12f6d716e11b15fd1978376588e235a4c2f9b5e7849962ed4a81e38bd1a9f74c2cb877325148c486c9f3045ebf8c0aa80459d9b6aa
+  metadata.gz: bd53c12635ecb49e6d2c6b43d8a0513ac0fd2c2c0b6de8081bc30318512ae7714c092c2e36a721059b2ec811ec521757a1b32889d2e6ff4cb516ce83877cfef6
+  data.tar.gz: 4a0e169b94bc54a61e944d3e44d5bd40a884783c73c2ad491dbb23a25c77c73bb2e120f0feb61494a8bf8762c234cbc3d983185e0bc2eb18a6ec8cb3d2c933ab

data/.github/workflows/main.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.5', '2.6', '2.7', '3.0', '3.1']
+        ruby-version: ['2.6', '2.7', '3.0', '3.1']
 
     steps:
     - uses: actions/checkout@v2

data/.gitignore

@@ -15,3 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+lib/synvert/core/node_query/lexer.rex.rb
+lib/synvert/core/node_query/parser.racc.rb
+lib/synvert/core/node_query/parser.output

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 1.0.0 (2022-04-25)
+
+* Introduce new node query language
+* Drop ruby 2.5 support
+
 ## 0.64.0 (2022-04-02)
 
 * Read absolute path of Gemfile.lock

data/Guardfile

@@ -2,6 +2,15 @@
 
 guard :rspec, cmd: 'bundle exec rspec' do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  watch('lib/synvert/core/node_query/lexer.rex.rb') { 'spec/synvert/core/node_query/lexer_spec.rb'  }
+  watch('lib/synvert/core/node_query/compiler.rb') { 'spec/synvert/core/node_query/parser_spec.rb'  }
+  watch(%r{^lib/synvert/core/node_query/compiler/.*\.rb$}) { 'spec/synvert/core/node_query/parser_spec.rb' }
+  watch('lib/synvert/core/node_query/parser.racc.rb') { 'spec/synvert/core/node_query/parser_spec.rb' }
+  watch('spec/spec_helper.rb') { "spec" }
+end
+
+guard :rake, task: 'generate' do
+  watch('lib/synvert/core/node_query/lexer.rex')
+  watch('lib/synvert/core/node_query/parser.y')
 end

data/README.md

@@ -2,8 +2,8 @@
 
 <img src="https://synvert.xinminlabs.com/img/logo_96.png" alt="logo" width="32" height="32" />
 
+[![AwesomeCode Status for xinminlabs/synvert-core-ruby](https://awesomecode.io/projects/033f7f02-7b22-41c3-a902-fca37f1ec72a/status)](https://awesomecode.io/repos/xinminlabs/synvert-core-ruby)
 ![Main workflow](https://github.com/xinminlabs/synvert-core-ruby/actions/workflows/main.yml/badge.svg)
-[![Gem Version](https://badge.fury.io/rb/synvert-core.png)](http://badge.fury.io/rb/synvert-core)
 
 Synvert core provides a set of DSLs to rewrite ruby code. e.g.
 
@@ -77,4 +77,4 @@ Actions:
 * [wrap](./Synvert/Core/Rewriter/Instance.html#wrap-instance_method) - wrap the current node with code
 * [replace_with](./Synvert/Core/Rewriter/Instance.html#replace_with-instance_method) - replace the whole code of current node
 * [warn](./Synvert/Core/Rewriter/Instance.html#warn-instance_method) - warn message
-* [replace_erb_stmt_with_expr](./Synvert/Core/Rewriter/Instance.html#replace_erb_stmt_with_expr-instance_method) - replace erb stmt code to expr code
+* [replace_erb_stmt_with_expr](./Synvert/Core/Rewriter/Instance.html#replace_erb_stmt_with_expr-instance_method) - replace erb stmt code to expr code

data/Rakefile

@@ -2,7 +2,21 @@
 
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
-
 RSpec::Core::RakeTask.new(:spec)
+require 'oedipus_lex'
+Rake.application.rake_require "oedipus_lex"
+
+file "lib/synvert/core/node_query/lexer.rex.rb" => "lib/synvert/core/node_query/lexer.rex"
+file "lib/synvert/core/node_query/parser.racc.rb" => "lib/synvert/core/node_query/parser.y"
+
+task :lexer  => "lib/synvert/core/node_query/lexer.rex.rb"
+task :parser => "lib/synvert/core/node_query/parser.racc.rb"
+task :generate  => [:lexer, :parser]
+
+rule '.racc.rb' => '.y' do |t|
+  cmd = "bundle exec racc -l -v -o #{t.name} #{t.source}"
+  sh cmd
+end
 
 task :default => :spec
+task :spec => :generate

data/lib/synvert/core/array_ext.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Extend Array.
+class Array
+  # Get child node by the name.
+  #
+  # @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.split('.', 2)
+    child_direct_child_node = direct_child_name =~ /\A\d+\z/ ? self[direct_child_name.to_i - 1] : self.send(direct_child_name)
+    return child_direct_child_node.child_node_by_name(nested_child_name) if 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 #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+  end
+
+  # Get the source range 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)
+    direct_child_name, nested_child_name = child_name.split('.', 2)
+    child_direct_child_node = direct_child_name =~ /\A\d+\z/ ? self[direct_child_name.to_i - 1] : self.send(direct_child_name)
+    if nested_child_name
+      return child_direct_child_node.child_node_range(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 #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+    end
+  end
+end

data/lib/synvert/core/engine/erb.rb

@@ -43,11 +43,13 @@ module Synvert::Core
         end
 
         def decode_html_output(source)
-          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text(Regexp.last_match(1)) }.gsub(
-            /@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/mo
-          ) { reverse_escape_text(Regexp.last_match(1)) }.gsub(
-            /@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/mo
-          ) { reverse_escape_text(Regexp.last_match(1)) }
+          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text(Regexp.last_match(1)) }
+                .gsub(
+                  /@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/mo
+                ) { reverse_escape_text(Regexp.last_match(1)) }
+                .gsub(
+                  /@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/mo
+                ) { reverse_escape_text(Regexp.last_match(1)) }
         end
 
         def remove_erubis_buf(source)
@@ -64,6 +66,7 @@ module Synvert::Core
 
     # borrowed from rails
     class Erubis < ::Erubis::Eruby
+      BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
       def add_preamble(src)
         @newline_pending = 0
         src << '@output_buffer = output_buffer || ActionView::OutputBuffer.new;'
@@ -76,7 +79,7 @@ module Synvert::Core
           @newline_pending += 1
         else
           src << "@output_buffer.safe_append='"
-          src << "\n" * @newline_pending if @newline_pending > 0
+          src << ("\n" * @newline_pending) if @newline_pending > 0
           src << escape_text(text)
           src << "'.freeze;"
 
@@ -95,8 +98,6 @@ module Synvert::Core
         end
       end
 
-      BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
       def add_expr_literal(src, code)
         flush_newline_if_pending(src)
         if BLOCK_EXPR.match?(code)

data/lib/synvert/core/node_ext.rb

@@ -27,8 +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}
+  # {https://synvert-playground.xinminlabs.com?language=ruby}
   class Node
+    # Initialize a 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.
@@ -123,9 +156,9 @@ module Parser::AST
     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?
@@ -311,7 +344,7 @@ module Parser::AST
     # 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)) ["str", :str]
+    #   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.
@@ -323,6 +356,8 @@ module Parser::AST
         true
       when :false
         false
+      when :nil
+        nil
       when :array
         children.map(&:to_value)
       when :irange
@@ -425,27 +460,12 @@ 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)
-            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
 
@@ -460,7 +480,11 @@ module Parser::AST
     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)',
@@ -490,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?
 
@@ -703,7 +706,7 @@ module Parser::AST
       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', '->')

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

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Attribute is a pair of key, value and operator,
+  class Attribute
+    # Initialize a Attribute.
+    # @param key [String] the key
+    # @param value the value can be any class implement {Synvert::Core::NodeQuery::Compiler::Comparable}
+    # @param operator [Symbol] the operator
+    def initialize(key:, value:, operator: :==)
+      @key = key
+      @value = value
+      @operator = operator
+    end
+
+    # Check if the node matches the attribute.
+    # @param node [Parser::AST::Node] the node
+    # @return [Boolean]
+    def match?(node)
+      @value.base_node = node if @value.is_a?(DynamicAttribute)
+      node && @value.match?(node.child_node_by_name(@key), @operator)
+    end
+
+    def to_s
+      case @operator
+      when :!=
+        "#{@key}!=#{@value}"
+      when :=~
+        "#{@key}=~#{@value}"
+      when :!~
+        "#{@key}!~#{@value}"
+      when :>
+        "#{@key}>#{@value}"
+      when :>=
+        "#{@key}>=#{@value}"
+      when :<
+        "#{@key}<#{@value}"
+      when :<=
+        "#{@key}<=#{@value}"
+      when :in
+        "#{@key} in (#{@value})"
+      when :not_in
+        "#{@key} not in (#{@value})"
+      when :includes
+        "#{@key} includes #{@value}"
+      else
+        "#{@key}=#{@value}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # AttributeList contains one or more {Synvert::Core::NodeQuery::Compiler::Attribute}.
+  class AttributeList
+    # Initialize a AttributeList.
+    # @param attribute [Synvert::Core::NodeQuery::Compiler::Attribute] the attribute
+    # @param rest [Synvert::Core::NodeQuery::Compiler::AttributeList] the rest attribute list
+    def initialize(attribute:, rest: nil)
+      @attribute = attribute
+      @rest = rest
+    end
+
+    # Check if the node matches the attribute list.
+    # @return [Boolean]
+    def match?(node)
+      @attribute.match?(node) && (!@rest || @rest.match?(node))
+    end
+
+    def to_s
+      "[#{@attribute}]#{@rest}"
+    end
+  end
+end

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

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

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Compare acutal value with expected value.
+  module Comparable
+    SIMPLE_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) > 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

@@ -0,0 +1,51 @@
+# 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