flavour_saver 0.3.6 → 1.0.0

data/spec/acceptance/if_else_spec.rb

@@ -8,10 +8,10 @@ describe 'Fixture: if_else.hbs' do
 
   it 'renders correctly when given a name' do
     context.name = 'Alan'
-    subject.should == "Say hello to Alan."
+    expect(subject).to eq "Say hello to Alan."
   end
 
   it 'renders correctly when not given a name' do
-    subject.should == "Nobody to say hi to."
+    expect(subject).to eq "Nobody to say hi to."
   end
 end

data/spec/acceptance/multi_level_with_spec.rb

@@ -9,7 +9,7 @@ describe 'Fixture: multi_level_with.hbs' do
   it 'renders correctly when person has a name' do
     context.person = Struct.new(:name).new('Alan')
     context.company = Struct.new(:name).new('Rad, Inc.')
-    subject.should == 'Alan - Rad, Inc.'
+    expect(subject).to eq 'Alan - Rad, Inc.'
   end
 
 end

data/spec/acceptance/one_character_identifier_spec.rb

@@ -7,7 +7,7 @@ describe 'Fixture: one_character_identifier.hbs' do
   let(:context)  { double(:context) }
 
   it 'renders correctly' do
-    context.should_receive(:a).and_return('foo')
-    subject.should == "foo"
+    expect(context).to receive(:a).and_return('foo')
+    expect(subject).to eq "foo"
   end
 end

data/spec/acceptance/raw_block_spec.rb

@@ -0,0 +1,12 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Fixture: raw.hbs' do
+  subject { Tilt.new(template).render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  let(:template) { File.expand_path('../../fixtures/raw.hbs', __FILE__) }
+  let(:context)  { double(:context) }
+
+  it 'renders correctly' do
+    expect(subject).to eq "{{=if brokensyntax}"
+  end
+end

data/spec/acceptance/runtime_run_spec.rb

@@ -20,7 +20,7 @@ describe FlavourSaver::Runtime do
         is_even_helper = proc { |n| n % 2 == 0 }
 
         locals[:is_even] = is_even_helper
-        subject.should == "24 is even"
+        expect(subject).to eq "24 is even"
       end
     end
   end

data/spec/acceptance/sections_spec.rb

@@ -8,18 +8,18 @@ describe 'Fixture: sections.hbs' do
 
   it 'renders correctly when given a name' do
     context.name = 'Alan'
-    subject.should == "Say hello to Alan."
+    expect(subject).to eq "Say hello to Alan."
   end
 
   it 'renders correctly when given a list of names' do
     context.names = ['Foo', 'Bar']
-    subject.should == "* Foo * Bar"
+    expect(subject).to eq "* Foo * Bar"
   end
 
   it 'renders correctly when given an order' do
     class Order; def number; 1234; end; end
     context.order = Order.new
-    subject.should == 'Number: 1234'
+    expect(subject).to eq 'Number: 1234'
   end
 end
 

data/spec/acceptance/segment_literals_spec.rb

@@ -17,10 +17,10 @@ describe FlavourSaver do
       foos = []
       foos << double(:foo)
       foos << double(:foo)
-      foos[1].should_receive(:bar).and_return('two')
+      expect(foos[1]).to receive(:bar).and_return('two')
 
-      context.stub(:foos).and_return(foos)
-      subject.should == 'two'
+      allow(context).to receive(:foos).and_return(foos)
+      expect(subject).to eq 'two'
     end
   end
 end

data/spec/acceptance/simple_expression_spec.rb

@@ -7,11 +7,11 @@ describe 'Fixture: simple_expression.hbs' do
   let(:context)  { double(:context) }
 
   it 'renders correctly' do
-    context.should_receive(:hello).and_return('hello world')
-    subject.should == "hello world"
+    expect(context).to receive(:hello).and_return('hello world')
+    expect(subject).to eq "hello world"
   end
 
   it 'renders nothing if undefined' do
-    subject.should == ""
+    expect(subject).to eq ""
   end
 end

data/spec/acceptance/subexpression_spec.rb

@@ -0,0 +1,37 @@
+require 'tilt'
+require 'flavour_saver'
+
+describe 'Subexpressions' do
+
+  subject { Tilt['handlebars'].new{ template }.render(context).gsub(/[\s\r\n]+/, ' ').strip }
+  
+  let(:context)  { double(:context) }
+  before(:all) do
+    FlavourSaver.register_helper(:sum) { |a,b| a + b}
+  end
+  context "simple subexpression" do
+    let(:template) { "{{sum 1 (sum 1 1)}}" }
+    specify{expect(subject).to eq "3"}
+  end
+
+  context "nested subexpressions" do
+    let(:template) { "{{sum 1 (sum 1 (sum 1 1))}}" }
+    specify{expect(subject).to eq "4"}
+  end
+
+  context "subexpression as argument" do
+    before {FlavourSaver.register_helper(:cents) { |a| a[:total] + 10}}
+    let(:template) { "{{cents total=(sum 1 1)}}" }
+    specify{expect(subject).to eq "12"}
+  end
+
+  context "subexpression in block" do
+    before {FlavourSaver.register_helper(:repeat) do |a, &block| 
+      s = ''
+      a.times {s += block.call.contents}
+      s
+    end}
+    let(:template) { "{{#repeat (sum 1 2)}}*{{/repeat}}" }
+    specify{expect(subject).to eq "***"}
+  end
+end

data/spec/fixtures/raw.hbs

@@ -0,0 +1,3 @@
+{{{{raw}}}}
+{{=if brokensyntax}
+{{{{/raw}}}}

data/spec/lib/flavour_saver/lexer_spec.rb

@@ -2,7 +2,7 @@ require 'flavour_saver/lexer'
 
 describe FlavourSaver::Lexer do
   it 'is an RLTK lexer' do
-    subject.should be_a(RLTK::Lexer)
+    expect(subject).to be_a(RLTK::Lexer)
   end
 
   describe 'Tokens' do
@@ -11,17 +11,17 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo}}" }
 
         it 'begins with an EXPRST' do
-          subject.first.type.should == :EXPRST
+          expect(subject.first.type).to eq :EXPRST
         end
 
         it 'ends with an EXPRE' do
-          subject[-2].type.should == :EXPRE
+          expect(subject[-2].type).to eq :EXPRE
         end
 
         it 'contains only the identifier "foo"' do
-          subject[1..-3].size.should == 1
-          subject[1].type.should == :IDENT
-          subject[1].value.should == 'foo'
+          expect(subject[1..-3].size).to eq 1
+          expect(subject[1].type).to eq :IDENT
+          expect(subject[1].value).to eq 'foo'
         end
       end
 
@@ -29,11 +29,11 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo bar}}" }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :IDENT, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :IDENT, :EXPRE, :EOS ]
         end
 
         it 'has values in the correct order' do
-          subject.map(&:value).compact.should == [ 'foo', 'bar' ]
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar' ]
         end
       end
 
@@ -41,11 +41,23 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo \"bar\"}}" }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :STRING, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :STRING, :EXPRE, :EOS ]
         end
 
         it 'has values in the correct order' do
-          subject.map(&:value).compact.should == [ 'foo', 'bar' ]
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar' ]
+        end
+      end
+
+      describe '{{foo (bar "baz")}}' do
+        subject { FlavourSaver::Lexer.lex "{{foo (bar 'baz')}}" }
+
+        it 'has tokens in the correct order' do
+          expect(subject.map(&:type)).to eq  [ :EXPRST, :IDENT, :WHITE, :OPAR, :IDENT, :WHITE, :S_STRING, :CPAR, :EXPRE, :EOS ]
+        end
+
+        it 'has values in the correct order' do
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz' ]
         end
       end
 
@@ -53,21 +65,54 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex '{{foo bar="baz" hello="goodbye"}}' }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :STRING, :WHITE, :IDENT, :EQ, :STRING, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :STRING, :WHITE, :IDENT, :EQ, :STRING, :EXPRE, :EOS ]
         end
 
         it 'has values in the correct order' do
-          subject.map(&:value).compact.should == [ 'foo', 'bar', 'baz', 'hello', 'goodbye' ]
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz', 'hello', 'goodbye' ]
         end
 
       end
     end
 
+    describe 'Identities' do
+
+      it 'supports as ruby methods' do
+        ids = %w( _ __ __123__ __ABC__ ABC123 Abc134def )
+        ids.each do |id|
+          subject = FlavourSaver::Lexer.lex "{{#{id}}}"
+          expect(subject[1].type).to eq :IDENT
+          expect(subject[1].value).to eq id
+        end
+      end
+
+      it 'maps non-ruby identities to literals' do
+        ids = %w( A-B 12_Mine - :example 0A test? )
+        ids.each do |id|
+          subject = FlavourSaver::Lexer.lex "{{#{id}}}"
+          expect(subject[1].type).to eq :LITERAL
+          expect(subject[1].value).to eq id
+        end
+      end
+    end
+
+    describe '{{foo bar=(baz qux)}}' do
+      subject { FlavourSaver::Lexer.lex '{{foo bar=(baz qux)}}' }
+
+      it 'has tokens in the correct order' do
+        expect(subject.map(&:type)).to eq [:EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :OPAR, :IDENT, :WHITE, :IDENT, :CPAR, :EXPRE, :EOS]
+      end
+
+      it 'has values in the correct order' do
+        expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz', 'qux' ]
+      end
+    end
+
     describe '{{else}}' do
       subject { FlavourSaver::Lexer.lex '{{else}}' }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [ :EXPRST, :ELSE, :EXPRE, :EOS ]
+        expect(subject.map(&:type)).to eq [ :EXPRST, :ELSE, :EXPRE, :EOS ]
       end
     end
 
@@ -76,11 +121,11 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo.bar}}" }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :IDENT, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :IDENT, :EXPRE, :EOS ]
         end
 
         it 'has the correct values' do
-          subject.map(&:value).compact.should == ['foo', 'bar']
+          expect(subject.map(&:value).compact).to eq ['foo', 'bar']
         end
       end
 
@@ -88,11 +133,11 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo.[10].bar}}" }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
         end
 
         it 'has the correct values' do
-          subject.map(&:value).compact.should == ['foo', '10', 'bar']
+          expect(subject.map(&:value).compact).to eq ['foo', '10', 'bar']
         end
       end
 
@@ -100,11 +145,11 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex '{{foo.[he!@#$(&@klA)].bar}}' }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
+          expect(subject.map(&:type)).to eq [ :EXPRST, :IDENT, :DOT, :LITERAL, :DOT, :IDENT, :EXPRE, :EOS ]
         end
 
         it 'has the correct values' do
-          subject.map(&:value).compact.should == ['foo', 'he!@#$(&@klA)', 'bar']
+          expect(subject.map(&:value).compact).to eq ['foo', 'he!@#$(&@klA)', 'bar']
         end
       end
     end
@@ -113,7 +158,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "{{{foo}}}" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [ :TEXPRST, :IDENT, :TEXPRE, :EOS ]
+        expect(subject.map(&:type)).to eq [ :TEXPRST, :IDENT, :TEXPRE, :EOS ]
       end
     end
 
@@ -121,7 +166,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "{{! WAT}}" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [ :EXPRST, :BANG, :COMMENT, :EXPRE, :EOS ]
+        expect(subject.map(&:type)).to eq [ :EXPRST, :BANG, :COMMENT, :EXPRE, :EOS ]
       end
     end
 
@@ -129,7 +174,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "{{../foo}}" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:EXPRST, :DOT, :DOT, :FWSL, :IDENT, :EXPRE, :EOS]
+        expect(subject.map(&:type)).to eq [:EXPRST, :DOT, :DOT, :FWSL, :IDENT, :EXPRE, :EOS]
       end
     end
 
@@ -137,7 +182,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "{{foo}}\n{{bar}}\r{{baz}}" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:EOS]
+        expect(subject.map(&:type)).to eq [:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:OUT,:EXPRST,:IDENT,:EXPRE,:EOS]
       end
     end
 
@@ -146,7 +191,7 @@ describe FlavourSaver::Lexer do
 
       describe '{{#foo}}{{bar}}{{/foo}}' do
         it 'has tokens in the correct order' do
-          subject.map(&:type).should == [
+          expect(subject.map(&:type)).to eq [
             :EXPRST, :HASH, :IDENT, :EXPRE,
             :EXPRST, :IDENT, :EXPRE,
             :EXPRST, :FWSL, :IDENT, :EXPRE,
@@ -155,7 +200,7 @@ describe FlavourSaver::Lexer do
         end
 
         it 'has identifiers in the correct order' do
-          subject.map(&:value).compact.should == [ 'foo', 'bar', 'foo' ]
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'foo' ]
         end
       end
     end
@@ -164,7 +209,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "\r" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:OUT,:EOS]
+        expect(subject.map(&:type)).to eq [:OUT,:EOS]
       end
     end
 
@@ -172,7 +217,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "\n" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:OUT,:EOS]
+        expect(subject.map(&:type)).to eq [:OUT,:EOS]
       end
     end
 
@@ -180,7 +225,7 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex "{" }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:OUT,:EOS]
+        expect(subject.map(&:type)).to eq [:OUT,:EOS]
       end
     end
   end