temple 0.9.0 → 0.10.0

data/{test/filters/test_dynamic_inliner.rb → spec/filters/dynamic_inliner_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::DynamicInliner do
   before do
@@ -6,38 +6,38 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should compile several statics into dynamic' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:static, "World\n "],
       [:static, "Have a nice day"]
-    ]).should.equal [:dynamic, '"Hello World\n Have a nice day"']
+    ])).to eq [:dynamic, '"Hello World\n Have a nice day"']
   end
 
   it 'should compile several dynamics into dynamic' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:dynamic, "@hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"]
-    ]).should.equal [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
+    ])).to eq [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
   end
 
   it 'should compile static and dynamic into dynamic' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"],
       [:static, "Nice"]
-    ]).should.equal [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
+    ])).to eq [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
   end
 
   it 'should merge statics and dynamics around a code' do
-    exp = @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:code, "Oh yeah"],
       [:dynamic, "@yeah"],
       [:static, "Once more"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:dynamic, '"Hello #{@world}"'],
       [:code, "Oh yeah"],
       [:dynamic, '"#{@yeah}Once more"']
@@ -45,19 +45,19 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should keep codes intact' do
-    @filter.call([:multi, [:code, 'foo']]).should.equal [:code, 'foo']
+    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
   end
 
   it 'should keep single statics intact' do
-    @filter.call([:multi, [:static, 'foo']]).should.equal [:static, 'foo']
+    expect(@filter.call([:multi, [:static, 'foo']])).to eq([:static, 'foo'])
   end
 
   it 'should keep single dynamic intact' do
-    @filter.call([:multi, [:dynamic, 'foo']]).should.equal [:dynamic, 'foo']
+    expect(@filter.call([:multi, [:dynamic, 'foo']])).to eq([:dynamic, 'foo'])
   end
 
   it 'should inline inside multi' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:multi,
@@ -65,7 +65,7 @@ describe Temple::Filters::DynamicInliner do
         [:dynamic, "@world"]],
       [:static, "Hello "],
       [:dynamic, "@world"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:dynamic, '"Hello #{@world}"'],
       [:dynamic, '"Hello #{@world}"'],
       [:dynamic, '"Hello #{@world}"']
@@ -73,20 +73,20 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should merge across newlines' do
-    exp = @filter.call([:multi,
+    exp = expect(@filter.call([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:dynamic, "@world"],
       [:newline]
-    ]).should.equal [:dynamic, ['"Hello \n"', '"#{@world}"', '""'].join("\\\n")]
+    ])).to eq [:dynamic, ['"Hello \n"', '"#{@world}"', '""'].join("\\\n")]
   end
 
   it 'should compile static followed by newline' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:code, "world"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:static, "Hello \n"],
       [:newline],
       [:code, "world"]

data/{test/filters/test_eraser.rb → spec/filters/eraser_spec.rb}

@@ -1,13 +1,13 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::Eraser do
   it 'should respect keep' do
     eraser = Temple::Filters::Eraser.new(keep: [:a])
-    eraser.call([:multi,
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:a],
       [:multi],
       [:multi]
@@ -16,11 +16,11 @@ describe Temple::Filters::Eraser do
 
   it 'should respect erase' do
     eraser = Temple::Filters::Eraser.new(erase: [:a])
-    eraser.call([:multi,
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:multi],
       [:b],
       [:c]
@@ -29,11 +29,11 @@ describe Temple::Filters::Eraser do
 
   it 'should choose erase over keep' do
     eraser = Temple::Filters::Eraser.new(keep: [:a, :b], erase: [:a])
-    eraser.call([:multi,
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:multi],
       [:b],
       [:multi]
@@ -42,11 +42,11 @@ describe Temple::Filters::Eraser do
 
   it 'should erase nested types' do
     eraser = Temple::Filters::Eraser.new(erase: [[:a, :b]])
-    eraser.call([:multi,
+    expect(eraser.call([:multi,
       [:a, :a],
       [:a, :b],
       [:b]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:a, :a],
       [:multi],
       [:b]

data/{test/filters/test_escapable.rb → spec/filters/escapable_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::Escapable do
   before do
@@ -6,11 +6,11 @@ describe Temple::Filters::Escapable do
   end
 
   it 'should handle escape expressions' do
-    @filter.call([:escape, true,
+    expect(@filter.call([:escape, true,
                   [:multi,
                    [:static, "a < b"],
                    [:dynamic, "ruby_method"]]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:static, "a &lt; b"],
       [:dynamic, "::Temple::Utils.escape_html((ruby_method))"],
     ]
@@ -18,32 +18,32 @@ describe Temple::Filters::Escapable do
 
   it 'should keep codes intact' do
     exp = [:multi, [:code, 'foo']]
-    @filter.call(exp).should.equal exp
+    expect(@filter.call(exp)).to eq(exp)
   end
 
   it 'should keep statics intact' do
     exp = [:multi, [:static, '<']]
-    @filter.call(exp).should.equal exp
+    expect(@filter.call(exp)).to eq(exp)
   end
 
   it 'should keep dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    @filter.call(exp).should.equal exp
+    expect(@filter.call(exp)).to eq(exp)
   end
 
   it 'should have use_html_safe option' do
     with_html_safe do
       filter = Temple::Filters::Escapable.new(use_html_safe: true)
-      filter.call([:escape, true,
+      expect(filter.call([:escape, true,
         [:static, Temple::HTML::SafeString.new("a < b")]
-      ]).should.equal [:static, "a < b"]
+      ])).to eq [:static, "a < b"]
     end
   end
 
   it 'should support censoring' do
     filter = Temple::Filters::Escapable.new(escape_code: '(%s).gsub("Temple sucks", "Temple rocks")')
-    filter.call([:escape, true,
+    expect(filter.call([:escape, true,
       [:static, "~~ Temple sucks ~~"]
-    ]).should.equal [:static, "~~ Temple rocks ~~"]
+    ])).to eq [:static, "~~ Temple rocks ~~"]
   end
 end

data/{test/filters/test_multi_flattener.rb → spec/filters/multi_flattener_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::MultiFlattener do
   before do
@@ -6,7 +6,7 @@ describe Temple::Filters::MultiFlattener do
   end
 
   it 'should flatten nested multi expressions' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "a"],
       [:multi,
        [:dynamic, "aa"],
@@ -17,7 +17,7 @@ describe Temple::Filters::MultiFlattener do
        [:dynamic, "ab"],
       ],
       [:static, "b"],
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:static, "a"],
       [:dynamic, "aa"],
       [:static, "aaa"],
@@ -28,6 +28,6 @@ describe Temple::Filters::MultiFlattener do
   end
 
   it 'should return first element' do
-    @filter.call([:multi, [:code, 'foo']]).should.equal [:code, 'foo']
+    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
   end
 end

data/{test/filters/test_static_analyzer.rb → spec/filters/static_analyzer_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::StaticAnalyzer do
   before do
@@ -8,21 +8,19 @@ describe Temple::Filters::StaticAnalyzer do
 
   if Temple::StaticAnalyzer.available?
     it 'should convert :dynamic to :static if code is static' do
-      @filter.call([:dynamic, '"#{"hello"}#{100}"']
-      ).should.equal [:static, 'hello100']
+      expect(@filter.call([:dynamic, '"#{"hello"}#{100}"'])).to eq([:static, 'hello100'])
     end
 
     it 'should not convert :dynamic if code is dynamic' do
       exp = [:dynamic, '"#{hello}#{100}"']
-      @filter.call(exp).should.equal(exp)
+      expect(@filter.call(exp)).to eq(exp)
     end
 
     it 'should not change number of newlines in generated code' do
       exp = [:dynamic, "[100,\n200,\n]"]
-      @filter.call(exp).should.equal([:multi, [:static, '[100, 200]'], [:newline], [:newline]])
+      expect(@filter.call(exp)).to eq([:multi, [:static, '[100, 200]'], [:newline], [:newline]])
 
-      @generator.call(@filter.call(exp)).count("\n").
-        should.equal(@generator.call(exp).count("\n"))
+      expect(@generator.call(@filter.call(exp)).count("\n")).to eq(@generator.call(exp).count("\n"))
     end
   else
     it 'should do nothing' do
@@ -30,7 +28,7 @@ describe Temple::Filters::StaticAnalyzer do
         [:dynamic, '"#{"hello"}#{100}"'],
         [:dynamic, '"#{hello}#{100}"'],
       ].each do |exp|
-        @filter.call(exp).should.equal(exp)
+        expect(@filter.call(exp)).to eq(exp)
       end
     end
   end

data/{test/filters/test_static_merger.rb → spec/filters/static_merger_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::StaticMerger do
   before do
@@ -6,21 +6,21 @@ describe Temple::Filters::StaticMerger do
   end
 
   it 'should merge serveral statics' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:static, "Good night"]
-    ]).should.equal [:static, "Hello World, Good night"]
+    ])).to eq [:static, "Hello World, Good night"]
   end
 
   it 'should merge serveral statics around code' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:static, "World!"],
       [:code, "123"],
       [:static, "Good night, "],
       [:static, "everybody"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:static, "Hello World!"],
       [:code, "123"],
       [:static, "Good night, everybody"]
@@ -28,12 +28,12 @@ describe Temple::Filters::StaticMerger do
   end
 
   it 'should merge serveral statics across newlines' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:newline],
       [:static, "Good night"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:static, "Hello World, Good night"],
       [:newline]
     ]

data/{test/filters/test_string_splitter.rb → spec/filters/string_splitter_spec.rb}

@@ -1,10 +1,10 @@
-require 'helper'
+require 'spec_helper'
 begin
   require 'ripper'
 rescue LoadError
 end
 
-if defined?(Ripper) && RUBY_VERSION >= "2.0.0"
+if defined?(Ripper)
   describe Temple::Filters::StringSplitter do
     before do
       @filter = Temple::Filters::StringSplitter.new
@@ -32,19 +32,18 @@ if defined?(Ripper) && RUBY_VERSION >= "2.0.0"
     }.each do |code, expected|
       it "should split #{code}" do
         actual = @filter.call([:dynamic, code])
-        actual.should.equal expected
+        expect(actual).to eq(expected)
       end
     end
 
     describe '.compile' do
       it 'should raise CompileError for non-string literals' do
-        lambda { Temple::Filters::StringSplitter.compile('1') }.
-          should.raise(Temple::FilterError)
+        expect { Temple::Filters::StringSplitter.compile('1') }.to raise_error(Temple::FilterError)
       end
 
       it 'should compile strings quoted with parenthesis' do
         tokens = Temple::Filters::StringSplitter.compile('%Q(href("#{1 + 1}");)')
-        tokens.should.equal [[:static, "href(\""], [:dynamic, "1 + 1"], [:static, "\");"]]
+        expect(tokens).to eq([[:static, "href(\""], [:dynamic, "1 + 1"], [:static, "\");"]])
       end
     end
   end

data/spec/generator_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+class SimpleGenerator < Temple::Generator
+  def preamble
+    "#{buffer} = BUFFER"
+  end
+
+  def postamble
+    buffer
+  end
+
+  def on_static(s)
+    concat "S:#{s}"
+  end
+
+  def on_dynamic(s)
+    concat "D:#{s}"
+  end
+
+  def on_code(s)
+    "C:#{s}"
+  end
+end
+
+describe Temple::Generator do
+  it 'should compile simple expressions' do
+    gen = SimpleGenerator.new
+
+    expect(gen.call([:static,  'test'])).to eq('_buf = BUFFER; _buf << (S:test); _buf')
+    expect(gen.call([:dynamic, 'test'])).to eq('_buf = BUFFER; _buf << (D:test); _buf')
+    expect(gen.call([:code,    'test'])).to eq('_buf = BUFFER; C:test; _buf')
+  end
+
+  it 'should compile multi expression' do
+    gen = SimpleGenerator.new(buffer: "VAR")
+    expect(gen.call([:multi,
+      [:static, "static"],
+      [:dynamic, "dynamic"],
+      [:code, "code"]
+    ])).to eq('VAR = BUFFER; VAR << (S:static); VAR << (D:dynamic); C:code; VAR')
+  end
+
+  it 'should compile capture' do
+    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
+    expect(gen.call([:capture, "foo",
+      [:static, "test"]
+    ])).to eq('VAR = BUFFER; foo = BUFFER; foo << (S:test); foo; VAR')
+  end
+
+  it 'should compile capture with multi' do
+    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
+    expect(gen.call([:multi,
+      [:static, "before"],
+
+      [:capture, "foo", [:multi,
+        [:static, "static"],
+        [:dynamic, "dynamic"],
+        [:code, "code"]]],
+
+      [:static, "after"]
+    ])).to eq('VAR = BUFFER; VAR << (S:before); foo = BUFFER; foo << (S:static); ' +
+      'foo << (D:dynamic); C:code; foo; VAR << (S:after); VAR')
+  end
+
+  it 'should compile newlines' do
+    gen = SimpleGenerator.new(buffer: "VAR")
+    expect(gen.call([:multi,
+      [:static, "static"],
+      [:newline],
+      [:dynamic, "dynamic"],
+      [:newline],
+      [:code, "code"]
+    ])).to eq("VAR = BUFFER; VAR << (S:static); \n; " +
+      "VAR << (D:dynamic); \n; C:code; VAR")
+  end
+end
+
+describe Temple::Generators::Array do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::Array.new(freeze_static: false)
+    expect(gen.call([:static,  'test'])).to eq('_buf = []; _buf << ("test"); _buf')
+    expect(gen.call([:dynamic, 'test'])).to eq('_buf = []; _buf << (test); _buf')
+    expect(gen.call([:code,    'test'])).to eq('_buf = []; test; _buf')
+
+    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = []; _buf << ("a"); _buf << ("b"); _buf')
+    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = []; _buf << ("a"); _buf << (b); _buf')
+  end
+
+  it 'should freeze static' do
+    gen = Temple::Generators::Array.new(freeze_static: true)
+    expect(gen.call([:static,  'test'])).to eq('_buf = []; _buf << ("test".freeze); _buf')
+  end
+end
+
+describe Temple::Generators::ArrayBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::ArrayBuffer.new(freeze_static: false)
+    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
+    expect(gen.call([:dynamic, 'test'])).to eq('_buf = (test).to_s')
+    expect(gen.call([:code,    'test'])).to eq('_buf = []; test; _buf = _buf.join("")')
+
+    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = []; _buf << ("a"); _buf << ("b"); _buf = _buf.join("")')
+    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = []; _buf << ("a"); _buf << (b); _buf = _buf.join("")')
+  end
+
+  it 'should freeze static' do
+    gen = Temple::Generators::ArrayBuffer.new(freeze_static: true)
+    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
+    expect(gen.call([:multi, [:dynamic, '1'], [:static,  'test']])).to eq('_buf = []; _buf << (1); _buf << ("test".freeze); _buf = _buf.join("".freeze)')
+  end
+end
+
+describe Temple::Generators::StringBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::StringBuffer.new(freeze_static: false)
+    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
+    expect(gen.call([:dynamic, 'test'])).to eq('_buf = (test).to_s')
+    expect(gen.call([:code,    'test'])).to eq('_buf = \'\'; test; _buf')
+
+    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = \'\'; _buf << ("a"); _buf << ("b"); _buf')
+    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = \'\'; _buf << ("a"); _buf << ((b).to_s); _buf')
+  end
+
+  it 'should freeze static' do
+    gen = Temple::Generators::StringBuffer.new(freeze_static: true)
+    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
+    expect(gen.call([:multi, [:dynamic, '1'], [:static,  'test']])).to eq('_buf = \'\'; _buf << ((1).to_s); _buf << ("test".freeze); _buf')
+  end
+end
+
+describe Temple::Generators::ERB do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::ERB.new
+    expect(gen.call([:static,  'test'])).to eq('test')
+    expect(gen.call([:dynamic, 'test'])).to eq('<%= test %>')
+    expect(gen.call([:code,    'test'])).to eq('<% test %>')
+
+    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('ab')
+    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('a<%= b %>')
+  end
+end
+
+describe Temple::Generators::RailsOutputBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: false)
+    expect(gen.call([:static,  'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
+      '@output_buffer.safe_concat(("test")); @output_buffer')
+    expect(gen.call([:dynamic, 'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
+      '@output_buffer.safe_concat(((test).to_s)); @output_buffer')
+    expect(gen.call([:code,    'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
+      'test; @output_buffer')
+  end
+
+  it 'should freeze static' do
+    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: true)
+    expect(gen.call([:static,  'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; @output_buffer.safe_concat(("test".freeze)); @output_buffer')
+  end
+end

data/spec/grammar_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Temple::Grammar do
+  it 'should match core expressions' do
+    expect(Temple::Grammar).to be_match([:multi])
+    expect(Temple::Grammar).to be_match([:multi, [:multi]])
+    expect(Temple::Grammar).to be_match([:static, 'Text'])
+    expect(Temple::Grammar).to be_match([:dynamic, 'Text'])
+    expect(Temple::Grammar).to be_match([:code, 'Text'])
+    expect(Temple::Grammar).to be_match([:capture, 'Text', [:multi]])
+    expect(Temple::Grammar).to be_match([:newline])
+  end
+
+  it 'should not match invalid core expressions' do
+    expect(Temple::Grammar).not_to be_match([:multi, 'String'])
+    expect(Temple::Grammar).not_to be_match([:static])
+    expect(Temple::Grammar).not_to be_match([:dynamic, 1])
+    expect(Temple::Grammar).not_to be_match([:code, :sym])
+    expect(Temple::Grammar).not_to be_match([:capture, [:multi]])
+    expect(Temple::Grammar).not_to be_match([:newline, [:multi]])
+  end
+
+  it 'should match control flow expressions' do
+    expect(Temple::Grammar).to be_match([:if, 'Condition', [:multi]])
+    expect(Temple::Grammar).to be_match([:if, 'Condition', [:multi], [:multi]])
+    expect(Temple::Grammar).to be_match([:block, 'Loop', [:multi]])
+    expect(Temple::Grammar).to be_match([:case, 'Arg', ['Cond1', [:multi]], ['Cond1', [:multi]], [:else, [:multi]]])
+    expect(Temple::Grammar).not_to be_match([:case, 'Arg', [:sym, [:multi]]])
+    expect(Temple::Grammar).to be_match([:cond, ['Cond1', [:multi]], ['Cond2', [:multi]], [:else, [:multi]]])
+    expect(Temple::Grammar).not_to be_match([:cond, [:sym, [:multi]]])
+  end
+
+  it 'should match escape expression' do
+    expect(Temple::Grammar).to be_match([:escape, true, [:multi]])
+    expect(Temple::Grammar).to be_match([:escape, false, [:multi]])
+  end
+
+  it 'should match html expressions' do
+    expect(Temple::Grammar).to be_match([:html, :doctype, 'Doctype'])
+    expect(Temple::Grammar).to be_match([:html, :comment, [:multi]])
+    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi]])
+    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi], [:multi]])
+    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi], [:static, 'Text']])
+    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:html, :attrs, [:html, :attr, 'id',
+                                  [:static, 'val']]], [:static, 'Text']])
+  end
+end

data/{test/html/test_attribute_merger.rb → spec/html/attribute_merger_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::HTML::AttributeMerger do
   before do
@@ -6,24 +6,24 @@ describe Temple::HTML::AttributeMerger do
   end
 
   it 'should pass static attributes through' do
-    @merger.call([:html, :tag,
+    expect(@merger.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                      [:html, :attrs,
                       [:html, :attr, "class", [:static, "b"]]],
                      [:content]]
   end
 
   it 'should preserve the order of html attributes' do
-    @merger.call([:html, :tag,
+    expect(@merger.call([:html, :tag,
       'meta',
       [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
                       [:html, :attr, 'd', [:static, '2']],
                       [:html, :attr, 'a', [:static, '3']],
                       [:html, :attr, 'b', [:static, '4']]]
-    ]).should.equal [:html, :tag, 'meta',
+    ])).to eq [:html, :tag, 'meta',
                      [:html, :attrs,
                       [:html, :attr, 'c', [:static, '1']],
                       [:html, :attr, 'd', [:static, '2']],
@@ -31,22 +31,22 @@ describe Temple::HTML::AttributeMerger do
                       [:html, :attr, 'b', [:static, '4']]]]
 
     # Use case:
-    @merger.call([:html, :tag,
+    expect(@merger.call([:html, :tag,
       'meta',
       [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
                       [:html, :attr, 'content', [:static, '']]]
-    ]).should.equal [:html, :tag, 'meta',
+    ])).to eq [:html, :tag, 'meta',
                      [:html, :attrs,
                       [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
                       [:html, :attr, 'content', [:static, '']]]]
   end
 
   it 'should merge ids' do
-    @merger.call([:html, :tag,
+    expect(@merger.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'id', [:dynamic, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                      [:html, :attrs,
                       [:html, :attr, "id",
                        [:multi,
@@ -58,11 +58,11 @@ describe Temple::HTML::AttributeMerger do
   end
 
   it 'should merge classes' do
-    @merger.call([:html, :tag,
+    expect(@merger.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                      [:html, :attrs,
                       [:html, :attr, "class",
                        [:multi,