cape 1.7.0 → 1.8.0

data/spec/cape/hash_list_spec.rb

@@ -2,49 +2,69 @@ require 'spec_helper'
 require 'cape/hash_list'
 
 describe Cape::HashList do
+  subject(:hash_list) { hash_list_class.new }
+
+  let(:hash_list_class) { described_class }
+
   describe 'that is empty' do
-    it { should be_empty }
+    specify { expect(hash_list).to be_empty }
 
-    its(:inspect) { should == '{}' }
+    describe '#inspect' do
+      specify { expect(hash_list.inspect).to eq('{}') }
+    end
 
-    its(:to_a) { should == [] }
+    describe '#to_a' do
+      specify { expect(hash_list.to_a).to eq([]) }
+    end
 
-    its(:to_hash) { should == {} }
+    describe '#to_hash' do
+      specify { expect(hash_list.to_hash).to eq({}) }
+    end
 
     describe 'when values are added out of order' do
       before :each do
-        subject['foo'] = 'xxx'
-        subject['foo'] = 'bar'
-        subject['baz'] = 'qux'
+        hash_list['foo'] = 'xxx'
+        hash_list['foo'] = 'bar'
+        hash_list['baz'] = 'qux'
       end
 
-      it { should == {'foo' => 'bar', 'baz' => 'qux'} }
+      specify { expect(hash_list).to eq({'foo' => 'bar', 'baz' => 'qux'}) }
 
-      its(:inspect) { should == '{"foo"=>"bar", "baz"=>"qux"}' }
+      describe '#inspect' do
+        specify {
+          expect(hash_list.inspect).to eq('{"foo"=>"bar", "baz"=>"qux"}')
+        }
+      end
 
-      its(:to_a) { should == [%w(foo bar), %w(baz qux)] }
+      describe '#to_a' do
+        specify { expect(hash_list.to_a).to eq([%w(foo bar), %w(baz qux)]) }
+      end
 
-      its(:to_hash) { should == {'foo' => 'bar', 'baz' => 'qux'} }
+      describe '#to_hash' do
+        specify {
+          expect(hash_list.to_hash).to eq({'foo' => 'bar', 'baz' => 'qux'})
+        }
+      end
     end
   end
 
   describe 'that has values out of order' do
-    subject { described_class.new 'foo' => 'bar', 'baz' => 'qux' }
+    subject(:hash_list) { hash_list_class.new 'foo' => 'bar', 'baz' => 'qux' }
 
-    it { should == {'foo' => 'bar', 'baz' => 'qux'} }
+    specify { expect(hash_list).to eq({'foo' => 'bar', 'baz' => 'qux'}) }
 
-    it 'should index the values as expected' do
-      subject['foo'].should == 'bar'
-      subject['baz'].should == 'qux'
-      subject['not-found'].should be_nil
+    it 'indexes the values as expected' do
+      expect(hash_list['foo']).to eq('bar')
+      expect(hash_list['baz']).to eq('qux')
+      expect(hash_list['not-found']).to be_nil
     end
 
-    describe 'when sent #clear' do
+    describe '#clear' do
       before :each do
-        subject.clear
+        hash_list.clear
       end
 
-      it { should be_empty }
+      specify { expect(hash_list).to be_empty }
     end
   end
 end

data/spec/cape/rake_spec.rb

@@ -2,52 +2,60 @@ require 'spec_helper'
 require 'cape/rake'
 
 describe Cape::Rake do
+  subject(:rake) { rake_class.new }
+
+  let(:rake_class) { described_class }
+
   describe '::DEFAULT_EXECUTABLE' do
-    subject { described_class::DEFAULT_EXECUTABLE }
+    subject(:constant) { rake_class::DEFAULT_EXECUTABLE }
 
-    it { should be_frozen }
+    specify { expect(constant).to be_frozen }
   end
 
-  describe '-- when sent #== --' do
-    it('should recognize equivalent instances to be equal') {
-      described_class.new.should == described_class.new
+  describe '#==' do
+    it('recognizes equivalent instances to be equal') {
+      expect(rake_class.new).to eq(rake_class.new)
     }
 
-    it('should compare using #local_executable') {
-      described_class.new.should_not == described_class.new(:local_executable => 'foo')
+    it('compares using #local_executable') {
+      expect(rake_class.new).not_to eq(rake_class.new(:local_executable => 'foo'))
     }
 
-    it('should compare using #remote_executable') {
-      described_class.new.should_not == described_class.new(:remote_executable => 'foo')
+    it('compares using #remote_executable') {
+      expect(rake_class.new).not_to eq(rake_class.new(:remote_executable => 'foo'))
     }
   end
 
   describe '-- without specified attributes --' do
-    its(:local_executable) { should == described_class::DEFAULT_EXECUTABLE }
+    describe '#local_executable' do
+      specify { expect(rake.local_executable).to eq(rake_class::DEFAULT_EXECUTABLE) }
+    end
 
-    its(:remote_executable) { should == described_class::DEFAULT_EXECUTABLE }
+    describe '#remote_executable' do
+      specify { expect(rake.remote_executable).to eq(rake_class::DEFAULT_EXECUTABLE) }
+    end
   end
 
   describe '-- with specified attributes --' do
-    subject {
-      described_class.new :local_executable => ('the specified value of ' +
-                                                '#local_executable'),
-                          :remote_executable => ('the specified value of ' +
-                                                 '#remote_executable')
+    subject(:rake) {
+      rake_class.new :local_executable => ('the specified value of ' +
+                                           '#local_executable'),
+                     :remote_executable => ('the specified value of ' +
+                                            '#remote_executable')
     }
 
-    its(:local_executable) {
-      should == 'the specified value of #local_executable'
-    }
+    describe '#local_executable' do
+      specify { expect(rake.local_executable).to eq('the specified value of #local_executable') }
+    end
 
-    its(:remote_executable) {
-      should == 'the specified value of #remote_executable'
-    }
+    describe '#remote_executable' do
+      specify { expect(rake.remote_executable).to eq('the specified value of #remote_executable') }
+    end
   end
 
   describe '-- with respect to caching --' do
     before :each do
-      subject.stub!(:fetch_output).and_return output
+      allow(rake).to receive(:fetch_output).and_return(output)
     end
 
     let(:output) {
@@ -58,63 +66,63 @@ rake baz # baz
       end_output
     }
 
-    describe 'when sent #each_task,' do
-      it 'should build and use a cache' do
-        subject.should_receive(:fetch_output).once.and_return output
-        subject.each_task do |t|
+    describe '#each_task' do
+      it 'builds and uses a cache' do
+        expect(rake).to receive(:fetch_output).once.and_return(output)
+        rake.each_task do |t|
         end
-        subject.each_task do |t|
+        rake.each_task do |t|
         end
       end
 
-      it 'should not expire the cache' do
-        subject.should_not_receive :expire_cache!
-        subject.each_task do |t|
+      it 'does not expire the cache' do
+        expect(rake).not_to receive(:expire_cache!)
+        rake.each_task do |t|
         end
       end
 
-      it 'should expire the cache in the event of an error' do
-        subject.should_receive(:expire_cache!).once
+      it 'expires the cache in the event of an error' do
+        expect(rake).to receive(:expire_cache!).once
         begin
-          subject.each_task do |t|
+          rake.each_task do |t|
             raise 'pow!'
           end
         rescue
         end
       end
 
-      it 'should not swallow errors' do
-        lambda {
-          subject.each_task do |t|
+      it 'does not swallow errors' do
+        expect {
+          rake.each_task do |t|
             raise ZeroDivisionError, 'pow!'
           end
-        }.should raise_error(ZeroDivisionError, 'pow!')
+        }.to raise_error(ZeroDivisionError, 'pow!')
       end
     end
 
-    describe 'when sent #expire_cache!,' do
-      it 'should expire the cache' do
-        subject.should_receive(:fetch_output).twice.and_return output
-        subject.each_task do |t|
+    describe '#expire_cache!' do
+      it 'expires the cache' do
+        expect(rake).to receive(:fetch_output).twice.and_return(output)
+        rake.each_task do |t|
         end
-        subject.expire_cache!
-        subject.each_task do |t|
+        rake.expire_cache!
+        rake.each_task do |t|
         end
       end
     end
 
-    describe 'when sent #local_executable=' do
+    describe '#local_executable=' do
       describe 'with the same value,' do
-        it 'should not expire the cache' do
-          subject.should_not_receive :expire_cache!
-          subject.local_executable = subject.local_executable
+        it 'does not expire the cache' do
+          expect(rake).not_to receive(:expire_cache!)
+          rake.local_executable = rake.local_executable
         end
       end
 
       describe 'with a different value,' do
-        it 'should expire the cache' do
-          subject.should_receive(:expire_cache!).once
-          subject.local_executable = subject.local_executable + ' foo'
+        it 'expires the cache' do
+          expect(rake).to receive(:expire_cache!).once
+          rake.local_executable = rake.local_executable + ' foo'
         end
       end
     end

data/spec/cape/recipe_definition_spec.rb

@@ -1,53 +1,65 @@
 require 'cape/recipe_definition'
 
 describe Cape::RecipeDefinition do
-  its(:cd) { should be_nil }
+  subject(:recipe_definition) { recipe_definition_class.new }
 
-  it 'should have a mutable #cd' do
-    subject.cd '/foo/bar'
-    subject.cd.should == '/foo/bar'
+  let(:recipe_definition_class) { described_class }
 
-    subject.cd lambda { '/foo/bar' }
-    subject.cd.call.should == '/foo/bar'
+  describe '#cd' do
+    specify { expect(recipe_definition.cd).to be_nil }
 
-    subject.cd { '/foo/bar' }
-    subject.cd.call.should == '/foo/bar'
-  end
+    it 'is mutable' do
+      recipe_definition.cd '/foo/bar'
+      expect(recipe_definition.cd).to eq('/foo/bar')
 
-  it 'should complain about a #cd with the wrong arity' do
-    expect {
-      subject.cd do |foo, bar|
-      end
-    }.to raise_error(ArgumentError, 'Must have 0 parameters but has 2')
-  end
+      recipe_definition.cd lambda { '/foo/bar' }
+      expect(recipe_definition.cd.call).to eq('/foo/bar')
 
-  its(:env) { should == {} }
+      recipe_definition.cd { '/foo/bar' }
+      expect(recipe_definition.cd.call).to eq('/foo/bar')
+    end
 
-  it 'should have a mutable #env' do
-    subject.env['FOO'] = 'bar'
-    subject.env.should == {'FOO' => 'bar'}
+    it 'complains about wrong arity' do
+      expect {
+        recipe_definition.cd do |foo, bar|
+        end
+      }.to raise_error(ArgumentError, 'Must have 0 parameters but has 2')
+    end
   end
 
-  its(:options) { should == {} }
+  describe '#env' do
+    specify { expect(recipe_definition.env).to eq({}) }
 
-  it 'should have mutable #options' do
-    subject.options[:some_option] = 'foo'
-    subject.options.should == {:some_option => 'foo'}
+    it 'is mutable' do
+      recipe_definition.env['FOO'] = 'bar'
+      expect(recipe_definition.env).to eq('FOO' => 'bar')
+    end
   end
 
-  its(:rename) { should be_nil }
+  describe '#options' do
+    specify { expect(recipe_definition.options).to eq({}) }
 
-  it 'should have a mutable #rename' do
-    subject.rename do |task_name|
-      "#{task_name}_recipe"
+    it 'is mutable' do
+      recipe_definition.options[:some_option] = 'foo'
+      expect(recipe_definition.options).to eq(:some_option => 'foo')
     end
-    subject.rename.call(:foo).should == 'foo_recipe'
   end
 
-  it 'should complain about a #rename with the wrong arity' do
-    expect {
-      subject.rename do |foo, bar|
+  describe '#rename' do
+    specify { expect(recipe_definition.rename).to be_nil }
+
+    it 'is mutable' do
+      recipe_definition.rename do |task_name|
+        "#{task_name}_recipe"
       end
-    }.to raise_error(ArgumentError, 'Must have 1 parameter but has 2')
+      expect(recipe_definition.rename.call(:foo)).to eq('foo_recipe')
+    end
+
+    it 'complains about wrong arity' do
+      expect {
+        recipe_definition.rename do |foo, bar|
+        end
+      }.to raise_error(ArgumentError, 'Must have 1 parameter but has 2')
+    end
   end
 end

data/spec/cape/util_spec.rb

@@ -3,43 +3,43 @@ require 'cape/util'
 
 describe Cape::Util do
   describe '.pluralize' do
-    it "should pluralize 'foo' as expected" do
-      Cape::Util.pluralize('foo').should == 'foos'
+    it "transforms 'foo' as expected" do
+      expect(Cape::Util.pluralize('foo')).to eq('foos')
     end
 
-    it "should pluralize 'foo' as expected for a count of 2" do
-      Cape::Util.pluralize('foo', 2).should == 'foos'
+    it "transforms 'foo' as expected for a count of 2" do
+      expect(Cape::Util.pluralize('foo', 2)).to eq('foos')
     end
 
-    it "should not pluralize 'foo' for a count of 1" do
-      Cape::Util.pluralize('foo', 1).should == 'foo'
+    it "does not transform 'foo' for a count of 1" do
+      expect(Cape::Util.pluralize('foo', 1)).to eq('foo')
     end
 
-    it "should pluralize 'foo' as expected for a count of 0" do
-      Cape::Util.pluralize('foo', 0).should == 'foos'
+    it "transforms 'foo' as expected for a count of 0" do
+      expect(Cape::Util.pluralize('foo', 0)).to eq('foos')
     end
 
-    it "should pluralize 'foo' as expected for a count of -1" do
-      Cape::Util.pluralize('foo', -1).should == 'foos'
+    it "transforms 'foo' as expected for a count of -1" do
+      expect(Cape::Util.pluralize('foo', -1)).to eq('foos')
     end
   end
 
   describe '.to_list_phrase' do
-    it 'should make the expected list phrase of an empty array' do
-      Cape::Util.to_list_phrase([]).should == ''
+    it 'makes the expected phrase of an empty array' do
+      expect(Cape::Util.to_list_phrase([])).to eq('')
     end
 
-    it 'should make the expected list phrase of a 1-element array' do
-      Cape::Util.to_list_phrase(%w(foo)).should == 'foo'
+    it 'makes the expected phrase of a 1-element array' do
+      expect(Cape::Util.to_list_phrase(%w(foo))).to eq('foo')
     end
 
-    it 'should make the expected list phrase of a 2-element array' do
-      Cape::Util.to_list_phrase(%w(foo bar)).should == 'foo and bar'
+    it 'makes the expected phrase of a 2-element array' do
+      expect(Cape::Util.to_list_phrase(%w(foo bar))).to eq('foo and bar')
     end
 
-    it 'should make the expected list phrase of a 3-element array' do
+    it 'makes the expected phrase of a 3-element array' do
       array = %w(foo bar baz)
-      Cape::Util.to_list_phrase(array).should == 'foo, bar, and baz'
+      expect(Cape::Util.to_list_phrase(array)).to eq('foo, bar, and baz')
     end
   end
 end 

data/spec/cape/version_spec.rb

@@ -2,5 +2,5 @@ require 'spec_helper'
 require 'cape/version'
 
 describe 'Cape::VERSION' do
-  specify { Cape::VERSION.should =~ /^\d+\.\d+\.\d+/ }
+  specify { expect(Cape::VERSION).to match(/^\d+\.\d+\.\d+/) }
 end

data/spec/cape/xterm_spec.rb

@@ -2,71 +2,71 @@ require 'spec_helper'
 require 'cape/xterm'
 
 describe Cape::XTerm do
+  let(:xterm_module) { described_class }
+
   describe '.format' do
-    it 'should not try to format a nil argument' do
-      described_class.format(nil).should be_nil
+    it 'does not try to format a nil argument' do
+      expect(xterm_module.format(nil)).to be_nil
     end
 
-    it 'should not try to format a nil argument with a recognized format' do
-      described_class.format(nil, :bold).should be_nil
+    it 'does not try to format a nil argument with a recognized format' do
+      expect(xterm_module.format(nil, :bold)).to be_nil
     end
 
-    it 'should complain about an unrecognized format' do
+    specify do
       expect {
-        described_class.format nil, :this_does_not_exist
+        xterm_module.format nil, :this_does_not_exist
       }.to raise_error(ArgumentError, 'Unrecognized format :this_does_not_exist')
+    end
+
+    specify do
       expect {
-        described_class.format 'foo', :this_does_not_exist
+        xterm_module.format 'foo', :this_does_not_exist
       }.to raise_error(ArgumentError, 'Unrecognized format :this_does_not_exist')
     end
 
     described_class::FORMATS.each do |format, code|
-      it "should format a String argument with the #{format.inspect} format" do
-        described_class.format('foo', format).should == "\e[#{code}mfoo\e[0m"
+      it "formats a String argument with the #{format.inspect} format" do
+        expect(xterm_module.format('foo',
+                                   format)).to eq("\e[#{code}mfoo\e[0m")
       end
     end
 
-    it "should format a String argument with the :bold and :foreground_red formats" do
-      described_class.format('foo',
-                             :bold,
-                             :foreground_red).should == "\e[1;31mfoo\e[0m"
+    it "formats a String argument with the :bold and :foreground_red formats" do
+      expect(xterm_module.format('foo',
+                                 :bold,
+                                 :foreground_red)).to eq("\e[1;31mfoo\e[0m")
     end
   end
 
-  it 'should not respond to :this_does_not_exist' do
-    described_class.should_not respond_to(:this_does_not_exist)
-  end
+  specify { expect(xterm_module).not_to respond_to(:this_does_not_exist) }
 
-  it '.this_does_not_exist should complain' do
+  specify do
     expect {
-      described_class.this_does_not_exist
+      xterm_module.this_does_not_exist
     }.to raise_error(NoMethodError,
-                     "undefined method `this_does_not_exist' for #{described_class.name}:Module")
+                     "undefined method `this_does_not_exist' for #{xterm_module.name}:Module")
   end
 
   described_class::FORMATS.each do |format, code|
-    it "should respond to .#{format.inspect}" do
-      described_class.should respond_to(format)
-    end
+    specify { expect(xterm_module).to respond_to(format) }
 
     describe ".#{format}" do
-      it "should format a String argument with the #{format.inspect} format" do
-        described_class.send(format,
-                             'foo').should == described_class.format('foo',
-                                                                     format)
+      it "formats a String argument with the #{format.inspect} format" do
+        expect(xterm_module.send(format,
+                                 'foo')).to eq(xterm_module.format('foo',
+                                                                   format))
       end
     end
   end
 
-  it 'should respond to .bold_and_foreground_red' do
-    described_class.should respond_to(:bold_and_foreground_red)
-  end
+  specify { expect(xterm_module).to respond_to(:bold_and_foreground_red) }
 
   describe '.bold_and_foreground_red' do
-    it "should format a String argument with the :bold and :foreground_red formats" do
-      described_class.bold_and_foreground_red('foo').should == described_class.format('foo',
-                                                                                      :bold,
-                                                                                      :foreground_red)
+    it "formats a String argument with the :bold and :foreground_red formats" do
+      expect(xterm_module.bold_and_foreground_red('foo')).to eq(xterm_module.format('foo',
+                                                                                    :bold,
+                                                                                    :foreground_red))
     end
   end
 end