flavour_saver 0.3.3

data/spec/acceptance/if_else_spec.rb

@@ -0,0 +1,17 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: if_else.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:context) { Struct.new(:name).new }
+  let(:template) { File.expand_path('../../fixtures/if_else.hbs', __FILE__) }
+
+  it 'renders correctly when given a name' do
+    context.name = 'Alan'
+    subject.should == "Say hello to Alan."
+  end
+
+  it 'renders correcrtly when not given a name' do
+    subject.should == "Nobody to say hi to."
+  end
+end

data/spec/acceptance/multi_level_with_spec.rb

@@ -0,0 +1,15 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: multi_level_with.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:template) { File.expand_path('../../fixtures/multi_level_with.hbs', __FILE__) }
+  let(:context) { Struct.new(:person,:company).new }
+
+  it 'renders correctly when person has a name' do
+    context.person = Struct.new(:name).new('Alan')
+    context.company = Struct.new(:name).new('Rad, Inc.')
+    subject.should == 'Alan - Rad, Inc.'
+  end
+
+end

data/spec/acceptance/one_character_identifier_spec.rb

@@ -0,0 +1,13 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: one_character_identifier.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:template) { File.expand_path('../../fixtures/one_character_identifier.hbs', __FILE__) }
+  let(:context)  { double(:context) }
+
+  it 'renders correctly' do
+    context.should_receive(:a).and_return('foo')
+    subject.should == "foo"
+  end
+end

data/spec/acceptance/runtime_run_spec.rb

@@ -0,0 +1,27 @@
+require "flavour_saver"
+
+describe FlavourSaver::Runtime do
+  describe ".run" do
+    subject do
+      FlavourSaver::Runtime.run(parsed_template, context, locals, helper_names)
+    end
+
+    let(:parsed_template) { FlavourSaver.parse(FlavourSaver.lex(template)) }
+    let(:context) { Object.new }
+    let(:locals) { {} }
+    let(:helper_names) { [] }
+
+    describe "with a local helper" do
+      let(:template) { "{{n}} is {{#is_even n}}even{{else}}odd{{/is_even}}" }
+      let(:context_class) { Struct.new(:n) }
+      let(:context) { context_class.new(24) }
+
+      it "uses the helper" do
+        is_even_helper = proc { |n| n % 2 == 0 }
+
+        locals[:is_even] = is_even_helper
+        subject.should == "24 is even"
+      end
+    end
+  end
+end

data/spec/acceptance/sections_spec.rb

@@ -0,0 +1,25 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: sections.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:context) { Struct.new(:name, :names, :order).new }
+  let(:template) { File.expand_path('../../fixtures/sections.hbs', __FILE__) }
+
+  it 'renders correctly when given a name' do
+    context.name = 'Alan'
+    subject.should == "Say hello to Alan."
+  end
+
+  it 'renders correctly when given a list of names' do
+    context.names = ['Foo', 'Bar']
+    subject.should == "* Foo * Bar"
+  end
+
+  it 'renders correctly when given an order' do
+    class Order; def number; 1234; end; end
+    context.order = Order.new
+    subject.should == 'Number: 1234'
+  end
+end
+

data/spec/acceptance/segment_literals_spec.rb

@@ -0,0 +1,26 @@
+require 'flavour_saver'
+
+describe FlavourSaver do
+  subject { FS.evaluate(template, context) }
+
+  let(:context) { double(:context) }
+
+  after do
+    FS.reset_helpers
+    FS.reset_partials
+  end
+
+  describe 'segment literal array access' do
+    let(:template) { '{{foos.[1].bar}}' }
+
+    it 'returns "two"' do
+      foos = []
+      foos << double(:foo)
+      foos << double(:foo)
+      foos[1].should_receive(:bar).and_return('two')
+
+      context.stub(:foos).and_return(foos)
+      subject.should == 'two'
+    end
+  end
+end

data/spec/acceptance/simple_expression_spec.rb

@@ -0,0 +1,13 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: simple_expression.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:template) { File.expand_path('../../fixtures/simple_expression.hbs', __FILE__) }
+  let(:context)  { double(:context) }
+
+  it 'renders correctly' do
+    context.should_receive(:hello).and_return('hello world')
+    subject.should == "hello world"
+  end
+end

data/spec/fixtures/backtrack.hbs

@@ -0,0 +1,4 @@
+{{#with person}}
+  {{name}} -
+  {{../company.name}}
+{{/with}}

data/spec/fixtures/comment.hbs

@@ -0,0 +1 @@
+I am {{!not }}a very nice person!

data/spec/fixtures/custom_block_helper.hbs

@@ -0,0 +1,3 @@
+{{#three_times}}
+  {{this}} time.
+{{/three_times}}

data/spec/fixtures/custom_helper.hbs

@@ -0,0 +1 @@
+{{say_what_again}}

data/spec/fixtures/if_else.hbs

@@ -0,0 +1,5 @@
+{{#if name}}
+  Say hello to {{name}}.
+  {{else}}
+  Nobody to say hi to.
+{{/if}}

data/spec/fixtures/multi_level_if.hbs

@@ -0,0 +1,12 @@
+{{#if person}}
+  {{#if person.name}}
+    Hi {{person.name}}.
+    {{else}}
+    Nobody to say hi to :(
+  {{/if}}
+{{/if}}
+{{#if company}}
+  - {{company.name}}
+  {{else}}
+  - No company.
+{{/if}}

data/spec/fixtures/multi_level_with.hbs

@@ -0,0 +1,11 @@
+{{#with person}}
+  {{#with name}}
+    {{this}}
+  {{/with}}
+{{/with}}
+{{#with company}}
+  -
+  {{#with name}}
+    {{this}}
+  {{/with}}
+{{/with}}

data/spec/fixtures/one_character_identifier.hbs

@@ -0,0 +1 @@
+{{a}}

data/spec/fixtures/sections.hbs

@@ -0,0 +1,9 @@
+{{#name}}
+  Say hello to {{.}}{{nothing}}.
+{{/name}}
+{{#names}}
+* {{.}}
+{{/names}}
+{{#order}}
+Number: {{number}}
+{{/order}}

data/spec/fixtures/simple_expression.hbs

@@ -0,0 +1 @@
+{{hello}}

data/spec/lib/flavour_saver/lexer_spec.rb

@@ -0,0 +1,187 @@
+require 'flavour_saver/lexer'
+
+describe FlavourSaver::Lexer do
+  it 'is an RLTK lexer' do
+    subject.should be_a(RLTK::Lexer)
+  end
+
+  describe 'Tokens' do
+    describe 'Expressions' do
+      describe '{{foo}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo}}" }
+
+        it 'begins with an EXPRST' do
+          subject.first.type.should == :EXPRST
+        end
+
+        it 'ends with an EXPRE' do
+          subject[-2].type.should == :EXPRE
+        end
+
+        it 'contains only the identifier "foo"' do
+          subject[1..-3].size.should == 1
+          subject[1].type.should == :IDENT
+          subject[1].value.should == 'foo'
+        end
+      end
+
+      describe '{{foo bar}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo bar}}" }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :IDENT, :EXPRE, :EOS ]
+        end
+
+        it 'has values in the correct order' do
+          subject.map(&:value).compact.should == [ 'foo', 'bar' ]
+        end
+      end
+
+      describe '{{foo "bar"}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo \"bar\"}}" }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :STRING, :EXPRE, :EOS ]
+        end
+
+        it 'has values in the correct order' do
+          subject.map(&:value).compact.should == [ 'foo', 'bar' ]
+        end
+      end
+
+      describe '{{foo bar="baz" hello="goodbye"}}' do
+        subject { FlavourSaver::Lexer.lex '{{foo bar="baz" hello="goodbye"}}' }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :STRING, :WHITE, :IDENT, :EQ, :STRING, :EXPRE, :EOS ]
+        end
+
+        it 'has values in the correct order' do
+          subject.map(&:value).compact.should == [ 'foo', 'bar', 'baz', 'hello', 'goodbye' ]
+        end
+
+      end
+    end
+
+    describe '{{else}}' do
+      subject { FlavourSaver::Lexer.lex '{{else}}' }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [ :EXPRST, :ELSE, :EXPRE, :EOS ]
+      end
+    end
+
+    describe 'Object path expressions' do
+      describe '{{foo.bar}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo.bar}}" }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :IDENT, :EXPRE, :EOS ]
+        end
+
+        it 'has the correct values' do
+          subject.map(&:value).compact.should == ['foo', 'bar']
+        end
+      end
+
+      describe '{{foo.[10].bar}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo.[10].bar}}" }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+        end
+
+        it 'has the correct values' do
+          subject.map(&:value).compact.should == ['foo', '10', 'bar']
+        end
+      end
+
+      describe '{{foo.[he!@#$(&@klA)].bar}}' do
+        subject { FlavourSaver::Lexer.lex '{{foo.[he!@#$(&@klA)].bar}}' }
+
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+        end
+
+        it 'has the correct values' do
+          subject.map(&:value).compact.should == ['foo', 'he!@#$(&@klA)', 'bar']
+        end
+      end
+    end
+
+    describe 'Triple-stash expressions' do
+      subject { FlavourSaver::Lexer.lex "{{{foo}}}" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [ :TEXPRST, :IDENT, :TEXPRE, :EOS ]
+      end
+    end
+
+    describe 'Comment expressions' do
+      subject { FlavourSaver::Lexer.lex "{{! WAT}}" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [ :EXPRST, :BANG, :COMMENT, :EXPRE, :EOS ]
+      end
+    end
+
+    describe 'Backtrack expression' do
+      subject { FlavourSaver::Lexer.lex "{{../foo}}" } 
+      
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [:EXPRST, :DOT, :DOT, :FWSL, :IDENT, :EXPRE, :EOS]
+      end
+    end
+
+    describe 'Carriage-return and new-lines' do
+      subject { FlavourSaver::Lexer.lex "{{foo}}\n{{bar}}\r{{baz}}" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:EOS]
+      end
+    end
+
+    describe 'Block Expressions' do
+      subject { FlavourSaver::Lexer.lex "{{#foo}}{{bar}}{{/foo}}" }
+
+      describe '{{#foo}}{{bar}}{{/foo}}' do
+        it 'has tokens in the correct order' do
+          subject.map(&:type).should == [
+            :EXPRST, :HASH, :IDENT, :EXPRE, 
+            :EXPRST, :IDENT, :EXPRE,
+            :EXPRST, :FWSL, :IDENT, :EXPRE,
+            :EOS
+          ]
+        end
+
+        it 'has identifiers in the correct order' do
+          subject.map(&:value).compact.should == [ 'foo', 'bar', 'foo' ]
+        end
+      end
+    end
+
+    describe 'Carriage return' do
+      subject { FlavourSaver::Lexer.lex "\r" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [:OUT,:EOS]
+      end
+    end
+
+    describe 'New line' do
+      subject { FlavourSaver::Lexer.lex "\n" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [:OUT,:EOS]
+      end
+    end
+
+    describe 'Single curly bracket' do
+      subject { FlavourSaver::Lexer.lex "{" }
+
+      it 'has tokens in the correct order' do
+        subject.map(&:type).should == [:OUT,:EOS]
+      end
+    end
+  end
+end

data/spec/lib/flavour_saver/parser_spec.rb

@@ -0,0 +1,277 @@
+require 'flavour_saver/parser'
+require 'flavour_saver/lexer'
+
+describe FlavourSaver::Parser do
+  let (:items) { subject.items }
+
+  it 'is a RLTK::Parser' do
+    subject.should be_a(RLTK::Parser)
+  end
+
+  describe 'HTML template' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('<html><h1>Hello world!</h1></html>')) }
+
+    it 'is an output node' do
+      items.first.should be_a(FlavourSaver::OutputNode)
+    end
+
+    it 'has the correct contents' do
+      items.first.value.should == '<html><h1>Hello world!</h1></html>'
+    end
+  end
+
+  describe 'HTML template containing a handlebars expression' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('<html>{{foo}}</html>')) }
+
+    it 'has template output either side of the expression' do
+      items.map(&:class).should == [FlavourSaver::OutputNode, FlavourSaver::ExpressionNode, FlavourSaver::OutputNode]
+    end
+  end
+
+  describe '{{foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo}}')) }
+
+    it 'contains an expression node' do
+      items.first.should be_an(FlavourSaver::ExpressionNode)
+    end
+
+    it 'calls the method "foo" with no arguments' do
+      items.first.method.should be_one
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.should be_empty
+    end
+   end
+
+  describe '{{foo.bar}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo.bar}}')) }
+
+    it 'calls two methods' do
+      items.first.method.size.should == 2
+    end
+
+    it 'calls the method "foo" with no arguments first' do
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.should be_empty
+    end
+
+    it 'calls the method "bar" with no arguments second' do
+      items.first.method[1].should be_a(FlavourSaver::CallNode)
+      items.first.method[1].name.should == 'bar'
+      items.first.method[1].arguments.should be_empty
+    end
+  end
+
+  describe '{{foo.[&@^$*].bar}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo.[&@^$*].bar}}')) }
+
+    it 'calls three methods' do
+      items.first.method.size.should == 3
+    end
+
+    it 'calls the method "foo" with no arguments first' do
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.should be_empty
+    end
+
+    it 'calls the method "&@^$*" with no arguments second' do
+      items.first.method[1].should be_a(FlavourSaver::CallNode)
+      items.first.method[1].name.should == '&@^$*'
+      items.first.method[1].arguments.should be_empty
+    end
+
+    it 'calls the method "bar" with no arguments third' do
+      items.first.method[2].should be_a(FlavourSaver::CallNode)
+      items.first.method[2].name.should == 'bar'
+      items.first.method[2].arguments.should be_empty
+    end
+  end
+
+  describe '{{foo bar}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar}}')) }
+
+    it 'calls the method "foo" with a method argument of "bar"' do
+      items.first.method.should be_one
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.should be_one
+      items.first.method.first.arguments.first.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.arguments.first.first.name.should == 'bar'
+    end
+  end
+
+  describe '{{foo "bar" }}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo "bar" }}')) }
+
+    it 'calls the method "foo" with a string argument of "bar"' do
+      items.first.method.should be_one
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.should be_one
+      items.first.method.first.arguments.first.should be_a(FlavourSaver::StringNode)
+      items.first.method.first.arguments.first.value.should == 'bar'
+    end
+  end
+
+  describe '{{foo     bar  "baz" }}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo    bar  "baz" }}')) }
+
+    it 'calls the method "foo"' do
+      items.first.method.should be_one
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+    end
+
+    describe 'with arguments' do
+      subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo    bar  "baz" }}')).items.first.method.first.arguments }
+
+      describe '[0]' do
+        it 'is the method call "bar" with no arguments' do
+          subject.first.first.should be_a(FlavourSaver::CallNode)
+          subject.first.first.name.should == 'bar'
+        end
+      end
+
+      describe '[1]' do
+        it 'is the string "baz"' do
+          subject[1].should be_a(FlavourSaver::StringNode)
+          subject[1].value.should == 'baz'
+        end
+      end
+    end
+  end
+
+  describe '{{foo bar="baz"}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar="baz"}}')) }
+
+    it 'calls the method "foo" with the hash {:bar => "baz"} as arguments' do
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.first.should be_a(Hash)
+      items.first.method.first.arguments.first.should == { :bar => FlavourSaver::StringNode.new('baz') }
+    end
+  end
+
+  describe '{{foo bar="baz" fred="wilma"}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar="baz" fred="wilma"}}')) }
+
+    it 'calls the method "foo" with the hash {:bar => "baz", :fred => "wilma"} as arguments' do
+      items.first.method.first.should be_a(FlavourSaver::CallNode)
+      items.first.method.first.name.should == 'foo'
+      items.first.method.first.arguments.first.should be_a(Hash)
+      items.first.method.first.arguments.first.should == { :bar => FlavourSaver::StringNode.new('baz'), :fred => FlavourSaver::StringNode.new('wilma') }
+    end
+  end
+
+  describe '{{foo bar="baz" fred "wilma"}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{foo bar="baz" fred "wilma"}}')) }
+
+    it 'raises an exception' do
+      -> { subject }.should raise_exception(RLTK::NotInLanguage)
+    end
+  end
+
+  describe '{{{foo}}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{{foo}}}')) }
+
+    it 'returns a safe expression node' do
+      items.first.should be_a(FlavourSaver::SafeExpressionNode)
+    end
+  end
+
+  describe '{{../foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{../foo}}')) }
+
+    it 'returns a parent call node' do
+      items.first.method.first.should be_a(FlavourSaver::ParentCallNode)
+    end
+  end
+
+  describe '{{! comment}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{! comment}}')) }
+
+    it 'returns a comment node' do
+      items.first.should be_a(FlavourSaver::CommentNode)
+    end
+  end
+
+  describe '{{#foo}}hello{{/foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}hello{{/foo}}')) }
+
+    it 'has a block start and end' do
+      items.map(&:class).should == [ FlavourSaver::BlockExpressionNode ]
+    end
+
+    describe '#contents' do
+      it 'contains a single output node' do
+        items.first.contents.items.size.should == 1
+        items.first.contents.items.first.should be_a(FlavourSaver::OutputNode)
+        items.first.contents.items.first.value.should == 'hello'
+      end
+    end
+  end
+
+  describe '{{/foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{/foo}}')) }
+
+    it 'raises a syntax error' do
+      -> { subject }.should raise_error
+    end
+  end
+
+  describe '{{#foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}')) }
+
+    it 'raises a syntax error' do
+      -> { subject }.should raise_error
+    end
+  end
+
+  describe "{{foo}}\n" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{foo}}\n")) }
+
+    it 'has a block start and end' do
+      items.map(&:class).should == [ FlavourSaver::ExpressionNode, FlavourSaver::OutputNode ]
+    end
+  end
+
+  describe '{{#foo}}{{#bar}}{{/foo}}' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}{{#bar}}{{/foo}}')) }
+
+    it 'raises a syntax error' do
+      -> { subject }.should raise_error
+    end
+  end
+
+  describe "{{#foo}}\n{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex("{{#foo}}\n{{/foo}}")) }
+
+    it "doesn't throw a NotInLanguage exception" do
+      -> { subject }.should_not raise_error
+    end
+  end
+
+  describe "{{#foo}}{#foo}}{{/foo}}{{/foo}}" do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('{{#foo}}{{#foo}}{{/foo}}{{/foo}}')) }
+
+    describe 'the outer block' do
+      let(:block) { subject.items.first }
+
+      it 'should contain another block' do
+        block.contents.items.size.should == 1
+        block.contents.items.first.should be_a(FlavourSaver::BlockExpressionNode)
+      end
+    end
+  end
+
+  describe '' do
+    subject { FlavourSaver::Parser.parse(FlavourSaver::Lexer.lex('')) }
+
+    it 'returns an empty template' do
+      items.should be_empty
+    end
+  end
+
+end