hotcell 0.0.1 → 0.1.0

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::If do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#validate!' do
+    specify { expect { parse('{{ if }}{{ end if }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `if` (0 for 1) at 1:4' }
+    specify { expect { parse('{{ if true }}{{ else true }}{{ end if }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `else` (1 for 0) at 1:17' }
+    specify { expect { parse('{{ if true }}{{ elsif }}{{ end if }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `elsif` (0 for 1) at 1:17' }
+    specify { expect { parse('{{ if true }}{{ else }}{{ elsif true }}{{ end if }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `if` command at 1:17' }
+    specify { expect { parse('{{ if true }}{{ else true }}{{ elsif true }}{{ end if }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `if` command at 1:17' }
+    specify { expect { parse('{{ if true }}{{ else }}{{ else }}{{ end if }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `if` command at 1:17' }
+  end
+
+  describe '#render' do
+    specify { parse('{{ if true }}Hello{{ end if }}').render.should == 'Hello' }
+    specify { parse('{{ if false }}Hello{{ end if }}').render.should == '' }
+    specify { parse('{{ if true }}Hello{{ else }}World{{ end if }}').render.should == 'Hello' }
+    specify { parse('{{ if false }}Hello{{ else }}World{{ end if }}').render.should == 'World' }
+    specify { parse('{{ if true }}Hello{{ elsif true }}Beautiful{{ else }}World{{ end if }}').render.should == 'Hello' }
+    specify { parse('{{ if false }}Hello{{ elsif true }}Beautiful{{ else }}World{{ end if }}').render.should == 'Beautiful' }
+    specify { parse('{{ if false }}Hello{{ elsif false }}Beautiful{{ else }}World{{ end if }}').render.should == 'World' }
+    specify { parse('{{ if false }}Hello{{ elsif true }}Beautiful{{ elsif true }}Ruby{{ else }}World{{ end if }}').render.should == 'Beautiful' }
+    specify { parse('{{ if false }}Hello{{ elsif false }}Beautiful{{ elsif true }}Ruby{{ else }}World{{ end if }}').render.should == 'Ruby' }
+    specify { parse('{{ if false }}Hello{{ elsif false }}Beautiful{{ elsif false }}Ruby{{ else }}World{{ end if }}').render.should == 'World' }
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::Include do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  let(:resolver_class) do
+    Class.new(Hotcell::Resolver) do
+      attr_reader :templates
+      def initialize templates
+        @templates = templates.stringify_keys
+      end
+
+      def resolve path, context = nil
+        templates[path] or raise 'Template not found'
+      end
+    end
+  end
+  let(:templates) { {
+    template1: 'Hello',
+    template2: 'Hello, {{ name }}',
+    template3: '{{ name }} - {{ action }}'
+  } }
+  let(:resolver) { resolver_class.new templates }
+  let(:render_options) { { shared: { resolver: resolver } } }
+
+  describe '#render' do
+    specify { parse("{{ include 'template0' }}").render(render_options).should =~ /Template not found/ }
+    specify { parse("{{ include 'template1' }}").render(render_options).should == 'Hello' }
+    specify { parse("{{ include 'template2' }}").render(render_options).should == 'Hello, ' }
+    specify { parse(
+      "{{ include 'template2', name: 'Pyrosha' }}"
+    ).render(render_options).should == 'Hello, Pyrosha' }
+    specify { parse(
+      "{{! name = Pyrosha; action = 'CRUSH!' }}{{ include 'template3', name: 'Hulk' }}"
+    ).render(render_options).should == 'Hulk - CRUSH!' }
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::Scope do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#render' do
+    specify { parse(
+      '{{ count = 42 }} {{ scope count: count + 8 }}{{ count }}{{ end scope }} {{ count }}'
+    ).render.should == '42 50 42' }
+    specify { parse(
+      '{{! captured = scope }}Hello{{ end scope }} {{ captured }}'
+    ).render(reraise: true).should == ' Hello' }
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::Unless do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#validate!' do
+    specify { expect { parse('{{ unless }}{{ end unless }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `unless` (0 for 1) at 1:4' }
+    specify { expect { parse('{{ unless true }}{{ else false }}{{ end unless }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `else` (1 for 0) at 1:21' }
+    specify { expect { parse('{{ unless true }}{{ else }}{{ else }}{{ end unless }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `unless` command at 1:31' }
+  end
+
+  describe '#render' do
+    specify { parse('{{ unless true }}Hello{{ end unless }}').render.should == '' }
+    specify { parse('{{ unless false }}Hello{{ end unless }}').render.should == 'Hello' }
+    specify { parse('{{ unless true }}Hello{{ else }}World{{ end unless }}').render.should == 'World' }
+    specify { parse('{{ unless false }}Hello{{ else }}World{{ end unless }}').render.should == 'Hello' }
+  end
+end

data/spec/lib/hotcell/config_spec.rb

@@ -6,36 +6,48 @@ describe Hotcell::Config do
   let(:command_class) { Class.new(Hotcell::Command) }
   let(:block_class) do
     Class.new(Hotcell::Block) do
-      subcommands :else, :elsif
+      subcommand :else
+      subcommand :elsif
     end
   end
   let(:misc_class) { Class.new }
 
   specify { subject.blocks.should == {} }
-  specify { subject.subcommands.should == {} }
   specify { subject.commands.should == {} }
+  specify { subject.helpers.should == [] }
+  specify { subject.resolver.should be_a Hotcell::Resolver }
+
+  describe '#resolver=' do
+    let(:resolver) { Hotcell::FileSystemResolver.new('/') }
+    before { subject.resolver = resolver }
+    its(:resolver) { should == resolver }
+  end
 
   describe '#register_command' do
     context do
       before { subject.register_command :for, command_class }
-      specify { subject.blocks.should == {} }
-      specify { subject.subcommands.should == {} }
-      specify { subject.commands.should == { 'for' => command_class } }
+      its(:blocks) { should == {} }
+      its(:commands) { should == { 'for' => command_class } }
     end
 
     context do
       before { subject.register_command 'for', block_class }
-      specify { subject.blocks.should == { 'for' => block_class } }
-      specify { subject.subcommands.should == { 'else' => block_class, 'elsif' => block_class } }
-      specify { subject.commands.should == {} }
+      its(:blocks) { should == { 'for' => block_class } }
+      its(:commands) { should == {} }
     end
 
     context do
       before { subject.register_command 'for', block_class }
       before { subject.register_command :forloop, block_class }
       before { subject.register_command :include, command_class }
-      specify { subject.blocks.should == { 'for' => block_class, 'forloop' => block_class } }
-      specify { subject.commands.should == { 'include' => command_class } }
+      its(:blocks) { should == { 'for' => block_class, 'forloop' => block_class } }
+      its(:commands) { should == { 'include' => command_class } }
+    end
+
+    context do
+      before { subject.register_command 'for' => block_class, forloop: block_class, include: command_class }
+      its(:blocks) { should == { 'for' => block_class, 'forloop' => block_class } }
+      its(:commands) { should == { 'include' => command_class } }
     end
 
     context 'errors' do
@@ -54,4 +66,17 @@ describe Hotcell::Config do
       end
     end
   end
+
+  describe '#register_helpers' do
+    context do
+      3.times do |i|
+        let("helper#{i+1}") { Module.new }
+      end
+      before { subject.register_helpers helper1, helper2 }
+      before { subject.register_helpers helper1 }
+      before { subject.register_helpers [helper3] }
+
+      its(:helpers) { should == [helper1, helper2, helper3] }
+    end
+  end
 end

data/spec/lib/hotcell/context_spec.rb

@@ -1,25 +1,49 @@
 require 'spec_helper'
 
 describe Hotcell::Context do
-  describe '#initialize' do
-    its('scope.scope') { should == [{}] }
-
-    context do
-      subject { described_class.new(
-        scope: { foo: 42, 'bar' => 'baz' },
-        variables: { baz: 'moo' },
-        boo: 'goo',
-        'taz' => 'man',
-        rescuer: ->{},
-        reraise: true
-      ) }
-      its('scope.scope') { should == [{foo: 42, 'bar' => 'baz', 'baz' => 'moo', 'boo' => 'goo', 'taz' => 'man'}] }
-    end
+  its('scope.scope') { should == [{}] }
+  its(:helpers) { should be_a Hotcell::Manipulator }
 
-    context do
-      subject { described_class.new(variables: { foo: 42, 'bar' => 'baz' }, environment: { 'baz' => 'moo' }) }
-      its('scope.scope') { should == [{'foo' => 42, 'bar' => 'baz', baz: 'moo'}] }
+  describe '#normalize_options' do
+    def result options = {}
+      default = { scope: {}, shared: {}, helpers: [], reraise: false, rescuer: described_class::DEFAULT_RESCUER }
+      default.merge options
     end
+    let(:rscr) { ->{} }
+
+    specify { subject.normalize_options({}).should == result }
+    specify { subject.normalize_options(foo: 42, 'bar' => 'baz').should == result(
+      scope: { 'foo' => 42, 'bar' => 'baz' }) }
+    specify { subject.normalize_options(foo: 42, scope: { bar: 'baz' }).should == result(
+      scope: { 'foo' => 42, bar: 'baz' }) }
+    specify { subject.normalize_options(foo: 42, variables: { bar: 'baz' }).should == result(
+      scope: { 'foo' => 42, 'bar' => 'baz' }) }
+    specify { subject.normalize_options(foo: 42, environment: { 'bar' => 'baz' }).should == result(
+      scope: { 'foo' => 42, bar: 'baz' }) }
+    specify { subject.normalize_options(shared: {resolver: 'resolver'}).should == result(
+      shared: {resolver: 'resolver'}) }
+    specify { subject.normalize_options(helpers: 'helper1').should == result(
+      helpers: ['helper1']) }
+    specify { subject.normalize_options(helpers: ['helper1', 'helper2']).should == result(
+      helpers: ['helper1', 'helper2']) }
+    specify { subject.normalize_options(reraise: nil).should == result(reraise: false) }
+    specify { subject.normalize_options(reraise: true).should == result(reraise: true) }
+    specify { subject.normalize_options(reraise: 'foo').should == result(reraise: true) }
+    specify { subject.normalize_options(rescuer: rscr).should == result(rescuer: rscr) }
+
+    specify { subject.normalize_options(
+      scope: { foo: 42, 'bar' => 'baz' },
+      variables: { baz: 'moo' },
+      environment: { hello: 'world' },
+      boo: 'goo',
+      'taz' => 'man',
+      rescuer: rscr,
+      reraise: true
+    ).should == result(
+      scope: { foo: 42, hello: 'world', 'bar' => 'baz', 'baz' => 'moo', 'boo' => 'goo', 'taz' => 'man' },
+      rescuer: rscr,
+      reraise: true
+    ) }
   end
 
   describe '#safe' do
@@ -46,8 +70,24 @@ describe Hotcell::Context do
   end
 
   describe '#manipulator_invoke' do
-    subject { described_class.new(variables: { foo: 42, 'bar' => 'baz' }, environment: { 'baz' => 'moo' }) }
+    subject { described_class.new(
+      variables: { foo: 42, 'bar' => 'baz' }, environment: { 'baz' => 'moo' },
+      helpers: Module.new do
+        def strip string
+          string.strip
+        end
+
+        def bar
+          'bazzzzz'
+        end
+      end
+    ) }
     specify { subject.manipulator_invoke('foo').should == 42 }
     specify { subject.manipulator_invoke('moo').should be_nil }
+    specify { subject.manipulator_invoke('baz').should be_nil }
+    specify { subject.manipulator_invoke('bar').should == 'baz' }
+    specify { expect { subject.manipulator_invoke('bar', 42) }.to raise_error ArgumentError }
+    specify { expect { subject.manipulator_invoke('strip') }.to raise_error ArgumentError }
+    specify { subject.manipulator_invoke('strip', '  hello  ').should == 'hello' }
   end
 end

data/spec/lib/hotcell/lexer_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 describe Hotcell::Lexer do
   def scan template
-    described_class.new(template).tokens
+    described_class.new(template).tokens.map { |token| [token[0], token[1][0]] }
   end
 
   def expression template
@@ -65,7 +65,8 @@ describe Hotcell::Lexer do
   context 'numeric' do
     context 'integer' do
       specify { expression('42').should == [[:INTEGER, 42]] }
-      specify { expression('-42').should == [[:MINUS, '-'], [:INTEGER, 42]] }
+      specify { expression('-42').should == [[:INTEGER, -42]] }
+      specify { expression('- 42').should == [[:MINUS, '-'], [:INTEGER, 42]] }
       specify { expression('!42').should == [[:NOT, '!'], [:INTEGER, 42]] }
       specify { expression('42.').should == [[:INTEGER, 42], [:PERIOD, '.']] }
       specify { expression('42.foo').should == [[:INTEGER, 42], [:PERIOD, '.'], [:IDENTIFER, 'foo']] }
@@ -74,7 +75,8 @@ describe Hotcell::Lexer do
 
     context 'float' do
       specify { expression('42.42').should == [[:FLOAT, 42.42]] }
-      specify { expression('-42.42').should == [[:MINUS, '-'], [:FLOAT, 42.42]] }
+      specify { expression('-42.42').should == [[:FLOAT, -42.42]] }
+      specify { expression('- 42.42').should == [[:MINUS, '-'], [:FLOAT, 42.42]] }
       specify { expression('!42.42').should == [[:NOT, '!'], [:FLOAT, 42.42]] }
       specify { expression('0.42').should == [[:FLOAT, 0.42]] }
       specify { expression('.42').should == [[:FLOAT, 0.42]] }
@@ -146,7 +148,8 @@ describe Hotcell::Lexer do
       specify { expression(%q{"fo\mo"}).should == [[:STRING, "fo\mo"]] }
       specify { expression(%q{"foo42"}).should == [[:STRING, "foo42"]] }
       specify { expression(%q{"привет"}).should == [[:STRING, "привет"]] }
-      specify { expression(%q{"при\вет"}).should == [[:STRING, "при\вет"]] }
+      # RBX can not handle this
+      # specify { expression(%q{"при\вет"}).should == [[:STRING, "при\вет"]] }
 
       context do
         let(:strings) { data 'dstrings' }
@@ -168,8 +171,11 @@ describe Hotcell::Lexer do
     specify { expression('/regexp/x').should == [[:REGEXP, /regexp/x]] }
     specify { expression('/regexp/sdmfri').should == [[:REGEXP, /regexp/im]] }
     specify { expression('/\.*/').should == [[:REGEXP, /\.*/]] }
-    specify { expression('/\//').should == [[:REGEXP, /\//]] }
-    specify { expression('/\//ix').should == [[:REGEXP, /\//ix]] }
+    # Funny ruby 2.0 bug. regexp1.to_s == regexp2.to_s, but regexp1 != regexp2
+    # specify { expression('/\//').should == [[:REGEXP, /\//]] }
+    # specify { expression('/\//ix').should == [[:REGEXP, /\//ix]] }
+    specify { expression('/\//').to_s.should == [[:REGEXP, /\//]].to_s }
+    specify { expression('/\//ix').to_s.should == [[:REGEXP, /\//ix]].to_s }
     specify { expression('/регексп/').should == [[:REGEXP, /регексп/]] }
     specify { expression('/регексп/m').should == [[:REGEXP, /регексп/m]] }
 
@@ -219,32 +225,32 @@ describe Hotcell::Lexer do
   end
 
   context 'errors' do
-    describe Hotcell::Errors::UnexpectedSymbol do
-      let(:error) { Hotcell::Errors::UnexpectedSymbol }
+    describe Hotcell::UnexpectedSymbol do
+      let(:error) { Hotcell::UnexpectedSymbol }
 
-      specify { expect { expression("hello @world") }.to raise_error(error, /1:10/) }
-      specify { expect { expression("@hello world") }.to raise_error(error, /1:4/) }
-      specify { expect { expression("hello world@") }.to raise_error(error, /1:15/) }
-      specify { expect { expression("hello\n@ world") }.to raise_error(error, /2:1/) }
-      specify { expect { expression("hello\n @world") }.to raise_error(error, /2:2/) }
-      specify { expect { expression("hello\n world@") }.to raise_error(error, /2:7/) }
-      specify { expect { expression("hello@\n world") }.to raise_error(error, /1:9/) }
-      specify { expect { expression("@hello\n world") }.to raise_error(error, /1:4/) }
-      specify { expect { expression("'привет' @ 'мир'") }.to raise_error(error, /1:13/) }
+      specify { expect { expression("hello @world") }.to raise_error(error, /`@`.*1:10/) }
+      specify { expect { expression("@hello world") }.to raise_error(error, /`@`.*1:4/) }
+      specify { expect { expression("hello world@") }.to raise_error(error, /`@`.*1:15/) }
+      specify { expect { expression("hello\n@ world") }.to raise_error(error, /`@`.*2:1/) }
+      specify { expect { expression("hello\n @world") }.to raise_error(error, /`@`.*2:2/) }
+      specify { expect { expression("hello\n world@") }.to raise_error(error, /`@`.*2:7/) }
+      specify { expect { expression("hello@\n world") }.to raise_error(error, /`@`.*1:9/) }
+      specify { expect { expression("@hello\n world") }.to raise_error(error, /`@`.*1:4/) }
+      specify { expect { expression("'привет' @ 'мир'") }.to raise_error(error, /`@`.*1:13/) }
     end
 
-    describe Hotcell::Errors::UnterminatedString do
-      let(:error) { Hotcell::Errors::UnterminatedString }
+    describe Hotcell::UnterminatedString do
+      let(:error) { Hotcell::UnterminatedString }
 
-      specify { expect { expression("hello 'world") }.to raise_error(error, /1:10/) }
-      specify { expect { expression("hello\nwor'ld") }.to raise_error(error, /2:4/) }
-      specify { expect { expression("hello 'world\\'") }.to raise_error(error, /1:10/) }
-      specify { expect { expression("hello 'wor\\'ld") }.to raise_error(error, /1:10/) }
-      specify { expect { expression("\"hello world") }.to raise_error(error, /1:4/) }
-      specify { expect { expression("he\"llo\\\" world") }.to raise_error(error, /1:6/) }
-      specify { expect { expression("he\"llo\\\" \nworld") }.to raise_error(error, /1:6/) }
-      specify { expect { expression("\"hello\\\"\n world") }.to raise_error(error, /1:4/) }
-      specify { expect { expression("'привет' 'мир") }.to raise_error(error, /1:13/) }
+      specify { expect { expression("hello 'world") }.to raise_error(error, /`'world }}`.*1:10/) }
+      specify { expect { expression("hello\nwor'ld") }.to raise_error(error, /`'ld }}`.*2:4/) }
+      specify { expect { expression("hello 'world\\'") }.to raise_error(error, /`'world\\' }}`.*1:10/) }
+      specify { expect { expression("hello 'wor\\'ld") }.to raise_error(error, /`'wor\\'ld }}`.*1:10/) }
+      specify { expect { expression("\"hello world") }.to raise_error(error, /`"hello world }}`.*1:4/) }
+      specify { expect { expression("he\"llo\\\" world") }.to raise_error(error, /`"llo\\" world }}`.*1:6/) }
+      specify { expect { expression("he\"llo\\\" \nworld") }.to raise_error(error, /`"llo\\" \nworld }}`.*1:6/) }
+      specify { expect { expression("\"hello\\\"\n world") }.to raise_error(error, /`"hello\\"\n world }}`.*1:4/) }
+      specify { expect { expression("'привет' 'мир") }.to raise_error(error, /`'мир }}`.*1:13/) }
     end
   end
 
@@ -326,6 +332,9 @@ describe Hotcell::Lexer do
 
   context 'template comments' do
     specify { scan('{{#').should == [[:COMMENT, "{{#"]] }
+    specify { scan('{{{#').should == [[:TOPEN, "{{"], [:HOPEN, "{"], [:COMMENT, "#"]] }
+    specify { scan('{{{{#').should == [[:TOPEN, "{{"], [:HOPEN, "{"], [:HOPEN, "{"], [:COMMENT, "#"]] }
+    specify { scan('{#').should == [[:TEMPLATE, "{#"]] }
     specify { scan('{{# }}').should == [[:COMMENT, "{{# }}"]] }
     specify { scan('{{##}}').should == [[:COMMENT, "{{##}}"]] }
     specify { scan('{{###}}').should == [[:COMMENT, "{{###}}"]] }

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

@@ -21,32 +21,33 @@ describe Hotcell::Block do
 
   let(:context) { Hotcell::Context.new }
 
-  describe 'complex parsing and rendering' do
+  context 'complex parsing and rendering' do
     def parse source
       Hotcell::Template.parse(source)
     end
 
     let(:if_tag) do
       Class.new(described_class) do
-        subcommands :else, :elsif
+        subcommand :else
+        subcommand :elsif
 
         def validate!
-          names = subcommands.map { |subcommand| subcommand[:name] }
+          names = subcommands.map { |subcommand| subcommand.name }
           valid = names.empty? || (
-            names.any? && names.last.in?('elsif', 'else') &&
-            names[0..-2].uniq.in?(['elsif'], [])
+            names.any? && %w(elsif else).include?(names.last) &&
+            [['elsif'], []].include?(names[0..-2].uniq)
           )
-          raise Hotcell::Errors::BlockError.new 'Invalid if syntax' unless valid
+          raise Hotcell::BlockError.new 'Invalid if syntax', *position_info unless valid
         end
 
-        def process context, subnodes, condition
+        def process context, condition
           conditions = [[condition]]
           subnodes.each do |subnode|
-            if subnode.is_a?(Hash)
+            if subnode.is_a?(Hotcell::Command)
               conditions.last[1] = '' if conditions.last[1] == nil
-              conditions << (subnode[:name] == 'elsif' ? [subnode[:args].first] : [true])
+              conditions << (subnode.name == 'elsif' ? [subnode.render_children(context).first] : [true])
             else
-              conditions.last[1] = subnode
+              conditions.last[1] = subnode.render(context)
             end
           end
           condition = conditions.detect { |condition| !!condition[0] }
@@ -57,7 +58,11 @@ describe Hotcell::Block do
 
     before { Hotcell.stub(:commands) { {} } }
     before { Hotcell.stub(:blocks) { { 'if' => if_tag } } }
-    before { Hotcell.stub(:subcommands) { { 'elsif' => if_tag, 'else' => if_tag } } }
+
+    specify { parse('{{ if true }}Hello{{ end if }}').render.should == 'Hello' }
+    specify { parse('{{! if true }}Hello{{ end if }}').render.should == '' }
+    specify { parse('{{ res = if true }}Hello{{ end if }} {{ res }}').render.should == 'Hello Hello' }
+    specify { parse('{{! res = if true }}Hello{{ end if }} {{ res }}').render.should == ' Hello' }
 
     context do
       subject(:template) { parse(<<-SOURCE
@@ -91,79 +96,46 @@ describe Hotcell::Block do
     context do
       specify { expect {
         parse("{{ if value == 'hello' }}{{ else }}world{{ elsif }}{{ end if }}").syntax
-      }.to raise_error Hotcell::Errors::BlockError }
+      }.to raise_error Hotcell::BlockError }
     end
   end
 
   describe '.subcommands' do
     subject { Class.new(described_class) }
 
-    before { subject.subcommands :elsif, :else }
-    its(:subcommands) { should == %w(elsif else) }
+    before { subject.subcommand elsif: Class.new(Hotcell::Command), else: Class.new(Hotcell::Command) }
+    its('subcommands.keys') { should == %w(elsif else) }
 
     context do
-      before { subject.subcommands :when }
-      its(:subcommands) { should == %w(elsif else when) }
+      before { subject.subcommand :when }
+      its('subcommands.keys') { should == %w(elsif else when) }
     end
   end
 
   describe '#subcommands' do
     specify { described_class.new('if',
-      subnodes: [{name: 'elsif'}, JOINER(), {name: 'else'}, JOINER()]).subcommands.should == [
-        {name: 'elsif'}, {name: 'else'}] }
-  end
-
-  describe '#render_subnodes' do
-    specify { described_class.new('if',
-      subnodes: [{name: 'elsif', args: ARRAY(3, 5)}, JOINER(42), {name: 'else'}, JOINER(43)]
-    ).render_subnodes(context).should == [
-      {name: 'elsif', args: [3, 5]}, '42', {name: 'else'}, '43'
-    ] }
+      subnodes: [COMMAND('elsif'), JOINER(), COMMAND('else'), JOINER()]).subcommands.should == [
+        COMMAND('elsif'), COMMAND('else')
+      ] }
   end
 
   describe '#render' do
     let(:block) do
       Class.new(described_class) do
-        def process context, subnodes, condition
+        def process context, condition
           "condition #{condition}"
         end
       end
     end
 
     specify { block.new('if').render(context).should =~ /ArgumentError/ }
-    specify { block.new('if', mode: :silence).render(context).should =~ /ArgumentError/ }
     specify { block.new('if', true).render(context).should == "condition true" }
-    specify { block.new('if', true, mode: :silence).render(context).should == '' }
-
-    context 'assigning' do
-      before { subject.render(context) }
-
-      context do
-        subject { block.new('if', assign: 'result') }
-        specify { context.key?('result').should be_false }
-      end
-
-      context do
-        subject { block.new('if', mode: :silence, assign: 'result') }
-        specify { context.key?('result').should be_false }
-      end
-
-      context do
-        subject { block.new('if', true, assign: 'result') }
-        specify { context['result'].should == "condition true" }
-      end
-
-      context do
-        subject { block.new('if', 42, mode: :silence, assign: 'result') }
-        specify { context['result'].should == "condition 42" }
-      end
-    end
   end
 
   context '#validate!' do
     let(:block) do
       Class.new(described_class) do
-        subcommands :else
+        subcommand :else
         def process context, subnodes, condition
           "condition #{condition}"
         end
@@ -176,12 +148,12 @@ describe Hotcell::Block do
     end
 
     context do
-      subject { block.new('if', true, subnodes: [{ name: 'else' }] ) }
+      subject { block.new('if', true, subnodes: [COMMAND('else')] ) }
       specify { expect { subject.validate! }.not_to raise_error }
     end
 
     context do
-      subject { block.new('if', true, subnodes: [{ name: 'case' }] ) }
+      subject { block.new('if', true, subnodes: [COMMAND('case')] ) }
       specify { expect { subject.validate! }.to raise_error }
     end
   end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Hotcell::Command do
   let(:context) { Hotcell::Context.new }
 
-  describe 'complex parsing and rendering' do
+  context 'complex parsing and rendering' do
     def parse source
       Hotcell::Template.parse(source)
     end
@@ -11,7 +11,7 @@ describe Hotcell::Command do
     let(:include_tag) do
       Class.new(described_class) do
         def validate!
-          raise Hotcell::Errors::ArgumentError.new('Template path is required') if children.count != 1
+          raise Hotcell::ArgumentError.new('Template path is required', *position_info) if children.count != 1
         end
 
         def process context, path
@@ -24,10 +24,12 @@ describe Hotcell::Command do
     before { Hotcell.stub(:blocks) { {} } }
     before { Hotcell.stub(:subcommands) { {} } }
 
+    specify { expect { parse("{{ include }}").syntax }.to raise_error Hotcell::ArgumentError }
     specify { parse("{{ include 'template/path' }}").render(context).should == 'included template/path' }
-    specify { expect {
-      parse("{{ include }}").syntax
-    }.to raise_error Hotcell::Errors::ArgumentError }
+    specify { parse("{{ include 'template/path' }}").render.should == 'included template/path' }
+    specify { parse("{{! include 'template/path' }}").render.should == '' }
+    specify { parse("{{ res = include 'template/path' }} {{ res }}").render.should == 'included template/path included template/path' }
+    specify { parse("{{! res = include 'template/path' }} {{ res }}").render.should == ' included template/path' }
   end
 
   describe '#render' do
@@ -40,32 +42,6 @@ describe Hotcell::Command do
     end
 
     specify { command.new('include').render(context).should =~ /ArgumentError/ }
-    specify { command.new('include', mode: :silence).render(context).should =~ /ArgumentError/ }
     specify { command.new('include', 'path').render(context).should == "rendered path" }
-    specify { command.new('include', 'path', mode: :silence).render(context).should == '' }
-
-    context 'assigning' do
-      before { subject.render(context) }
-
-      context do
-        subject { command.new('include', assign: 'inclusion') }
-        specify { context.key?('inclusion').should be_false }
-      end
-
-      context do
-        subject { command.new('include', mode: :silence, assign: 'inclusion') }
-        specify { context.key?('inclusion').should be_false }
-      end
-
-      context do
-        subject { command.new('include', 'path', assign: 'inclusion') }
-        specify { context['inclusion'].should == "rendered path" }
-      end
-
-      context do
-        subject { command.new('include', 'path', mode: :silence, assign: 'inclusion') }
-        specify { context['inclusion'].should == "rendered path" }
-      end
-    end
   end
 end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Hotcell::Tag do
+  let(:context) { Hotcell::Context.new }
+
+  context 'complex parsing and rendering' do
+    def parse source
+      Hotcell::Template.parse(source)
+    end
+
+    specify { parse("{{ 'Hello' }}").render.should == 'Hello' }
+    specify { parse("{{! 'Hello' }}").render.should == '' }
+    specify { parse("{{ res = 'Hello' }} {{ res }}").render.should == 'Hello Hello' }
+    specify { parse("{{! res = 'Hello' }} {{ res }}").render.should == ' Hello' }
+  end
+end