hotcell 0.0.1

data/spec/lib/hotcell/lexer_spec.rb

@@ -0,0 +1,340 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Hotcell::Lexer do
+  def scan template
+    described_class.new(template).tokens
+  end
+
+  def expression template
+    scan("{{ #{template} }}")[1..-2]
+  end
+
+  specify { scan('').should == [] }
+  specify { scan('{{ }}').should == [[:TOPEN, "{{"], [:TCLOSE, "}}"]] }
+  specify { expression('').should == [] }
+
+  context 'arithmetic' do
+    specify { expression('+').should == [[:PLUS, '+']] }
+    specify { expression('-').should == [[:MINUS, '-']] }
+    specify { expression('*').should == [[:MULTIPLY, '*']] }
+    specify { expression('* *').should == [[:MULTIPLY, '*'], [:MULTIPLY, '*']] }
+    specify { expression('**').should == [[:POWER, '**']] }
+    specify { expression('/').should == [[:DIVIDE, '/']] }
+    specify { expression('%').should == [[:MODULO, '%']] }
+  end
+
+  context 'logic' do
+    specify { expression('&&').should == [[:AND, '&&']] }
+    specify { expression('||').should == [[:OR, '||']] }
+    specify { expression('!').should == [[:NOT, '!']] }
+    specify { expression('!!').should == [[:NOT, '!'], [:NOT, '!']] }
+    specify { expression('==').should == [[:EQUAL, '==']] }
+    specify { expression('!=').should == [[:INEQUAL, '!=']] }
+    specify { expression('! =').should == [[:NOT, '!'], [:ASSIGN, '=']] }
+    specify { expression('>').should == [[:GT, '>']] }
+    specify { expression('>=').should == [[:GTE, '>=']] }
+    specify { expression('> =').should == [[:GT, '>'], [:ASSIGN, '=']] }
+    specify { expression('<').should == [[:LT, '<']] }
+    specify { expression('<=').should == [[:LTE, '<=']] }
+    specify { expression('< =').should == [[:LT, '<'], [:ASSIGN, '=']] }
+  end
+
+  context 'flow' do
+    specify { expression('=').should == [[:ASSIGN, '=']] }
+    specify { expression('= =').should == [[:ASSIGN, '='], [:ASSIGN, '=']] }
+    specify { expression(',').should == [[:COMMA, ',']] }
+    specify { expression('.').should == [[:PERIOD, '.']] }
+    specify { expression(':').should == [[:COLON, ':']] }
+    specify { expression('?').should == [[:QUESTION, '?']] }
+    specify { expression('hello?').should == [[:IDENTIFER, 'hello?']] }
+    specify { expression('hello ?').should == [[:IDENTIFER, 'hello'], [:QUESTION, '?']] }
+    specify { expression(';').should == [[:SEMICOLON, ';']] }
+    specify { expression("\n").should == [[:NEWLINE, "\n"]] }
+  end
+
+  context 'structure' do
+    specify { expression('[').should == [[:AOPEN, '[']] }
+    specify { expression(']').should == [[:ACLOSE, ']']] }
+    specify { expression('{').should == [[:HOPEN, '{']] }
+    specify { expression('}').should == [[:HCLOSE, '}']] }
+    specify { expression('(').should == [[:POPEN, '(']] }
+    specify { expression(')').should == [[:PCLOSE, ')']] }
+  end
+
+  context 'numeric' do
+    context 'integer' do
+      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']] }
+      specify { expression('42foo').should == [[:INTEGER, 42], [:IDENTIFER, 'foo']] }
+    end
+
+    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 == [[:NOT, '!'], [:FLOAT, 42.42]] }
+      specify { expression('0.42').should == [[:FLOAT, 0.42]] }
+      specify { expression('.42').should == [[:FLOAT, 0.42]] }
+      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]] }
+    end
+  end
+
+  context 'identifer' do
+    specify { expression('foo').should == [[:IDENTIFER, 'foo']] }
+    specify { expression('foo42').should == [[:IDENTIFER, 'foo42']] }
+    specify { expression('f42').should == [[:IDENTIFER, 'f42']] }
+    specify { expression('foo42bar').should == [[:IDENTIFER, 'foo42bar']] }
+    specify { expression('42foo42').should == [[:INTEGER, 42], [:IDENTIFER, 'foo42']] }
+    specify { expression('foo?').should == [[:IDENTIFER, 'foo?']] }
+    specify { expression('foo?bar').should == [[:IDENTIFER, 'foo?'], [:IDENTIFER, 'bar']] }
+    specify { expression('foo!').should == [[:IDENTIFER, 'foo!']] }
+    specify { expression('foo!bar').should == [[:IDENTIFER, 'foo!'], [:IDENTIFER, 'bar']] }
+    specify { expression('foo.bar').should == [[:IDENTIFER, 'foo'], [:PERIOD, '.'], [:IDENTIFER, 'bar']] }
+    specify { expression('!foo').should == [[:NOT, '!'], [:IDENTIFER, 'foo']] }
+    specify { expression('-foo').should == [[:MINUS, '-'], [:IDENTIFER, 'foo']] }
+
+    context 'constants' do
+      specify { expression('nil').should == [[:NIL, nil]] }
+      specify { expression('"nil"').should == [[:STRING, 'nil']] }
+      specify { expression('null').should == [[:NIL, nil]] }
+      specify { expression('"null"').should == [[:STRING, 'null']] }
+      specify { expression('false').should == [[:FALSE, false]] }
+      specify { expression('"false"').should == [[:STRING, 'false']] }
+      specify { expression('true').should == [[:TRUE, true]] }
+      specify { expression('"true"').should == [[:STRING, 'true']] }
+    end
+  end
+
+  context 'string' do
+    context 'single quoted' do
+      specify { expression(%q{''}).should == [[:STRING, '']] }
+      specify { expression(%q{'foo'}).should == [[:STRING, 'foo']] }
+      specify { expression(%q{'fo"o'}).should == [[:STRING, 'fo"o']] }
+      specify { expression(%q{'fo\o'}).should == [[:STRING, 'fo\o']] }
+      specify { expression(%q{'fo\'o'}).should == [[:STRING, 'fo\'o']] }
+      specify { expression(%q{'fo\"o'}).should == [[:STRING, 'fo\"o']] }
+      specify { expression(%q{'fo\no'}).should == [[:STRING, 'fo\no']] }
+      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, 'при\вет']] }
+
+      context do
+        let(:strings) { data 'sstrings' }
+
+        specify { expression(strings).delete_if { |token| token.first == :NEWLINE }.should == [
+          [:STRING, 'fo\'o'], [:STRING, 'fo\o'], [:STRING, 'fo\\o'],
+          [:STRING, 'fo\no'], [:STRING, "foo\nbar"]
+        ] }
+      end
+    end
+
+    context 'double quoted' do
+      specify { expression(%q{""}).should == [[:STRING, ""]] }
+      specify { expression(%q{"foo"}).should == [[:STRING, "foo"]] }
+      specify { expression(%q{"fo'o"}).should == [[:STRING, "fo'o"]] }
+      specify { expression(%q{"fo\o"}).should == [[:STRING, "fo\o"]] }
+      specify { expression(%q{"fo\"o"}).should == [[:STRING, "fo\"o"]] }
+      specify { expression(%q{"fo\'o"}).should == [[:STRING, "fo\'o"]] }
+      specify { expression(%q{"fo\no"}).should == [[:STRING, "fo\no"]] }
+      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, "при\вет"]] }
+
+      context do
+        let(:strings) { data 'dstrings' }
+
+        specify { expression(strings).delete_if { |token| token.first == :NEWLINE }.should == [
+          [:STRING, "fo\"o"], [:STRING, "fo\o"], [:STRING, "fo\\o"],
+          [:STRING, "fo\no"], [:STRING, "fo\mo"], [:STRING, "fo\to"],
+          [:STRING, "foo\nbar"]
+        ] }
+      end
+    end
+  end
+
+  context 'regexp' do
+    specify { expression('//').should == [[:REGEXP, //]] }
+    specify { expression('/regexp/').should == [[:REGEXP, /regexp/]] }
+    specify { expression('/regexp/i').should == [[:REGEXP, /regexp/i]] }
+    specify { expression('/regexp/m').should == [[:REGEXP, /regexp/m]] }
+    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]] }
+    specify { expression('/регексп/').should == [[:REGEXP, /регексп/]] }
+    specify { expression('/регексп/m').should == [[:REGEXP, /регексп/m]] }
+
+    context 'ambiguity' do
+      specify { expression('hello /regexp/').should == [
+        [:IDENTIFER, "hello"], [:DIVIDE, "/"], [:IDENTIFER, "regexp"], [:DIVIDE, "/"]
+      ] }
+      specify { expression('hello(/regexp/)').should == [
+        [:IDENTIFER, "hello"], [:POPEN, "("], [:REGEXP, /regexp/], [:PCLOSE, ")"]
+      ] }
+      specify { expression('[/regexp/]').should == [
+        [:AOPEN, "["], [:REGEXP, /regexp/], [:ACLOSE, "]"]
+      ] }
+      specify { expression('[42, /regexp/]').should == [
+        [:AOPEN, "["], [:INTEGER, 42], [:COMMA, ","], [:REGEXP, /regexp/], [:ACLOSE, "]"]
+      ] }
+      specify { expression('{/regexp/: 42}').should == [
+        [:HOPEN, "{"], [:REGEXP, /regexp/], [:COLON, ":"], [:INTEGER, 42], [:HCLOSE, "}"]
+      ] }
+      specify { expression('42 : /regexp/').should == [
+        [:INTEGER, 42], [:COLON, ":"], [:REGEXP, /regexp/]
+      ] }
+      specify { expression('42; /regexp/').should == [
+        [:INTEGER, 42], [:SEMICOLON, ";"], [:REGEXP, /regexp/]
+      ] }
+      specify { expression('"hello" /regexp/').should == [
+        [:STRING, "hello"], [:DIVIDE, "/"], [:IDENTIFER, "regexp"], [:DIVIDE, "/"]
+      ] }
+    end
+  end
+
+  context 'expression comments' do
+    specify { scan('{{ # }}').should == [[:TOPEN, '{{'], [:COMMENT, '# '], [:TCLOSE, '}}']] }
+    specify { scan('{{ #}}').should == [[:TOPEN, '{{'], [:COMMENT, '#'], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hello }}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello '], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hello}}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello'], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hello}}}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello'], [:TCLOSE, '}}'], [:TEMPLATE, '}']] }
+    specify { scan('{{ #hello} }}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello} '], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hello# }}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello# '], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hello#}}').should == [[:TOPEN, '{{'], [:COMMENT, '#hello#'], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hel}lo#}}').should == [[:TOPEN, '{{'], [:COMMENT, '#hel}lo#'], [:TCLOSE, '}}']] }
+    specify { scan('{{ #hel{lo#}}').should == [[:TOPEN, '{{'], [:COMMENT, '#hel{lo#'], [:TCLOSE, '}}']] }
+    specify { scan("{{ #hel{\nlo#}}").should == [[:TOPEN, "{{"], [:COMMENT, "#hel{"], [:NEWLINE, "\n"],
+      [:IDENTIFER, "lo"], [:COMMENT, "#"], [:TCLOSE, "}}"]] }
+    specify { scan("{{ #hel{#\n#lo#}}").should == [[:TOPEN, "{{"], [:COMMENT, "#hel{#"], [:NEWLINE, "\n"],
+      [:COMMENT, "#lo#"], [:TCLOSE, "}}"]] }
+  end
+
+  context 'errors' do
+    describe Hotcell::Errors::UnexpectedSymbol do
+      let(:error) { Hotcell::Errors::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/) }
+    end
+
+    describe Hotcell::Errors::UnterminatedString do
+      let(:error) { Hotcell::Errors::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/) }
+    end
+  end
+
+  context 'complex expressions' do
+    specify { expression('3+2 * 9').should == [
+      [:INTEGER, 3], [:PLUS, "+"], [:INTEGER, 2],
+      [:MULTIPLY, "*"], [:INTEGER, 9]
+    ] }
+    specify { expression('3 / 2 / 9').should == [
+      [:INTEGER, 3], [:DIVIDE, "/"], [:INTEGER, 2],
+      [:DIVIDE, "/"], [:INTEGER, 9]
+    ] }
+    specify { expression("foo.bar.baz('hello', 16)").should == [
+      [:IDENTIFER, "foo"], [:PERIOD, "."], [:IDENTIFER, "bar"],
+      [:PERIOD, "."], [:IDENTIFER, "baz"], [:POPEN, "("],
+      [:STRING, "hello"], [:COMMA, ","], [:INTEGER, 16],
+      [:PCLOSE, ")"]
+    ] }
+    specify { expression("foo(36.6);\n  a = \"привет\"").should == [
+      [:IDENTIFER, "foo"], [:POPEN, "("], [:FLOAT, 36.6],
+      [:PCLOSE, ")"], [:SEMICOLON, ";"], [:NEWLINE, "\n"],
+      [:IDENTIFER, "a"], [:ASSIGN, "="], [:STRING, "привет"]
+    ] }
+    specify { expression("'foo'.match(\"^foo$\")").should == [
+      [:STRING, "foo"], [:PERIOD, "."], [:IDENTIFER, "match"],
+      [:POPEN, "("], [:STRING, "^foo$"], [:PCLOSE, ")"]
+    ] }
+  end
+
+  context 'templates' do
+    specify { scan(' ').should == [[:TEMPLATE, " "]] }
+    specify { scan('{').should == [[:TEMPLATE, "{"]] }
+    specify { scan('}').should == [[:TEMPLATE, "}"]] }
+    specify { scan('{{').should == [[:TOPEN, "{{"]] }
+    specify { scan('}}').should == [[:TEMPLATE, "}}"]] }
+    specify { scan('hello').should == [[:TEMPLATE, "hello"]] }
+    specify { scan('hel{lo').should == [[:TEMPLATE, "hel{lo"]] }
+    specify { scan('hel{{lo').should == [
+      [:TEMPLATE, "hel"], [:TOPEN, "{{"], [:IDENTIFER, "lo"]
+    ] }
+    specify { scan('hel}lo').should == [[:TEMPLATE, "hel}lo"]] }
+    specify { scan('hel}}lo').should == [[:TEMPLATE, "hel}}lo"]] }
+    specify { scan('}}hello').should == [[:TEMPLATE, "}}hello"]] }
+    specify { scan('hello{{').should == [[:TEMPLATE, "hello"], [:TOPEN, "{{"]] }
+    specify { scan('2 + 3').should == [[:TEMPLATE, "2 + 3"]] }
+    specify { scan('hel}}lo{{}}').should == [
+      [:TEMPLATE, "hel}}lo"], [:TOPEN, "{{"], [:TCLOSE, "}}"]
+    ] }
+    specify { scan('hel}}lo{{').should == [[:TEMPLATE, "hel}}lo"], [:TOPEN, "{{"]] }
+    specify { scan('hel}}lo{{ !empty').should == [
+      [:TEMPLATE, "hel}}lo"], [:TOPEN, "{{"], [:NOT, "!"], [:IDENTIFER, "empty"]
+    ] }
+    specify { scan(' {{ }} ').should == [
+      [:TEMPLATE, " "], [:TOPEN, "{{"], [:TCLOSE, "}}"], [:TEMPLATE, " "]
+    ] }
+    specify { scan('2 + 3 {{ 2 || 3 }} hello').should == [
+      [:TEMPLATE, "2 + 3 "], [:TOPEN, "{{"], [:INTEGER, 2],
+      [: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, "}}"]
+      ] }
+    end
+  end
+
+  context 'template comments' do
+    specify { scan('{{#').should == [[:COMMENT, "{{#"]] }
+    specify { scan('{{# }}').should == [[:COMMENT, "{{# }}"]] }
+    specify { scan('{{##}}').should == [[:COMMENT, "{{##}}"]] }
+    specify { scan('{{###}}').should == [[:COMMENT, "{{###}}"]] }
+    specify { scan('{{# {{# blabla').should == [[:COMMENT, "{{# {{# blabla"]] }
+    specify { scan('{{# {{# }} blabla').should == [[:COMMENT, "{{# {{# }} blabla"]] }
+    specify { scan('{{# {{ #}} blabla').should == [[:COMMENT, "{{# {{ #}}"], [:TEMPLATE, " blabla"]] }
+    specify { scan('{# {{}}{{# {{# blabla').should == [[:TEMPLATE, "{# "], [:TOPEN, "{{"], [:TCLOSE, "}}"],
+      [:COMMENT, "{{# {{# blabla"]] }
+    specify { scan('{{ } {{# blabla').should == [[:TOPEN, "{{"], [:HCLOSE, "}"], [:HOPEN, "{"],
+      [:HOPEN, "{"], [:COMMENT, "# blabla"]] }
+  end
+end

data/spec/lib/hotcell/manipulator_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Hotcell::Manipulator do
+  context 'mixed in' do
+    context do
+      let(:klass) do
+        Class.new(Numeric) do
+          include Hotcell::Manipulator::Mixin
+        end
+      end
+      subject { klass.new }
+
+      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 }
+    end
+
+    context do
+      let(:klass) do
+        Class.new(String) do
+          include Hotcell::Manipulator::Mixin
+
+          manipulator :split, :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 }
+    end
+  end
+
+  context 'inherited' do
+    let(:klass) do
+      Class.new(described_class) do
+        def foo
+          'foo'
+        end
+
+        def bar arg1, arg2
+          arg1 + arg2
+        end
+      end
+    end
+    subject { klass.new }
+
+    its('manipulator_methods.to_a') { should =~ %w(foo bar) }
+    its(:to_manipulator) { should === subject }
+    specify { subject.manipulator_invoke('send').should be_nil }
+    specify { subject.manipulator_invoke(:bar).should be_nil }
+    specify { subject.manipulator_invoke('foo').should == 'foo' }
+    specify { subject.manipulator_invoke('bar', 5, 8).should == 13 }
+    specify { expect { subject.manipulator_invoke('bar') }.to raise_error ArgumentError }
+  end
+end

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

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Hotcell::Block do
+  def method_missing method, *args, &block
+    klass = Hotcell::Calculator::HANDLERS[method] ?
+      Hotcell::Calculator : Hotcell::Node
+
+    instance = Hotcell::Assigner.new *args if method == :ASSIGN
+    instance = Hotcell::Summoner.new *args if method == :METHOD
+    klass = Hotcell::Arrayer if [:ARRAY, :PAIR].include?(method)
+    klass = Hotcell::Hasher if method == :HASH
+    klass = Hotcell::Sequencer if method == :SEQUENCE
+
+    klass = Hotcell::Tag if method == :TAG
+    instance = Hotcell::Command.new *args if method == :COMMAND
+    instance = Hotcell::Block.new *args if method == :BLOCK
+    klass = Hotcell::Joiner if method == :JOINER
+
+    instance || klass.new(method, *args)
+  end
+
+  let(:context) { Hotcell::Context.new }
+
+  describe '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
+
+        def validate!
+          names = subcommands.map { |subcommand| subcommand[:name] }
+          valid = names.empty? || (
+            names.any? && names.last.in?('elsif', 'else') &&
+            names[0..-2].uniq.in?(['elsif'], [])
+          )
+          raise Hotcell::Errors::BlockError.new 'Invalid if syntax' unless valid
+        end
+
+        def process context, subnodes, condition
+          conditions = [[condition]]
+          subnodes.each do |subnode|
+            if subnode.is_a?(Hash)
+              conditions.last[1] = '' if conditions.last[1] == nil
+              conditions << (subnode[:name] == 'elsif' ? [subnode[:args].first] : [true])
+            else
+              conditions.last[1] = subnode
+            end
+          end
+          condition = conditions.detect { |condition| !!condition[0] }
+          condition ? condition[1] : nil
+        end
+      end
+    end
+
+    before { Hotcell.stub(:commands) { {} } }
+    before { Hotcell.stub(:blocks) { { 'if' => if_tag } } }
+    before { Hotcell.stub(:subcommands) { { 'elsif' => if_tag, 'else' => if_tag } } }
+
+    context do
+      subject(:template) { parse(<<-SOURCE
+        {{ if value == 'hello' }}
+          hello
+        {{ elsif value == 'world' }}
+          world
+        {{ else }}
+          foobar
+        {{ end if }}
+        SOURCE
+      ) }
+      specify { subject.render(value: 'hello').strip.should == 'hello' }
+      specify { subject.render(value: 'world').strip.should == 'world' }
+      specify { subject.render(value: 'foo').strip.should == 'foobar' }
+    end
+
+    context do
+      subject(:template) { parse("{{ if value == 'hello' }}{{ elsif value == 'world' }}world{{ end if }}") }
+      specify { subject.render(value: 'hello').should == '' }
+      specify { subject.render(value: 'world').should == 'world' }
+      specify { subject.render(value: 'foo').should == '' }
+    end
+
+    context do
+      subject(:template) { parse("{{ if value == 'hello' }}{{ else }}world{{ end if }}") }
+      specify { subject.render(value: 'hello').should == '' }
+      specify { subject.render(value: 'foo').should == 'world' }
+    end
+
+    context do
+      specify { expect {
+        parse("{{ if value == 'hello' }}{{ else }}world{{ elsif }}{{ end if }}").syntax
+      }.to raise_error Hotcell::Errors::BlockError }
+    end
+  end
+
+  describe '.subcommands' do
+    subject { Class.new(described_class) }
+
+    before { subject.subcommands :elsif, :else }
+    its(:subcommands) { should == %w(elsif else) }
+
+    context do
+      before { subject.subcommands :when }
+      its(:subcommands) { 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'
+    ] }
+  end
+
+  describe '#render' do
+    let(:block) do
+      Class.new(described_class) do
+        def process context, subnodes, 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
+        def process context, subnodes, condition
+          "condition #{condition}"
+        end
+      end
+    end
+
+    context do
+      subject { block.new('if', true, subnodes: [TEMPLATE('hello')] ) }
+      specify { expect { subject.validate! }.not_to raise_error }
+    end
+
+    context do
+      subject { block.new('if', true, subnodes: [{ name: 'else' }] ) }
+      specify { expect { subject.validate! }.not_to raise_error }
+    end
+
+    context do
+      subject { block.new('if', true, subnodes: [{ name: 'case' }] ) }
+      specify { expect { subject.validate! }.to raise_error }
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Hotcell::Command do
+  let(:context) { Hotcell::Context.new }
+
+  describe 'complex parsing and rendering' do
+    def parse source
+      Hotcell::Template.parse(source)
+    end
+
+    let(:include_tag) do
+      Class.new(described_class) do
+        def validate!
+          raise Hotcell::Errors::ArgumentError.new('Template path is required') if children.count != 1
+        end
+
+        def process context, path
+          "included #{path}"
+        end
+      end
+    end
+
+    before { Hotcell.stub(:commands) { { 'include' => include_tag } } }
+    before { Hotcell.stub(:blocks) { {} } }
+    before { Hotcell.stub(:subcommands) { {} } }
+
+    specify { parse("{{ include 'template/path' }}").render(context).should == 'included template/path' }
+    specify { expect {
+      parse("{{ include }}").syntax
+    }.to raise_error Hotcell::Errors::ArgumentError }
+  end
+
+  describe '#render' do
+    let(:command) do
+      Class.new(described_class) do
+        def process context, path
+          "rendered #{path}"
+        end
+      end
+    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