hotcell 0.1.0 → 0.2.0

data/lib/hotcell/parser.y

@@ -45,6 +45,7 @@ prechigh
   nonassoc EQUAL INEQUAL
   left AND
   left OR
+  nonassoc RANGE
   right TERNARY
   right ASSIGN
   nonassoc COMMA COLON
@@ -57,9 +58,16 @@ rule
   document_unit: template | tag | block_tag | command_tag
 
   template: TEMPLATE { result = val[0] }
-  tag: TOPEN TCLOSE { result = build Tag, :TAG, mode: TAG_MODES[val[0]], position: pospoppush(2) }
+  tag: TOPEN TCLOSE {
+         result = build Tag, :TAG,
+           mode: tag_modes(val[0], @escape_tags ? :escape : :normal),
+           position: pospoppush(2)
+       }
      | TOPEN sequence TCLOSE {
-         result = build Tag, :TAG, *Array.wrap(val[1]).flatten, mode: TAG_MODES[val[0]], position: pospoppush(3)
+         result = build Tag, :TAG,
+           *Array.wrap(val[1]).flatten,
+           mode: tag_modes(val[0], @escape_tags ? :escape : :normal),
+           position: pospoppush(3)
        }
 
   command_body: COMMAND { result = build @commands[val[0]] || Command, val[0], position: pospoppush(1) }
@@ -73,7 +81,7 @@ rule
   command_tag: TOPEN command TCLOSE {
                  command = val[1].is_a?(Command) ? val[1] : val[1].children[0]
                  command.validate!
-                 result = build Tag, :TAG, val[1], mode: TAG_MODES[val[0]], position: pospoppush(3)
+                 result = build Tag, :TAG, val[1], mode: tag_modes(val[0]), position: pospoppush(3)
                }
 
   subcommand: SUBCOMMAND { result = build @substack.last[val[0]], val[0], position: pospoppush(1) }
@@ -94,7 +102,7 @@ rule
              | END BLOCK { pospoppush(2) }
              | END
   block_open_tag: TOPEN block_open TCLOSE {
-                    result = build Tag, :TAG, val[1], mode: TAG_MODES[val[0]], position: pospoppush(3)
+                    result = build Tag, :TAG, val[1], mode: tag_modes(val[0]), position: pospoppush(3)
                   }
   block_close_tag: TOPEN block_close TCLOSE { pospoppush(3) }
   block_subnodes: block_subnodes document_unit {
@@ -130,27 +138,27 @@ rule
           | NEWLINE { result = [] }
           | expr { result = [val[0]] }
 
-  expr: expr MULTIPLY expr { result = build Calculator, :MULTIPLY, val[0], val[2], position: pospoppush(3) }
-      | expr POWER expr { result = build Calculator, :POWER, val[0], val[2], position: pospoppush(3) }
-      | expr DIVIDE expr { result = build Calculator, :DIVIDE, val[0], val[2], position: pospoppush(3) }
-      | expr PLUS expr { result = build Calculator, :PLUS, val[0], val[2], position: pospoppush(3) }
-      | expr MINUS expr { result = build Calculator, :MINUS, val[0], val[2], position: pospoppush(3) }
-      | expr MODULO expr { result = build Calculator, :MODULO, val[0], val[2], position: pospoppush(3) }
-      | MINUS expr =UMINUS { result = build Calculator, :UMINUS, val[1], position: pospoppush(2) }
-      | PLUS expr =UPLUS { result = build Calculator, :UPLUS, val[1], position: pospoppush(2) }
-      | expr AND expr { result = build Calculator, :AND, val[0], val[2], position: pospoppush(3) }
-      | expr OR expr { result = build Calculator, :OR, val[0], val[2], position: pospoppush(3) }
-      | expr GT expr { result = build Calculator, :GT, val[0], val[2], position: pospoppush(3) }
-      | expr GTE expr { result = build Calculator, :GTE, val[0], val[2], position: pospoppush(3) }
-      | expr LT expr { result = build Calculator, :LT, val[0], val[2], position: pospoppush(3) }
-      | expr LTE expr { result = build Calculator, :LTE, val[0], val[2], position: pospoppush(3) }
-      | expr EQUAL expr { result = build Calculator, :EQUAL, val[0], val[2], position: pospoppush(3) }
-      | expr INEQUAL expr { result = build Calculator, :INEQUAL, val[0], val[2], position: pospoppush(3) }
-      | NOT expr { result = build Calculator, :NOT, val[1], position: pospoppush(2) }
+  expr: expr MULTIPLY expr { result = build Expression, :MULTIPLY, val[0], val[2], position: pospoppush(3) }
+      | expr POWER expr { result = build Expression, :POWER, val[0], val[2], position: pospoppush(3) }
+      | expr DIVIDE expr { result = build Expression, :DIVIDE, val[0], val[2], position: pospoppush(3) }
+      | expr PLUS expr { result = build Expression, :PLUS, val[0], val[2], position: pospoppush(3) }
+      | expr MINUS expr { result = build Expression, :MINUS, val[0], val[2], position: pospoppush(3) }
+      | expr MODULO expr { result = build Expression, :MODULO, val[0], val[2], position: pospoppush(3) }
+      | MINUS expr =UMINUS { result = build Expression, :UMINUS, val[1], position: pospoppush(2) }
+      | PLUS expr =UPLUS { result = build Expression, :UPLUS, val[1], position: pospoppush(2) }
+      | expr AND expr { result = build Expression, :AND, val[0], val[2], position: pospoppush(3) }
+      | expr OR expr { result = build Expression, :OR, val[0], val[2], position: pospoppush(3) }
+      | expr GT expr { result = build Expression, :GT, val[0], val[2], position: pospoppush(3) }
+      | expr GTE expr { result = build Expression, :GTE, val[0], val[2], position: pospoppush(3) }
+      | expr LT expr { result = build Expression, :LT, val[0], val[2], position: pospoppush(3) }
+      | expr LTE expr { result = build Expression, :LTE, val[0], val[2], position: pospoppush(3) }
+      | expr EQUAL expr { result = build Expression, :EQUAL, val[0], val[2], position: pospoppush(3) }
+      | expr INEQUAL expr { result = build Expression, :INEQUAL, val[0], val[2], position: pospoppush(3) }
+      | NOT expr { result = build Expression, :NOT, val[1], position: pospoppush(2) }
       | IDENTIFER ASSIGN expr { result = build Assigner, val[0], val[2], position: pospoppush(3) }
       | expr PERIOD method { pospoppush(3); val[2].children[0] = val[0]; result = val[2] }
       | expr AOPEN arguments ACLOSE {
-          result = build Summoner, 'manipulator_brackets', val[0], *val[2], position: pospoppush(4)
+          result = build Summoner, '[]', val[0], *val[2], position: pospoppush(4)
         }
       | POPEN PCLOSE { pospoppush(2); result = nil }
       | POPEN sequence PCLOSE {
@@ -164,12 +172,17 @@ rule
         }
       | value
 
-  value: const | number | string | array | hash | method
+  value: const | number | string | range | array | hash | method
 
   const: NIL | TRUE | FALSE
   number: INTEGER | FLOAT
   string: STRING | REGEXP
 
+  range: expr RANGE expr {
+           result = build Expression, val[1] == '..' ? :RANGE : :ERANGE,
+             val[0], val[2], position: pospoppush(3)
+         }
+
   array: AOPEN ACLOSE { result = build Arrayer, :ARRAY, position: pospoppush(2) }
        | AOPEN params ACLOSE { result = build Arrayer, :ARRAY, *val[1], position: pospoppush(3) }
   params: params COMMA expr { pospoppush(3); val[0].push(val[2]) }
@@ -207,7 +220,10 @@ rule
   NEWLINE_PRED = Set.new(BOPEN.values + OPERATIONS.values)
   NEWLINE_NEXT = Set.new(BCLOSE.values + [:NEWLINE])
 
-  TAG_MODES = { '{{' => :normal, '{{!' => :silence }
+  TAG_MODES = {
+    '!' => :silence, '^' => :escape, 'e' => :escape,
+    '~' => :normal, 'r' => :normal
+  }
 
   def initialize source, options = {}
     @source = Source.wrap(source)
@@ -218,6 +234,7 @@ rule
     @commands = options[:commands] || {}
     @blocks = options[:blocks] || {}
     @endblocks = Set.new(@blocks.keys.map { |identifer| "end#{identifer}" })
+    @escape_tags = !!options[:escape_tags]
 
     @substack = []
     @posstack = []
@@ -237,6 +254,11 @@ rule
     reduced
   end
 
+  def tag_modes tag, default = :normal
+    mode = tag.gsub(/^{{/, '').first
+    TAG_MODES[mode] || default
+  end
+
   def parse
     if @tokens.size == 0
       build Joiner, :JOINER, position: 0

data/lib/hotcell/template.rb

@@ -5,7 +5,8 @@ module Hotcell
     def self.parse source
       new source,
         commands: Hotcell.commands,
-        blocks: Hotcell.blocks
+        blocks: Hotcell.blocks,
+        escape_tags: Hotcell.escape_tags
     end
 
     def initialize source, options = {}
@@ -14,7 +15,7 @@ module Hotcell
     end
 
     def syntax
-      @syntax ||= Parser.new(source, options.slice(:commands, :blocks)).parse
+      @syntax ||= Parser.new(source, options.slice(:commands, :blocks, :escape_tags)).parse
     end
 
     def render context = {}

data/lib/hotcell/version.rb

@@ -1,3 +1,3 @@
 module Hotcell
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/hotcell.rb

@@ -8,7 +8,7 @@ module Hotcell
   def self.config; Config.instance; end
 
   singleton_class.delegate :commands, :blocks, :helpers, :register_command, :register_helpers,
-    :resolver, :resolver=, to: :config
+    :resolver, :resolver=, :escape_tags, :escape_tags=, to: :config
 end
 
 require 'hotcell/manipulator'

data/spec/lib/hotcell/commands/for_spec.rb

@@ -17,6 +17,9 @@ describe Hotcell::Commands::For do
   describe '#render' do
     specify { parse('{{ for item, in: [1, 2, 3] }}{{ end for }}').render.should == '' }
     specify { parse('{{ for item, in: [1, 2, 3] }}{{ item }}{{ end for }}').render.should == '123' }
+    specify { parse('{{ for item, in: 1..3 }}{{ item }}{{ end for }}').render.should == '123' }
+    specify { parse('{{ for item, in: { a: 1, b: 2, c: 3 } }}{{ item[0] }}{{ end }}').render.should == 'abc' }
+    specify { parse('{{ for item, in: { a: 1, b: 2, c: 3 } }}{{ item[1] }}{{ end }}').render.should == '123' }
     specify { parse(
       '{{ for item, in: [1, 2, 3] }}{{ item }} * 3 = {{ item * 3 }}; {{ end for }}'
     ).render(reraise: true).should == '1 * 3 = 3; 2 * 3 = 6; 3 * 3 = 9; ' }

data/spec/lib/hotcell/config_spec.rb

@@ -16,6 +16,7 @@ describe Hotcell::Config do
   specify { subject.commands.should == {} }
   specify { subject.helpers.should == [] }
   specify { subject.resolver.should be_a Hotcell::Resolver }
+  specify { subject.escape_tags.should be_false }
 
   describe '#resolver=' do
     let(:resolver) { Hotcell::FileSystemResolver.new('/') }
@@ -23,6 +24,11 @@ describe Hotcell::Config do
     its(:resolver) { should == resolver }
   end
 
+  describe '#escape_tags=' do
+    before { subject.escape_tags = true }
+    its(:escape_tags) { should be_true }
+  end
+
   describe '#register_command' do
     context do
       before { subject.register_command :for, command_class }

data/spec/lib/hotcell/lexer_spec.rb

@@ -45,6 +45,8 @@ describe Hotcell::Lexer do
     specify { expression('= =').should == [[:ASSIGN, '='], [:ASSIGN, '=']] }
     specify { expression(',').should == [[:COMMA, ',']] }
     specify { expression('.').should == [[:PERIOD, '.']] }
+    specify { expression('..').should == [[:RANGE, '..']] }
+    specify { expression('...').should == [[:RANGE, '...']] }
     specify { expression(':').should == [[:COLON, ':']] }
     specify { expression('?').should == [[:QUESTION, '?']] }
     specify { expression('hello?').should == [[:IDENTIFER, 'hello?']] }
@@ -83,7 +85,7 @@ describe Hotcell::Lexer do
       specify { expression('.42.').should == [[:FLOAT, 0.42], [:PERIOD, '.']] }
       specify { expression('.42.foo').should == [[:FLOAT, 0.42], [:PERIOD, '.'], [:IDENTIFER, 'foo']] }
       specify { expression('.42foo').should == [[:FLOAT, 0.42], [:IDENTIFER, 'foo']] }
-      specify { expression('..42').should == [[:PERIOD, '.'], [:FLOAT, 0.42]] }
+      specify { expression('..42').should == [[:RANGE, '..'], [:INTEGER, 42]] }
     end
   end
 
@@ -311,22 +313,31 @@ describe Hotcell::Lexer do
       [:OR, "||"], [:INTEGER, 3], [:TCLOSE, "}}"], [:TEMPLATE, " hello"]
     ] }
 
-    context 'tag types' do
-      specify { scan('{{hello}}').should == [
-        [:TOPEN, "{{"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]
-      ] }
-      specify { scan('{{! hello}}').should == [
-        [:TOPEN, "{{!"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]
-      ] }
-      specify { scan('{{ !hello}}').should == [
-        [:TOPEN, "{{"], [:NOT, "!"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]
-      ] }
-      specify { scan('{{/ hello}}').should == [
-        [:TOPEN, "{{"], [:DIVIDE, "/"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]
-      ] }
-      specify { scan('{{ /hello}}').should == [
-        [:TOPEN, "{{"], [:DIVIDE, "/"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]
-      ] }
+    context 'tag modifers' do
+      specify { scan('{{hello}}').should == [[:TOPEN, "{{"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+
+      specify { scan('{{! hello}}').should == [[:TOPEN, "{{!"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{!hello}}').should == [[:TOPEN, "{{!"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{ !hello}}').should == [[:TOPEN, "{{"], [:NOT, "!"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{!}}').should == [[:TOPEN, "{{!"], [:TCLOSE, "}}"]] }
+
+      specify { scan('{{~ hello}}').should == [[:TOPEN, "{{~"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{~hello}}').should == [[:TOPEN, "{{~"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { expect { scan('{{ ~hello}}') }.to raise_error Hotcell::UnexpectedSymbol }
+      specify { scan('{{~}}').should == [[:TOPEN, "{{~"], [:TCLOSE, "}}"]] }
+
+      specify { scan('{{^ hello}}').should == [[:TOPEN, "{{^"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{^hello}}').should == [[:TOPEN, "{{^"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { expect { scan('{{ ^hello}}') }.to raise_error Hotcell::UnexpectedSymbol }
+      specify { scan('{{^}}').should == [[:TOPEN, "{{^"], [:TCLOSE, "}}"]] }
+
+      specify { scan('{{r hello}}').should == [[:TOPEN, "{{r "], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{ r hello}}').should == [[:TOPEN, "{{"], [:IDENTIFER, "r"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{rhello}}').should == [[:TOPEN, "{{"], [:IDENTIFER, "rhello"], [:TCLOSE, "}}"]] }
+
+      specify { scan('{{e hello}}').should == [[:TOPEN, "{{e "], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{ e hello}}').should == [[:TOPEN, "{{"], [:IDENTIFER, "e"], [:IDENTIFER, "hello"], [:TCLOSE, "}}"]] }
+      specify { scan('{{ehello}}').should == [[:TOPEN, "{{"], [:IDENTIFER, "ehello"], [:TCLOSE, "}}"]] }
     end
   end
 

data/spec/lib/hotcell/manipulator_spec.rb

@@ -6,6 +6,8 @@ describe Hotcell::Manipulator do
       let(:klass) do
         Class.new(Numeric) do
           include Hotcell::Manipulator::Mixin
+
+          def foo; end
         end
       end
       subject { klass.new }
@@ -13,9 +15,9 @@ describe Hotcell::Manipulator do
       its(:manipulator_methods) { should be_a Set }
       its(:manipulator_methods) { should be_empty }
       its(:to_manipulator) { should === subject }
-      specify { subject.manipulator_invoke('round').should be_nil }
-      specify { subject.manipulator_invoke(:round).should be_nil }
-      specify { subject.manipulator_invoke('round', 42, :arg).should be_nil }
+      specify { subject.manipulator_invoke('foo').should be_nil }
+      specify { subject.manipulator_invoke(:foo).should be_nil }
+      specify { subject.manipulator_invoke('foo', 42, :arg).should be_nil }
     end
 
     context do
@@ -23,19 +25,22 @@ describe Hotcell::Manipulator do
         Class.new(String) do
           include Hotcell::Manipulator::Mixin
 
-          manipulator :split, :size
+          manipulate :foo, :bar
+
+          alias_method :foo, :split
+          alias_method :bar, :size
         end
       end
       subject { klass.new('hello world') }
 
-      its('manipulator_methods.to_a') { should =~ %w(split size) }
       its(:to_manipulator) { should === subject }
-      specify { subject.manipulator_invoke('length').should be_nil }
-      specify { subject.manipulator_invoke('length', 42, :arg).should be_nil }
-      specify { subject.manipulator_invoke(:split).should be_nil }
-      specify { subject.manipulator_invoke('split').should == %w(hello world) }
-      specify { subject.manipulator_invoke('size').should == 11 }
-      specify { expect { subject.manipulator_invoke('size', 42) }.to raise_error ArgumentError }
+      specify { (subject.manipulator_methods.to_a & %w(foo bar)).should =~ %w(foo bar) }
+      specify { subject.manipulator_invoke('baz').should be_nil }
+      specify { subject.manipulator_invoke('baz', 42, :arg).should be_nil }
+      specify { subject.manipulator_invoke(:foo).should be_nil }
+      specify { subject.manipulator_invoke('foo').should == %w(hello world) }
+      specify { subject.manipulator_invoke('bar').should == 11 }
+      specify { expect { subject.manipulator_invoke('bar', 42) }.to raise_error ArgumentError }
     end
   end
 

data/spec/lib/hotcell/node/block_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Hotcell::Block do
   def method_missing method, *args, &block
-    klass = Hotcell::Calculator::HANDLERS[method] ?
-      Hotcell::Calculator : Hotcell::Node
+    klass = Hotcell::Expression::HANDLERS[method] ?
+      Hotcell::Expression : Hotcell::Node
 
     instance = Hotcell::Assigner.new *args if method == :ASSIGN
     instance = Hotcell::Summoner.new *args if method == :METHOD

data/spec/lib/hotcell/parser_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 
 describe Hotcell::Parser do
   def method_missing method, *args, &block
-    klass = Hotcell::Calculator::HANDLERS[method] ?
-      Hotcell::Calculator : Hotcell::Node
+    klass = Hotcell::Expression::HANDLERS[method] ?
+      Hotcell::Expression : Hotcell::Node
 
     instance = Hotcell::Assigner.new *args if method == :ASSIGN
     instance = Hotcell::Summoner.new *args if method == :METHOD
@@ -157,6 +157,12 @@ describe Hotcell::Parser do
     specify { parse('{{ (\'hello\') }}').should be_equal_node_to JOINER(TAG('hello', mode: :normal)) }
     specify { parse('{{ () }}').should be_equal_node_to JOINER(TAG(nil, mode: :normal)) }
 
+    specify { parse('{{ \'a\'..\'z\' }}').should be_equal_node_to JOINER(TAG('a'..'z', mode: :normal)) }
+    specify { parse('{{ 0..10 }}').should be_equal_node_to JOINER(TAG(0..10, mode: :normal)) }
+    specify { parse('{{ 0...10 }}').should be_equal_node_to JOINER(TAG(0...10, mode: :normal)) }
+    specify { parse('{{ 3 + 0..10 + 5 }}').should be_equal_node_to JOINER(TAG(3..15, mode: :normal)) }
+    specify { parse('{{ 3 + (0..var) + 5 }}').should be_equal_node_to JOINER(TAG(PLUS(PLUS(3, RANGE(0, METHOD('var'))), 5), mode: :normal)) }
+
     specify { parse('{{ bar > 2 }}').should be_equal_node_to JOINER(TAG(GT(METHOD('bar'), 2), mode: :normal)) }
     specify { parse('{{ 2 < bar }}').should be_equal_node_to JOINER(TAG(LT(2, METHOD('bar')), mode: :normal)) }
     specify { parse('{{ 2 >= tru }}').should be_equal_node_to JOINER(TAG(GTE(2, METHOD('tru')), mode: :normal)) }
@@ -202,7 +208,7 @@ describe Hotcell::Parser do
       mode: :normal)) }
       specify { parse('{{ foo(\'hello\').bar[2].baz(-42) }}').should be_equal_node_to JOINER(TAG(
         METHOD('baz',
-          METHOD('manipulator_brackets',
+          METHOD('[]',
             METHOD('bar',
               METHOD('foo', nil, 'hello')
             ), 2
@@ -216,7 +222,7 @@ describe Hotcell::Parser do
     specify { parse('{{ [] }}').should be_equal_node_to JOINER(TAG(ARRAY(), mode: :normal)) }
     specify { parse('{{ [ 2 ] }}').should be_equal_node_to JOINER(TAG(ARRAY(2), mode: :normal)) }
     specify { parse('{{ [ 2, 3 ] }}').should be_equal_node_to JOINER(TAG(ARRAY(2, 3), mode: :normal)) }
-    specify { parse('{{ [2, 3][42] }}').should be_equal_node_to JOINER(TAG(METHOD('manipulator_brackets', ARRAY(2, 3), 42), mode: :normal)) }
+    specify { parse('{{ [2, 3][42] }}').should be_equal_node_to JOINER(TAG(METHOD('[]', ARRAY(2, 3), 42), mode: :normal)) }
     specify { parse('{{ [2 + foo, (2 * bar)] }}').should be_equal_node_to JOINER(TAG(ARRAY(PLUS(2, METHOD('foo')), MULTIPLY(2, METHOD('bar'))), mode: :normal)) }
     specify { parse('{{ [[2, 3], 42] }}').should be_equal_node_to JOINER(TAG(ARRAY(ARRAY(2, 3), 42), mode: :normal)) }
   end
@@ -227,7 +233,7 @@ describe Hotcell::Parser do
       JOINER(TAG(HASH(PAIR('hello', 'world')), mode: :normal))
     ) }
     specify { parse('{{ {hello: \'world\'}[\'hello\'] }}').should be_equal_node_to(
-      JOINER(TAG(METHOD('manipulator_brackets', HASH(PAIR('hello', 'world')), 'hello'), mode: :normal))
+      JOINER(TAG(METHOD('[]', HASH(PAIR('hello', 'world')), 'hello'), mode: :normal))
     ) }
     specify { parse('{{ { hello: 3, world: 6 * foo } }}').should be_equal_node_to(
       JOINER(TAG(HASH(
@@ -238,11 +244,11 @@ describe Hotcell::Parser do
   end
 
   context '[]' do
-    specify { parse('{{ hello[3] }}').should be_equal_node_to JOINER(TAG(METHOD('manipulator_brackets', METHOD('hello'), 3), mode: :normal)) }
-    specify { parse('{{ \'boom\'[3] }}').should be_equal_node_to JOINER(TAG(METHOD('manipulator_brackets', 'boom', 3), mode: :normal)) }
-    specify { parse('{{ 7[3] }}').should be_equal_node_to JOINER(TAG(METHOD('manipulator_brackets', 7, 3), mode: :normal)) }
-    specify { parse('{{ 3 + 5[7] }}').should be_equal_node_to JOINER(TAG(PLUS(3, METHOD('manipulator_brackets', 5, 7)), mode: :normal)) }
-    specify { parse('{{ (3 + 5)[7] }}').should be_equal_node_to JOINER(TAG(METHOD('manipulator_brackets', 8, 7), mode: :normal)) }
+    specify { parse('{{ hello[3] }}').should be_equal_node_to JOINER(TAG(METHOD('[]', METHOD('hello'), 3), mode: :normal)) }
+    specify { parse('{{ \'boom\'[3] }}').should be_equal_node_to JOINER(TAG(METHOD('[]', 'boom', 3), mode: :normal)) }
+    specify { parse('{{ 7[3] }}').should be_equal_node_to JOINER(TAG(METHOD('[]', 7, 3), mode: :normal)) }
+    specify { parse('{{ 3 + 5[7] }}').should be_equal_node_to JOINER(TAG(PLUS(3, METHOD('[]', 5, 7)), mode: :normal)) }
+    specify { parse('{{ (3 + 5)[7] }}').should be_equal_node_to JOINER(TAG(METHOD('[]', 8, 7), mode: :normal)) }
   end
 
   context 'function arguments' do
@@ -306,62 +312,139 @@ describe Hotcell::Parser do
     specify { parse("hello {{ world# foo}}").should be_equal_node_to JOINER('hello ', TAG(METHOD('world'), mode: :normal)) }
   end
 
+  context 'tag modes' do
+    specify { parse('{{  }}').should be_equal_node_to JOINER(TAG(mode: :normal)) }
+    specify { parse('{{!  }}').should be_equal_node_to JOINER(TAG(mode: :silence)) }
+    specify { parse('{{^  }}').should be_equal_node_to JOINER(TAG(mode: :escape)) }
+    specify { parse('{{e  }}').should be_equal_node_to JOINER(TAG(mode: :escape)) }
+    specify { parse('{{~  }}').should be_equal_node_to JOINER(TAG(mode: :normal)) }
+    specify { parse('{{r  }}').should be_equal_node_to JOINER(TAG(mode: :normal)) }
+
+    context 'escape_tags' do
+      specify { parse('{{  }}', escape_tags: true).should be_equal_node_to JOINER(TAG(mode: :escape)) }
+    end
+
+    context 'commands' do
+      let(:snippet_command) { Class.new(Hotcell::Command) }
+      let(:commands) { { snippet: snippet_command }.stringify_keys }
+
+      specify { parse('{{ snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :normal)
+      ) }
+      specify { parse('{{! snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :silence)
+      ) }
+      specify { parse('{{^ snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :escape)
+      ) }
+      specify { parse('{{e snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :escape)
+      ) }
+      specify { parse('{{~ snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :normal)
+      ) }
+      specify { parse('{{r snippet }}', commands: commands).should be_equal_node_to JOINER(
+        TAG(snippet_command.build('snippet'), mode: :normal)
+      ) }
+
+      context 'escape_tags' do
+        specify { parse('{{ snippet }}',
+          commands: commands, escape_tags: true
+        ).should be_equal_node_to JOINER(
+          TAG(snippet_command.build('snippet'), mode: :normal)
+        ) }
+      end
+    end
+
+    context 'blocks' do
+      let(:cycle_block) { Class.new(Hotcell::Block) }
+      let(:blocks) { { cycle: cycle_block }.stringify_keys }
+
+      specify { parse('{{ cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :normal)
+      ) }
+      specify { parse('{{! cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :silence)
+      ) }
+      specify { parse('{{^ cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :escape)
+      ) }
+      specify { parse('{{e cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :escape)
+      ) }
+      specify { parse('{{~ cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :normal)
+      ) }
+      specify { parse('{{r cycle }}{{ end }}', blocks: blocks).should be_equal_node_to JOINER(
+        TAG(cycle_block.build('cycle'), mode: :normal)
+      ) }
+
+      context 'escape_tags' do
+        specify { parse('{{ cycle }}{{ end }}',
+          blocks: blocks, escape_tags: true
+        ).should be_equal_node_to JOINER(
+          TAG(cycle_block.build('cycle'), mode: :normal)
+        ) }
+      end
+    end
+  end
+
   context 'commands' do
-    let(:include_tag) { Class.new(Hotcell::Command) }
-    let(:snippet_tag) { Class.new(Hotcell::Command) }
+    let(:include_command) { Class.new(Hotcell::Command) }
+    let(:snippet_command) { Class.new(Hotcell::Command) }
     let(:commands) do
       {
-        include: include_tag,
-        snippet: snippet_tag
+        include: include_command,
+        snippet: snippet_command
       }.stringify_keys
     end
 
     specify { parse("{{ include 'some/partial' }}",
       commands: commands).should be_equal_node_to JOINER(
-        TAG(include_tag.build('include', 'some/partial'), mode: :normal)
+        TAG(include_command.build('include', 'some/partial'), mode: :normal)
       ) }
     specify { parse("{{ include }}",
       commands: commands).should be_equal_node_to JOINER(
-        TAG(include_tag.build('include'), mode: :normal)
+        TAG(include_command.build('include'), mode: :normal)
       ) }
     specify { parse("{{! include 'some/partial' }}\n{{ snippet 'sidebar' }}",
       commands: commands).should be_equal_node_to JOINER(
-        TAG(include_tag.build('include', 'some/partial'), mode: :silence),
+        TAG(include_command.build('include', 'some/partial'), mode: :silence),
         "\n",
-        TAG(snippet_tag.build('snippet', 'sidebar'), mode: :normal),
+        TAG(snippet_command.build('snippet', 'sidebar'), mode: :normal),
       ) }
     specify { parse("{{! variable = include }}",
       commands: commands).should be_equal_node_to JOINER(
-        TAG(ASSIGN('variable', include_tag.build('include')), mode: :silence)
+        TAG(ASSIGN('variable', include_command.build('include')), mode: :silence)
       ) }
     specify { parse("{{ variable = include 'some/partial' }}",
       commands: commands).should be_equal_node_to JOINER(
-        TAG(ASSIGN('variable', include_tag.build('include', 'some/partial')), mode: :normal)
+        TAG(ASSIGN('variable', include_command.build('include', 'some/partial')), mode: :normal)
       ) }
   end
 
   context 'blocks' do
-    let(:scoped_tag) { Class.new(Hotcell::Block) }
-    let(:each_tag) { Class.new(Hotcell::Block) }
+    let(:scoped_block) { Class.new(Hotcell::Block) }
+    let(:each_block) { Class.new(Hotcell::Block) }
     let(:blocks) do
       {
-        scoped: scoped_tag,
-        each: each_tag
+        scoped: scoped_block,
+        each: each_block
       }.stringify_keys
     end
 
     specify { parse("{{ scoped }}{{ end scoped }}",
       blocks: blocks).should be_equal_node_to JOINER(
-        TAG(scoped_tag.build('scoped'), mode: :normal)
+        TAG(scoped_block.build('scoped'), mode: :normal)
       ) }
     specify { parse("{{ scoped var: 'hello' }}{{ endscoped }}",
       blocks: blocks).should be_equal_node_to JOINER(
-        TAG(scoped_tag.build('scoped', HASH(PAIR('var', 'hello'))), mode: :normal)
+        TAG(scoped_block.build('scoped', HASH(PAIR('var', 'hello'))), mode: :normal)
       ) }
     specify { parse("<article>\n{{ each post, in: posts }}\n<h1>{{ post.title }}</h1>\n{{ end each }}\n</article>",
       blocks: blocks).should be_equal_node_to JOINER(
         "<article>\n",
-        TAG(each_tag.build('each',
+        TAG(each_block.build('each',
           METHOD('post'),
           HASH(PAIR('in', METHOD('posts'))),
           subnodes: [JOINER(
@@ -374,7 +457,7 @@ describe Hotcell::Parser do
       ) }
     specify { parse("{{! iter = each post, in: posts }}\n<h1>{{ post.title }}</h1>\n{{ end each }}",
       blocks: blocks).should be_equal_node_to JOINER(
-        TAG(ASSIGN('iter', each_tag.build('each',
+        TAG(ASSIGN('iter', each_block.build('each',
           METHOD('post'),
           HASH(PAIR('in', METHOD('posts'))),
           subnodes: [JOINER(
@@ -386,10 +469,10 @@ describe Hotcell::Parser do
       ) }
     specify { parse("{{ capture = scoped }} hello {{ each post, in: posts }} {{ loop }} {{ end each }}{{ endscoped }}",
       blocks: blocks).should be_equal_node_to JOINER(
-        TAG(ASSIGN('capture', scoped_tag.build('scoped',
+        TAG(ASSIGN('capture', scoped_block.build('scoped',
           subnodes: [JOINER(
             ' hello ',
-            TAG(each_tag.build('each',
+            TAG(each_block.build('each',
               METHOD('post'),
               HASH(PAIR('in', METHOD('posts'))),
               subnodes: [JOINER(