yard 0.8.7.6 → 0.9.0

data/spec/templates/helpers/text_helper_spec.rb

@@ -5,7 +5,7 @@ describe YARD::Templates::Helpers::TextHelper do
   include YARD::Templates::Helpers::TextHelper
   include YARD::Templates::Helpers::MethodHelper
 
-  describe '#signature' do
+  describe "#signature" do
     before do
       @results = {
         :regular => "root.foo -> Object",
@@ -30,15 +30,15 @@ describe YARD::Templates::Helpers::TextHelper do
     it_should_behave_like "signature"
   end
 
-  describe '#align_right' do
-    it "should align text right" do
+  describe "#align_right" do
+    it "aligns text right" do
       text = "Method: #some_method (SomeClass)"
-      align_right(text).should == ' ' * 40 + text
+      expect(align_right(text)).to eq ' ' * 40 + text
     end
 
-    it "should truncate text that is longer than allowed width" do
+    it "truncates text that is longer than allowed width" do
       text = "(Defined in: /home/user/.rip/.packages/some_gem-2460672e333ac07b9190ade88ec9a91c/long/path.rb)"
-      align_right(text).should == ' ' + text[0,68] + '...'
+      expect(align_right(text)).to eq ' ' + text[0,68] + '...'
     end
   end
 end

data/spec/templates/method_spec.rb

@@ -7,16 +7,16 @@ describe YARD::Templates::Engine.template(:default, :method) do
   before { Registry.clear }
 
   shared_examples_for "all formats" do
-    it "should render html format correctly" do
+    it "renders html format correctly" do
       html_equals(Registry.at('#m').format(html_options), @template)
     end
 
-    it "should render text format correctly" do
+    it "renders text format correctly" do
       text_equals(Registry.at('#m').format(text_options), @template)
     end
   end
 
-  describe 'regular (deprecated) method' do
+  describe "regular (deprecated) method" do
     before do
       @template = :method001
       YARD.parse_string <<-'eof'
@@ -36,7 +36,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
     it_should_behave_like "all formats"
   end
 
-  describe 'method with 1 overload' do
+  describe "method with 1 overload" do
     before do
       @template = :method002
       YARD.parse_string <<-'eof'
@@ -52,7 +52,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
     it_should_behave_like "all formats"
   end
 
-  describe 'method with 2 overloads' do
+  describe "method with 2 overloads" do
     before do
       @template = :method003
       YARD.parse_string <<-'eof'
@@ -73,7 +73,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
     it_should_behave_like "all formats"
   end
 
-  describe 'method void return' do
+  describe "method void return" do
     before do
       @template = :method004
       YARD.parse_string <<-'eof'
@@ -85,7 +85,7 @@ describe YARD::Templates::Engine.template(:default, :method) do
     it_should_behave_like "all formats"
   end
 
-  describe 'method void return in an overload' do
+  describe "method void return in an overload" do
     before do
       @template = :method005
       YARD.parse_string <<-'eof'

data/spec/templates/module_spec.rb

@@ -65,13 +65,13 @@ describe YARD::Templates::Engine.template(:default, :module) do
     eof
   end
 
-  it "should render html format correctly" do
+  it "renders html format correctly" do
     html_equals(Registry.at('A').format(html_options(:hide_void_return => true,
       :verifier => Verifier.new('object.type != :method || object.visibility == :public'))),
         :module001)
   end
 
-  it "should render text format correctly" do
+  it "renders text format correctly" do
     YARD.parse_string <<-'eof'
       module A
         include D, E, F, A::B::C
@@ -81,11 +81,11 @@ describe YARD::Templates::Engine.template(:default, :module) do
     text_equals(Registry.at('A').format(text_options), :module001)
   end
 
-  it "should render dot format correctly" do
-    Registry.at('A').format(:format => :dot, :dependencies => true, :full => true).should == example_contents(:module001, 'dot')
+  it "renders dot format correctly" do
+    expect(Registry.at('A').format(:format => :dot, :dependencies => true, :full => true)).to eq example_contents(:module001, 'dot')
   end
 
-  it "should render groups correctly in html" do
+  it "renders groups correctly in html" do
     Registry.clear
     YARD.parse_string <<-'eof'
       module A
@@ -106,7 +106,7 @@ describe YARD::Templates::Engine.template(:default, :module) do
     html_equals(Registry.at('A').format(html_options), :module002)
   end
 
-  it "should ignore overwritten/private attributes/constants from inherited list" do
+  it "ignores overwritten/private attributes/constants from inherited list" do
     Registry.clear
     YARD.parse_string <<-'eof'
       module B
@@ -128,7 +128,7 @@ describe YARD::Templates::Engine.template(:default, :module) do
       :verifier => Verifier.new('!@private'))), :module003)
   end
 
-  it "should embed mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
+  it "embeds mixins with :embed_mixins = ['Foo', 'Bar', 'Baz::A*']" do
     Registry.clear
     YARD.parse_string <<-'eof'
       class A

data/spec/templates/onefile_spec.rb

@@ -52,13 +52,13 @@ describe YARD::Templates::Engine.template(:default, :onefile) do
       ]
   end
 
-  it "should render html" do
+  it "renders html" do
     render
-    @files.should == ['index.html']
-    @output.should include("This is a code comment")
-    @output.should include("This is a license!")
-    @output.should include("Class: A")
-    @output.should include("Foo method")
-    @output.should include("Bar method")
+    expect(@files).to eq ['index.html']
+    expect(@output).to include("This is a code comment")
+    expect(@output).to include("This is a license!")
+    expect(@output).to include("Class: A")
+    expect(@output).to include("Foo method")
+    expect(@output).to include("Bar method")
   end
 end

data/spec/templates/section_spec.rb

@@ -3,144 +3,141 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Templates::Section do
   include YARD::Templates
 
-  describe '#initialize' do
-    it "should convert first argument to splat if it is array" do
+  describe "#initialize" do
+    it "converts first argument to splat if it is array" do
       s = Section.new(:name, [:foo, :bar])
-      s.name.should == :name
-      s[0].name.should == :foo
-      s[1].name.should == :bar
+      expect(s.name).to eq :name
+      expect(s[0].name).to eq :foo
+      expect(s[1].name).to eq :bar
     end
 
-    it "should allow initialization with Section objects" do
+    it "allows initialization with Section objects" do
       s = Section.new(:name, [:foo, Section.new(:bar)])
-      s.name.should == :name
-      s[0].should == Section.new(:foo)
-      s[1].should == Section.new(:bar)
+      expect(s.name).to eq :name
+      expect(s[0]).to eq Section.new(:foo)
+      expect(s[1]).to eq Section.new(:bar)
     end
 
-    it "should make a list of sections" do
+    it "makes a list of sections" do
       s = Section.new(:name, [:foo, [:bar]])
-      s.should == Section.new(:name, Section.new(:foo, Section.new(:bar)))
+      expect(s).to eq Section.new(:name, Section.new(:foo, Section.new(:bar)))
     end
   end
 
-  describe '#[]' do
-    it "should use Array#[] if argument is integer" do
-      Section.new(:name, [:foo, :bar])[0].name.should == :foo
+  describe "#[]" do
+    it "uses Array#[] if argument is integer" do
+      expect(Section.new(:name, [:foo, :bar])[0].name).to eq :foo
     end
 
-    it "should return new Section object if more than one argument" do
-      Section.new(:name, :foo, :bar, :baz)[1, 2].should ==
-        Section.new(:name, :bar, :baz)
+    it "returns new Section object if more than one argument" do
+      expect(Section.new(:name, :foo, :bar, :baz)[1, 2]).to eq Section.new(:name, :bar, :baz)
     end
 
-    it "should return new Section object if arg is Range" do
-      Section.new(:name, :foo, :bar, :baz)[1..2].should ==
-        Section.new(:name, :bar, :baz)
+    it "returns new Section object if arg is Range" do
+      expect(Section.new(:name, :foo, :bar, :baz)[1..2]).to eq Section.new(:name, :bar, :baz)
     end
 
-    it "should look for section by name if arg is object" do
-      Section.new(:name, :foo, :bar, [:baz])[:bar][:baz].should ==
-        Section.new(:baz)
+    it "looks for section by name if arg is object" do
+      expect(Section.new(:name, :foo, :bar, [:baz])[:bar][:baz]).to eq Section.new(:baz)
     end
   end
 
-  describe '#eql?' do
-    it "should check for equality of two equal sections" do
-      Section.new(:foo, [:a, :b]).should be_eql(Section.new(:foo, :a, :b))
-      Section.new(:foo, [:a, :b]).should == Section.new(:foo, :a, :b)
+  describe "#eql?" do
+    it "checks for equality of two equal sections" do
+      expect(Section.new(:foo, [:a, :b])).to eql(Section.new(:foo, :a, :b))
+      expect(Section.new(:foo, [:a, :b])).to eq Section.new(:foo, :a, :b)
     end
 
-    it "should not be equal if section names are different" do
-      Section.new(:foo, [:a, :b]).should_not be_eql(Section.new(:bar, :a, :b))
-      Section.new(:foo, [:a, :b]).should_not == Section.new(:bar, :a, :b)
+    it "is not equal if section names are different" do
+      expect(Section.new(:foo, [:a, :b])).not_to eql(Section.new(:bar, :a, :b))
+      expect(Section.new(:foo, [:a, :b])).not_to eq Section.new(:bar, :a, :b)
     end
   end
 
-  describe '#==' do
-    it "should allow comparison to Symbol" do
-      Section.new(:foo, 2, 3).should == :foo
+  describe "#==" do
+    it "allows comparison to Symbol" do
+      expect(Section.new(:foo, 2, 3)).to eq :foo
     end
 
-    it "should allow comparison to String" do
-      Section.new("foo", 2, 3).should == "foo"
+    it "allows comparison to String" do
+      expect(Section.new("foo", 2, 3)).to eq "foo"
     end
 
-    it "should allow comparison to Template" do
+    it "allows comparison to Template" do
       t = YARD::Templates::Engine.template!(:xyzzy, '/full/path/xyzzy')
-      Section.new(t, 2, 3).should == t
+      expect(Section.new(t, 2, 3)).to eq t
     end
 
-    it "should allow comparison to Section" do
-      Section.new(1, [2, 3]).should == Section.new(1, 2, 3)
+    it "allows comparison to Section" do
+      expect(Section.new(1, [2, 3])).to eq Section.new(1, 2, 3)
     end
 
-    it "should allow comparison to Object" do
-      Section.new(1, [2, 3]).should == 1
+    it "allows comparison to Object" do
+      expect(Section.new(1, [2, 3])).to eq 1
     end
 
-    it "should allow comparison to Array" do
-      Section.new(1, 2, [3]).should == [1, [2, [3]]]
+    it "allows comparison to Array" do
+      expect(Section.new(1, 2, [3])).to eq [1, [2, [3]]]
     end
   end
 
-  describe '#to_a' do
-    it "should convert Section to regular Array list" do
+  describe "#to_a" do
+    it "converts Section to regular Array list" do
       arr = Section.new(1, 2, [3, [4]]).to_a
-      arr.class.should == Array
-      arr.should == [1, [2, [3, [4]]]]
+      expect(arr.class).to eq Array
+      expect(arr).to eq [1, [2, [3, [4]]]]
     end
   end
 
-  describe '#place' do
-    it "should place objects as Sections" do
-      Section.new(1, 2, 3).place(4).before(3).should == [1, [2, 4, 3]]
+  describe "#place" do
+    it "places objects as Sections" do
+      expect(Section.new(1, 2, 3).place(4).before(3)).to eq [1, [2, 4, 3]]
     end
 
-    it "should place objects anywhere inside Section with before/after_any" do
-      Section.new(1, 2, [3, [4]]).place(5).after_any(4).should == [1, [2, [3, [4, 5]]]]
-      Section.new(1, 2, [3, [4]]).place(5).before_any(4).should == [1, [2, [3, [5, 4]]]]
+    it "places objects anywhere inside Section with before/after_any" do
+      expect(Section.new(1, 2, [3, [4]]).place(5).after_any(4)).to eq [1, [2, [3, [4, 5]]]]
+      expect(Section.new(1, 2, [3, [4]]).place(5).before_any(4)).to eq [1, [2, [3, [5, 4]]]]
     end
 
-    it "should allow multiple sections to be placed" do
-      Section.new(1, 2, 3).place(4, 5).after(3).to_a.should == [1, [2, 3, 4, 5]]
-      Section.new(1, 2, 3).place(4, [5]).after(3).to_a.should == [1, [2, 3, 4, [5]]]
+    it "allows multiple sections to be placed" do
+      expect(Section.new(1, 2, 3).place(4, 5).after(3).to_a).to eq [1, [2, 3, 4, 5]]
+      expect(Section.new(1, 2, 3).place(4, [5]).after(3).to_a).to eq [1, [2, 3, 4, [5]]]
     end
   end
 
-  describe '#push' do
-    it "should push objects as Sections" do
+  describe "#push" do
+    it "pushes objects as Sections" do
       s = Section.new(:foo)
       s.push :bar
-      s[0].should == Section.new(:bar)
+      expect(s[0]).to eq Section.new(:bar)
     end
 
-    it "should alias to #<<" do
+    it "is aliased as #<<" do
       s = Section.new(1)
       s << :index
-      s[:index].should be_a(Section)
+      expect(s[:index]).to be_a(Section)
     end
   end
 
-  describe '#unshift' do
-    it "should unshift objects as Sections" do
+  describe "#unshift" do
+    it "unshifts objects as Sections" do
       s = Section.new(:foo)
       s.unshift :bar
-      s[0].should == Section.new(:bar)
+      expect(s[0]).to eq Section.new(:bar)
     end
   end
 
-  describe '#any' do
-    it "should find item inside sections" do
+  describe "#any" do
+    it "finds item inside sections" do
       s = Section.new(:foo, Section.new(:bar, Section.new(:bar)))
       s.any(:bar).push(:baz)
-      s.to_a.should == [:foo, [:bar, [:bar, :baz]]]
+      expect(s.to_a).to eq [:foo, [:bar, [:bar, :baz]]]
     end
 
-    it "should find item in any deeply nested set of sections" do
+    it "finds item in any deeply nested set of sections" do
       s = Section.new(:foo, Section.new(:bar, Section.new(:baz)))
       s.any(:baz).push(:qux)
-      s.to_a.should == [:foo, [:bar, [:baz, [:qux]]]]
+      expect(s.to_a).to eq [:foo, [:bar, [:baz, [:qux]]]]
     end
   end
 end

data/spec/templates/spec_helper.rb

@@ -15,7 +15,7 @@ def text_equals(result, expected_example)
 end
 
 def text_equals_string(result, expected)
-  result.should == expected
+  expect(result).to eq expected
 end
 
 def html_equals(result, expected_example)

data/spec/templates/tag_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Templates::Engine.template(:default, :tags) do
   before { Registry.clear }
 
-  describe 'all known tags' do
+  describe "all known tags" do
     before do
       YARD.parse_string <<-'eof'
         # Comments
@@ -32,20 +32,20 @@ describe YARD::Templates::Engine.template(:default, :tags) do
       eof
     end
 
-    it "should render text format correctly" do
+    it "renders text format correctly" do
       text_equals(Registry.at('#m').format(text_options), :tag001)
     end
   end
 
-  describe 'param tags on non-methods' do
-    it 'should not display @param tags on non-method objects' do
+  describe "param tags on non-methods" do
+    it "does not display @param tags on non-method objects" do
       YARD.parse_string <<-'eof'
         # @param [#to_s] name the name
         module Foo; end
       eof
 
       proc = lambda { Registry.at('Foo').format(html_options) }
-      proc.should_not raise_error(NoMethodError)
+      expect(proc).not_to raise_error
     end
   end
 end

data/spec/templates/template_spec.rb

@@ -9,282 +9,282 @@ describe YARD::Templates::Template do
     YARD::Templates::ErbCache.clear!
   end
 
-  describe '.include_parent' do
-    it "should not include parent directory if parent directory is a template root path" do
+  describe ".include_parent" do
+    it "does not include parent directory if parent directory is a template root path" do
       mod = template('q')
-      mod.should_not include(template(''))
+      expect(mod).not_to include(template(''))
     end
 
-    it "should include overridden parent directory" do
-      Engine.stub!(:template_paths).and_return(['/foo', '/bar'])
-      File.should_receive(:directory?).with('/foo/a/b').and_return(true)
-      File.should_receive(:directory?).with('/bar/a/b').and_return(false)
-      File.should_receive(:directory?).with('/foo/a').at_least(1).times.and_return(true)
-      File.should_receive(:directory?).with('/bar/a').at_least(1).times.and_return(true)
+    it "includes overridden parent directory" do
+      allow(Engine).to receive(:template_paths).and_return(['/foo', '/bar'])
+      expect(File).to receive(:directory?).with('/foo/a/b').and_return(true)
+      expect(File).to receive(:directory?).with('/bar/a/b').and_return(false)
+      expect(File).to receive(:directory?).with('/foo/a').at_least(1).times.and_return(true)
+      expect(File).to receive(:directory?).with('/bar/a').at_least(1).times.and_return(true)
       ancestors = Engine.template('a/b').ancestors.map {|c| c.class_name }
-      ancestors[0, 3].should == %w( Template__foo_a_b Template__bar_a Template__foo_a )
+      expect(ancestors[0, 3]).to eq %w( Template__foo_a_b Template__bar_a Template__foo_a )
     end
 
-    it "should include parent directory template if exists" do
+    it "includes parent directory template if exists" do
       mod1 = template('x')
       mod2 = template('x/y')
-      mod2.should include(mod1)
+      expect(mod2).to include(mod1)
     end
   end
 
-  describe '.full_paths' do
-    it "should list full_path" do
+  describe ".full_paths" do
+    it "lists full_path" do
       mod = template(:a)
-      mod.full_paths.should == ['/full/path/a']
+      expect(mod.full_paths).to eq ['/full/path/a']
     end
 
-    it "should list paths of included modules" do
+    it "lists paths of included modules" do
       mod = template(:a)
       mod.send(:include, template(:b))
-      mod.full_paths.should == ['/full/path/a', '/full/path/b']
+      expect(mod.full_paths).to eq ['/full/path/a', '/full/path/b']
     end
 
-    it "should list paths from modules of included modules" do
+    it "lists paths from modules of included modules" do
       mod = template(:c)
       mod.send(:include, template(:d))
       mod.send(:include, template(:a))
-      mod.full_paths.should == ['c', 'a', 'b', 'd'].map {|o| '/full/path/' + o }
+      expect(mod.full_paths).to eq ['c', 'a', 'b', 'd'].map {|o| '/full/path/' + o }
     end
 
-    it "should only list full paths of modules that respond to full_paths" do
+    it "only lists full paths of modules that respond to full_paths" do
       mod = template(:d)
       mod.send(:include, Enumerable)
-      mod.full_paths.should == ['/full/path/d']
+      expect(mod.full_paths).to eq ['/full/path/d']
     end
   end
 
-  describe '.load_setup_rb' do
-    it "should load setup.rb file for module" do
-      File.should_receive(:file?).with('/full/path/e/setup.rb').and_return(true)
-      File.should_receive(:read).with('/full/path/e/setup.rb').and_return('def success; end')
-      template(:e).new.should respond_to(:success)
+  describe ".load_setup_rb" do
+    it "loads setup.rb file for module" do
+      expect(File).to receive(:file?).with('/full/path/e/setup.rb').and_return(true)
+      expect(File).to receive(:read).with('/full/path/e/setup.rb').and_return('def success; end')
+      expect(template(:e).new).to respond_to(:success)
     end
   end
 
-  describe '.T' do
-    it "should load template from absolute path" do
+  describe ".T" do
+    it "loads template from absolute path" do
       mod = template(:a)
-      Engine.should_receive(:template).with('other')
+      expect(Engine).to receive(:template).with('other')
       mod.T('other')
     end
   end
 
-  describe '.find_file' do
-    it "should find file in module's full_path" do
-      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
-      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
-      template(:a).find_file('basename').should == '/full/path/b/basename'
+  describe ".find_file" do
+    it "finds file in the module's full_path" do
+      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(false)
+      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
+      expect(template(:a).find_file('basename')).to eq '/full/path/b/basename'
     end
 
-    it "should return nil if no file is found" do
-      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
-      File.should_receive(:file?).with('/full/path/b/basename').and_return(false)
-      template(:a).find_file('basename').should be_nil
+    it "returns nil if no file is found" do
+      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(false)
+      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(false)
+      expect(template(:a).find_file('basename')).to be nil
     end
   end
 
-  describe '.find_nth_file' do
-    it "should find 2nd existing file in template paths" do
-      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
-      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
-      template(:a).find_nth_file('basename', 2).should == '/full/path/b/basename'
+  describe ".find_nth_file" do
+    it "finds 2nd existing file in template paths" do
+      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(true)
+      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
+      expect(template(:a).find_nth_file('basename', 2)).to eq '/full/path/b/basename'
     end
 
-    it "should return nil if no file is found" do
-      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
-      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
-      template(:a).find_nth_file('basename', 3).should be_nil
+    it "returns nil if no file is found" do
+      expect(File).to receive(:file?).with('/full/path/a/basename').and_return(true)
+      expect(File).to receive(:file?).with('/full/path/b/basename').and_return(true)
+      expect(template(:a).find_nth_file('basename', 3)).to be nil
     end
   end
 
-  describe '.extra_includes' do
-    it "should be included when a module is initialized" do
+  describe ".extra_includes" do
+    it "is included when a module is initialized" do
       module MyModule; end
       Template.extra_includes << MyModule
-      template(:e).new.should be_kind_of(MyModule)
+      expect(template(:e).new).to be_kind_of(MyModule)
     end
 
-    it "should support lambdas in list" do
+    it "supports lambdas in list" do
       module MyModule2; end
       Template.extra_includes << lambda {|opts| MyModule2 if opts.format == :html }
-      template(:f).new(:format => :html).should be_kind_of(MyModule2)
+      expect(template(:f).new(:format => :html)).to be_kind_of(MyModule2)
       metaclass = (class << template(:g).new(:format => :text); self end)
-      metaclass.ancestors.should_not include(MyModule2)
+      expect(metaclass.ancestors).not_to include(MyModule2)
     end
   end
 
-  describe '.is_a?' do
-    it "should be kind of Template" do
-      template(:e).is_a?(Template).should == true
+  describe ".is_a?" do
+    it "is kind of Template" do
+      expect(template(:e).is_a?(Template)).to be true
     end
   end
 
-  describe '#T' do
-    it "should delegate to class method" do
-      template(:e).should_receive(:T).with('test')
+  describe "#T" do
+    it "delegates to class method" do
+      expect(template(:e)).to receive(:T).with('test')
       template(:e).new.T('test')
     end
   end
 
-  describe '#init' do
-    it "should be called during initialization" do
+  describe "#init" do
+    it "is called during initialization" do
       module YARD::Templates::Engine::Template__full_path_e
         def init; sections 1, 2, 3 end
       end
-      template(:e).new.sections.should == Section.new(nil, 1, 2, 3)
+      expect(template(:e).new.sections).to eq Section.new(nil, 1, 2, 3)
     end
   end
 
-  describe '#file' do
-    it "should read the file if it exists" do
-      File.should_receive(:file?).with('/full/path/e/abc').and_return(true)
-      IO.should_receive(:read).with('/full/path/e/abc').and_return('hello world')
-      template(:e).new.file('abc').should == 'hello world'
+  describe "#file" do
+    it "reads the file if it exists" do
+      expect(File).to receive(:file?).with('/full/path/e/abc').and_return(true)
+      expect(IO).to receive(:read).with('/full/path/e/abc').and_return('hello world')
+      expect(template(:e).new.file('abc')).to eq 'hello world'
     end
 
-    it "should raise ArgumentError if the file does not exist" do
-      File.should_receive(:file?).with('/full/path/e/abc').and_return(false)
-      lambda { template(:e).new.file('abc') }.should raise_error(ArgumentError)
+    it "raises ArgumentError if the file does not exist" do
+      expect(File).to receive(:file?).with('/full/path/e/abc').and_return(false)
+      expect { template(:e).new.file('abc') }.to raise_error(ArgumentError)
     end
 
-    it "should replace {{{__super__}}} with inherited template contents if allow_inherited=true" do
-      File.should_receive(:file?).with('/full/path/a/abc').twice.and_return(true)
-      File.should_receive(:file?).with('/full/path/b/abc').and_return(true)
-      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
-      IO.should_receive(:read).with('/full/path/b/abc').and_return('bar')
-      template(:a).new.file('abc', true).should == "foo bar"
+    it "replaces {{{__super__}}} with inherited template contents if allow_inherited=true" do
+      expect(File).to receive(:file?).with('/full/path/a/abc').twice.and_return(true)
+      expect(File).to receive(:file?).with('/full/path/b/abc').and_return(true)
+      expect(IO).to receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      expect(IO).to receive(:read).with('/full/path/b/abc').and_return('bar')
+      expect(template(:a).new.file('abc', true)).to eq "foo bar"
     end
 
-    it "should not replace {{{__super__}}} with inherited template contents if allow_inherited=false" do
-      File.should_receive(:file?).with('/full/path/a/abc').and_return(true)
-      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
-      template(:a).new.file('abc').should == "foo {{{__super__}}}"
+    it "does not replace {{{__super__}}} with inherited template contents if allow_inherited=false" do
+      expect(File).to receive(:file?).with('/full/path/a/abc').and_return(true)
+      expect(IO).to receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      expect(template(:a).new.file('abc')).to eq "foo {{{__super__}}}"
     end
   end
 
-  describe '#superb' do
-    it "should return the inherited erb template contents" do
-      File.should_receive(:file?).with('/full/path/a/test.erb').and_return(true)
-      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
-      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+  describe "#superb" do
+    it "returns the inherited erb template contents" do
+      expect(File).to receive(:file?).with('/full/path/a/test.erb').and_return(true)
+      expect(File).to receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      expect(IO).to receive(:read).with('/full/path/b/test.erb').and_return('bar')
       template = template(:a).new
       template.section = :test
-      template.superb.should == "bar"
+      expect(template.superb).to eq "bar"
     end
 
-    it "should work inside an erb template" do
-      File.should_receive(:file?).with('/full/path/a/test.erb').twice.and_return(true)
-      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
-      IO.should_receive(:read).with('/full/path/a/test.erb').and_return('foo<%= superb %>!')
-      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+    it "works inside an erb template" do
+      expect(File).to receive(:file?).with('/full/path/a/test.erb').twice.and_return(true)
+      expect(File).to receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      expect(IO).to receive(:read).with('/full/path/a/test.erb').and_return('foo<%= superb %>!')
+      expect(IO).to receive(:read).with('/full/path/b/test.erb').and_return('bar')
       template = template(:a).new
       template.section = :test
-      template.erb(:test).should == "foobar!"
+      expect(template.erb(:test)).to eq "foobar!"
     end
   end
 
-  describe '#sections' do
-    it "should allow sections to be set if arguments are provided" do
+  describe "#sections" do
+    it "allows sections to be set if arguments are provided" do
       mod = template(:e).new
       mod.sections 1, 2, [3]
-      mod.sections.should == Section.new(nil, 1, 2, [3])
+      expect(mod.sections).to eq Section.new(nil, 1, 2, [3])
     end
   end
 
-  describe '#run' do
-    it "should render all sections" do
+  describe "#run" do
+    it "renders all sections" do
       mod = template(:e).new
-      mod.should_receive(:render_section).with(Section.new(:a)).and_return('a')
-      mod.should_receive(:render_section).with(Section.new(:b)).and_return('b')
-      mod.should_receive(:render_section).with(Section.new(:c)).and_return('c')
+      allow(mod).to receive(:render_section) { |section| section.name.to_s }
       mod.sections :a, :b, :c
-      mod.run.should == 'abc'
+      expect(mod.run).to eq 'abc'
     end
 
-    it "should render all sections with options" do
+    it "renders all sections with options" do
       mod = template(:e).new
-      mod.should_receive(:render_section).with(Section.new(:a)).and_return('a')
-      mod.should_receive(:add_options).with(:a => 1).and_yield
+      allow(mod).to receive(:render_section) { |section| section.name.to_s }
+      expect(mod).to receive(:add_options).with(:a => 1).and_yield
       mod.sections :a
-      mod.run(:a => 1).should == 'a'
+      expect(mod.run(:a => 1)).to eq 'a'
     end
 
-    it "should run section list if provided" do
+    it "runs section list if provided" do
       mod = template(:e).new
-      mod.should_receive(:render_section).with(Section.new(:q))
-      mod.should_receive(:render_section).with(Section.new(:x))
+      expect(mod).to receive(:render_section).exactly(2).times do |section|
+        expect([:q, :x]).to include(section.name)
+        section.name.to_s
+      end
       mod.run({}, [:q, :x])
     end
 
-    it "should accept a nil section as empty string" do
+    it "accepts a nil section as empty string" do
       mod = template(:e).new
-      mod.should_receive(:render_section).with(Section.new(:a))
+      allow(mod).to receive(:render_section) { nil }
       mod.sections :a
-      mod.run.should == ""
+      expect(mod.run).to eq ""
     end
   end
 
-  describe '#add_options' do
-    it "should set instance variables in addition to options" do
+  describe "#add_options" do
+    it "sets instance variables in addition to options" do
       mod = template(:f).new
       mod.send(:add_options, {:a => 1, :b => 2})
-      mod.options.should == {:a => 1, :b => 2}
-      mod.instance_variable_get("@a").should == 1
-      mod.instance_variable_get("@b").should == 2
+      expect(mod.options).to eq({:a => 1, :b => 2})
+      expect(mod.instance_variable_get("@a")).to eq 1
+      expect(mod.instance_variable_get("@b")).to eq 2
     end
 
-    it "should set instance variables and options only for the block" do
+    it "sets instance variables and options only for the block" do
       mod = template(:f).new
       mod.send(:add_options, {:a => 100, :b => 200}) do
-        mod.options.should == {:a => 100, :b => 200}
+        expect(mod.options).to eq({:a => 100, :b => 200})
       end
-      mod.options.should_not == {:a => 100, :b => 200}
+      expect(mod.options).not_to eq({:a => 100, :b => 200})
     end
   end
 
-  describe '#render_section' do
-    it "should call method if method exists by section name as Symbol" do
+  describe "#render_section" do
+    it "calls method if method exists by section name as Symbol" do
       mod = template(:f).new
-      mod.should_receive(:respond_to?).with(:a).and_return(true)
-      mod.should_receive(:respond_to?).with('a').and_return(true)
-      mod.should_receive(:send).with(:a).and_return('a')
-      mod.should_receive(:send).with('a').and_return('a')
-      mod.run({}, [:a, 'a']).should == 'aa'
+      expect(mod).to receive(:respond_to?).with(:a).and_return(true)
+      expect(mod).to receive(:respond_to?).with('a').and_return(true)
+      expect(mod).to receive(:send).with(:a).and_return('a')
+      expect(mod).to receive(:send).with('a').and_return('a')
+      expect(mod.run({}, [:a, 'a'])).to eq 'aa'
     end
 
-    it "should call erb if no method exists by section name" do
+    it "calls erb if no method exists by section name" do
       mod = template(:f).new
-      mod.should_receive(:respond_to?).with(:a).and_return(false)
-      mod.should_receive(:respond_to?).with('a').and_return(false)
-      mod.should_receive(:erb).with(:a).and_return('a')
-      mod.should_receive(:erb).with('a').and_return('a')
-      mod.run({}, [:a, 'a']).should == 'aa'
+      expect(mod).to receive(:respond_to?).with(:a).and_return(false)
+      expect(mod).to receive(:respond_to?).with('a').and_return(false)
+      expect(mod).to receive(:erb).with(:a).and_return('a')
+      expect(mod).to receive(:erb).with('a').and_return('a')
+      expect(mod.run({}, [:a, 'a'])).to eq 'aa'
     end
 
-    it "should run a template if section is one" do
+    it "runs a template if section is one" do
       mod2 = template(:g)
-      mod2.should_receive(:run)
+      expect(mod2).to receive(:run)
       mod = template(:f).new
       mod.sections mod2
       mod.run
     end
 
-    it "should run a template instance if section is one" do
+    it "runs a template instance if section is one" do
       mod2 = template(:g).new
-      mod2.should_receive(:run)
+      expect(mod2).to receive(:run)
       mod = template(:f).new
       mod.sections mod2
       mod.run
     end
   end
 
-  describe '#yield' do
-    it "should yield a subsection" do
+  describe "#yield" do
+    it "yields a subsection" do
       mod = template(:e).new
       mod.sections :a, [:b, :c]
       class << mod
@@ -293,10 +293,10 @@ describe YARD::Templates::Template do
         def c; "c" end
       end
 
-      mod.run.should == "(b)"
+      expect(mod.run).to eq "(b)"
     end
 
-    it "should yield a subsection within a yielded subsection" do
+    it "yields a subsection within a yielded subsection" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c]]
       class << mod
@@ -305,10 +305,10 @@ describe YARD::Templates::Template do
         def c; "c" end
       end
 
-      mod.run.should == "(c)"
+      expect(mod.run).to eq "(c)"
     end
 
-    it "should support arbitrary nesting" do
+    it "supports arbitrary nesting" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c, [:d, [:e]]]]
       class << mod
@@ -319,10 +319,10 @@ describe YARD::Templates::Template do
         def e; "e" end
       end
 
-      mod.run.should == "(e)"
+      expect(mod.run).to eq "(e)"
     end
 
-    it "should yield first two elements if yield is called twice" do
+    it "yields first two elements if yield is called twice" do
       mod = template(:e).new
       mod.sections :a, [:b, :c, :d]
       class << mod
@@ -331,10 +331,10 @@ describe YARD::Templates::Template do
         def c; "c" end
       end
 
-      mod.run.should == "(bc)"
+      expect(mod.run).to eq "(bc)"
     end
 
-    it "should ignore any subsections inside subsection yields" do
+    it "ignores any subsections inside subsection yields" do
       mod = template(:e).new
       mod.sections :a, [:b, [:c], :d]
       class << mod
@@ -343,10 +343,10 @@ describe YARD::Templates::Template do
         def d; "d" end
       end
 
-      mod.run.should == "(bd)"
+      expect(mod.run).to eq "(bd)"
     end
 
-    it "should allow extra options passed via yield" do
+    it "allows extra options passed via yield" do
       mod = template(:e).new
       mod.sections :a, [:b]
       class << mod
@@ -354,12 +354,12 @@ describe YARD::Templates::Template do
         def b; options.x + @x end
       end
 
-      mod.run.should == "(aa)"
+      expect(mod.run).to eq "(aa)"
     end
   end
 
-  describe '#yieldall' do
-    it "should yield all subsections" do
+  describe "#yieldall" do
+    it "yields all subsections" do
       mod = template(:e).new
       mod.sections :a, [:b, [:d, [:e]], :c]
       class << mod
@@ -370,10 +370,10 @@ describe YARD::Templates::Template do
         def e; 'e' end
       end
 
-      mod.run.should == "(bdec)"
+      expect(mod.run).to eq "(bdec)"
     end
 
-    it "should yield options to all subsections" do
+    it "yields options to all subsections" do
       mod = template(:e).new
       mod.sections :a, [:b, :c]
       class << mod
@@ -381,10 +381,10 @@ describe YARD::Templates::Template do
         def b; @x end
         def c; @x end
       end
-      mod.run.should == "(22)"
+      expect(mod.run).to eq "(22)"
     end
 
-    it "should yield all subsections more than once" do
+    it "yields all subsections more than once" do
       mod = template(:e).new
       mod.sections :a, [:b]
       class << mod
@@ -392,10 +392,10 @@ describe YARD::Templates::Template do
         def b; "b" end
       end
 
-      mod.run.should == "(bb)"
+      expect(mod.run).to eq "(bb)"
     end
 
-    it "should not yield if no yieldall is called" do
+    it "does not yield if no yieldall is called" do
       mod = template(:e).new
       mod.sections :a, [:b]
       class << mod
@@ -403,7 +403,7 @@ describe YARD::Templates::Template do
         def b; "b" end
       end
 
-      mod.run.should == "()"
+      expect(mod.run).to eq "()"
     end
   end
 end