macros4cuke 0.3.25 → 0.3.26

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.3.26 / 2013-05-31
+* [CHANGE] All RSpec files: migrated to the expect syntax instead of the should syntax.
+* [CHANGE] `spec_helper.rb`: RSpec is configured to allow the expect syntax only.
+
 ### 0.3.25 / 2013-05-30
 * [NEW] File `exceptions.rb`: New exception class AmbiguousArgumentValue.
 * [CHANGE] Method `MacroStep#validate_params`: an AmbiguousArgumentValue is raised when a macro argument get its value from phrase and data table at the same time.

data/lib/macros4cuke/constants.rb

@@ -4,7 +4,7 @@
 
 module Macros4Cuke # Module used as a namespace
   # The version number of the gem.
-  Version = '0.3.25'
+  Version = '0.3.26'
 
   # Brief description of the gem.
   Description = 'Macros for Cucumber'

data/spec/macros4cuke/macro-collection_spec.rb

@@ -14,7 +14,7 @@ describe MacroCollection do
 
   context 'Initialization:' do
     it 'should be empty' do
-      singleton.macro_steps.should be_empty
+      expect(singleton.macro_steps).to be_empty
     end
 
   end
@@ -35,13 +35,13 @@ SNIPPET
     it 'should accept the addition of a new macro-step' do
       phrase = '[enter my credentials]'
       args = [phrase, sample_substeps, true]
-      ->() { singleton.add_macro(*args) }.should_not raise_error
-      singleton.should have(1).macro_steps
+      expect { singleton.add_macro(*args) }.not_to raise_error
+      expect(singleton).to have(1).macro_steps
 
       # Error case: inserting another macro with same phrase.
       msg = "A macro-step with phrase '[enter my credentials]' already exist."
-      ->(){ singleton.add_macro(*args) }.should 
-        raise_error(Macros4Cuke::DuplicateMacroError, msg)
+      expect { singleton.add_macro(*args) }.to raise_error(
+        Macros4Cuke::DuplicateMacroError, msg)
     end
 
     it 'should return the rendition of a given macro-step' do
@@ -55,7 +55,7 @@ SNIPPET
   And I fill in "Password" with "no-secret"
   And I click "Submit"
 SNIPPET
-      rendered.should == expected
+      expect(rendered).to eq(expected)
     end
     
 

data/spec/macros4cuke/macro-step-support_spec.rb

@@ -44,13 +44,13 @@ SNIPPET
   
   context 'Defining macro(s):' do
     it 'should add valid new macro' do
-      ->(){ world.add_macro(m1_phrase, m1_substeps, true) }.should_not raise_error
+      expect { world.add_macro m1_phrase, m1_substeps, true }.not_to raise_error
     end
     
     it 'should complain when entering the same macro again' do
       # Error case: trying to register another macro with same key/phrase.
       msg = "A macro-step with phrase 'enter the credentials' already exist."
-      -> { world.add_macro(m1_phrase, m1_substeps, true) }.should raise_error(
+      expect { world.add_macro(m1_phrase, m1_substeps, true) }.to raise_error(
         Macros4Cuke::DuplicateMacroError, msg)
     end
     
@@ -59,7 +59,7 @@ SNIPPET
       # but the macro has no mechanism to pass the needed data.
       phrase = 'fill in the credentials'
       msg = "The sub-step argument 'userid' does not appear in the phrase."
-      ->(){ world.add_macro(phrase, m1_substeps, false) }.should raise_error(
+      expect { world.add_macro(phrase, m1_substeps, false) }.to raise_error(
         Macros4Cuke::UnreachableSubstepArgument, msg)    
     end
   end # context
@@ -69,7 +69,7 @@ SNIPPET
     it 'should complain when invoking an unknown macro-step' do
       phrase_unknown = 'dream of a perfect world'
       msg = "Unknown macro-step with phrase: 'dream of a perfect world'."
-      ->(){ world.invoke_macro(phrase_unknown) }.should raise_error(
+      expect { world.invoke_macro(phrase_unknown) }.to raise_error(
         Macros4Cuke::UnknownMacroError, msg)
     end
 
@@ -78,10 +78,10 @@ SNIPPET
   context 'Clearing macro(s):' do
   
     it 'should clear all macros' do
-      ->(){ world.clear_macros() }.should_not raise_error
+      expect { world.clear_macros() }.not_to raise_error
       
       # Control the post-condition
-      MacroCollection.instance.macro_steps.should be_empty
+      expect(MacroCollection.instance.macro_steps).to be_empty
     end  
 
   end # context

data/spec/macros4cuke/macro-step_spec.rb

@@ -30,13 +30,13 @@ end
 
   context 'Creation & initialization:' do
     it 'should be created with a phrase, substeps and a table use indicator' do
-      ->(){ MacroStep.new(sample_phrase, sample_template, true) }.should_not raise_error
+      expect { MacroStep.new(sample_phrase, sample_template, true) }.not_to raise_error
     end
 
 
     it 'should complain when a sub-step argument can never be assigned a value via the phrase' do
       msg = "The sub-step argument 'password' does not appear in the phrase."
-      ->(){ MacroStep.new(sample_phrase, sample_template, false) }.should raise_error(
+      expect { MacroStep.new(sample_phrase, sample_template, false) }.to raise_error(
         Macros4Cuke::UnreachableSubstepArgument, msg)
     end
 
@@ -44,21 +44,21 @@ end
     it 'should complain when an argument in phrase never occurs in substeps' do
       phrase = 'enter my credentials as <foobar>'
       msg = "The phrase argument 'foobar' does not appear in a sub-step."
-      ->(){ MacroStep.new(phrase, sample_template, true) }.should raise_error(
+      expect { MacroStep.new(phrase, sample_template, true) }.to raise_error(
         Macros4Cuke::UselessPhraseArgument, msg)
     end
 
 
     it 'should know its key' do
-      subject.key.should == 'enter_my_credentials_as_X_T'
+      expect(subject.key).to eq('enter_my_credentials_as_X_T')
     end
 
     it 'should know the tags(placeholders) from its phrase' do
-      subject.phrase_args.should == %w[userid]
+      expect(subject.phrase_args).to eq(%w[userid])
     end
 
     it 'should know the tags(placeholders) from its phrase and template' do
-      subject.args.should == %w[userid password]
+      expect(subject.args).to eq(%w[userid password])
     end
 
   end # context
@@ -77,7 +77,7 @@ end
   And I click "Submit"
 SNIPPET
 
-      text.should == expectation
+      expect(text).to eq(expectation)
     end
 
     it 'should render steps even when one argument has no actual value' do
@@ -91,7 +91,7 @@ SNIPPET
   And I click "Submit"
 SNIPPET
 
-      text.should == expectation
+      expect(text).to eq(expectation)
     end
 
     it 'should un-escape the double-quotes for phrase arguments' do
@@ -105,7 +105,7 @@ SNIPPET
   And I click "Submit"
 SNIPPET
 
-      text.should == expectation
+      expect(text).to eq(expectation)
     end
 
 
@@ -113,17 +113,17 @@ SNIPPET
       # Error case: there is no macro argument called <unknown>
       error_message = "Unknown macro-step argument 'unknown'."
       args = [ %w(unknown anything) ]
-      ->(){ subject.expand(phrase_instance, args) }.should raise_error(
+      expect { subject.expand(phrase_instance, args) }.to raise_error(
         UnknownArgumentError, error_message)
     end
- 
-    
+
+
     it 'should complain when argument gets a value from phrase and table' do
       # Error case: there is no macro argument called <unknown>
       phrase = %Q|enter my credentials as "nobody"|
       msg = "The macro argument 'userid' has value 'nobody' and 'valueTable'."
       args = [ %w(userid someone), %w(password no-secret) ]
-      ->(){ subject.expand(phrase, args) }.should raise_error(
+       expect { subject.expand(phrase, args) }.to raise_error(
         AmbiguousArgumentValue, msg)
     end
 
@@ -138,13 +138,13 @@ SNIPPET
   San Francisco
   <quotes>
 SNIPPET
-       
+
       instance = MacroStep.new(phrase, substeps, true)
       actual = instance.expand(phrase, [])
       expected = substeps.gsub(/<quotes>/, '"""')
-      actual.should == expected
+      expect(actual).to eq(expected)
     end
-  
+
 
   end # context
 

data/spec/macros4cuke/templating/engine_spec.rb

@@ -57,7 +57,7 @@ SNIPPET
 
     it 'should parse an empty text line' do
       # Expectation: result should be an empty array.
-      Engine.parse('').should be_empty
+      expect(Engine.parse('')).to be_empty
     end
 
     it 'should parse a text line without tag' do
@@ -66,8 +66,8 @@ SNIPPET
 
       # Expectation: an array with one couple: 
       # [:static, the source text]
-      result.should have(1).items
-      result[0].should == [:static, sample_text]
+      expect(result).to have(1).items
+      expect(result[0]).to eq([:static, sample_text])
     end
 
     it 'should parse a text line that consists of just a tag' do
@@ -76,8 +76,8 @@ SNIPPET
 
       # Expectation: an array with one couple: 
       # [:static, the source text]
-      result.should have(1).items
-      result[0].should == [:dynamic, strip_chevrons(sample_text)]
+      expect(result).to have(1).items
+      expect(result[0]).to eq([:dynamic, strip_chevrons(sample_text)])
     end
 
     it 'should parse a text line with a tag at the start' do
@@ -86,9 +86,9 @@ SNIPPET
 
       # Expectation: an array with two couples: 
       # [dynamic, 'some_tag'][:static, some text]
-      result.should have(2).items
-      result[0].should == [:dynamic, 'some_tag']
-      result[1].should == [:static,  'some text']
+      expect(result).to have(2).items
+      expect(result[0]).to eq([:dynamic, 'some_tag'])
+      expect(result[1]).to eq([:static,  'some text'])
     end
 
     it 'should parse a text line with a tag at the end' do
@@ -97,9 +97,9 @@ SNIPPET
 
       # Expectation: an array with two couples: 
       # [:static, some text] [dynamic, 'some_tag']
-      result.should have(2).items
-      result[0].should == [:static,  'some text']
-      result[1].should == [:dynamic, 'some_tag']
+      expect(result).to have(2).items
+      expect(result[0]).to eq([:static,  'some text'])
+      expect(result[1]).to eq([:dynamic, 'some_tag'])
     end
 
     it 'should parse a text line with a tag in the middle' do
@@ -107,10 +107,10 @@ SNIPPET
       result = Engine.parse(sample_text)
 
       # Expectation: an array with three couples:
-      result.should have(3).items
-      result[0].should == [:static,  'begin ']
-      result[1].should == [:dynamic, 'some_tag']
-      result[2].should == [:static,  ' end']
+      expect(result).to have(3).items
+      expect(result[0]).to eq([:static,  'begin '])
+      expect(result[1]).to eq([:dynamic, 'some_tag'])
+      expect(result[2]).to eq([:static,  ' end'])
     end
 
     it 'should parse a text line with two tags in the middle' do
@@ -118,23 +118,23 @@ SNIPPET
       result = Engine.parse(sample_text)
 
       # Expectation: an array with items couples:
-      result.should have(5).items
-      result[0].should == [:static ,  'begin ']
-      result[1].should == [:dynamic, 'some_tag']
-      result[2].should == [:static , 'middle']
-      result[3].should == [:dynamic, 'another_tag']
-      result[4].should == [:static,  ' end']
+      expect(result).to have(5).items
+      expect(result[0]).to eq([:static ,  'begin '])
+      expect(result[1]).to eq([:dynamic, 'some_tag'])
+      expect(result[2]).to eq([:static , 'middle'])
+      expect(result[3]).to eq([:dynamic, 'another_tag'])
+      expect(result[4]).to eq([:static,  ' end'])
 
       # Case: two consecutive tags
       sample_text = 'begin <some_tag><another_tag> end'
       result = Engine.parse(sample_text)
 
       # Expectation: an array with four couples:
-      result.should have(4).items
-      result[0].should == [:static,  'begin ']
-      result[1].should == [:dynamic, 'some_tag']
-      result[2].should == [:dynamic, 'another_tag']
-      result[3].should == [:static,  ' end']
+      expect(result).to have(4).items
+      expect(result[0]).to eq([:static,  'begin '])
+      expect(result[1]).to eq([:dynamic, 'some_tag'])
+      expect(result[2]).to eq([:dynamic, 'another_tag'])
+      expect(result[3]).to eq([:static,  ' end'])
     end
 
     it 'should parse a text line with escaped chevrons' do
@@ -142,8 +142,8 @@ SNIPPET
       result = Engine.parse(sample_text)
 
       # Expectation: an array with one couple: [:static, the source text]
-      result.should have(1).items
-      result[0].should == [:static, sample_text]
+      expect(result).to have(1).items
+      expect(result[0]).to eq([:static, sample_text])
     end
 
     it 'should parse a text line with escaped chevrons in a tag' do
@@ -151,30 +151,30 @@ SNIPPET
       result = Engine.parse(sample_text)
 
       # Expectation: an array with three couples:
-      result.should have(3).items
-      result[0].should == [:static,  'begin ']
-      result[1].should == [:dynamic, 'some_\<\\>weird\>_tag']
-      result[2].should == [:static,  ' end']
+      expect(result).to have(3).items
+      expect(result[0]).to eq([:static,  'begin '])
+      expect(result[1]).to eq([:dynamic, 'some_\<\\>weird\>_tag'])
+      expect(result[2]).to eq([:static,  ' end'])
     end
 
     it 'should complain if a tag misses an closing chevron' do
       sample_text = 'begin <some_tag\> end'
       error_message = "Missing closing chevron '>'."
-      ->(){ Engine.parse(sample_text) }.should raise_error(
+      expect { Engine.parse(sample_text) }.to raise_error(
         StandardError, error_message)
     end
 
     it  'should complain if a text misses an opening chevron' do
       sample_text = 'begin <some_tag> > end'
       error_message = "Missing opening chevron '<'."
-      ->(){ Engine.parse(sample_text) }.should raise_error(
+      expect { Engine.parse(sample_text) }.to raise_error(
         StandardError, error_message)
     end
 
     it  'should complain if a text has nested opening chevrons' do
       sample_text = 'begin <<some_tag> > end'
       error_message = "Nested opening chevron '<'."
-      ->(){ Engine.parse(sample_text) }.should raise_error(
+      expect { Engine.parse(sample_text) }.to raise_error(
         StandardError, error_message)
     end
 
@@ -183,41 +183,41 @@ SNIPPET
   context 'Creation and initialization:' do
 
     it 'should accept an empty template text' do
-      ->(){ Engine.new '' }.should_not raise_error
+      expect { Engine.new '' }.not_to raise_error
     end
 
     it 'should be created with a template text' do
-      ->(){ Engine.new sample_template }.should_not raise_error
+      expect { Engine.new sample_template }.not_to raise_error
     end
 
     it 'should know the source text' do
-      subject.source.should == sample_template
+      expect(subject.source).to eq(sample_template)
 
       # Case of an empty template
       instance = Engine.new ''
-      instance.source.should be_empty
+      expect(instance.source).to be_empty
     end
     
     it 'should accept conditional section' do
-      ->(){ Engine.new sophisticated_template }.should_not raise_error
+      expect { Engine.new sophisticated_template }.not_to raise_error
       instance = Engine.new sophisticated_template
       elements = instance.instance_variable_get(:@representation)
       sections = elements.select { |e| e.is_a?(Section) }
       names = sections.map { |e| e.to_s }
-      names.should == %w(<?address> <?birthdate> <?dummy>)
+      expect(names).to eq(%w(<?address> <?birthdate> <?dummy>))
     end
 
     it 'should complain when a placeholder is empty or blank' do
       text_w_empty_arg = sample_template.sub(/userid/, '')
       msg = %q(An empty or blank argument occurred in 'And I fill in "Username" with "<>"'.)
-      ->(){ Engine.new text_w_empty_arg }.should raise_error(
+      expect { Engine.new text_w_empty_arg }.to raise_error(
         Macros4Cuke::EmptyArgumentError, msg)
     end
 
     it 'should complain when a placeholder contains an invalid character' do
       text_w_empty_arg = sample_template.sub(/userid/, 'user%id')
       msg = "The invalid sign '%' occurs in the argument 'user%id'."
-      ->(){ Engine.new text_w_empty_arg }.should raise_error(
+      expect { Engine.new text_w_empty_arg }.to raise_error(
         Macros4Cuke::InvalidCharError, msg)
     end
     
@@ -226,7 +226,7 @@ SNIPPET
       text_w_open_section = sophisticated_template.sub(/<\/address>/, '')
 
       error_message = 'Unterminated section <?address>.'
-      ->(){ Engine.new text_w_open_section }.should raise_error(
+      expect { Engine.new text_w_open_section }.to raise_error(
         StandardError, error_message)
     end
     
@@ -235,7 +235,7 @@ SNIPPET
       text_w_wrong_end = sophisticated_template.sub(/<\/address>/, '</foobar>')
 
       msg = "End of section</foobar> doesn't match current section 'address'."
-      ->(){ Engine.new text_w_wrong_end }.should raise_error(
+      expect { Engine.new text_w_wrong_end }.to raise_error(
         StandardError, msg)
     end
     
@@ -243,7 +243,7 @@ SNIPPET
       # Replacing an end of section tag by another...
       wrong_end = sophisticated_template.sub(/<\?birthdate>/, '</foobar>')
       msg = 'End of section</foobar> found while no corresponding section is open.'
-      ->(){ Engine.new wrong_end }.should raise_error(StandardError, msg)
+      expect { Engine.new wrong_end }.to raise_error(StandardError, msg)
     end    
     
   end # context
@@ -256,7 +256,7 @@ SNIPPET
 
       # Case of an empty source template text
       instance = Engine.new ''
-      instance.variables.should be_empty
+      expect(instance.variables).to be_empty
     end
 
 
@@ -264,7 +264,7 @@ SNIPPET
       substeps = "  # Comment 1 <miscellaneous>\n" + sample_template
       substeps += "  #\n Comment 2 <haphazard>"
       instance = Engine.new substeps
-      instance.variables == [:userid, :password]
+      # expect(instance.variables).to eq([:userid, :password])
     end
 
 
@@ -280,7 +280,7 @@ SNIPPET
   And I click "Sign in"
 SNIPPET
 
-      rendered_text.should == expected
+      expect(rendered_text).to eq(expected)
 
       # Case of an actual that's not a String
       locals = { 'userid' => 'johndoe', 'password' => 12345 }
@@ -293,7 +293,7 @@ SNIPPET
   And I click "Sign in"
 SNIPPET
 
-      rendered_text.should == expected
+      expect(rendered_text).to eq(expected)
 
 
       # Place actual value in context object
@@ -308,12 +308,12 @@ SNIPPET
   And I click "Sign in"
 SNIPPET
 
-      rendered_text.should == expected
+      expect(rendered_text).to eq(expected)
 
 
       # Case of an empty source template text
       instance = Engine.new ''
-      instance.render(nil, {}).should be_empty
+      expect(instance.render(nil, {})).to be_empty
     end
     
     
@@ -332,7 +332,7 @@ SNIPPET
   And I click "Register"
 SNIPPET
 
-      rendered_text.should == expected
+      expect(rendered_text).to eq(expected)
       
       # Redo with another context
       locals['birthdate'] = nil
@@ -346,7 +346,7 @@ SNIPPET
   And I click "Register"
 SNIPPET
 
-      rendered_text.should == expected      
+      expect(rendered_text).to eq(expected)
     end
     
 
@@ -362,7 +362,7 @@ SNIPPET
   And I click "Sign in"
 SNIPPET
 
-      rendered_text.should == expected
+      expect(rendered_text).to eq(expected)
     end
   end # context
 

data/spec/macros4cuke/templating/placeholder_spec.rb

@@ -18,11 +18,11 @@ describe Placeholder do
   context 'Creation and initialization:' do
 
     it 'should be created with a variable name' do
-      ->() { Placeholder.new('foobar') }.should_not raise_error
+      expect { Placeholder.new('foobar') }.not_to raise_error
     end
 
     it 'should know the name of its variable' do
-      subject.name.should == 'foobar'
+      expect(subject.name).to eq('foobar')
     end
 
   end # context
@@ -31,11 +31,11 @@ describe Placeholder do
     it 'should render an empty string when no actual value is absent' do
       # Case: context has no value associated to 'foobar'
       rendered_text = subject.render(Object.new, {})
-      rendered_text.should be_empty
+      expect(rendered_text).to be_empty
 
       # Case: locals Hash has a nil value associated to 'foobar'
       rendered_text = subject.render(Object.new, { 'foobar' => nil })
-      rendered_text.should be_empty
+      expect(rendered_text).to be_empty
 
       # Case: context object has a nil value associated to 'foobar'
       context = Object.new
@@ -43,13 +43,13 @@ describe Placeholder do
         nil
       end
       rendered_text = subject.render(context, {})
-      rendered_text.should be_empty
+      expect(rendered_text).to be_empty
     end
 
     it 'should render the actual value bound to the placeholder' do
       # Case: locals Hash has a value associated to 'foobar'
       rendered_text = subject.render(Object.new, { 'foobar' => 'hello' })
-      rendered_text.should == 'hello'
+      expect(rendered_text).to eq('hello')
 
       # Case: context object has a value associated to 'foobar'
       context = Object.new
@@ -57,7 +57,7 @@ describe Placeholder do
         'world'
       end
       rendered_text = subject.render(context, {})
-      rendered_text.should == 'world'
+      expect(rendered_text).to eq('world')
     end
 
   end # context

data/spec/macros4cuke/templating/section_spec.rb

@@ -26,15 +26,15 @@ describe Section do
   context 'Creation and initialization' do
 
     it 'should be created with a variable name' do
-      ->() { Section.new('foobar') }.should_not raise_error
+      expect { Section.new('foobar') }.not_to raise_error
     end
 
     it 'should know the name of its variable' do
-      subject.name.should == 'foobar'
+      expect(subject.name).to eq('foobar')
     end
 
     it 'should have no child at start' do
-      subject.should have(0).children
+       expect(subject).to have(0).children
     end
 
   end # context
@@ -46,13 +46,13 @@ describe Section do
       end
 
       # Control that the addition work as expected
-      subject.children.should == sample_children
+      expect(subject.children).to eq(sample_children)
     end
 
     it 'should know the name all child placeholders' do
       # Case: simple flat list of children
       sample_children.each { |a_child| subject.add_child(a_child) }
-      subject.variables.should == [ 'user' ]
+      expect(subject.variables).to eq([ 'user' ])
 
       # Case: at least one child is a group
       parent = Section.new('son')
@@ -62,13 +62,13 @@ describe Section do
         EOLine.new
       ].each { |a_child| parent.add_child(a_child) }
 
-      parent.variables.should == %w(user firstname)
+      expect(parent.variables).to eq(%w(user firstname))
     end
 
 
     it 'should expect that its subclasses render the children' do
       error_message = 'Method Section.render must be implemented in subclass.'
-      ->(){ subject.send(:render, Object.new, {}) }.should raise_error(
+       expect { subject.send(:render, Object.new, {}) }.to raise_error(
         NotImplementedError, error_message)
     end
 
@@ -84,14 +84,14 @@ describe ConditionalSection do
   context 'Creation and initialization:' do
 
     it 'should be created with a variable name and a boolean' do
-      ->(){ ConditionalSection.new('foobar', false) }.should_not raise_error
-      ->(){ ConditionalSection.new('foobar', true) }.should_not raise_error
+      expect { ConditionalSection.new('foobar', false) }.not_to raise_error
+      expect { ConditionalSection.new('foobar', true) }.not_to raise_error
     end
 
     it 'should know whether the rendition on existence of actual value' do
       [false, true].each do |existence|
         instance = ConditionalSection.new('foobar', existence)
-        instance.existence.should == existence
+        expect(instance.existence).to eq(existence)
       end
     end
 
@@ -110,7 +110,7 @@ describe ConditionalSection do
     subject { ConditionalSection.new('foobar', true) }
 
     it 'should know its original source text' do
-      subject.to_s.should == '<?foobar>'
+      expect(subject.to_s).to eq('<?foobar>')
     end
 
     it 'should render its children when conditions are met' do
@@ -121,7 +121,7 @@ describe ConditionalSection do
       locals = { 'user' => 'joe', 'foobar' => 'exists' }
       rendered_text = subject.render(Object.new, locals)
       expected_text = "Hello joe\n"
-      rendered_text.should == expected_text
+      expect(rendered_text).to eq(expected_text)
 
       # Case of a conditional section that should be
       # rendering when value is non-existing.
@@ -131,7 +131,7 @@ describe ConditionalSection do
       # Case of a non-existing actual
       locals = { 'user' => 'joe' }
       rendered_text = instance.render(Object.new, locals)
-      rendered_text.should == expected_text
+      expect(rendered_text).to eq(expected_text)
     end
 
     it "should render noting when conditions are'nt met" do
@@ -141,7 +141,7 @@ describe ConditionalSection do
       # Case of a non-existing actual
       locals = { 'user' => 'joe' }
       rendered_text = subject.render(Object.new, locals)
-      rendered_text.should == ''
+      expect(rendered_text).to eq('')
 
       # Case of a conditional section that should be
       # rendering when value is non-existing.
@@ -151,7 +151,7 @@ describe ConditionalSection do
       # Case of a non-existing actual
       locals = { 'user' => 'joe', 'foobar' => 'exists' }
       rendered_text = instance.render(Object.new, locals)
-      rendered_text.should == ''
+      expect(rendered_text).to eq('')
     end
 
   end # context

data/spec/spec_helper.rb

@@ -8,4 +8,12 @@ require 'simplecov'
 require 'rspec'	# Use the RSpec framework
 require 'pp'	# Use pretty-print for debugging purposes
 
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    # Disable the `should` syntax...
+    c.syntax = :expect
+  end
+end
+
+
 # End of file

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: macros4cuke
 version: !ruby/object:Gem::Version
-  version: 0.3.25
+  version: 0.3.26
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-30 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber