temple 0.6.7 → 0.10.0

data/lib/temple.rb

@@ -10,9 +10,10 @@ module Temple
   autoload :Filter,               'temple/filter'
   autoload :Templates,            'temple/templates'
   autoload :Grammar,              'temple/grammar'
-  autoload :ImmutableHash,        'temple/hash'
-  autoload :MutableHash,          'temple/hash'
-  autoload :OptionHash,           'temple/hash'
+  autoload :ImmutableMap,         'temple/map'
+  autoload :MutableMap,           'temple/map'
+  autoload :OptionMap,            'temple/map'
+  autoload :StaticAnalyzer,       'temple/static_analyzer'
 
   module Mixins
     autoload :Dispatcher,         'temple/mixins/dispatcher'
@@ -20,7 +21,7 @@ module Temple
     autoload :EngineDSL,          'temple/mixins/engine_dsl'
     autoload :GrammarDSL,         'temple/mixins/grammar_dsl'
     autoload :Options,            'temple/mixins/options'
-    autoload :DefaultOptions,     'temple/mixins/options'
+    autoload :ClassOptions,       'temple/mixins/options'
     autoload :Template,           'temple/mixins/template'
   end
 
@@ -40,10 +41,13 @@ module Temple
   end
 
   module Filters
+    autoload :Ambles,             'temple/filters/ambles'
     autoload :CodeMerger,         'temple/filters/code_merger'
     autoload :ControlFlow,        'temple/filters/control_flow'
     autoload :MultiFlattener,     'temple/filters/multi_flattener'
+    autoload :StaticAnalyzer,     'temple/filters/static_analyzer'
     autoload :StaticMerger,       'temple/filters/static_merger'
+    autoload :StringSplitter,     'temple/filters/string_splitter'
     autoload :DynamicInliner,     'temple/filters/dynamic_inliner'
     autoload :Escapable,          'temple/filters/escapable'
     autoload :Eraser,             'temple/filters/eraser'

data/spec/engine_spec.rb

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+class Callable1
+  def call(exp)
+    exp
+  end
+end
+
+class Callable2
+  def call(exp)
+    exp
+  end
+end
+
+class MySpecialFilter
+  def initialize(opts = {})
+  end
+
+  def call(exp)
+    exp
+  end
+end
+
+class TestEngine < Temple::Engine
+  use(:Parser) do |input|
+    [:static, input]
+  end
+  use :MyFilter1, proc {|exp| exp }
+  use :MyFilter2, proc {|exp| exp }
+  use Temple::HTML::Pretty, pretty: true
+  filter :MultiFlattener
+  generator :ArrayBuffer
+  use(:BeforeBeforeLast) { MySpecialFilter }
+  use :BeforeLast, Callable1.new
+  use(:Last) { Callable2.new }
+end
+
+describe Temple::Engine do
+  it 'should build chain' do
+    expect(TestEngine.chain.size).to eq(9)
+
+    expect(TestEngine.chain[0].first).to eq(:Parser)
+    expect(TestEngine.chain[0].size).to eq(2)
+    expect(TestEngine.chain[0].last).to be_a(Proc)
+
+    expect(TestEngine.chain[1].first).to eq(:MyFilter1)
+    expect(TestEngine.chain[1].size).to eq(2)
+    expect(TestEngine.chain[1].last).to be_a(Proc)
+
+    expect(TestEngine.chain[2].first).to eq(:MyFilter2)
+    expect(TestEngine.chain[2].size).to eq(2)
+    expect(TestEngine.chain[2].last).to be_a(Proc)
+
+    expect(TestEngine.chain[3].first).to eq(:'Temple::HTML::Pretty')
+    expect(TestEngine.chain[3].size).to eq(2)
+    expect(TestEngine.chain[3].last).to be_a(Proc)
+
+    expect(TestEngine.chain[4].first).to eq(:MultiFlattener)
+    expect(TestEngine.chain[4].size).to eq(2)
+    expect(TestEngine.chain[4].last).to be_a(Proc)
+
+    expect(TestEngine.chain[5].first).to eq(:ArrayBuffer)
+    expect(TestEngine.chain[5].size).to eq(2)
+    expect(TestEngine.chain[5].last).to be_a(Proc)
+
+    expect(TestEngine.chain[6].first).to eq(:BeforeBeforeLast)
+    expect(TestEngine.chain[6].size).to eq(2)
+    expect(TestEngine.chain[6].last).to be_a(Proc)
+
+    expect(TestEngine.chain[7].first).to eq(:BeforeLast)
+    expect(TestEngine.chain[7].size).to eq(2)
+    expect(TestEngine.chain[7].last).to be_a(Proc)
+
+    expect(TestEngine.chain[8].first).to eq(:Last)
+    expect(TestEngine.chain[8].size).to eq(2)
+    expect(TestEngine.chain[8].last).to be_a(Proc)
+  end
+
+  it 'should instantiate chain' do
+    call_chain = TestEngine.new.send(:call_chain)
+    expect(call_chain[0]).to be_a(Method)
+    expect(call_chain[1]).to be_a(Method)
+    expect(call_chain[2]).to be_a(Method)
+    expect(call_chain[3]).to be_a(Temple::HTML::Pretty)
+    expect(call_chain[4]).to be_a(Temple::Filters::MultiFlattener)
+    expect(call_chain[5]).to be_a(Temple::Generators::ArrayBuffer)
+    expect(call_chain[6]).to be_a(MySpecialFilter)
+    expect(call_chain[7]).to be_a(Callable1)
+    expect(call_chain[8]).to be_a(Callable2)
+  end
+
+  it 'should have #append' do
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(9)
+
+    engine.append :MyFilter3 do |exp|
+      exp
+    end
+
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[9].first).to eq(:MyFilter3)
+    expect(engine.chain[9].size).to eq(2)
+    expect(engine.chain[9].last).to be_a(Proc)
+
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(10)
+    expect(call_chain[9]).to be_a(Method)
+  end
+
+  it 'should have #prepend' do
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(9)
+
+    engine.prepend :MyFilter0 do |exp|
+      exp
+    end
+
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:MyFilter0)
+    expect(engine.chain[0].size).to eq(2)
+    expect(engine.chain[0].last).to be_a(Proc)
+    expect(engine.chain[1].first).to eq(:Parser)
+
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(10)
+    expect(call_chain[0]).to be_a(Method)
+  end
+
+  it 'should have #after' do
+    engine = TestEngine.new
+    engine.after :Parser, :MyFilter0 do |exp|
+      exp
+    end
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter0)
+    expect(engine.chain[2].first).to eq(:MyFilter1)
+  end
+
+  it 'should have #before' do
+    engine = TestEngine.new
+    engine.before :MyFilter1, :MyFilter0 do |exp|
+      exp
+    end
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter0)
+    expect(engine.chain[2].first).to eq(:MyFilter1)
+  end
+
+  it 'should have #remove' do
+    engine = TestEngine.new
+    engine.remove :MyFilter1
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(8)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter2)
+
+    engine = TestEngine.new
+    engine.remove /Last/
+    expect(engine.chain.size).to eq(6)
+  end
+
+  it 'should have #replace' do
+    engine = TestEngine.new
+    engine.replace :Parser, :MyParser do |exp|
+      exp
+    end
+    expect(engine.chain.size).to eq(9)
+    expect(engine.chain[0].first).to eq(:MyParser)
+  end
+
+  it 'should work with inheritance' do
+    inherited_engine = Class.new(TestEngine)
+    expect(inherited_engine.chain.size).to eq(9)
+    inherited_engine.append :MyFilter3 do |exp|
+      exp
+    end
+    expect(inherited_engine.chain.size).to eq(10)
+    expect(TestEngine.chain.size).to eq(9)
+  end
+end

data/{test/test_erb.rb → spec/erb_spec.rb}

@@ -1,6 +1,5 @@
-require 'helper'
-require 'erb'
-require 'tilt'
+require 'spec_helper'
+require 'tilt/erubi'
 
 describe Temple::ERB::Engine do
   it 'should compile erb' do
@@ -12,7 +11,7 @@ describe Temple::ERB::Engine do
 <% end %>
 }
 
-    erb(src).should.equal ERB.new(src).result
+    expect(erb(src)).to eq(erubi(src))
   end
 
   it 'should recognize comments' do
@@ -21,7 +20,7 @@ hello
   <%# comment -- ignored -- useful in testing %>
 world}
 
-    erb(src).should.equal ERB.new(src).result
+    expect(erb(src)).to eq(erubi(src))
   end
 
   it 'should recognize <%% and %%>' do
@@ -32,19 +31,19 @@ world}
 <% end %>
 }
 
-    erb(src).should.equal "\n<%\n\n  %>\n\n" #ERB.new(src).result
+    expect(erb(src)).to eq("\n<%\n  %>\n")
   end
 
   it 'should escape automatically' do
-    src = '<%= "<" %>'
+    src = '<%== "<" %>'
     ans = '&lt;'
-    erb(src).should.equal ans
+    expect(erb(src)).to eq(ans)
   end
 
-  it 'should support == to disable automatic escape' do
-    src = '<%== "<" %>'
+  it 'should support = to disable automatic escape' do
+    src = '<%= "<" %>'
     ans = '<'
-    erb(src).should.equal ans
+    expect(erb(src)).to eq(ans)
   end
 
   it 'should support trim mode' do
@@ -56,7 +55,7 @@ world}
 <% end %>
 }
 
-    erb(src, :trim_mode => '>').should.equal ERB.new(src, nil, '>').result
-    erb(src, :trim_mode => '<>').should.equal ERB.new(src, nil, '<>').result
+    expect(erb(src, trim: true)).to eq(erubi(src, trim: true))
+    expect(erb(src, trim: false)).to eq(erubi(src, trim: false))
   end
 end

data/spec/filter_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class SimpleFilter < Temple::Filter
+  define_options :key
+
+  def on_test(arg)
+    [:on_test, arg]
+  end
+end
+
+describe Temple::Filter do
+  it 'should support options' do
+    expect(Temple::Filter).to respond_to(:default_options)
+    expect(Temple::Filter).to respond_to(:set_default_options)
+    expect(Temple::Filter).to respond_to(:define_options)
+    expect(Temple::Filter.new.options).to be_a(Temple::ImmutableMap)
+    expect(SimpleFilter.new(key: 3).options[:key]).to eq(3)
+  end
+
+  it 'should implement call' do
+    expect(Temple::Filter.new.call([:exp])).to eq([:exp])
+  end
+
+  it 'should process expressions' do
+    filter = SimpleFilter.new
+    expect(filter.call([:unhandled])).to eq([:unhandled])
+    expect(filter.call([:test, 42])).to eq([:on_test, 42])
+  end
+end

data/{test/filters/test_code_merger.rb → spec/filters/code_merger_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::CodeMerger do
   before do
@@ -6,21 +6,21 @@ describe Temple::Filters::CodeMerger do
   end
 
   it 'should merge serveral codes' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:code, "c"]
-    ]).should.equal [:code, "a; b; c"]
+    ])).to eq [:code, "a; b; c"]
   end
 
   it 'should merge serveral codes around static' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:static, "123"],
       [:code, "a"],
       [:code, "b"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, "a; b"],
       [:static, "123"],
       [:code, "a; b"]
@@ -28,11 +28,11 @@ describe Temple::Filters::CodeMerger do
   end
 
   it 'should merge serveral codes with newlines' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:newline],
       [:code, "c"]
-    ]).should.equal [:code, "a; b\nc"]
+    ])).to eq [:code, "a; b\nc"]
   end
 end

data/{test/filters/test_control_flow.rb → spec/filters/control_flow_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::ControlFlow do
   before do
@@ -6,18 +6,18 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process blocks' do
-    @filter.call([:block, 'loop do',
+    expect(@filter.call([:block, 'loop do',
       [:static, 'Hello']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, 'loop do'],
                      [:static, 'Hello'],
                      [:code, 'end']]
   end
 
   it 'should process if' do
-    @filter.call([:if, 'condition',
+    expect(@filter.call([:if, 'condition',
       [:static, 'Hello']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition'],
       [:static, 'Hello'],
       [:code, 'end']
@@ -25,10 +25,10 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process if with else' do
-    @filter.call([:if, 'condition',
+    expect(@filter.call([:if, 'condition',
       [:static, 'True'],
       [:static, 'False']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition'],
       [:static, 'True'],
       [:code, 'else'],
@@ -38,12 +38,12 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should create elsif' do
-    @filter.call([:if, 'condition1',
+    expect(@filter.call([:if, 'condition1',
       [:static, '1'],
       [:if, 'condition2',
        [:static, '2'],
        [:static, '3']]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition1'],
       [:static, '1'],
       [:code, 'elsif condition2'],
@@ -55,11 +55,11 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process cond' do
-    @filter.call([:cond,
+    expect(@filter.call([:cond,
       ['cond1', [:exp1]],
       ['cond2', [:exp2]],
       [:else,   [:exp3]],
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'case'],
       [:code, 'when cond1'],
       [:exp1],
@@ -72,11 +72,11 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process case' do
-    @filter.call([:case, 'var',
+    expect(@filter.call([:case, 'var',
       ['Array',  [:exp1]],
       ['String', [:exp2]],
       [:else,    [:exp3]],
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'case (var)'],
       [:code, 'when Array'],
       [:exp1],

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,
+    eraser = Temple::Filters::Eraser.new(keep: [:a])
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:a],
       [:multi],
       [:multi]
@@ -15,12 +15,12 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should respect erase' do
-    eraser = Temple::Filters::Eraser.new(:erase => [:a])
-    eraser.call([:multi,
+    eraser = Temple::Filters::Eraser.new(erase: [:a])
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:multi],
       [:b],
       [:c]
@@ -28,12 +28,12 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should choose erase over keep' do
-    eraser = Temple::Filters::Eraser.new(:keep => [:a, :b], :erase => [:a])
-    eraser.call([:multi,
+    eraser = Temple::Filters::Eraser.new(keep: [:a, :b], erase: [:a])
+    expect(eraser.call([:multi,
       [:a],
       [:b],
       [:c]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:multi],
       [:b],
       [:multi]
@@ -41,12 +41,12 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should erase nested types' do
-    eraser = Temple::Filters::Eraser.new(:erase => [[:a, :b]])
-    eraser.call([:multi,
+    eraser = Temple::Filters::Eraser.new(erase: [[:a, :b]])
+    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,30 +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
-    filter = Temple::Filters::Escapable.new(:use_html_safe => true)
-    filter.call([:escape, true,
-      [:static, HtmlSafeString.new("a < b")]
-    ]).should.equal [:static, "a < b"]
+    with_html_safe do
+      filter = Temple::Filters::Escapable.new(use_html_safe: true)
+      expect(filter.call([:escape, true,
+        [:static, Temple::HTML::SafeString.new("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,
+    filter = Temple::Filters::Escapable.new(escape_code: '(%s).gsub("Temple sucks", "Temple rocks")')
+    expect(filter.call([:escape, true,
       [:static, "~~ Temple sucks ~~"]
-    ]).should.equal [:static, "~~ Temple rocks ~~"]
+    ])).to eq [:static, "~~ Temple rocks ~~"]
   end
 end