mvz-ruby-handlebars 0.0.8 → 0.0.9

data/lib/ruby-handlebars/helpers/if_helper.rb

@@ -0,0 +1,23 @@
+require_relative 'default_helper'
+
+module Handlebars
+  module Helpers
+    class IfHelper < DefaultHelper
+      def self.registry_name
+        'if'
+      end
+
+      def self.apply(context, condition, block, else_block)
+        condition = !condition.empty? if condition.respond_to?(:empty?)
+
+        if condition
+          block.fn(context)
+        elsif else_block
+          else_block.fn(context)
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/helpers/register_default_helpers.rb

@@ -0,0 +1,15 @@
+require_relative 'each_helper'
+require_relative 'helper_missing_helper'
+require_relative 'if_helper'
+require_relative 'unless_helper'
+
+module Handlebars
+  module Helpers
+    def self.register_default_helpers(hbs)
+      EachHelper.register(hbs)
+      HelperMissingHelper.register(hbs)
+      IfHelper.register(hbs)
+      UnlessHelper.register(hbs)
+    end
+  end
+end

data/lib/ruby-handlebars/helpers/unless_helper.rb

@@ -0,0 +1,21 @@
+require_relative 'default_helper'
+
+module Handlebars
+  module Helpers
+    class UnlessHelper < DefaultHelper
+      def self.registry_name
+        'unless'
+      end
+
+      def self.apply(context, condition, block, else_block)
+        condition = !condition.empty? if condition.respond_to?(:empty?)
+
+        unless condition
+          block.fn(context)
+        else
+          else_block ? else_block.fn(context) : ""
+        end
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/parser.rb

@@ -10,12 +10,21 @@ module Handlebars
     rule(:slash)       { str('/')}
     rule(:ocurly)      { str('{')}
     rule(:ccurly)      { str('}')}
+    rule(:pipe)        { str('|')}
+    rule(:eq)          { str('=')}
+
 
     rule(:docurly)     { ocurly >> ocurly }
     rule(:dccurly)     { ccurly >> ccurly }
+    rule(:tocurly)     { ocurly >> ocurly >> ocurly }
+    rule(:tccurly)     { ccurly >> ccurly >> ccurly }
+
+    rule(:else_kw)     { str('else') }
+    rule(:as_kw)       { str('as') }
 
-    rule(:identifier)  { match['a-zA-Z0-9_\?'].repeat(1) }
-    rule(:path)        { identifier >> (dot >> identifier).repeat }
+    rule(:identifier)  { (else_kw >> space? >> dccurly).absent? >> match['@\-a-zA-Z0-9_\?'].repeat(1) }
+    rule(:directory)   { (else_kw >> space? >> dccurly).absent? >> match['@\-a-zA-Z0-9_\/\?'].repeat(1) }
+    rule(:path)        { identifier >> (dot >> (identifier | else_kw)).repeat }
 
     rule(:nocurly)     { match('[^{}]') }
     rule(:eof)         { any.absent? }
@@ -27,18 +36,49 @@ module Handlebars
         ocurly >> eof       # Opening curly that doesn't start a {{}} because it's the end
       ).repeat(1).as(:template_content) }
 
+    rule(:unsafe_replacement) { docurly >> space? >> path.as(:replaced_unsafe_item) >> space? >> dccurly }
+    rule(:safe_replacement) { tocurly >> space? >> path.as(:replaced_safe_item) >> space? >> tccurly }
+
     rule(:sq_string)   { match("'") >> match("[^']").repeat.maybe.as(:str_content) >> match("'") }
     rule(:dq_string)   { match('"') >> match('[^"]').repeat.maybe.as(:str_content) >> match('"') }
     rule(:string)      { sq_string | dq_string }
 
-    rule(:parameter)   { (path | string).as(:parameter_name) }
+    rule(:parameter)   {
+      (as_kw >> space? >> pipe).absent? >>
+      (
+        (path | string).as(:parameter_name) |
+        (str('(') >> space? >> identifier.as(:safe_helper_name) >> (space? >> parameters.as(:parameters)).maybe >> space? >> str(')'))
+      )
+    }
     rule(:parameters)  { parameter >> (space >> parameter).repeat }
 
-    rule(:unsafe_helper) { docurly >> space? >> path.as(:helper_name) >> (space? >> parameters.as(:parameters)).maybe >> space? >> dccurly}
-    rule(:safe_helper) { ocurly >> helper >> ccurly }
+    rule(:argument)    { identifier.as(:key) >> space? >> eq >> space? >> parameter.as(:value) }
+    rule(:arguments)   { argument >> (space >> argument).repeat }
+
+    rule(:unsafe_helper) { docurly >> space? >> identifier.as(:unsafe_helper_name) >> (space? >> parameters.as(:parameters)).maybe >> space? >> dccurly }
+    rule(:safe_helper) { tocurly >> space? >> identifier.as(:safe_helper_name) >> (space? >> parameters.as(:parameters)).maybe >> space? >> tccurly }
 
     rule(:helper) { unsafe_helper | safe_helper }
 
+    rule(:as_block_helper) {
+      docurly >>
+      hash >>
+      identifier.capture(:helper_name).as(:helper_name) >>
+      space >> parameters.as(:parameters) >>
+      space >> as_kw >> space >> pipe >> space? >> parameters.as(:as_parameters) >> space? >> pipe >>
+      space? >>
+      dccurly >>
+      scope {
+        block
+      } >>
+      scope {
+        docurly >> space? >> else_kw >> space? >> dccurly >> scope { block_item.repeat.as(:else_block_items) }
+      }.maybe >>
+      dynamic { |src, scope|
+        docurly >> slash >> str(scope.captures[:helper_name]) >> dccurly
+      }
+    }
+
     rule(:block_helper) {
       docurly >>
       hash >>
@@ -49,6 +89,9 @@ module Handlebars
       scope {
         block
       } >>
+      scope {
+        docurly >> space? >> else_kw >> space? >> dccurly >> scope { block_item.repeat.as(:else_block_items) }
+      }.maybe >>
       dynamic { |src, scope|
         docurly >> slash >> str(scope.captures[:helper_name]) >> dccurly
       }
@@ -58,12 +101,15 @@ module Handlebars
       docurly >>
       gt >>
       space? >>
-      identifier.as(:partial_name) >>
+      directory.as(:partial_name) >>
+      space? >>
+      arguments.as(:arguments).maybe >>
       space? >>
       dccurly
     }
 
-    rule(:block) { (template_content | helper | partial | block_helper ).repeat.as(:block_items) }
+    rule(:block_item) { (template_content | unsafe_replacement | safe_replacement | helper | partial | block_helper | as_block_helper) }
+    rule(:block) { block_item.repeat.as(:block_items) }
 
     root :block
   end

data/lib/ruby-handlebars/tree.rb

@@ -14,6 +14,23 @@ module Handlebars
       end
     end
 
+    class Replacement < TreeItem.new(:item)
+      def _eval(context)
+        helper = context.get_helper(item.to_s)
+        if helper && helper.arity == 1
+          helper.apply(context)
+        else
+          context.get(item.to_s)
+        end
+      end
+    end
+
+    class EscapedReplacement < Replacement
+      def _eval(context)
+        context.escaper.escape(super(context).to_s)
+      end
+    end
+
     class String < TreeItem.new(:content)
       def _eval(context)
         return content
@@ -30,17 +47,31 @@ module Handlebars
       end
     end
 
-    class Helper < TreeItem.new(:name, :parameters, :block)
+    class Helper < TreeItem.new(:name, :parameters, :block, :else_block)
       def _eval(context)
-        if context.get_helper(name.to_s).nil?
-          context.get(name.to_s)
+        helper = context.get_helper(name.to_s)
+        if helper.nil?
+          context.get_helper('helperMissing').apply(context, String.new(name.to_s))
         else
-          context.get_helper(name.to_s).apply(context, parameters, block)
+          helper.apply(context, parameters, block, else_block)
         end
       end
+    end
 
-      def is_else?
-        name.to_s == 'else'
+    class AsHelper < TreeItem.new(:name, :parameters, :as_parameters, :block, :else_block)
+      def _eval(context)
+        helper = context.get_as_helper(name.to_s)
+        if helper.nil?
+          context.get_helper('helperMissing').apply(context, String.new(name.to_s))
+        else
+          helper.apply_as(context, parameters, as_parameters, block, else_block)
+        end
+      end
+    end
+
+    class EscapedHelper < Helper
+      def _eval(context)
+        context.escaper.escape(super(context).to_s)
       end
     end
 
@@ -50,6 +81,15 @@ module Handlebars
       end
     end
 
+    class PartialWithArgs < TreeItem.new(:partial_name, :arguments)
+      def _eval(context)
+        [arguments].flatten.map(&:values).map do |vals| 
+          context.add_item vals.first.to_s, vals.last._eval(context)
+        end
+        context.get_partial(partial_name.to_s).call_with_context(context)
+      end
+    end
+
     class Block < TreeItem.new(:items)
       def _eval(context)
         items.map {|item| item._eval(context)}.join()
@@ -59,22 +99,26 @@ module Handlebars
       def add_item(i)
         items << i
       end
+
     end
   end
 
   class Transform < Parslet::Transform
     rule(template_content: simple(:content)) {Tree::TemplateContent.new(content)}
+    rule(replaced_unsafe_item: simple(:item)) {Tree::EscapedReplacement.new(item)}
+    rule(replaced_safe_item: simple(:item)) {Tree::Replacement.new(item)}
     rule(str_content: simple(:content)) {Tree::String.new(content)}
     rule(parameter_name: simple(:name)) {Tree::Parameter.new(name)}
 
     rule(
-      helper_name: simple(:name)
+      unsafe_helper_name: simple(:name),
+      parameters: subtree(:parameters)
     ) {
-      Tree::Helper.new(name, [])
+      Tree::EscapedHelper.new(name, parameters)
     }
 
     rule(
-      helper_name: simple(:name),
+      safe_helper_name: simple(:name),
       parameters: subtree(:parameters)
     ) {
       Tree::Helper.new(name, parameters)
@@ -82,20 +126,64 @@ module Handlebars
 
     rule(
       helper_name: simple(:name),
-      block_items: subtree(:block_items)
+      block_items: subtree(:block_items),
     ) {
       Tree::Helper.new(name, [], block_items)
     }
 
+    rule(
+      helper_name: simple(:name),
+      block_items: subtree(:block_items),
+      else_block_items: subtree(:else_block_items)
+    ) {
+      Tree::Helper.new(name, [], block_items, else_block_items)
+    }
+
     rule(
       helper_name: simple(:name),
       parameters: subtree(:parameters),
-      block_items: subtree(:block_items)
+      block_items: subtree(:block_items),
     ) {
       Tree::Helper.new(name, parameters, block_items)
     }
 
+    rule(
+      helper_name: simple(:name),
+      parameters: subtree(:parameters),
+      block_items: subtree(:block_items),
+      else_block_items: subtree(:else_block_items)
+    ) {
+      Tree::Helper.new(name, parameters, block_items, else_block_items)
+    }
+
+    rule(
+      helper_name: simple(:name),
+      parameters: subtree(:parameters),
+      as_parameters: subtree(:as_parameters),
+      block_items: subtree(:block_items),
+    ) {
+      Tree::AsHelper.new(name, parameters, as_parameters, block_items)
+    }
+
+    rule(
+      helper_name: simple(:name),
+      parameters: subtree(:parameters),
+      as_parameters: subtree(:as_parameters),
+      block_items: subtree(:block_items),
+      else_block_items: subtree(:else_block_items)
+    ) {
+      Tree::AsHelper.new(name, parameters, as_parameters, block_items, else_block_items)
+    }
+    
+    rule(
+      partial_name: simple(:partial_name),
+      arguments: subtree(:arguments)
+    ) {
+      Tree::PartialWithArgs.new(partial_name, arguments)
+    }
+
     rule(partial_name: simple(:partial_name)) {Tree::Partial.new(partial_name)}
     rule(block_items: subtree(:block_items)) {Tree::Block.new(block_items)}
+    rule(else_block_items: subtree(:else_block_items)) {Tree::Block.new(block_items)}
   end
 end

data/lib/ruby-handlebars/version.rb

@@ -1,3 +1,3 @@
 module Handlebars
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/spec/handlebars_spec.rb

@@ -1,5 +1,7 @@
 require_relative 'spec_helper'
 require_relative '../lib/ruby-handlebars'
+require_relative '../lib/ruby-handlebars/escapers/dummy_escaper'
+
 
 describe Handlebars::Handlebars do
   let(:hbs) {Handlebars::Handlebars.new}
@@ -17,6 +19,18 @@ describe Handlebars::Handlebars do
       expect(evaluate('Hello {{name}}', {name: 'world'})).to eq('Hello world')
     end
 
+    it 'a double braces replacement with unsafe characters' do
+      expect(evaluate('Hello {{name}}', {name: '<"\'>&'})).to eq('Hello &lt;&quot;&#39;&gt;&amp;')
+    end
+
+    it 'a double braces replacement with nil' do
+      expect(evaluate('Hello {{name}}', {name: nil})).to eq('Hello ')
+    end
+
+    it 'a triple braces replacement with unsafe characters' do
+      expect(evaluate('Hello {{{name}}}', {name: '<"\'>&'})).to eq('Hello <"\'>&')
+    end
+
     it 'allows values specified by methods' do
       expect(evaluate('Hello {{name}}', double(name: 'world'))).to eq('Hello world')
     end
@@ -33,16 +47,55 @@ describe Handlebars::Handlebars do
       expect(evaluate('My simple template: {{person.name}}', {person: {name: 'Another name'}})).to eq('My simple template: Another name')
     end
 
+    it 'prefers a replacement even if its name matches a helper' do
+      expect(evaluate('Hello {{each}}', {each: 'world'})).to eq('Hello world')
+    end
+
+    it 'handles a parameter with a dash' do
+      expect(evaluate('Hello {{first-name}}', double("first-name": 'world'))).to eq('Hello world')
+    end
+
     context 'partials' do
       it 'simple' do
         hbs.register_partial('plic', "Plic")
         expect(evaluate("Hello {{> plic}}")).to eq("Hello Plic")
       end
 
+      it 'using a name with a slash' do
+        hbs.register_partial('parent/plic', "Plic")
+        expect(evaluate("Hello {{> parent/plic}}")).to eq("Hello Plic")
+      end
+
+      it 'using a name that begins with a slash' do
+        hbs.register_partial('/parent/plic', "Plic")
+        expect(evaluate("Hello {{> /parent/plic}}")).to eq("Hello Plic")
+      end
+
       it 'using context' do
         hbs.register_partial('brackets', "[{{name}}]")
         expect(evaluate("Hello {{> brackets}}", {name: 'world'})).to eq("Hello [world]")
       end
+      
+      it 'with a string argument' do
+        hbs.register_partial('with_args', "[{{name}}]")
+        expect(evaluate("Hello {{> with_args name='jon'}}")).to eq("Hello [jon]")
+      end
+
+      it 'with string arguments' do
+        hbs.register_partial('with_args', "[{{fname}} {{lname}}]")
+        expect(evaluate("Hello {{> with_args fname='jon' lname='doe'}}")).to eq("Hello [jon doe]")
+      end
+
+      it 'with variables in arguments' do
+         hbs.register_partial('with_args', "[{{fname}} {{lname}}]")
+        expect(evaluate("Hello {{> with_args fname='jon' lname=last_name}}", {last_name: 'doe'})).to eq("Hello [jon doe]")
+      end
+
+      it 'with a helper as an argument' do
+        hbs.register_helper('wrap_parens') {|context, value| "(#{value})"}
+        hbs.register_partial('with_args', "[{{fname}} {{lname}}]")
+        expect(evaluate("Hello {{> with_args fname='jon' lname=(wrap_parens 'doe')}}")).to eq("Hello [jon (doe)]")
+      end
     end
 
     context 'helpers' do
@@ -60,7 +113,22 @@ describe Handlebars::Handlebars do
       it 'with multiple arguments, including strings' do
         hbs.register_helper('add') {|context, left, op, right| "#{left} #{op} #{right}"}
 
-        expect(evaluate("{{add left '&' right}}", {left: 'Law', right: 'Order'})).to eq("Law & Order")
+        expect(evaluate("{{add left '&' right}}", {left: 'Law', right: 'Order'})).to eq("Law &amp; Order")
+        expect(evaluate("{{{add left '&' right}}}", {left: 'Law', right: 'Order'})).to eq("Law & Order")
+      end
+
+      it 'with an empty string argument' do
+        hbs.register_helper('noah') {|context, value| value.to_s.gsub(/a/, '')}
+
+        expect(evaluate("hey{{noah ''}}there", {})).to eq("heythere")
+      end
+
+      it 'with helpers as arguments' do
+        hbs.register_helper('wrap_parens') {|context, value| "(#{value})"}
+        hbs.register_helper('wrap_dashes') {|context, value| "-#{value}-"}
+
+        expect(evaluate('{{wrap_dashes (wrap_parens "hello")}}', {})).to eq("-(hello)-")
+        expect(evaluate('{{wrap_dashes (wrap_parens world)}}', {world: "world"})).to eq("-(world)-")
       end
 
       it 'with an empty string argument' do
@@ -115,213 +183,95 @@ describe Handlebars::Handlebars do
         data = {company: {people: ['a', 'b', 'c']}}
         expect(evaluate("{{#each company.people}}{{{this}}}{{/each}}", data)).to eq('abc')
       end
+
+      it 'a else keyword out of a helper will raise an error' do
+        expect { evaluate('My {{ else }} template') }.to raise_exception(Parslet::ParseFailed)
+      end
+
+      it '"else" can be part of a path' do
+        expect(evaluate('My {{ something.else }} template', { something: { else: 'awesome' }})).to eq('My awesome template')
+      end
     end
 
-    context 'default helpers' do
-      context 'if' do
-        it 'without else' do
-          template = [
-            "{{#if condition}}",
-            "  Show something",
-            "{{/if}}"
-          ].join("\n")
-          expect(evaluate(template, {condition: true})).to eq("\n  Show something\n")
-          expect(evaluate(template, {condition: false})).to eq("")
+    context 'as_helpers' do
+      it 'can be used to have names parameters inside the block' do
+        hbs.register_as_helper('test_with') do |context, value, name, block|
+          context.with_temporary_context(name => value) do
+            block.fn(context)
+          end
         end
 
-        it 'with an else' do
-          template = [
-            "{{#if condition}}",
-            "  Show something",
-            "{{ else }}",
-            "  Do not show something",
-            "{{/if}}"
-          ].join("\n")
-          expect(evaluate(template, {condition: true})).to eq("\n  Show something\n")
-          expect(evaluate(template, {condition: false})).to eq("\n  Do not show something\n")
-        end
+        expect(evaluate("{{#test_with name as |duck|}}Duck name is: {{duck}}{{/test_with}}", {name: "Dewey"})).to eq('Duck name is: Dewey')
+      end
+
+      it 'can have multiple "as" parameters' do
+        hbs.register_as_helper('test_with') do |context, value1, value2, name1, name2, block|
+          mapping = {}
+          mapping[name1] = value1
+          mapping[name2] = value2
 
-        it 'imbricated ifs' do
-          template = [
-            "{{#if first_condition}}",
-            "  {{#if second_condition}}",
-            "    Case 1",
-            "  {{else}}",
-            "    Case 2",
-            "  {{/if}}",
-            "{{else}}",
-            "  {{#if second_condition}}",
-            "    Case 3",
-            "  {{else}}",
-            "    Case 4",
-            "  {{/if}}",
-            "{{/if}}"
-          ].join("\n")
-
-          expect(evaluate(template, {first_condition: true, second_condition: true}).strip).to eq("Case 1")
-          expect(evaluate(template, {first_condition: true, second_condition: false}).strip).to eq("Case 2")
-          expect(evaluate(template, {first_condition: false, second_condition: true}).strip).to eq("Case 3")
-          expect(evaluate(template, {first_condition: false, second_condition: false}).strip).to eq("Case 4")
+          context.with_temporary_context(mapping) do
+            block.fn(context)
+          end
         end
+
+        expect(evaluate("{{#test_with name1 name2 as |duck1 duck2|}}Duck names are {{duck1}} and {{duck2}}{{/test_with}}", {name1: "Huey", name2: "Dewey"})).to eq('Duck names are Huey and Dewey')
       end
+    end
+  end
 
-      context 'each' do
-        let(:ducks) {[{name: 'Huey'}, {name: 'Dewey'}, {name: 'Louis'}]}
-
-        it 'simple case' do
-          template = [
-            "<ul>",
-            "{{#each items}}  <li>{{this.name}}</li>",
-            "{{/each}}</ul>"
-          ].join("\n")
-
-          data = {items: ducks}
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "  <li>Huey</li>",
-            "  <li>Dewey</li>",
-            "  <li>Louis</li>",
-            "</ul>"
-          ].join("\n"))
-
-          data = {items: []}
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "</ul>"
-          ].join("\n"))
-        end
+  context 'escaping characters' do
+    let(:escaper) { nil }
+    let(:name) { '<"\'>&' }
+    let(:replacement_escaped) { evaluate('Hello {{ name }}', {name: name}) }
+    let(:helper_replacement_escaped) {
+      hbs.register_helper('wrap_parens') {|context, value| "(#{value})"}
+      evaluate('Hello {{wrap_parens name}}', {name: name})
+    }
+
+    before do
+      hbs.set_escaper(escaper)
+    end
 
-        it 'considers not found items as an empty list and does not raise an error' do
-          template = [
-            "<ul>",
-            "{{#each stuff}}  <li>{{this.name}}</li>",
-            "{{/each}}</ul>"
-          ].join("\n")
-
-          expect(evaluate(template, {})).to eq([
-            "<ul>",
-            "</ul>"
-          ].join("\n"))
-        end
+    context 'default escaper' do
+      it 'escapes HTML characters in simple replacements' do
+        expect(replacement_escaped).to eq('Hello &lt;&quot;&#39;&gt;&amp;')
+      end
 
-        it 'considers not found items as an empty list and uses else block if provided' do
-          template = [
-            "<ul>",
-            "{{#each stuff}}  <li>{{this.name}}</li>",
-            "{{else}}  <li>No stuff found....</li>",
-            "{{/each}}</ul>"
-          ].join("\n")
-
-          expect(evaluate(template, {})).to eq([
-            "<ul>",
-            "  <li>No stuff found....</li>",
-            "</ul>"
-          ].join("\n"))
-        end
+      it 'escapes HTML characters in helpers' do
+        expect(helper_replacement_escaped).to eq('Hello (&lt;&quot;&#39;&gt;&amp;)')
+      end
+    end
 
-        it 'works with non-hash data' do
-          template = [
-            "<ul>",
-            "{{#each items}}  <li>{{this.name}}</li>",
-            "{{/each}}</ul>"
-          ].join("\n")
-
-          data = double(items: ducks)
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "  <li>Huey</li>",
-            "  <li>Dewey</li>",
-            "  <li>Louis</li>",
-            "</ul>"
-          ].join("\n"))
-
-          data = {items: []}
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "</ul>"
-          ].join("\n"))
-        end
+    context 'DummyEscaper' do
+      let(:escaper) { Handlebars::Escapers::DummyEscaper }
 
-        it 'using an else statement' do
-          template = [
-            "<ul>",
-            "{{#each items}}  <li>{{this.name}}</li>",
-            "{{else}}  <li>No ducks to display</li>",
-            "{{/each}}</ul>"
-          ].join("\n")
-
-          data = {items: ducks}
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "  <li>Huey</li>",
-            "  <li>Dewey</li>",
-            "  <li>Louis</li>",
-            "</ul>"
-          ].join("\n"))
-
-          data = {items: []}
-          expect(evaluate(template, data)).to eq([
-            "<ul>",
-            "  <li>No ducks to display</li>",
-            "</ul>"
-          ].join("\n"))
-        end
+      it 'escapes nothing' do
+        expect(replacement_escaped).to eq('Hello <"\'>&')
+      end
+
+      it 'escapes nothing in helpers' do
+        expect(helper_replacement_escaped).to eq('Hello (<"\'>&)')
+      end
+    end
 
-        it 'imbricated' do
-          data = {people: [
-            {
-              name: 'Huey',
-              email: 'huey@junior-woodchucks.example.com',
-              phones: ['1234', '5678'],
-            },
-            {
-              name: 'Dewey',
-              email: 'dewey@junior-woodchucks.example.com',
-              phones: ['4321'],
-            }
-          ]}
-
-          template = [
-            "People:",
-            "<ul>",
-            "  {{#each people}}",
-            "  <li>",
-            "    <ul>",
-            "      <li>Name: {{this.name}}</li>",
-            "      <li>Phones: {{#each this.phones}} {{this}} {{/each}}</li>",
-            "      <li>email: {{this.email}}</li>",
-            "    </ul>",
-            "  </li>",
-            "  {{else}}",
-            "  <li>No one to display</li>",
-            "  {{/each}}",
-            "</ul>"
-          ].join("\n")
-
-          expect(evaluate(template, data)).to eq([
-            "People:",
-            "<ul>",
-            "  ",
-            "  <li>",
-            "    <ul>",
-            "      <li>Name: Huey</li>",
-            "      <li>Phones:  1234  5678 </li>",
-            "      <li>email: huey@junior-woodchucks.example.com</li>",
-            "    </ul>",
-            "  </li>",
-            "  ",
-            "  <li>",
-            "    <ul>",
-            "      <li>Name: Dewey</li>",
-            "      <li>Phones:  4321 </li>",
-            "      <li>email: dewey@junior-woodchucks.example.com</li>",
-            "    </ul>",
-            "  </li>",
-            "  ",
-            "</ul>"
-          ].join("\n"))
+    context 'custom escaper' do
+      class VowelEscaper
+        def self.escape(value)
+          value.gsub(/([aeiuo])/, '-\1')
         end
       end
+
+      let(:escaper) { VowelEscaper }
+      let(:name) { 'Her Serene Highness' }
+
+      it 'applies the escaping' do
+        expect(replacement_escaped).to eq('Hello H-er S-er-en-e H-ighn-ess')
+      end
+
+      it 'applies the escaping in helpers' do
+        expect(helper_replacement_escaped).to eq('Hello (H-er S-er-en-e H-ighn-ess)')
+      end
     end
   end
 end