flavour_saver 0.3.9 → 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

@@ -7,6 +7,6 @@ describe 'Fixture: raw.hbs' do
   let(:context)  { double(:context) }
 
   it 'renders correctly' do
-    subject.should == "{{=if brokensyntax}"
+    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

@@ -11,18 +11,18 @@ describe 'Subexpressions' do
   end
   context "simple subexpression" do
     let(:template) { "{{sum 1 (sum 1 1)}}" }
-    specify{subject.should == "3"}
+    specify{expect(subject).to eq "3"}
   end
 
   context "nested subexpressions" do
     let(:template) { "{{sum 1 (sum 1 (sum 1 1))}}" }
-    specify{subject.should == "4"}
+    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{subject.should == "12"}
+    specify{expect(subject).to eq "12"}
   end
 
   context "subexpression in block" do
@@ -32,7 +32,6 @@ describe 'Subexpressions' do
       s
     end}
     let(:template) { "{{#repeat (sum 1 2)}}*{{/repeat}}" }
-    specify{subject.should == "***"}
+    specify{expect(subject).to eq "***"}
   end
-  
 end

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,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, :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
 
@@ -53,11 +53,11 @@ describe FlavourSaver::Lexer do
         subject { FlavourSaver::Lexer.lex "{{foo (bar 'baz')}}" }
 
         it 'has tokens in the correct order' do
-          subject.map(&:type).should ==  [ :EXPRST, :IDENT, :WHITE, :OPAR, :IDENT, :WHITE, :S_STRING, :CPAR, :EXPRE, :EOS ]
+          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
-          subject.map(&:value).compact.should == [ 'foo', 'bar', 'baz' ]
+          expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz' ]
         end
       end
 
@@ -65,11 +65,11 @@ 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
@@ -81,8 +81,8 @@ describe FlavourSaver::Lexer do
         ids = %w( _ __ __123__ __ABC__ ABC123 Abc134def )
         ids.each do |id|
           subject = FlavourSaver::Lexer.lex "{{#{id}}}"
-          subject[1].type.should == :IDENT
-          subject[1].value.should == id
+          expect(subject[1].type).to eq :IDENT
+          expect(subject[1].value).to eq id
         end
       end
 
@@ -90,8 +90,8 @@ describe FlavourSaver::Lexer do
         ids = %w( A-B 12_Mine - :example 0A test? )
         ids.each do |id|
           subject = FlavourSaver::Lexer.lex "{{#{id}}}"
-          subject[1].type.should == :LITERAL
-          subject[1].value.should == id
+          expect(subject[1].type).to eq :LITERAL
+          expect(subject[1].value).to eq id
         end
       end
     end
@@ -100,11 +100,11 @@ describe FlavourSaver::Lexer do
       subject { FlavourSaver::Lexer.lex '{{foo bar=(baz qux)}}' }
 
       it 'has tokens in the correct order' do
-        subject.map(&:type).should == [:EXPRST, :IDENT, :WHITE, :IDENT, :EQ, :OPAR, :IDENT, :WHITE, :IDENT, :CPAR, :EXPRE, :EOS]
+        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
-        subject.map(&:value).compact.should == [ 'foo', 'bar', 'baz', 'qux' ]
+        expect(subject.map(&:value).compact).to eq [ 'foo', 'bar', 'baz', 'qux' ]
       end
     end
 
@@ -112,7 +112,7 @@ describe FlavourSaver::Lexer 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
 
@@ -121,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
 
@@ -133,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
 
@@ -145,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
@@ -158,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
 
@@ -166,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
 
@@ -174,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
 
@@ -182,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
 
@@ -191,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,
@@ -200,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
@@ -209,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
 
@@ -217,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
 
@@ -225,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