fudge 0.5.0 → 0.6.0

data/spec/lib/fudge/exceptions_spec.rb

@@ -2,20 +2,27 @@ require 'spec_helper'
 
 module Fudge::Exceptions
   describe Base do
-    it { should be_a StandardError }
+    it { is_expected.to be_a StandardError }
   end
 
   describe BuildFailed do
-    it { should be_a Base }
-    its(:message) { should be_a String }
+    it { is_expected.to be_a Base }
+
+    describe '#message' do
+      subject { super().message }
+      it { is_expected.to be_a String }
+    end
   end
 
   describe TaskNotFound do
     subject { described_class.new :foo }
 
-    it { should be_a Base }
+    it { is_expected.to be_a Base }
 
-    its(:message) { should be_a String }
+    describe '#message' do
+      subject { super().message }
+      it { is_expected.to be_a String }
+    end
 
     it "should take a task name as a parameter" do
       expect { described_class.new }.to raise_error ArgumentError
@@ -25,9 +32,12 @@ module Fudge::Exceptions
   describe TaskGroupNotFound do
     subject { described_class.new :foo }
 
-    it { should be_a Base }
+    it { is_expected.to be_a Base }
 
-    its(:message) { should be_a String }
+    describe '#message' do
+      subject { super().message }
+      it { is_expected.to be_a String }
+    end
 
     it "should take a task group name as a parameter" do
       expect { described_class.new }.to raise_error ArgumentError

data/spec/lib/fudge/formatters/simple_spec.rb

@@ -5,49 +5,49 @@ describe Fudge::Formatters::Simple do
 
   subject { described_class.new(stdout) }
 
-  describe :error do
+  describe "#error" do
     it "returns message in RED" do
       string = subject.error "a message"
-      string.should == "\e[31ma message\e[0m"
+      expect(string).to eq("\e[31ma message\e[0m")
     end
   end
 
-  describe :success do
+  describe "#success" do
     it "returns message in BRIGHT GREEN" do
       string = subject.success "a message"
-      string.should == "\e[1m\e[32ma message\e[0m"
+      expect(string).to eq("\e[1m\e[32ma message\e[0m")
     end
   end
 
-  describe :info do
+  describe "#info" do
     it "returns message in CYAN" do
       string = subject.info "a message"
-      string.should == "\e[36ma message\e[0m"
+      expect(string).to eq("\e[36ma message\e[0m")
     end
   end
 
-  describe :notice do
+  describe "#notice" do
     it "returns message in YELLOW" do
       string = subject.notice "a message"
-      string.should == "\e[33ma message\e[0m"
+      expect(string).to eq("\e[33ma message\e[0m")
     end
   end
 
-  describe :normal do
+  describe "#normal" do
     it "returns unchanged message" do
       string = subject.normal "a message"
-      string.should == "a message"
+      expect(string).to eq("a message")
     end
   end
 
-  describe :puts do
+  describe "#puts" do
     it "outputs message on stdout" do
       subject.puts "a message"
-      stdout.string.should == "a message" + "\n"
+      expect(stdout.string).to eq("a message" + "\n")
     end
   end
 
-  describe :write do
+  describe "#write" do
     it "supports chaining types to stdout" do
       subject.write do |w|
         w.normal('normal').
@@ -57,11 +57,11 @@ describe Fudge::Formatters::Simple do
           error('error')
       end
 
-      stdout.string.should == 'normal' + ' ' +
+      expect(stdout.string).to eq('normal' + ' ' +
                               "\e[33mnotice\e[0m" + ' ' +
                               "\e[36minfo\e[0m" + ' ' +
                               "\e[1m\e[32msuccess\e[0m" + ' ' +
-                              "\e[31merror\e[0m" + "\n"
+                              "\e[31merror\e[0m" + "\n")
 
     end
   end

data/spec/lib/fudge/output_checker_spec.rb

@@ -10,7 +10,7 @@ describe Fudge::OutputChecker do
     context "when the output does not match the check" do
        it 'send a mismatch message to the output io' do
           subject.check('bar')
-          output_io.string.should include "Output didn't match (?-mix:foo)."
+          expect(output_io.string).to include "Output didn't match (?-mix:foo)."
        end
     end
 
@@ -25,7 +25,7 @@ describe Fudge::OutputChecker do
       it 'sends error mesage to the output io' do
         subject.check('foo')
 
-        output_io.string.should include "Output matched (?-mix:foo) but condition failed."
+        expect(output_io.string).to include "Output matched (?-mix:foo) but condition failed."
       end
     end
   end

data/spec/lib/fudge/parser_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Fudge::Parser do
   use_tmp_dir
 
-  describe :parse do
+  describe '#parse' do
     before :each do
       @path = 'FudgeFile'
 
@@ -13,11 +13,11 @@ describe Fudge::Parser do
     end
 
     it "should read a file and evaluate it" do
-      subject.parse(@path).should be_a Fudge::Description
+      expect(subject.parse(@path)).to be_a Fudge::Description
     end
 
     it "should pass the contents to the new description" do
-      subject.parse(@path).instance_variable_get(:@foo).should == :bar
+      expect(subject.parse(@path).instance_variable_get(:@foo)).to eq(:bar)
     end
   end
 end

data/spec/lib/fudge/runner_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Fudge::Runner do
   let(:input) do
     StringIO.new('build :default do; task :dummy; end').tap do |s|
-      s.stub(:path).and_return('')
+      allow(s).to receive(:path).and_return('')
     end
   end
   let(:description) { Fudge::Description.new(input) }
   subject { described_class.new(description) }
 
-  describe :run_build do
+  describe '#run_build' do
     it "should run the default task in the description" do
       subject.run_build
 
-      DummyTask.ran.should be_true
+      expect(DummyTask.ran).to be_truthy
     end
 
     it "should raise an exception if the build fails" do
-      Fudge::Build.any_instance.stub(:run).and_return(false)
+      allow_any_instance_of(Fudge::Build).to receive(:run).and_return(false)
 
       expect { subject.run_build }.to raise_error Fudge::Exceptions::BuildFailed
     end
@@ -31,14 +31,14 @@ describe Fudge::Runner do
       end
 
       it "puts all output to given formatter instead stdout" do
-        stdout.string.should_not be_empty
-        stdout.string.should include "Running build"
-        stdout.string.should include "default"
-        stdout.string.should include "Build SUCCEEDED!"
+        expect(stdout.string).not_to be_empty
+        expect(stdout.string).to include "Running build"
+        expect(stdout.string).to include "default"
+        expect(stdout.string).to include "Build SUCCEEDED!"
       end
 
       it "runs the task passing the formatter down" do
-        DummyTask.run_options.should == {:formatter => formatter}
+        expect(DummyTask.run_options).to eq({:formatter => formatter})
       end
     end
   end

data/spec/lib/fudge/tasks/brakeman_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Fudge::Tasks::Brakeman do
-  it { should be_registered_as :brakeman }
+  it { is_expected.to be_registered_as :brakeman }
 
   it_should_behave_like 'bundle aware'
 
@@ -40,21 +40,21 @@ Model Warnings:
 EOF
   end
 
-  describe :run do
+  describe '#run' do
     it 'runs brakeman on the codebase' do
-      subject.should run_command 'brakeman '
+      expect(subject).to run_command 'brakeman '
     end
 
-    it { should_not succeed_with_output output_bad }
-    it { should succeed_with_output output_good }
+    it { is_expected.not_to succeed_with_output output_bad }
+    it { is_expected.to succeed_with_output output_good }
 
     context 'when :max score is supplied' do
       it 'fails when score is higher than max' do
         task = described_class.new :max => 0
-        task.should_not succeed_with_output output_bad
+        expect(task).not_to succeed_with_output output_bad
 
         task = described_class.new :max => 1
-        task.should succeed_with_output output_bad
+        expect(task).to succeed_with_output output_bad
       end
     end
   end

data/spec/lib/fudge/tasks/bundler_spec.rb

@@ -22,9 +22,9 @@ class TestNonBundlerAwareTask
 end
 
 describe Fudge::Tasks::CleanBundlerEnv do
-  it { should be_registered_as :clean_bundler_env }
+  it { is_expected.to be_registered_as :clean_bundler_env }
 
-  describe :run do
+  describe '#run' do
     let(:bundle_aware_task) { TestBundlerAwareTask.new }
     let(:non_bundle_aware_task) { TestNonBundlerAwareTask.new }
 
@@ -33,14 +33,14 @@ describe Fudge::Tasks::CleanBundlerEnv do
         subject.tasks << bundle_aware_task
         subject.tasks << non_bundle_aware_task
 
-        subject.run.should be_true
+        expect(subject.run).to be_truthy
       end
 
       it "runs each task with a clean bundle env" do
-        Bundler.should_receive(:with_clean_env).and_call_original
+        expect(Bundler).to receive(:with_clean_env).and_call_original
 
         subject.tasks << bundle_aware_task
-        subject.run.should be_true
+        expect(subject.run).to be_truthy
       end
     end
   end

data/spec/lib/fudge/tasks/cane_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
 describe Fudge::Tasks::Cane do
-  it { should be_registered_as :cane }
+  it { is_expected.to be_registered_as :cane }
 
   it_should_behave_like 'bundle aware'
 
-  describe :run do
+  describe '#run' do
     it "runs cane on the codebase" do
-      subject.should run_command "cane"
+      expect(subject).to run_command "cane"
     end
 
     context 'with :doc => false' do
       subject {described_class.new :doc => false }
 
       it "runs with --no-doc" do
-        subject.should run_command "cane --no-doc"
+        expect(subject).to run_command "cane --no-doc"
       end
     end
 
@@ -22,7 +22,7 @@ describe Fudge::Tasks::Cane do
       subject {described_class.new :style => false }
 
       it "runs with --no-style" do
-        subject.should run_command "cane --no-style"
+        expect(subject).to run_command "cane --no-style"
       end
     end
 
@@ -30,11 +30,11 @@ describe Fudge::Tasks::Cane do
       subject {described_class.new :max_width => 100 }
 
       it "runs with --style-measure 100" do
-        subject.should run_command "cane --style-measure 100"
+        expect(subject).to run_command "cane --style-measure 100"
       end
     end
 
-    it { should_not succeed_with_output 'any output from cane is bad' }
-    it { should succeed_with_output '' }
+    it { is_expected.not_to succeed_with_output 'any output from cane is bad' }
+    it { is_expected.to succeed_with_output '' }
   end
 end

data/spec/lib/fudge/tasks/composite_task_spec.rb

@@ -10,29 +10,30 @@ Fudge::Tasks.register(DummyTask2)
 describe Fudge::Tasks::CompositeTask do
   subject { described_class.new do; end }
 
-  describe :run do
+  describe '#run' do
     before :each do
       subject.tasks << DummyTask.new
       subject.tasks << DummyTask2.new
+
+      @task_two_run = false
+      allow_any_instance_of(DummyTask2).to receive(:run) { |*_| @task_two_run = true }
     end
 
     it "should run all tasks defined and return true if they all succeed" do
-      DummyTask.any_instance.should_receive(:run).and_return(true)
-      DummyTask2.any_instance.should_receive(:run).and_return(true)
-
-      subject.run.should be_true
+      expect_any_instance_of(DummyTask).to receive(:run).and_return(true)
+      expect(subject.run).to be_truthy
+      expect(@task_two_run).to be_truthy
     end
 
     it "should return false if any of the tasks fail" do
-      DummyTask.any_instance.should_receive(:run).and_return(false)
-      DummyTask2.any_instance.should_not_receive(:run)
-
-      subject.run.should be_false
+      expect_any_instance_of(DummyTask).to receive(:run).and_return(false)
+      expect(subject.run).to be_falsey
+      expect(@task_two_run).to be_falsey
     end
   end
 
   describe "Using TaskDSL" do
-    describe :task do
+    describe '#task' do
       class AnotherCompositeTask < Fudge::Tasks::CompositeTask
         include Fudge::TaskDSL
 
@@ -49,11 +50,11 @@ describe Fudge::Tasks::CompositeTask do
       subject { AnotherCompositeTask.new }
 
       it "should define a task for each new instance of the composite task" do
-        subject.should run_command 'foo bar'
+        expect(subject).to run_command 'foo bar'
       end
 
       it "should support defining composite tasks" do
-        subject.tasks[1].tasks.first.should be_a DummyTask
+        expect(subject.tasks[1].tasks.first).to be_a DummyTask
       end
 
       context "when provided an output" do
@@ -61,14 +62,14 @@ describe Fudge::Tasks::CompositeTask do
         let(:formatter) { Fudge::Formatters::Simple.new(output) }
 
         before :each do
-          Fudge::Tasks::Shell.any_instance.stub(:run)
+          allow_any_instance_of(Fudge::Tasks::Shell).to receive(:run)
         end
 
         it "prints messages to the output instead of stdout" do
           subject.run :formatter => formatter
 
-          output.string.should_not be_empty
-          output.string.should match /Running task.*shell.*foo, bar/
+          expect(output.string).not_to be_empty
+          expect(output.string).to match /Running task.*shell.*foo, bar/
         end
       end
     end

data/spec/lib/fudge/tasks/each_directory_spec.rb

@@ -14,15 +14,15 @@ Fudge::Tasks.register(TestEachDirectoryTask)
 
 describe Fudge::Tasks::EachDirectory do
   subject { described_class.new 'spec/*' }
-  it { should be_registered_as :each_directory }
+  it { is_expected.to be_registered_as :each_directory }
 
-  describe :initialize do
+  describe '#initialize' do
     it "should take a directory pattern as first argument" do
       expect { described_class.new }.to raise_error ArgumentError
     end
   end
 
-  describe :run do
+  describe '#run' do
     let(:task) { TestEachDirectoryTask.new }
     let(:dirs) do
       files = Dir[File.expand_path('../../../../*', __FILE__)]
@@ -36,36 +36,36 @@ describe Fudge::Tasks::EachDirectory do
     it "should change to the given directories and run child tasks" do
       subject.run
 
-      task.pwds.should == dirs
+      expect(task.pwds).to eq(dirs)
     end
 
     it "should allow explicit specification of directories through an array" do
       ed2 = described_class.new ["spec/lib","spec/support"]
       ed2.tasks << task
       ed2.run
-      task.pwds.should == dirs.sort
+      expect(task.pwds).to eq(dirs.sort)
     end
 
     it "should respect the order of the directories as specified" do
       ed2 = described_class.new ["spec/support","spec/lib"]
       ed2.tasks << task
       ed2.run
-      task.pwds.should_not == dirs.sort
-      task.pwds.sort.should == dirs.sort
+      expect(task.pwds).not_to eq(dirs.sort)
+      expect(task.pwds.sort).to eq(dirs.sort)
     end
 
     it "should load fudge_settings.yml in the right directory" do
       ed2 = described_class.new ['spec/lib']
       ed2.tasks << Fudge::Tasks::Shell.new('pwd')
       ed2.run
-      ed2.tasks.first.options[:test].should == 'coverage'
+      expect(ed2.tasks.first.options[:test]).to eq('coverage')
     end
 
     it "should not load fudge_settings.yml in the wrong directory" do
       ed2 = described_class.new ['spec/support']
       ed2.tasks << Fudge::Tasks::Shell.new('pwd')
       ed2.run
-      ed2.tasks.first.options.size.should == 0
+      expect(ed2.tasks.first.options.size).to eq(0)
     end
   end
 end