temple 0.8.2 → 0.9.1

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,

data/{test/html/test_attribute_remover.rb → spec/html/attribute_remover_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::HTML::AttributeRemover do
   before do
@@ -6,22 +6,22 @@ describe Temple::HTML::AttributeRemover do
   end
 
   it 'should pass static attributes through' do
-    @remover.call([:html, :tag,
+    expect(@remover.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                      [:multi,
                       [:html, :attr, "class", [:static, "b"]]],
                      [:content]]
   end
 
   it 'should check for empty dynamic attribute if it is included in :remove_empty_attrs' do
-    @remover.call([:html, :tag,
+    expect(@remover.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                     [:multi,
                       [:multi,
                        [:capture, "_temple_html_attributeremover1", [:dynamic, "b"]],
@@ -31,11 +31,11 @@ describe Temple::HTML::AttributeRemover do
   end
 
   it 'should not check for empty dynamic attribute if it is not included in :remove_empty_attrs' do
-    @remover.call([:html, :tag,
+    expect(@remover.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'name', [:dynamic, 'b']]],
       [:content]
-    ]).should.equal [:html, :tag, "div",
+    ])).to eq [:html, :tag, "div",
                      [:multi,
                       [:html, :attr, "name", [:dynamic, "b"]]],
                      [:content]]

data/{test/html/test_attribute_sorter.rb → spec/html/attribute_sorter_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::HTML::AttributeSorter do
   before do
@@ -7,13 +7,13 @@ describe Temple::HTML::AttributeSorter do
   end
 
   it 'should sort html attributes by name by default, when :sort_attrs is true' do
-    @ordered.call([:html, :tag,
+    expect(@ordered.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, 'a', [:static, '3']],
                       [:html, :attr, 'b', [:static, '4']],
@@ -22,13 +22,13 @@ describe Temple::HTML::AttributeSorter do
   end
 
   it 'should preserve the order of html attributes when :sort_attrs is false' do
-    @unordered.call([:html, :tag,
+    expect(@unordered.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']],
@@ -36,11 +36,11 @@ describe Temple::HTML::AttributeSorter do
                       [:html, :attr, 'b', [:static, '4']]]]
 
     # Use case:
-    @unordered.call([:html, :tag,
+    expect(@unordered.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, '']]]]

data/{test/html/test_fast.rb → spec/html/fast_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::HTML::Fast do
   before do
@@ -6,37 +6,37 @@ describe Temple::HTML::Fast do
   end
 
   it 'should compile html doctype' do
-    @html.call([:multi, [:html, :doctype, '5']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
-    @html.call([:multi, [:html, :doctype, 'html']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
-    @html.call([:multi, [:html, :doctype, '1.1']]).should.equal [:multi,
+    expect(@html.call([:multi, [:html, :doctype, '5']])).to eq([:multi, [:static, '<!DOCTYPE html>']])
+    expect(@html.call([:multi, [:html, :doctype, 'html']])).to eq([:multi, [:static, '<!DOCTYPE html>']])
+    expect(@html.call([:multi, [:html, :doctype, '1.1']])).to eq [:multi,
       [:static, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">']]
   end
 
   it 'should compile xml encoding' do
-    @html.call([:html, :doctype, 'xml latin1']).should.equal [:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"]
+    expect(@html.call([:html, :doctype, 'xml latin1'])).to eq([:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"])
   end
 
   it 'should compile html comment' do
-    @html.call([:html, :comment, [:static, 'test']]).should.equal [:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]]
+    expect(@html.call([:html, :comment, [:static, 'test']])).to eq([:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]])
   end
 
   it 'should compile js wrapped in comments' do
-    Temple::HTML::Fast.new(js_wrapper: nil).call([:html, :js, [:static, 'test']]).should.equal [:static, "test"]
-    Temple::HTML::Fast.new(js_wrapper: :comment).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
-    Temple::HTML::Fast.new(js_wrapper: :cdata).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(js_wrapper: :both).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]]
+    expect(Temple::HTML::Fast.new(js_wrapper: nil).call([:html, :js, [:static, 'test']])).to eq([:static, "test"])
+    expect(Temple::HTML::Fast.new(js_wrapper: :comment).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :cdata).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :both).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]])
   end
 
   it 'should guess default js comment' do
-    Temple::HTML::Fast.new(js_wrapper: :guess, format: :xhtml).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(js_wrapper: :guess, format: :html).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+    expect(Temple::HTML::Fast.new(js_wrapper: :guess, format: :xhtml).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :guess, format: :html).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]])
   end
 
   it 'should compile autoclosed html tag' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'img', [:attrs],
       [:multi, [:newline]]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<img"],
                      [:attrs],
                      [:static, " />"],
@@ -44,18 +44,18 @@ describe Temple::HTML::Fast do
   end
 
   it 'should compile explicitly closed html tag' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'closed', [:attrs]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<closed"],
                      [:attrs],
                      [:static, " />"]]
   end
 
   it 'should compile html with content' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'div', [:attrs], [:content]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<div"],
                      [:attrs],
                      [:static, ">"],
@@ -64,13 +64,13 @@ describe Temple::HTML::Fast do
   end
 
   it 'should compile html with attrs' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'div',
       [:html, :attrs,
        [:html, :attr, 'id', [:static, 'test']],
        [:html, :attr, 'class', [:dynamic, 'block']]],
        [:content]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<div"],
                      [:multi,
                       [:multi, [:static, " id=\""], [:static, "test"], [:static, '"']],
@@ -82,16 +82,16 @@ describe Temple::HTML::Fast do
 
   it 'should keep codes intact' do
     exp = [:multi, [:code, 'foo']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
 
   it 'should keep statics intact' do
     exp = [:multi, [:static, '<']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
 
   it 'should keep dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
 end

data/{test/html/test_pretty.rb → spec/html/pretty_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::HTML::Pretty do
   before do
@@ -6,9 +6,9 @@ describe Temple::HTML::Pretty do
   end
 
   it 'should indent nested tags' do
-    @html.call([:html, :tag, 'div', [:multi],
+    expect(@html.call([:html, :tag, 'div', [:multi],
       [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<div"],
@@ -26,9 +26,9 @@ describe Temple::HTML::Pretty do
   end
 
   it 'should not indent preformatted tags' do
-    @html.call([:html, :tag, 'pre', [:multi],
+    expect(@html.call([:html, :tag, 'pre', [:multi],
       [:html, :tag, 'p', [:multi], [:static, 'text']]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<pre"],
@@ -45,9 +45,9 @@ describe Temple::HTML::Pretty do
 
   it 'should not escape html_safe strings' do
     with_html_safe do
-      @html.call(
+      expect(@html.call(
         [:dynamic, '"text<".html_safe']
-      ).should.equal [:multi,
+      )).to eq [:multi,
                       [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                       [:dynamic, "::Temple::Utils.indent_dynamic((\"text<\".html_safe), nil, \"\\n\", _temple_html_pretty1)"]]
     end

data/spec/map_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Temple::ImmutableMap do
+  it 'has read accessor' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    expect(hash[:a]).to eq(1)
+    expect(hash[:b]).to eq(2)
+  end
+
+  it 'has include?' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    expect(hash).to include(:a)
+    expect(hash).to include(:b)
+    expect(hash).not_to include(:c)
+  end
+
+  it 'has values' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).values.sort).to eq([1,2])
+  end
+
+  it 'has keys' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).keys).to eq([:a,:b])
+  end
+
+  it 'has to_a' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).to_a).to eq([[:a, 1], [:b, 2]])
+  end
+end
+
+describe Temple::MutableMap do
+  it 'has write accessor' do
+    parent = {a: 1}
+    hash = Temple::MutableMap.new(parent)
+    expect(hash[:a]).to eq(1)
+    hash[:a] = 2
+    expect(hash[:a]).to eq(2)
+    expect(parent[:a]).to eq(1)
+  end
+end

data/{test/mixins/test_dispatcher.rb → spec/mixins/dispatcher_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 class FilterWithDispatcherMixin
   include Temple::Mixins::Dispatcher
@@ -40,31 +40,31 @@ describe Temple::Mixins::Dispatcher do
   end
 
   it 'should return unhandled expressions' do
-    @filter.call([:unhandled]).should.equal [:unhandled]
+    expect(@filter.call([:unhandled])).to eq([:unhandled])
   end
 
   it 'should dispatch first level' do
-    @filter.call([:test, 42]).should.equal [:on_test, 42]
+    expect(@filter.call([:test, 42])).to eq([:on_test, 42])
   end
 
   it 'should dispatch second level' do
-    @filter.call([:second, :test, 42]).should.equal [:on_second_test, 42]
+    expect(@filter.call([:second, :test, 42])).to eq([:on_second_test, 42])
   end
 
   it 'should dispatch second level if prefixed' do
-    @filter.call([:test, :check, 42]).should.equal [:on_check, 42]
+    expect(@filter.call([:test, :check, 42])).to eq([:on_check, 42])
   end
 
   it 'should dispatch parent level' do
-    @filter.call([:a, 42]).should == [:a, 42]
-    @filter.call([:a, :b, 42]).should == [:on_ab, 42]
-    @filter.call([:a, :b, :test, 42]).should == [:on_ab_test, 42]
-    @filter.call([:a, :b, :c, 42]).should == [:on_ab, :c, 42]
-    @filter.call([:a, :b, :c, :d, 42]).should == [:on_ab, :c, :d, 42]
-    @filter.call([:a, :b, :c, :d, :test, 42]).should == [:on_abcd_test, 42]
+    expect(@filter.call([:a, 42])).to eq [:a, 42]
+    expect(@filter.call([:a, :b, 42])).to eq [:on_ab, 42]
+    expect(@filter.call([:a, :b, :test, 42])).to eq [:on_ab_test, 42]
+    expect(@filter.call([:a, :b, :c, 42])).to eq [:on_ab, :c, 42]
+    expect(@filter.call([:a, :b, :c, :d, 42])).to eq [:on_ab, :c, :d, 42]
+    expect(@filter.call([:a, :b, :c, :d, :test, 42])).to eq [:on_abcd_test, 42]
   end
 
   it 'should dispatch zero level' do
-    FilterWithDispatcherMixinAndOn.new.call([:foo,42]).should == [:on_zero, :foo, 42]
+    expect(FilterWithDispatcherMixinAndOn.new.call([:foo,42])).to eq [:on_zero, :foo, 42]
   end
 end

data/{test/mixins/test_grammar_dsl.rb → spec/mixins/grammar_dsl_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 module BasicGrammar
   extend Temple::Mixins::GrammarDSL
@@ -28,42 +28,42 @@ end
 
 describe Temple::Mixins::GrammarDSL do
   it 'should support class types' do
-    BasicGrammar.should.match :symbol
-    BasicGrammar.should.not.match [:symbol]
-    BasicGrammar.should.not.match 'string'
-    BasicGrammar.should.not.match ['string']
+    expect(BasicGrammar).to be_match(:symbol)
+    expect(BasicGrammar).not_to be_match([:symbol])
+    expect(BasicGrammar).not_to be_match('string')
+    expect(BasicGrammar).not_to be_match(['string'])
   end
 
   it 'should support value types' do
-    BasicGrammar.should.match 42
-    BasicGrammar.should.not.match 43
+    expect(BasicGrammar).to be_match(42)
+    expect(BasicGrammar).not_to be_match(43)
   end
 
   it 'should support nesting' do
-    BasicGrammar.should.match [:zero_or_more, [:zero_or_more]]
+    expect(BasicGrammar).to be_match([:zero_or_more, [:zero_or_more]])
   end
 
   it 'should support *' do
-    BasicGrammar.should.match [:zero_or_more]
-    BasicGrammar.should.match [:zero_or_more, nil, 42]
+    expect(BasicGrammar).to be_match([:zero_or_more])
+    expect(BasicGrammar).to be_match([:zero_or_more, nil, 42])
   end
 
   it 'should support +' do
-    BasicGrammar.should.not.match [:one_or_more]
-    BasicGrammar.should.match     [:one_or_more, 42]
-    BasicGrammar.should.match     [:one_or_more, 42, nil]
+    expect(BasicGrammar).not_to be_match([:one_or_more])
+    expect(BasicGrammar).to be_match(    [:one_or_more, 42])
+    expect(BasicGrammar).to be_match(    [:one_or_more, 42, nil])
   end
 
   it 'should support ?' do
-    BasicGrammar.should.not.match [:zero_or_one, nil, 42]
-    BasicGrammar.should.match     [:zero_or_one]
-    BasicGrammar.should.match     [:zero_or_one, 42]
+    expect(BasicGrammar).not_to be_match([:zero_or_one, nil, 42])
+    expect(BasicGrammar).to be_match(    [:zero_or_one])
+    expect(BasicGrammar).to be_match(    [:zero_or_one, 42])
   end
 
   it 'should support extended grammars' do
-    ExtendedGrammar.should.match [:extended, [:extended, 42]]
-    BasicGrammar.should.not.match [:zero_or_more, [:extended, nil]]
-    BasicGrammar.should.not.match [:extended, [:extended, 42]]
+    expect(ExtendedGrammar).to be_match([:extended, [:extended, 42]])
+    expect(BasicGrammar).not_to be_match([:zero_or_more, [:extended, nil]])
+    expect(BasicGrammar).not_to be_match([:extended, [:extended, 42]])
   end
 
   it 'should have validate!' do

data/{test/helper.rb → spec/spec_helper.rb}

@@ -1,4 +1,3 @@
-require 'bacon'
 require 'temple'
 
 module TestHelper
@@ -13,18 +12,18 @@ module TestHelper
   end
 
   def grammar_validate(grammar, exp, message)
-    lambda { grammar.validate!(exp) }.should.raise(Temple::InvalidExpression).message.should.equal message
+    expect { grammar.validate!(exp) }.to raise_error(Temple::InvalidExpression, message)
   end
 
   def erb(src, options = {})
     Temple::ERB::Template.new(options) { src }.render
   end
 
-  def erubis(src, options = {})
-    Tilt::ErubisTemplate.new(options) { src }.render
+  def erubi(src, options = {})
+    Tilt::ErubiTemplate.new(options) { src }.render
   end
 end
 
-class Bacon::Context
-  include TestHelper
+RSpec.configure do |config|
+  config.include TestHelper
 end

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

@@ -1,9 +1,9 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::StaticAnalyzer do
   describe '.available?' do
     it 'should return true if its dependency is available' do
-      Temple::StaticAnalyzer.available?.should.equal(defined?(Ripper) && Ripper.respond_to?(:lex))
+      expect(Temple::StaticAnalyzer.available?).to eq(defined?(Ripper) && Ripper.respond_to?(:lex))
     end
   end
 
@@ -11,13 +11,13 @@ describe Temple::StaticAnalyzer do
     describe '.static?' do
       it 'should return true if given Ruby expression is static' do
         ['true', 'false', '"hello world"', "[1, { 2 => 3 }]", "[\n1,\n]"].each do |exp|
-          Temple::StaticAnalyzer.static?(exp).should.equal(true)
+          expect(Temple::StaticAnalyzer.static?(exp)).to eq(true)
         end
       end
 
       it 'should return false if given Ruby expression is dynamic' do
         ['1 + 2', 'variable', 'method_call(a)', 'CONSTANT'].each do |exp|
-          Temple::StaticAnalyzer.static?(exp).should.equal(false)
+          expect(Temple::StaticAnalyzer.static?(exp)).to eq(false)
         end
       end
     end
@@ -25,13 +25,13 @@ describe Temple::StaticAnalyzer do
     describe '.syntax_error?' do
       it 'should return false if given Ruby expression is valid' do
         ['Foo.bar.baz { |c| c.d! }', '{ foo: bar }'].each do |exp|
-          Temple::StaticAnalyzer.syntax_error?(exp).should.equal(false)
+          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(false)
         end
       end
 
       it 'should return true if given Ruby expression is invalid' do
         ['Foo.bar.baz { |c| c.d! ', ' foo: bar '].each do |exp|
-          Temple::StaticAnalyzer.syntax_error?(exp).should.equal(true)
+          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(true)
         end
       end
     end

data/spec/utils_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class UniqueTest
+  include Temple::Utils
+end
+
+describe Temple::Utils do
+  it 'has empty_exp?' do
+    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi]])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:newline]], [:newline]])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:static, 'text']]])).to eq(false)
+    expect(Temple::Utils.empty_exp?([:multi, [:newline], [:multi, [:dynamic, 'text']]])).to eq(false)
+  end
+
+  it 'has unique_name' do
+    u = UniqueTest.new
+    expect(u.unique_name).to eq('_uniquetest1')
+    expect(u.unique_name).to eq('_uniquetest2')
+    expect(UniqueTest.new.unique_name).to eq('_uniquetest1')
+  end
+
+  it 'has escape_html' do
+    expect(Temple::Utils.escape_html('<')).to eq('&lt;')
+  end
+
+  it 'should escape unsafe html strings' do
+    with_html_safe do
+      expect(Temple::Utils.escape_html_safe('<')).to eq('&lt;')
+    end
+  end
+
+  it 'should not escape safe html strings' do
+    with_html_safe do
+      expect(Temple::Utils.escape_html_safe('<'.html_safe)).to eq('<')
+    end
+  end
+end