yard 0.8.7.6 → 0.9.0

data/spec/config_spec.rb

@@ -3,174 +3,174 @@ require File.join(File.dirname(__FILE__), "spec_helper")
 require 'yaml'
 
 describe YARD::Config do
-  describe '.load' do
+  describe ".load" do
     before do
-      File.should_receive(:file?).twice.with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      expect(File).to receive(:file?).twice.with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
     end
 
-    it "should use default options if no ~/.yard/config is found" do
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+    it "uses default options if no ~/.yard/config is found" do
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
       YARD::Config.load
-      YARD::Config.options.should == YARD::Config::DEFAULT_CONFIG_OPTIONS
+      expect(YARD::Config.options).to eq YARD::Config::DEFAULT_CONFIG_OPTIONS
     end
 
-    it "should overwrite options with data in ~/.yard/config" do
-      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      YAML.should_receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return({'test' => true})
+    it "overwrites options with data in ~/.yard/config" do
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(YAML).to receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return({'test' => true})
       YARD::Config.load
-      YARD::Config.options[:test].should be_true
+      expect(YARD::Config.options[:test]).to be true
     end
 
-    it "should ignore any plugins specified in '~/.yard/ignored_plugins'" do
-      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
-      File.should_receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
+    it "ignores any plugins specified in '~/.yard/ignored_plugins'" do
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      expect(File).to receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
       YARD::Config.load
-      YARD::Config.options[:ignored_plugins].should == ['yard-plugin', 'yard-plugin2']
-      YARD::Config.should_not_receive(:require).with('yard-plugin2')
-      YARD::Config.load_plugin('yard-plugin2').should == false
+      expect(YARD::Config.options[:ignored_plugins]).to eq ['yard-plugin', 'yard-plugin2']
+      expect(YARD::Config).not_to receive(:require).with('yard-plugin2')
+      expect(YARD::Config.load_plugin('yard-plugin2')).to be false
     end
 
-    it "should load safe_mode setting from --safe command line option" do
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+    it "loads safe_mode setting from --safe command line option" do
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
       ARGV.replace(['--safe'])
       YARD::Config.load
-      YARD::Config.options[:safe_mode].should be_true
+      expect(YARD::Config.options[:safe_mode]).to be true
       ARGV.replace([''])
     end
   end
 
-  describe '.save' do
-    it "should save options to config file" do
-      YARD::Config.stub!(:options).and_return(:a => 1, :b => %w(a b c))
-      file = mock(:file)
-      File.should_receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
-      file.should_receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
+  describe ".save" do
+    it "saves options to config file" do
+      allow(YARD::Config).to receive(:options).and_return(:a => 1, :b => %w(a b c))
+      file = double(:file)
+      expect(File).to receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
+      expect(file).to receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
       YARD::Config.save
     end
   end
 
-  describe '.load_plugin' do
-    it "should load a plugin by 'name' as 'yard-name'" do
-      YARD::Config.should_receive(:require).with('yard-foo')
-      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
-      YARD::Config.load_plugin('foo').should == true
+  describe ".load_plugin" do
+    it "loads a plugin by 'name' as 'yard-name'" do
+      expect(YARD::Config).to receive(:require).with('yard-foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('foo')).to be true
     end
 
-    it "should not load plugins like 'doc-*'" do
-      YARD::Config.should_not_receive(:require).with('yard-doc-core')
+    it "does not load plugins like 'doc-*'" do
+      expect(YARD::Config).not_to receive(:require).with('yard-doc-core')
       YARD::Config.load_plugin('doc-core')
       YARD::Config.load_plugin('yard-doc-core')
     end
 
-    it "should load plugin by 'yard-name' as 'yard-name'" do
-      YARD::Config.should_receive(:require).with('yard-foo')
-      log.should_receive(:debug).with(/Loading plugin 'yard-foo'/).once
-      YARD::Config.load_plugin('yard-foo').should == true
+    it "loads plugin by 'yard-name' as 'yard-name'" do
+      expect(YARD::Config).to receive(:require).with('yard-foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('yard-foo')).to be true
     end
 
-    it "should load plugin by 'yard_name' as 'yard_name'" do
-      YARD::Config.should_receive(:require).with('yard_foo')
-      log.should_receive(:debug).with(/Loading plugin 'yard_foo'/).once
+    it "loads plugin by 'yard_name' as 'yard_name'" do
+      expect(YARD::Config).to receive(:require).with('yard_foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard_foo'/).once
       log.show_backtraces = false
-      YARD::Config.load_plugin('yard_foo').should == true
+      expect(YARD::Config.load_plugin('yard_foo')).to be true
     end
 
-    it "should log error if plugin is not found" do
-      YARD::Config.should_receive(:require).with('yard-foo').and_raise(LoadError)
-      log.should_receive(:warn).with(/Error loading plugin 'yard-foo'/).once
-      YARD::Config.load_plugin('yard-foo').should == false
+    it "logs error if plugin is not found" do
+      expect(YARD::Config).to receive(:require).with('yard-foo').and_raise(LoadError)
+      expect(log).to receive(:warn).with(/Error loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('yard-foo')).to be false
     end
 
-    it "should sanitize plugin name (remove /'s)" do
-      YARD::Config.should_receive(:require).with('yard-foofoo')
-      YARD::Config.load_plugin('foo/foo').should == true
+    it "sanitizes plugin name (remove /'s)" do
+      expect(YARD::Config).to receive(:require).with('yard-foofoo')
+      expect(YARD::Config.load_plugin('foo/foo')).to be true
     end
 
-    it "should ignore plugins in :ignore_plugins" do
-      YARD::Config.stub!(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
-      YARD::Config.load_plugin('foo').should == false
-      YARD::Config.load_plugin('bar').should == false
+    it "ignores plugins in :ignore_plugins" do
+      allow(YARD::Config).to receive(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
+      expect(YARD::Config.load_plugin('foo')).to be false
+      expect(YARD::Config.load_plugin('bar')).to be false
     end
   end
 
-  describe '.load_plugins' do
-    it "should load gem plugins if :load_plugins is true" do
-      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
-      YARD::Config.stub!(:load_plugin)
-      YARD::Config.should_receive(:require).with('rubygems')
+  describe ".load_plugins" do
+    it "loads gem plugins if :load_plugins is true" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      allow(YARD::Config).to receive(:load_plugin)
+      expect(YARD::Config).to receive(:require).with('rubygems')
       YARD::Config.load_plugins
     end
 
-    it "should ignore gem loading if RubyGems cannot load" do
-      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
-      YARD::Config.should_receive(:require).with('rubygems').and_raise(LoadError)
-      YARD::Config.load_plugins.should == false
+    it "ignores gem loading if RubyGems cannot load" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      expect(YARD::Config).to receive(:require).with('rubygems').and_raise(LoadError)
+      expect(YARD::Config.load_plugins).to be false
     end
 
-    it "should load certain plugins automatically when specified in :autoload_plugins" do
-      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
-      YARD::Config.stub!(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
-      YARD::Config.should_receive(:require).with('yard-plugin').and_return(true)
-      YARD::Config.load_plugins.should == true
+    it "loads certain plugins automatically when specified in :autoload_plugins" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
+      expect(YARD::Config).to receive(:require).with('yard-plugin').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
     end
 
-    it "should parse --plugin from command line arguments" do
-      YARD::Config.should_receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
-      YARD::Config.should_receive(:load_plugin).with('foo').and_return(true)
-      YARD::Config.should_receive(:load_plugin).with('bar').and_return(true)
-      YARD::Config.load_plugins.should == true
+    it "parses --plugin from command line arguments" do
+      expect(YARD::Config).to receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
+      expect(YARD::Config).to receive(:load_plugin).with('foo').and_return(true)
+      expect(YARD::Config).to receive(:load_plugin).with('bar').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
     end
 
-    it "should load --plugin arguments from .yardopts" do
-      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return(true)
-      File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      File.should_receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return('--plugin foo')
-      YARD::Config.should_receive(:load_plugin).with('foo')
+    it "loads --plugin arguments from .yardopts" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return(true)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return('--plugin foo')
+      expect(YARD::Config).to receive(:load_plugin).with('foo')
       YARD::Config.load
     end
 
-    it "should load any gem plugins starting with 'yard_' or 'yard-'" do
-      File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
-      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
+    it "loads any gem plugins starting with 'yard_' or 'yard-'" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
       plugins = {
-        'yard' => mock('yard'),
-        'yard_plugin' => mock('yard_plugin'),
-        'yard-plugin' => mock('yard-plugin'),
-        'my-yard-plugin' => mock('yard-plugin'),
-        'rspec' => mock('rspec'),
+        'yard' => double('yard'),
+        'yard_plugin' => double('yard_plugin'),
+        'yard-plugin' => double('yard-plugin'),
+        'my-yard-plugin' => double('yard-plugin'),
+        'rspec' => double('rspec'),
       }
       plugins.each do |k, v|
-        v.should_receive(:name).at_least(1).times.and_return(k)
+        expect(v).to receive(:name).at_least(1).times.and_return(k)
       end
 
-      source_mock = mock(:source_index)
-      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
-      Gem.should_receive(:source_index).and_return(source_mock)
-      YARD::Config.should_receive(:load_plugin).with('yard_plugin').and_return(false)
-      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_return(true)
-      YARD::Config.load_plugins.should == true
+      source_mock = double(:source_index)
+      expect(source_mock).to receive(:find_name).with('').and_return(plugins.values)
+      expect(Gem).to receive(:source_index).and_return(source_mock)
+      expect(YARD::Config).to receive(:load_plugin).with('yard_plugin').and_return(false)
+      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
     end
 
-    it "should log an error if a gem raises an error" do
-      YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+    it "logs an error if a gem raises an error" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
       plugins = {
-        'yard-plugin' => mock('yard-plugin')
+        'yard-plugin' => double('yard-plugin')
       }
       plugins.each do |k, v|
-        v.should_receive(:name).at_least(1).times.and_return(k)
+        expect(v).to receive(:name).at_least(1).times.and_return(k)
       end
 
-      source_mock = mock(:source_index)
-      source_mock.should_receive(:find_name).with('').and_return(plugins.values)
-      Gem.should_receive(:source_index).and_return(source_mock)
-      YARD::Config.should_receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
-      log.should_receive(:warn).with(/Error loading plugin 'yard-plugin'/)
-      YARD::Config.load_plugins.should == false
+      source_mock = double(:source_index)
+      expect(source_mock).to receive(:find_name).with('').and_return(plugins.values)
+      expect(Gem).to receive(:source_index).and_return(source_mock)
+      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
+      expect(log).to receive(:warn).with(/Error loading plugin 'yard-plugin'/)
+      expect(YARD::Config.load_plugins).to be false
     end
   end
 end

data/spec/core_ext/array_spec.rb

@@ -1,13 +1,13 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Array do
-  describe '#place' do
-    it "should create an Insertion object" do
-      [].place('x').should be_kind_of(Insertion)
+  describe "#place" do
+    it "creates an Insertion object" do
+      expect([].place('x')).to be_kind_of(Insertion)
     end
 
-    it "should allow multiple objects to be placed" do
-      [1, 2].place('x', 'y', 'z').before(2).should == [1, 'x', 'y', 'z', 2]
+    it "allows multiple objects to be placed" do
+      expect([1, 2].place('x', 'y', 'z').before(2)).to eq [1, 'x', 'y', 'z', 2]
     end
   end
 end

data/spec/core_ext/file_spec.rb

@@ -2,66 +2,66 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe File do
   describe ".relative_path" do
-    it "should return the relative path between two files" do
-      File.relative_path('a/b/c/d.html', 'a/b/d/q.html').should == '../d/q.html'
+    it "returns the relative path between two files" do
+      expect(File.relative_path('a/b/c/d.html', 'a/b/d/q.html')).to eq '../d/q.html'
     end
 
-    it "should return the relative path between two directories" do
-      File.relative_path('a/b/c/d/', 'a/b/d/').should == '../d'
+    it "returns the relative path between two directories" do
+      expect(File.relative_path('a/b/c/d/', 'a/b/d/')).to eq '../d'
     end
 
-    it "should return only the to file if from file is in the same directory as the to file" do
-      File.relative_path('a/b/c/d', 'a/b/c/e').should == 'e'
+    it "returns only the to file if from file is in the same directory as the to file" do
+      expect(File.relative_path('a/b/c/d', 'a/b/c/e')).to eq 'e'
     end
 
-    it "should handle non-normalized paths" do
-      File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred').should == '../../Fred'
-      File.relative_path('A//B/C', 'Q/X').should == '../../Q/X'
+    it "handles non-normalized paths" do
+      expect(File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred')).to eq '../../Fred'
+      expect(File.relative_path('A//B/C', 'Q/X')).to eq '../../Q/X'
     end
   end
 
-  describe '.cleanpath' do
-    it "should clean double brackets" do
-      File.cleanpath('A//B/C').should == "A/B/C"
+  describe ".cleanpath" do
+    it "cleans double brackets" do
+      expect(File.cleanpath('A//B/C')).to eq "A/B/C"
     end
 
-    it "should clean a path with ." do
-      File.cleanpath('Hello/./I/.Am/Fred').should == "Hello/I/.Am/Fred"
+    it "cleans a path with ." do
+      expect(File.cleanpath('Hello/./I/.Am/Fred')).to eq "Hello/I/.Am/Fred"
     end
 
-    it "should clean a path with .." do
-      File.cleanpath('Hello/../World').should == "World"
+    it "cleans a path with .." do
+      expect(File.cleanpath('Hello/../World')).to eq "World"
     end
 
-    it "should clean a path with multiple .." do
-      File.cleanpath('A/B/C/../../D').should == "A/D"
+    it "cleans a path with multiple .." do
+      expect(File.cleanpath('A/B/C/../../D')).to eq "A/D"
     end
 
-    it "should clean a path ending in .." do
-      File.cleanpath('A/B/C/D/..').should == "A/B/C"
+    it "cleans a path ending in .." do
+      expect(File.cleanpath('A/B/C/D/..')).to eq "A/B/C"
     end
 
-    it "should pass the initial directory" do
-      File.cleanpath('C/../../D').should == "../D"
+    it "passes the initial directory" do
+      expect(File.cleanpath('C/../../D')).to eq "../D"
     end
 
-    it "should not remove multiple '../' at the beginning" do
-      File.cleanpath('../../A/B').should == '../../A/B'
+    it "does not remove multiple '../' at the beginning" do
+      expect(File.cleanpath('../../A/B')).to eq '../../A/B'
     end
   end
 
-  describe '.open!' do
-    it "should create the path before opening" do
-      File.should_receive(:directory?).with('/path/to').and_return(false)
-      FileUtils.should_receive(:mkdir_p).with('/path/to')
-      File.should_receive(:open).with('/path/to/file', 'w')
+  describe ".open!" do
+    it "creates the path before opening" do
+      expect(File).to receive(:directory?).with('/path/to').and_return(false)
+      expect(FileUtils).to receive(:mkdir_p).with('/path/to')
+      expect(File).to receive(:open).with('/path/to/file', 'w')
       File.open!('/path/to/file', 'w')
     end
 
-    it "should just open the file if the path exists" do
-      File.should_receive(:directory?).with('/path/to').and_return(true)
-      FileUtils.should_not_receive(:mkdir_p)
-      File.should_receive(:open).with('/path/to/file', 'w')
+    it "just opens the file if the path exists" do
+      expect(File).to receive(:directory?).with('/path/to').and_return(true)
+      expect(FileUtils).not_to receive(:mkdir_p)
+      expect(File).to receive(:open).with('/path/to/file', 'w')
       File.open!('/path/to/file', 'w')
     end
   end

data/spec/core_ext/hash_spec.rb

@@ -1,14 +1,14 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Hash do
-  describe '.[]' do
-    it "should accept an Array argument (Ruby 1.8.6 and older)" do
+  describe ".[]" do
+    it "accepts an Array argument (Ruby 1.8.6 and older)" do
       list = [['foo', 'bar'], ['foo2', 'bar2']]
-      Hash[list].should == {'foo' => 'bar', 'foo2' => 'bar2'}
+      expect(Hash[list]).to eq({'foo' => 'bar', 'foo2' => 'bar2'})
     end
 
-    it "should accept an array as a key" do
-      Hash[['a', 'b'], 1].should == {['a', 'b'] => 1}
+    it "accepts an array as a key" do
+      expect(Hash[['a', 'b'], 1]).to eq({['a', 'b'] => 1})
     end
   end
 end

data/spec/core_ext/insertion_spec.rb

@@ -1,37 +1,37 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Insertion do
-  describe '#before' do
-    it "should place an object before another" do
-      [1, 2].place(3).before(2).should == [1, 3, 2]
-      [1, 2].place(3).before(1).should == [3, 1, 2]
-      [1, [4], 2].place(3).before(2).should == [1, [4], 3, 2]
+  describe "#before" do
+    it "places an object before another" do
+      expect([1, 2].place(3).before(2)).to eq [1, 3, 2]
+      expect([1, 2].place(3).before(1)).to eq [3, 1, 2]
+      expect([1, [4], 2].place(3).before(2)).to eq [1, [4], 3, 2]
     end
   end
 
-  describe '#after' do
-    it "should place an object after another" do
-      [1, 2].place(3).after(2).should == [1, 2, 3]
+  describe "#after" do
+    it "places an object after another" do
+      expect([1, 2].place(3).after(2)).to eq [1, 2, 3]
     end
 
-    it "should no longer place an object after another and its subsections (0.6)" do
-      [1, [2]].place(3).after(1).should == [1, 3, [2]]
+    it "no longer places an object after another and its subsections (0.6)" do
+      expect([1, [2]].place(3).after(1)).to eq [1, 3, [2]]
     end
 
-    it "should place an array after an object" do
-      [1, 2, 3].place([4]).after(1).should == [1, [4], 2, 3]
+    it "places an array after an object" do
+      expect([1, 2, 3].place([4]).after(1)).to eq [1, [4], 2, 3]
     end
   end
 
-  describe '#before_any' do
-    it "should place an object before another anywhere inside list (including sublists)" do
-      [1, 2, [3]].place(4).before_any(3).should == [1, 2, [4, 3]]
+  describe "#before_any" do
+    it "places an object before another anywhere inside list (including sublists)" do
+      expect([1, 2, [3]].place(4).before_any(3)).to eq [1, 2, [4, 3]]
     end
   end
 
-  describe '#after_any' do
-    it "should place an object after another anywhere inside list (including sublists)" do
-      [1, 2, [3]].place(4).after_any(3).should == [1, 2, [3, 4]]
+  describe "#after_any" do
+    it "places an object after another anywhere inside list (including sublists)" do
+      expect([1, 2, [3]].place(4).after_any(3)).to eq [1, 2, [3, 4]]
     end
   end
 end