hotcell 0.2.0 → 0.3.0

data/lib/hotcell/parser.y

@@ -46,15 +46,15 @@ prechigh
   left AND
   left OR
   nonassoc RANGE
-  right TERNARY
+  right QUESTION
   right ASSIGN
   nonassoc COMMA COLON
   left SEMICOLON NEWLINE
 preclow
 start document
 rule
-  document: document document_unit { pospoppush(2); val[0].children.push(val[1]) }
-          | document_unit { result = build Joiner, :JOINER, val[0], position: pospoppush(1) }
+  document: document document_unit { pospoppush(2); val[0].push(val[1]) }
+          | document_unit { result = [val[0]] }
   document_unit: template | tag | block_tag | command_tag
 
   template: TEMPLATE { result = val[0] }
@@ -155,6 +155,7 @@ rule
       | expr EQUAL expr { result = build Expression, :EQUAL, val[0], val[2], position: pospoppush(3) }
       | expr INEQUAL expr { result = build Expression, :INEQUAL, val[0], val[2], position: pospoppush(3) }
       | NOT expr { result = build Expression, :NOT, val[1], position: pospoppush(2) }
+      | expr QUESTION expr COLON expr { result = build Expression, :TERNARY, val[0], val[2], val[4], position: pospoppush(5) }
       | IDENTIFER ASSIGN expr { result = build Assigner, val[0], val[2], position: pospoppush(3) }
       | expr PERIOD method { pospoppush(3); val[2].children[0] = val[0]; result = val[2] }
       | expr AOPEN arguments ACLOSE {
@@ -162,21 +163,37 @@ rule
         }
       | POPEN PCLOSE { pospoppush(2); result = nil }
       | POPEN sequence PCLOSE {
-          position = pospoppush(3)
           result = case val[1].size
           when 1
             val[1][0]
           else
-            build Sequencer, :SEQUENCE, *val[1].flatten, position: position
+            build Sequencer, :SEQUENCE, *val[1].flatten, position: pospoppush(3)
           end
         }
       | value
 
-  value: const | number | string | range | array | hash | method
+  value: const | number | string | dstring | regexp | range | array | hash | method
 
   const: NIL | TRUE | FALSE
   number: INTEGER | FLOAT
-  string: STRING | REGEXP
+  string: STRING
+  regexp: REGEXP
+
+  dstring: DOPEN dstring_content DCLOSE { result = build Expression, :DSTRING, *val[1], position: pospoppush(3) }
+         | DOPEN DCLOSE { pospoppush(2); result = '' }
+  dstring_content: STRING { result = [val[0]] }
+                 | dstring_interpolation { result = [val[0]] }
+                 | dstring_content STRING { pospoppush(2); val[0].push(val[1]); result = val[0] }
+                 | dstring_content dstring_interpolation { pospoppush(2); val[0].push(val[1]); result = val[0] }
+  dstring_interpolation: IOPEN sequence ICLOSE {
+                           result = case val[1].size
+                           when 1
+                             val[1][0]
+                           else
+                             build Sequencer, :SEQUENCE, *val[1].flatten, position: pospoppush(3)
+                           end
+                         }
+                       | IOPEN ICLOSE { pospoppush(2); result = nil }
 
   range: expr RANGE expr {
            result = build Expression, val[1] == '..' ? :RANGE : :ERANGE,
@@ -260,11 +277,8 @@ rule
   end
 
   def parse
-    if @tokens.size == 0
-      build Joiner, :JOINER, position: 0
-    else
-      do_parse
-    end
+    children = @tokens.size.zero? ? [] : do_parse
+    build Joiner, :JOINER, *children, position: 0
   end
 
   def next_token

data/lib/hotcell/tong.rb

@@ -0,0 +1,54 @@
+module Hotcell
+  class Tong
+    module Mixin
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :tong_methods, instance_writter: false
+        self.tong_methods = Set.new
+
+        def self.manipulate *methods
+          self.tong_methods = Set.new(tong_methods.to_a + methods.flatten.map(&:to_s))
+        end
+      end
+
+      def to_tong
+        self
+      end
+
+      def tong_invoke method, *arguments
+        if method == '[]'
+          tong_invoke_brackets *arguments
+        elsif tong_invokable? method
+          send(method, *arguments)
+        else
+          tong_missing(method, *arguments)
+        end
+      end
+
+      def tong_missing method, *arguments
+      end
+
+    private
+
+      def tong_invokable? method
+        tong_methods.include? method
+      end
+
+      def tong_invoke_brackets *arguments
+        if respond_to? :[]
+          self[*arguments]
+        else
+          tong_invoke *arguments
+        end
+      end
+    end
+
+    include Mixin
+
+    def tong_methods
+      @tong_methods ||= Set.new((self.class.public_instance_methods -
+        Hotcell::Tong.public_instance_methods).map(&:to_s))
+    end
+  end
+end

data/lib/hotcell/version.rb

@@ -1,3 +1,3 @@
 module Hotcell
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/lib/hotcell/commands/include_spec.rb

@@ -27,7 +27,7 @@ describe Hotcell::Commands::Include do
 
   describe '#render' do
     specify { parse("{{ include 'template0' }}").render(render_options).should =~ /Template not found/ }
-    specify { parse("{{ include 'template1' }}").render(render_options).should == 'Hello' }
+    specify { parse("{{ include 'template1' }}").render!(render_options).should == 'Hello' }
     specify { parse("{{ include 'template2' }}").render(render_options).should == 'Hello, ' }
     specify { parse(
       "{{ include 'template2', name: 'Pyrosha' }}"

data/spec/lib/hotcell/context_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Hotcell::Context do
   its('scope.scope') { should == [{}] }
-  its(:helpers) { should be_a Hotcell::Manipulator }
+  its(:helpers) { should be_a Hotcell::Tong }
 
   describe '#normalize_options' do
     def result options = {}
@@ -69,7 +69,7 @@ describe Hotcell::Context do
     end
   end
 
-  describe '#manipulator_invoke' do
+  describe '#tong_invoke' do
     subject { described_class.new(
       variables: { foo: 42, 'bar' => 'baz' }, environment: { 'baz' => 'moo' },
       helpers: Module.new do
@@ -82,12 +82,12 @@ describe Hotcell::Context do
         end
       end
     ) }
-    specify { subject.manipulator_invoke('foo').should == 42 }
-    specify { subject.manipulator_invoke('moo').should be_nil }
-    specify { subject.manipulator_invoke('baz').should be_nil }
-    specify { subject.manipulator_invoke('bar').should == 'baz' }
-    specify { expect { subject.manipulator_invoke('bar', 42) }.to raise_error ArgumentError }
-    specify { expect { subject.manipulator_invoke('strip') }.to raise_error ArgumentError }
-    specify { subject.manipulator_invoke('strip', '  hello  ').should == 'hello' }
+    specify { subject.tong_invoke('foo').should == 42 }
+    specify { subject.tong_invoke('moo').should be_nil }
+    specify { subject.tong_invoke('baz').should be_nil }
+    specify { subject.tong_invoke('bar').should == 'baz' }
+    specify { expect { subject.tong_invoke('bar', 42) }.to raise_error ArgumentError }
+    specify { expect { subject.tong_invoke('strip') }.to raise_error ArgumentError }
+    specify { subject.tong_invoke('strip', '  hello  ').should == 'hello' }
   end
 end

data/spec/lib/hotcell/lexer_spec.rb

@@ -105,13 +105,13 @@ describe Hotcell::Lexer do
 
     context 'constants' do
       specify { expression('nil').should == [[:NIL, nil]] }
-      specify { expression('"nil"').should == [[:STRING, 'nil']] }
+      specify { expression('"nil"').should == [[:DOPEN, '"'], [:STRING, 'nil'], [:DCLOSE, '"']] }
       specify { expression('null').should == [[:NIL, nil]] }
-      specify { expression('"null"').should == [[:STRING, 'null']] }
+      specify { expression('"null"').should == [[:DOPEN, '"'], [:STRING, 'null'], [:DCLOSE, '"']] }
       specify { expression('false').should == [[:FALSE, false]] }
-      specify { expression('"false"').should == [[:STRING, 'false']] }
+      specify { expression('"false"').should == [[:DOPEN, '"'], [:STRING, 'false'], [:DCLOSE, '"']] }
       specify { expression('true').should == [[:TRUE, true]] }
-      specify { expression('"true"').should == [[:STRING, 'true']] }
+      specify { expression('"true"').should == [[:DOPEN, '"'], [:STRING, 'true'], [:DCLOSE, '"']] }
     end
   end
 
@@ -130,7 +130,7 @@ describe Hotcell::Lexer do
       specify { expression(%q{'при\вет'}).should == [[:STRING, 'при\вет']] }
 
       context do
-        let(:strings) { data 'sstrings' }
+        let(:strings) { data 'strings' }
 
         specify { expression(strings).delete_if { |token| token.first == :NEWLINE }.should == [
           [:STRING, 'fo\'o'], [:STRING, 'fo\o'], [:STRING, 'fo\\o'],
@@ -141,28 +141,64 @@ describe Hotcell::Lexer do
 
     context 'double quoted' do
       specify { expression(%q{""}).should == [[:STRING, ""]] }
-      specify { expression(%q{"foo"}).should == [[:STRING, "foo"]] }
-      specify { expression(%q{"fo'o"}).should == [[:STRING, "fo'o"]] }
-      specify { expression(%q{"fo\o"}).should == [[:STRING, "fo\o"]] }
-      specify { expression(%q{"fo\"o"}).should == [[:STRING, "fo\"o"]] }
-      specify { expression(%q{"fo\'o"}).should == [[:STRING, "fo\'o"]] }
-      specify { expression(%q{"fo\no"}).should == [[:STRING, "fo\no"]] }
-      specify { expression(%q{"fo\mo"}).should == [[:STRING, "fo\mo"]] }
-      specify { expression(%q{"foo42"}).should == [[:STRING, "foo42"]] }
-      specify { expression(%q{"привет"}).should == [[:STRING, "привет"]] }
+      specify { expression(%q{"foo"}).should == [[:DOPEN, '"'], [:STRING, "foo"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo'o"}).should == [[:DOPEN, '"'], [:STRING, "fo'o"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo\o"}).should == [[:DOPEN, '"'], [:STRING, "fo\o"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo\"o"}).should == [[:DOPEN, '"'], [:STRING, "fo\"o"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo\'o"}).should == [[:DOPEN, '"'], [:STRING, "fo\'o"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo\no"}).should == [[:DOPEN, '"'], [:STRING, "fo\no"], [:DCLOSE, '"']] }
+      specify { expression(%q{"fo\mo"}).should == [[:DOPEN, '"'], [:STRING, "fo\mo"], [:DCLOSE, '"']] }
+      specify { expression(%q{"foo42"}).should == [[:DOPEN, '"'], [:STRING, "foo42"], [:DCLOSE, '"']] }
+      specify { expression(%q{"привет"}).should == [[:DOPEN, '"'], [:STRING, "привет"], [:DCLOSE, '"']] }
       # RBX can not handle this
       # specify { expression(%q{"при\вет"}).should == [[:STRING, "при\вет"]] }
 
       context do
         let(:strings) { data 'dstrings' }
 
-        specify { expression(strings).delete_if { |token| token.first == :NEWLINE }.should == [
+        specify { expression(strings).delete_if { |token|
+          [:NEWLINE, :DOPEN, :DCLOSE].include?(token.first)
+        }.should == [
           [:STRING, "fo\"o"], [:STRING, "fo\o"], [:STRING, "fo\\o"],
           [:STRING, "fo\no"], [:STRING, "fo\mo"], [:STRING, "fo\to"],
           [:STRING, "foo\nbar"]
         ] }
       end
     end
+
+    context 'interpolation' do
+      specify { expression('"{ }"').should == [[:DOPEN, '"'], [:STRING, '{ }'], [:DCLOSE, '"']] }
+      specify { expression('"#"').should == [[:DOPEN, '"'], [:STRING, '#'], [:DCLOSE, '"']] }
+      specify { expression('"# "').should == [[:DOPEN, '"'], [:STRING, '# '], [:DCLOSE, '"']] }
+      specify { expression('" #"').should == [[:DOPEN, '"'], [:STRING, ' #'], [:DCLOSE, '"']] }
+      specify { expression('"#{ var }"').should == [[:DOPEN, '"'], [:IOPEN, "\#{"], [:IDENTIFER, "var"],
+        [:ICLOSE, "}"], [:DCLOSE, '"']] }
+      specify { expression('"#{ } world"').should == [[:DOPEN, '"'], [:IOPEN, "\#{"], [:ICLOSE, "}"],
+        [:STRING, " world"], [:DCLOSE, '"']] }
+      specify { expression('"hello #{ }"').should == [[:DOPEN, '"'], [:STRING, "hello "], [:IOPEN, "\#{"],
+        [:ICLOSE, "}"], [:DCLOSE, '"']] }
+      specify { expression('"hello#{ } world"').should == [[:DOPEN, '"'], [:STRING, "hello"], [:IOPEN, "\#{"],
+        [:ICLOSE, "}"], [:STRING, " world"], [:DCLOSE, '"']] }
+      specify { expression('"hello #{ 2 + 3 }world"').should == [[:DOPEN, '"'], [:STRING, "hello "],
+        [:IOPEN, "\#{"], [:INTEGER, 2], [:PLUS, "+"], [:INTEGER, 3],
+        [:ICLOSE, "}"], [:STRING, "world"], [:DCLOSE, '"']] }
+      specify { expression('"\#{ var }"').should == [[:DOPEN, '"'], [:STRING, '#{ var }'], [:DCLOSE, '"']] }
+      specify { expression('"#{ } }"').should == [[:DOPEN, '"'], [:IOPEN, "\#{"], [:ICLOSE, "}"],
+        [:STRING, ' }'], [:DCLOSE, '"']] }
+      specify { expression('"#{ { } }"').should == [[:DOPEN, '"'], [:IOPEN, "\#{"], [:HOPEN, "{"],
+        [:HCLOSE, "}"], [:ICLOSE, "}"], [:DCLOSE, '"']] }
+      specify { expression('"#{ [ ] }"').should == [[:DOPEN, '"'], [:IOPEN, "\#{"], [:AOPEN, "["],
+        [:ACLOSE, "]"], [:ICLOSE, "}"], [:DCLOSE, '"']] }
+      specify { expression('"#\{ }"').should == [[:DOPEN, '"'], [:STRING, '#{ }'], [:DCLOSE, '"']] }
+      specify { expression('"##{ }"').should == [[:DOPEN, '"'], [:STRING, '#'], [:IOPEN, "\#{"], [:ICLOSE, "}"], [:DCLOSE, '"']] }
+      specify { expression('"###{ } #{ }"').should == [[:DOPEN, '"'], [:STRING, '##'], [:IOPEN, "\#{"],
+        [:ICLOSE, "}"], [:STRING, ' '], [:IOPEN, "\#{"], [:ICLOSE, "}"], [:DCLOSE, '"']] }
+
+      context 'exceptions' do
+        specify { expect { expression('"#{"') }.to raise_error Hotcell::UnterminatedString, /`" }}`.*1:7/ }
+        specify { expect { expression('"#{ { }"') }.to raise_error Hotcell::UnterminatedString, /`" }}`.*1:11/ }
+      end
+    end
   end
 
   context 'regexp' do
@@ -204,7 +240,8 @@ describe Hotcell::Lexer do
         [:INTEGER, 42], [:SEMICOLON, ";"], [:REGEXP, /regexp/]
       ] }
       specify { expression('"hello" /regexp/').should == [
-        [:STRING, "hello"], [:DIVIDE, "/"], [:IDENTIFER, "regexp"], [:DIVIDE, "/"]
+        [:DOPEN, '"'], [:STRING, "hello"], [:DCLOSE, '"'],
+        [:DIVIDE, "/"], [:IDENTIFER, "regexp"], [:DIVIDE, "/"]
       ] }
     end
   end
@@ -274,11 +311,13 @@ describe Hotcell::Lexer do
     specify { expression("foo(36.6);\n  a = \"привет\"").should == [
       [:IDENTIFER, "foo"], [:POPEN, "("], [:FLOAT, 36.6],
       [:PCLOSE, ")"], [:SEMICOLON, ";"], [:NEWLINE, "\n"],
-      [:IDENTIFER, "a"], [:ASSIGN, "="], [:STRING, "привет"]
+      [:IDENTIFER, "a"], [:ASSIGN, "="], [:DOPEN, '"'],
+      [:STRING, "привет"], [:DCLOSE, '"']
     ] }
     specify { expression("'foo'.match(\"^foo$\")").should == [
       [:STRING, "foo"], [:PERIOD, "."], [:IDENTIFER, "match"],
-      [:POPEN, "("], [:STRING, "^foo$"], [:PCLOSE, ")"]
+      [:POPEN, "("], [:DOPEN, '"'], [:STRING, "^foo$"],
+      [:DCLOSE, '"'], [:PCLOSE, ")"]
     ] }
   end
 

data/spec/lib/hotcell/parser_spec.rb

@@ -218,6 +218,54 @@ describe Hotcell::Parser do
     end
   end
 
+  context 'ternary operator' do
+    specify { parse('{{ true ? 42 : 43 }}').should be_equal_node_to JOINER(TAG(42, mode: :normal)) }
+    specify { parse('{{ false ? 42 : 43 }}').should be_equal_node_to JOINER(TAG(43, mode: :normal)) }
+    specify { parse('{{ cond ? branch1 : branch2 }}').should be_equal_node_to JOINER(
+      TAG(TERNARY(METHOD('cond'), METHOD('branch1'), METHOD('branch2')), mode: :normal)
+    ) }
+    specify { parse('{{ cond1 ? branch1 : cond2 ? branch2 : branch3 }}').should be_equal_node_to JOINER(
+      TAG(TERNARY(
+        METHOD('cond1'), METHOD('branch1'),
+        TERNARY(METHOD('cond2'), METHOD('branch2'), METHOD('branch3'))
+      ), mode: :normal)
+    ) }
+    specify { parse('{{ (cond1 ? branch1 : cond2) ? branch2 : branch3 }}').should be_equal_node_to JOINER(
+      TAG(TERNARY(
+        TERNARY(METHOD('cond1'), METHOD('branch1'), METHOD('cond2')),
+        METHOD('branch2'), METHOD('branch3')
+      ), mode: :normal)
+    ) }
+    specify { parse('{{ cond1 ? cond2 ? branch1 : branch2 : branch3 }}').should be_equal_node_to JOINER(
+      TAG(TERNARY(
+        METHOD('cond1'),
+        TERNARY(METHOD('cond2'), METHOD('branch1'), METHOD('branch2')),
+        METHOD('branch3')
+      ), mode: :normal)
+    ) }
+    specify { parse('{{ res = cond ? branch1 + 3 : branch2 && true }}').should be_equal_node_to JOINER(
+      TAG(ASSIGN('res',
+        TERNARY(METHOD('cond'), PLUS(METHOD('branch1'), 3), AND(METHOD('branch2'), true)
+      )), mode: :normal)
+    ) }
+    specify { expect { parse('{{ (1 ? 2) : 3 }}') }.to raise_error Hotcell::UnexpectedLexem, "Unexpected PCLOSE `)` at 1:10"}
+  end
+
+  context 'interpolation' do
+    specify { parse('{{ "hello" }}').should be_equal_node_to JOINER(TAG('hello', mode: :normal)) }
+    specify { parse('{{ \'#{}\' }}').should be_equal_node_to JOINER(TAG('#{}', mode: :normal)) }
+    specify { parse('{{ "#{}" }}').should be_equal_node_to JOINER(TAG('', mode: :normal)) }
+    specify { parse('{{ "#{ 3 }" }}').should be_equal_node_to JOINER(TAG('3', mode: :normal)) }
+    specify { parse('{{ "#{ var }" }}').should be_equal_node_to JOINER(TAG(DSTRING(METHOD('var')), mode: :normal)) }
+    specify { parse('{{ "#{ var }world" }}').should be_equal_node_to JOINER(TAG(DSTRING(METHOD('var'), 'world'), mode: :normal)) }
+    specify { parse('{{ "hello#{}" }}').should be_equal_node_to JOINER(TAG('hello', mode: :normal)) }
+    specify { parse('{{ "hello#{}world" }}').should be_equal_node_to JOINER(TAG('helloworld', mode: :normal)) }
+    specify { parse('{{ "hello#{ 6 * 7 }world" }}').should be_equal_node_to JOINER(TAG('hello42world', mode: :normal)) }
+    specify { parse('{{ "hello#{ var = 6 * 7; var + 1 }world" }}').should be_equal_node_to JOINER(
+      TAG(DSTRING('hello', SEQUENCE(ASSIGN('var', 42), PLUS(METHOD('var'), 1)),  'world'), mode: :normal)
+    ) }
+  end
+
   context 'arrays' do
     specify { parse('{{ [] }}').should be_equal_node_to JOINER(TAG(ARRAY(), mode: :normal)) }
     specify { parse('{{ [ 2 ] }}').should be_equal_node_to JOINER(TAG(ARRAY(2), mode: :normal)) }

data/spec/lib/hotcell/template_spec.rb

@@ -67,11 +67,11 @@ describe Hotcell::Template do
     specify { described_class.parse(<<-SOURCE
         {{ for i, in: [1, 2, 3, 4] }}
           {{ if i % 2 == 1 }}
-            {{ i }}
+            {{ "number\#{i}" }}
           {{ end if }}
         {{ end for }}
       SOURCE
-    ).render.gsub(/[\s\n]+/, ' ').strip.should == '1 3' }
+    ).render.gsub(/[\s\n]+/, ' ').strip.should == 'number1 number3' }
 
     specify { described_class.parse(<<-SOURCE
         {{ for i, in: [1, 2, 3, 4] }}

data/spec/lib/hotcell/tong_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Hotcell::Tong do
+  context 'mixed in' do
+    context do
+      let(:klass) do
+        Class.new(Numeric) do
+          include Hotcell::Tong::Mixin
+
+          def foo; end
+        end
+      end
+      subject { klass.new }
+
+      its(:tong_methods) { should be_a Set }
+      its(:tong_methods) { should be_empty }
+      its(:to_tong) { should === subject }
+      specify { subject.tong_invoke('foo').should be_nil }
+      specify { subject.tong_invoke(:foo).should be_nil }
+      specify { subject.tong_invoke('foo', 42, :arg).should be_nil }
+    end
+
+    context do
+      let(:klass) do
+        Class.new(String) do
+          include Hotcell::Tong::Mixin
+
+          manipulate :foo, :bar
+
+          alias_method :foo, :split
+          alias_method :bar, :size
+        end
+      end
+      subject { klass.new('hello world') }
+
+      its(:to_tong) { should === subject }
+      specify { (subject.tong_methods.to_a & %w(foo bar)).should =~ %w(foo bar) }
+      specify { subject.tong_invoke('baz').should be_nil }
+      specify { subject.tong_invoke('baz', 42, :arg).should be_nil }
+      specify { subject.tong_invoke(:foo).should be_nil }
+      specify { subject.tong_invoke('foo').should == %w(hello world) }
+      specify { subject.tong_invoke('bar').should == 11 }
+      specify { expect { subject.tong_invoke('bar', 42) }.to raise_error ArgumentError }
+    end
+  end
+
+  context 'inherited' do
+    let(:klass) do
+      Class.new(described_class) do
+        def foo
+          'foo'
+        end
+
+        def bar arg1, arg2
+          arg1 + arg2
+        end
+      end
+    end
+    subject { klass.new }
+
+    its('tong_methods.to_a') { should =~ %w(foo bar) }
+    its(:to_tong) { should === subject }
+    specify { subject.tong_invoke('send').should be_nil }
+    specify { subject.tong_invoke(:bar).should be_nil }
+    specify { subject.tong_invoke('foo').should == 'foo' }
+    specify { subject.tong_invoke('bar', 5, 8).should == 13 }
+    specify { expect { subject.tong_invoke('bar') }.to raise_error ArgumentError }
+  end
+
+  describe '#tong_missing' do
+    let(:klass) do
+      Class.new(described_class) do
+        def tong_missing method, *args
+          "missing #{method} with #{args}"
+        end
+      end
+    end
+    subject { klass.new }
+
+    specify { subject.tong_invoke('foo').should == 'missing foo with []' }
+    specify { subject.tong_invoke('bar', 42).should == 'missing bar with [42]' }
+  end
+end