thor 0.16.0 → 0.17.0

data/spec/actions/inject_into_file_spec.rb

@@ -16,11 +16,11 @@ describe Thor::Actions::InjectIntoFile do
   end
 
   def invoke!(*args, &block)
-    capture(:stdout){ invoker.insert_into_file(*args, &block) }
+    capture(:stdout) { invoker.insert_into_file(*args, &block) }
   end
 
   def revoke!(*args, &block)
-    capture(:stdout){ revoker.insert_into_file(*args, &block) }
+    capture(:stdout) { revoker.insert_into_file(*args, &block) }
   end
 
   def file
@@ -30,12 +30,12 @@ describe Thor::Actions::InjectIntoFile do
   describe "#invoke!" do
     it "changes the file adding content after the flag" do
       invoke! "doc/README", "\nmore content", :after => "__start__"
-      File.read(file).should == "__start__\nmore content\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nmore content\nREADME\n__end__\n")
     end
 
     it "changes the file adding content before the flag" do
       invoke! "doc/README", "more content\n", :before => "__end__"
-      File.read(file).should == "__start__\nREADME\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
     end
 
     it "accepts data as a block" do
@@ -43,17 +43,17 @@ describe Thor::Actions::InjectIntoFile do
         "more content\n"
       end
 
-      File.read(file).should == "__start__\nREADME\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
     end
 
     it "logs status" do
-      invoke!("doc/README", "\nmore content", :after => "__start__").should == "      insert  doc/README\n"
+      expect(invoke!("doc/README", "\nmore content", :after => "__start__")).to eq("      insert  doc/README\n")
     end
 
     it "does not change the file if pretending" do
       invoker :pretend => true
       invoke! "doc/README", "\nmore content", :after => "__start__"
-      File.read(file).should == "__start__\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
     it "does not change the file if already include content" do
@@ -61,13 +61,13 @@ describe Thor::Actions::InjectIntoFile do
         "more content\n"
       end
 
-      File.read(file).should == "__start__\nREADME\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
 
       invoke! "doc/README", :before => "__end__" do
         "more content\n"
       end
 
-      File.read(file).should == "__start__\nREADME\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
     end
 
     it "does change the file if already include content and :force == true" do
@@ -75,13 +75,13 @@ describe Thor::Actions::InjectIntoFile do
         "more content\n"
       end
 
-      File.read(file).should == "__start__\nREADME\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
 
       invoke! "doc/README", :before => "__end__", :force => true do
         "more content\n"
       end
 
-      File.read(file).should == "__start__\nREADME\nmore content\nmore content\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\nmore content\nmore content\n__end__\n")
     end
 
   end
@@ -90,46 +90,46 @@ describe Thor::Actions::InjectIntoFile do
     it "substracts the destination file after injection" do
       invoke! "doc/README", "\nmore content", :after => "__start__"
       revoke! "doc/README", "\nmore content", :after => "__start__"
-      File.read(file).should == "__start__\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
     it "substracts the destination file before injection" do
       invoke! "doc/README", "more content\n", :before => "__start__"
       revoke! "doc/README", "more content\n", :before => "__start__"
-      File.read(file).should == "__start__\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
     it "substracts even with double after injection" do
       invoke! "doc/README", "\nmore content", :after => "__start__"
       invoke! "doc/README", "\nanother stuff", :after => "__start__"
       revoke! "doc/README", "\nmore content", :after => "__start__"
-      File.read(file).should == "__start__\nanother stuff\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("__start__\nanother stuff\nREADME\n__end__\n")
     end
 
     it "substracts even with double before injection" do
       invoke! "doc/README", "more content\n", :before => "__start__"
       invoke! "doc/README", "another stuff\n", :before => "__start__"
       revoke! "doc/README", "more content\n", :before => "__start__"
-      File.read(file).should == "another stuff\n__start__\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("another stuff\n__start__\nREADME\n__end__\n")
     end
 
     it "substracts when prepending" do
       invoke! "doc/README", "more content\n", :after => /\A/
       invoke! "doc/README", "another stuff\n", :after => /\A/
       revoke! "doc/README", "more content\n", :after => /\A/
-      File.read(file).should == "another stuff\n__start__\nREADME\n__end__\n"
+      expect(File.read(file)).to eq("another stuff\n__start__\nREADME\n__end__\n")
     end
 
     it "substracts when appending" do
       invoke! "doc/README", "more content\n", :before => /\z/
       invoke! "doc/README", "another stuff\n", :before => /\z/
       revoke! "doc/README", "more content\n", :before => /\z/
-      File.read(file).should == "__start__\nREADME\n__end__\nanother stuff\n"
+      expect(File.read(file)).to eq("__start__\nREADME\n__end__\nanother stuff\n")
     end
 
     it "shows progress information to the user" do
       invoke!("doc/README", "\nmore content", :after => "__start__")
-      revoke!("doc/README", "\nmore content", :after => "__start__").should == "    subtract  doc/README\n"
+      expect(revoke!("doc/README", "\nmore content", :after => "__start__")).to eq("    subtract  doc/README\n")
     end
   end
 end

data/spec/actions_spec.rb

@@ -6,7 +6,7 @@ describe Thor::Actions do
   end
 
   def action(*args, &block)
-    capture(:stdout){ runner.send(*args, &block) }
+    capture(:stdout) { runner.send(*args, &block) }
   end
 
   def file
@@ -15,34 +15,34 @@ describe Thor::Actions do
 
   describe "on include" do
     it "adds runtime options to the base class" do
-      MyCounter.class_options.keys.should include(:pretend)
-      MyCounter.class_options.keys.should include(:force)
-      MyCounter.class_options.keys.should include(:quiet)
-      MyCounter.class_options.keys.should include(:skip)
+      expect(MyCounter.class_options.keys).to include(:pretend)
+      expect(MyCounter.class_options.keys).to include(:force)
+      expect(MyCounter.class_options.keys).to include(:quiet)
+      expect(MyCounter.class_options.keys).to include(:skip)
     end
   end
 
   describe "#initialize" do
     it "has default behavior invoke" do
-      runner.behavior.should == :invoke
+      expect(runner.behavior).to eq(:invoke)
     end
 
     it "can have behavior revoke" do
-      MyCounter.new([1], {}, :behavior => :revoke).behavior.should == :revoke
+      expect(MyCounter.new([1], {}, :behavior => :revoke).behavior).to eq(:revoke)
     end
 
     it "when behavior is set to force, overwrite options" do
       runner = MyCounter.new([1], { :force => false, :skip => true }, :behavior => :force)
-      runner.behavior.should == :invoke
-      runner.options.force.should be_true
-      runner.options.skip.should_not be_true
+      expect(runner.behavior).to eq(:invoke)
+      expect(runner.options.force).to be_true
+      expect(runner.options.skip).not_to be_true
     end
 
     it "when behavior is set to skip, overwrite options" do
       runner = MyCounter.new([1], ["--force"], :behavior => :skip)
-      runner.behavior.should == :invoke
-      runner.options.force.should_not be_true
-      runner.options.skip.should be_true
+      expect(runner.behavior).to eq(:invoke)
+      expect(runner.options.force).not_to be_true
+      expect(runner.options.skip).to be_true
     end
   end
 
@@ -51,82 +51,82 @@ describe Thor::Actions do
       it "gets the current directory and expands the path to set the root" do
         base = MyCounter.new([1])
         base.destination_root = "here"
-        base.destination_root.should == File.expand_path(File.join(File.dirname(__FILE__), "..", "here"))
+        expect(base.destination_root).to eq(File.expand_path(File.join(File.dirname(__FILE__), "..", "here")))
       end
 
       it "does not use the current directory if one is given" do
         root = File.expand_path("/")
         base = MyCounter.new([1])
         base.destination_root = root
-        base.destination_root.should == root
+        expect(base.destination_root).to eq(root)
       end
 
       it "uses the current directory if none is given" do
         base = MyCounter.new([1])
-        base.destination_root.should == File.expand_path(File.join(File.dirname(__FILE__), ".."))
+        expect(base.destination_root).to eq(File.expand_path(File.join(File.dirname(__FILE__), "..")))
       end
     end
 
     describe "#relative_to_original_destination_root" do
       it "returns the path relative to the absolute root" do
-        runner.relative_to_original_destination_root(file).should == "foo"
+        expect(runner.relative_to_original_destination_root(file)).to eq("foo")
       end
 
       it "does not remove dot if required" do
-        runner.relative_to_original_destination_root(file, false).should == "./foo"
+        expect(runner.relative_to_original_destination_root(file, false)).to eq("./foo")
       end
 
       it "always use the absolute root" do
         runner.inside("foo") do
-          runner.relative_to_original_destination_root(file).should == "foo"
+          expect(runner.relative_to_original_destination_root(file)).to eq("foo")
         end
       end
 
       it "creates proper relative paths for absolute file location" do
-        runner.relative_to_original_destination_root('/test/file').should == "/test/file"
+        expect(runner.relative_to_original_destination_root('/test/file')).to eq("/test/file")
       end
 
       it "does not fail with files constaining regexp characters" do
         runner = MyCounter.new([1], {}, { :destination_root => File.join(destination_root, "fo[o-b]ar") })
-        runner.relative_to_original_destination_root("bar").should == "bar"
+        expect(runner.relative_to_original_destination_root("bar")).to eq("bar")
       end
 
       describe "#source_paths_for_search" do
         it "add source_root to source_paths_for_search" do
-          MyCounter.source_paths_for_search.should include(File.expand_path("fixtures", File.dirname(__FILE__)))
+          expect(MyCounter.source_paths_for_search).to include(File.expand_path("fixtures", File.dirname(__FILE__)))
         end
 
         it "keeps only current source root in source paths" do
-          ClearCounter.source_paths_for_search.should include(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
-          ClearCounter.source_paths_for_search.should_not include(File.expand_path("fixtures", File.dirname(__FILE__)))
+          expect(ClearCounter.source_paths_for_search).to include(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
+          expect(ClearCounter.source_paths_for_search).not_to include(File.expand_path("fixtures", File.dirname(__FILE__)))
         end
 
         it "customized source paths should be before source roots" do
-          ClearCounter.source_paths_for_search[0].should == File.expand_path("fixtures/doc", File.dirname(__FILE__))
-          ClearCounter.source_paths_for_search[1].should == File.expand_path("fixtures/bundle", File.dirname(__FILE__))
+          expect(ClearCounter.source_paths_for_search[0]).to eq(File.expand_path("fixtures/doc", File.dirname(__FILE__)))
+          expect(ClearCounter.source_paths_for_search[1]).to eq(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
         end
 
         it "keeps inherited source paths at the end" do
-          ClearCounter.source_paths_for_search.last.should == File.expand_path("fixtures/broken", File.dirname(__FILE__))
+          expect(ClearCounter.source_paths_for_search.last).to eq(File.expand_path("fixtures/broken", File.dirname(__FILE__)))
         end
       end
     end
 
     describe "#find_in_source_paths" do
       it "raises an error if source path is empty" do
-        lambda {
+        expect {
           A.new.find_in_source_paths("foo")
-        }.should raise_error(Thor::Error, /Currently you have no source paths/)
+        }.to raise_error(Thor::Error, /Currently you have no source paths/)
       end
 
       it "finds a template inside the source path" do
-        runner.find_in_source_paths("doc").should == File.expand_path("doc", source_root)
-        lambda { runner.find_in_source_paths("README") }.should raise_error
+        expect(runner.find_in_source_paths("doc")).to eq(File.expand_path("doc", source_root))
+        expect{ runner.find_in_source_paths("README") }.to raise_error
 
         new_path = File.join(source_root, "doc")
         runner.instance_variable_set(:@source_paths, nil)
         runner.source_paths.unshift(new_path)
-        runner.find_in_source_paths("README").should == File.expand_path("README", new_path)
+        expect(runner.find_in_source_paths("README")).to eq(File.expand_path("README", new_path))
       end
     end
   end
@@ -134,49 +134,49 @@ describe Thor::Actions do
   describe "#inside" do
     it "executes the block inside the given folder" do
       runner.inside("foo") do
-        Dir.pwd.should == file
+        expect(Dir.pwd).to eq(file)
       end
     end
 
     it "changes the base root" do
       runner.inside("foo") do
-        runner.destination_root.should == file
+        expect(runner.destination_root).to eq(file)
       end
     end
 
     it "creates the directory if it does not exist" do
       runner.inside("foo") do
-        File.exists?(file).should be_true
+        expect(File.exists?(file)).to be_true
       end
     end
 
     describe "when pretending" do
       it "no directories should be created" do
         runner.inside("bar", :pretend => true) {}
-        File.exists?("bar").should be_false
+        expect(File.exists?("bar")).to be_false
       end
     end
 
     describe "when verbose" do
       it "logs status" do
-        capture(:stdout) do
+        expect(capture(:stdout) {
           runner.inside("foo", :verbose => true) {}
-        end.should =~ /inside  foo/
+        }).to match(/inside  foo/)
       end
 
       it "uses padding in next status" do
-        capture(:stdout) do
+        expect(capture(:stdout) {
           runner.inside("foo", :verbose => true) do
             runner.say_status :cool, :padding
           end
-        end.should =~ /cool    padding/
+        }).to match(/cool    padding/)
       end
 
       it "removes padding after block" do
-        capture(:stdout) do
+        expect(capture(:stdout) {
           runner.inside("foo", :verbose => true) {}
           runner.say_status :no, :padding
-        end.should =~ /no  padding/
+        }).to match(/no  padding/)
       end
     end
   end
@@ -184,20 +184,20 @@ describe Thor::Actions do
   describe "#in_root" do
     it "executes the block in the root folder" do
       runner.inside("foo") do
-        runner.in_root { Dir.pwd.should == destination_root }
+        runner.in_root { expect(Dir.pwd).to eq(destination_root) }
       end
     end
 
     it "changes the base root" do
       runner.inside("foo") do
-        runner.in_root { runner.destination_root.should == destination_root }
+        runner.in_root { expect(runner.destination_root).to eq(destination_root) }
       end
     end
 
     it "returns to the previous state" do
       runner.inside("foo") do
         runner.in_root { }
-        runner.destination_root.should == file
+        expect(runner.destination_root).to eq(file)
       end
     end
   end
@@ -234,21 +234,21 @@ describe Thor::Actions do
 
     it "opens a file and executes its content in the instance binding" do
       action :apply, @file
-      runner.instance_variable_get("@foo").should == "FOO"
+      expect(runner.instance_variable_get("@foo")).to eq("FOO")
     end
 
     it "applies padding to the content inside the file" do
-      action(:apply, @file).should =~ /cool    padding/
+      expect(action(:apply, @file)).to match(/cool    padding/)
     end
 
     it "logs its status" do
-      action(:apply, @file).should =~ /       apply  #{@file}\n/
+      expect(action(:apply, @file)).to match(/       apply  #{@file}\n/)
     end
 
     it "does not log status" do
       content = action(:apply, @file, :verbose => false)
-      content.should =~ /cool  padding/
-      content.should_not =~ /apply http/
+      expect(content).to match(/cool  padding/)
+      expect(content).not_to match(/apply http/)
     end
   end
 
@@ -262,11 +262,11 @@ describe Thor::Actions do
     end
 
     it "logs status" do
-      action(:run, "ls").should == "         run  ls from \".\"\n"
+      expect(action(:run, "ls")).to eq("         run  ls from \".\"\n")
     end
 
     it "does not log status if required" do
-      action(:run, "ls", :verbose => false).should be_empty
+      expect(action(:run, "ls", :verbose => false)).to be_empty
     end
 
     it "accepts a color as status" do
@@ -286,11 +286,11 @@ describe Thor::Actions do
     end
 
     it "logs status" do
-      action(:run_ruby_script, "script.rb").should == "         run  jruby script.rb from \".\"\n"
+      expect(action(:run_ruby_script, "script.rb")).to eq("         run  jruby script.rb from \".\"\n")
     end
 
     it "does not log status if required" do
-      action(:run_ruby_script, "script.rb", :verbose => false).should be_empty
+      expect(action(:run_ruby_script, "script.rb", :verbose => false)).to be_empty
     end
   end
 
@@ -315,12 +315,12 @@ describe Thor::Actions do
 
     it "logs status" do
       runner.should_receive(:system).with("thor list")
-      action(:thor, :list).should == "         run  thor list from \".\"\n"
+      expect(action(:thor, :list)).to eq("         run  thor list from \".\"\n")
     end
 
     it "does not log status if required" do
       runner.should_receive(:system).with("thor list --foo 1 2 3")
-      action(:thor, :list, :foo => [1,2,3], :verbose => false).should be_empty
+      expect(action(:thor, :list, :foo => [1,2,3], :verbose => false)).to be_empty
     end
 
     it "captures the output when :capture is given" do

data/spec/base_spec.rb

@@ -12,94 +12,94 @@ describe Thor::Base do
   describe "#initialize" do
     it "sets arguments array" do
       base = MyCounter.new [1, 2]
-      base.first.should == 1
-      base.second.should == 2
+      expect(base.first).to eq(1)
+      expect(base.second).to eq(2)
     end
 
     it "sets arguments default values" do
       base = MyCounter.new [1]
-      base.second.should == 2
+      expect(base.second).to eq(2)
     end
 
     it "sets options default values" do
       base = MyCounter.new [1, 2]
-      base.options[:third].should == 3
+      expect(base.options[:third]).to eq(3)
     end
 
     it "allows options to be given as symbols or strings" do
       base = MyCounter.new [1, 2], :third => 4
-      base.options[:third].should == 4
+      expect(base.options[:third]).to eq(4)
 
       base = MyCounter.new [1, 2], "third" => 4
-      base.options[:third].should == 4
+      expect(base.options[:third]).to eq(4)
     end
 
     it "creates options with indifferent access" do
       base = MyCounter.new [1, 2], :third => 3
-      base.options['third'].should == 3
+      expect(base.options['third']).to eq(3)
     end
 
     it "creates options with magic predicates" do
       base = MyCounter.new [1, 2], :third => 3
-      base.options.third.should == 3
+      expect(base.options.third).to eq(3)
     end
   end
 
   describe "#no_tasks" do
     it "avoids methods being added as tasks" do
-      MyScript.tasks.keys.should include("animal")
-      MyScript.tasks.keys.should_not include("this_is_not_a_task")
+      expect(MyScript.tasks.keys).to include("animal")
+      expect(MyScript.tasks.keys).not_to include("this_is_not_a_task")
     end
   end
 
   describe "#argument" do
     it "sets a value as required and creates an accessor for it" do
-      MyCounter.start(["1", "2", "--third", "3"])[0].should == 1
-      Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"]).should == "my_special_param"
+      expect(MyCounter.start(["1", "2", "--third", "3"])[0]).to eq(1)
+      expect(Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"])).to eq("my_special_param")
     end
 
     it "does not set a value in the options hash" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[0].should be_nil
+      expect(BrokenCounter.start(["1", "2", "--third", "3"])[0]).to be_nil
     end
   end
 
   describe "#arguments" do
     it "returns the arguments for the class" do
-      MyCounter.arguments.should have(2).items
+      expect(MyCounter.arguments).to have(2).items
     end
   end
 
   describe "#class_option" do
     it "sets options class wise" do
-      MyCounter.start(["1", "2", "--third", "3"])[2].should == 3
+      expect(MyCounter.start(["1", "2", "--third", "3"])[2]).to eq(3)
     end
 
     it "does not create an accessor for it" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[3].should be_false
+      expect(BrokenCounter.start(["1", "2", "--third", "3"])[3]).to be_false
     end
   end
 
   describe "#class_options" do
     it "sets default options overwriting superclass definitions" do
       options = Scripts::MyScript.class_options
-      options[:force].should_not be_required
+      expect(options[:force]).not_to be_required
     end
   end
 
   describe "#remove_argument" do
     it "removes previous defined arguments from class" do
-      ClearCounter.arguments.should be_empty
+      expect(ClearCounter.arguments).to be_empty
     end
 
     it "undefine accessors if required" do
-      ClearCounter.new.should_not respond_to(:first)
-      ClearCounter.new.should_not respond_to(:second)
+      expect(ClearCounter.new).not_to respond_to(:first)
+      expect(ClearCounter.new).not_to respond_to(:second)
     end
   end
 
   describe "#remove_class_option" do
     it "removes previous defined class option" do
-      ClearCounter.class_options[:third].should be_nil
+      expect(ClearCounter.class_options[:third]).to be_nil
     end
   end
 
@@ -109,125 +109,125 @@ describe Thor::Base do
     end
 
     it "shows options description" do
-      @content.should =~ /# The third argument/
+      expect(@content).to match(/# The third argument/)
     end
 
     it "shows usage with banner content" do
-      @content.should =~ /\[\-\-third=THREE\]/
+      expect(@content).to match(/\[\-\-third=THREE\]/)
     end
 
     it "shows default values below description" do
-      @content.should =~ /# Default: 3/
+      expect(@content).to match(/# Default: 3/)
     end
 
     it "shows options in different groups" do
-      @content.should =~ /Options\:/
-      @content.should =~ /Runtime options\:/
-      @content.should =~ /\-p, \[\-\-pretend\]/
+      expect(@content).to match(/Options\:/)
+      expect(@content).to match(/Runtime options\:/)
+      expect(@content).to match(/\-p, \[\-\-pretend\]/)
     end
 
     it "use padding in options that does not have aliases" do
-      @content.should =~ /^  -t, \[--third/
-      @content.should =~ /^      \[--fourth/
+      expect(@content).to match(/^  -t, \[--third/)
+      expect(@content).to match(/^      \[--fourth/)
     end
 
     it "allows extra options to be given" do
       hash = { "Foo" => B.class_options.values }
 
       content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
-      content.should =~ /Foo options\:/
-      content.should =~ /--last-name=LAST_NAME/
+      expect(content).to match(/Foo options\:/)
+      expect(content).to match(/--last-name=LAST_NAME/)
     end
 
     it "displays choices for enums" do
       content = capture(:stdout) { Enum.help(Thor::Base.shell.new) }
-      content.should =~ /Possible values\: apple, banana/
+      expect(content).to match(/Possible values\: apple, banana/)
     end
   end
 
   describe "#namespace" do
     it "returns the default class namespace" do
-      Scripts::MyScript.namespace.should == "scripts:my_script"
+      expect(Scripts::MyScript.namespace).to eq("scripts:my_script")
     end
 
     it "sets a namespace to the class" do
-      Scripts::MyDefaults.namespace.should == "default"
+      expect(Scripts::MyDefaults.namespace).to eq("default")
     end
   end
 
   describe "#group" do
     it "sets a group" do
-      MyScript.group.should == "script"
+      expect(MyScript.group).to eq("script")
     end
 
     it "inherits the group from parent" do
-      MyChildScript.group.should == "script"
+      expect(MyChildScript.group).to eq("script")
     end
 
     it "defaults to standard if no group is given" do
-      Amazing.group.should == "standard"
+      expect(Amazing.group).to eq("standard")
     end
   end
 
   describe "#subclasses" do
     it "tracks its subclasses in an Array" do
-      Thor::Base.subclasses.should include(MyScript)
-      Thor::Base.subclasses.should include(MyChildScript)
-      Thor::Base.subclasses.should include(Scripts::MyScript)
+      expect(Thor::Base.subclasses).to include(MyScript)
+      expect(Thor::Base.subclasses).to include(MyChildScript)
+      expect(Thor::Base.subclasses).to include(Scripts::MyScript)
     end
   end
 
   describe "#subclass_files" do
     it "returns tracked subclasses, grouped by the files they come from" do
       thorfile = File.join(File.dirname(__FILE__), "fixtures", "script.thor")
-      Thor::Base.subclass_files[File.expand_path(thorfile)].should == [
+      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to eq([
         MyScript, MyScript::AnotherScript, MyChildScript, Barn,
         Scripts::MyScript, Scripts::MyDefaults, Scripts::ChildDefault
-      ]
+      ])
     end
 
     it "tracks a single subclass across multiple files" do
       thorfile = File.join(File.dirname(__FILE__), "fixtures", "task.thor")
-      Thor::Base.subclass_files[File.expand_path(thorfile)].should include(Amazing)
-      Thor::Base.subclass_files[File.expand_path(__FILE__)].should include(Amazing)
+      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to include(Amazing)
+      expect(Thor::Base.subclass_files[File.expand_path(__FILE__)]).to include(Amazing)
     end
   end
 
   describe "#tasks" do
     it "returns a list with all tasks defined in this class" do
-      MyChildScript.new.should respond_to("animal")
-      MyChildScript.tasks.keys.should include("animal")
+      expect(MyChildScript.new).to respond_to("animal")
+      expect(MyChildScript.tasks.keys).to include("animal")
     end
 
     it "raises an error if a task with reserved word is defined" do
-      lambda {
+      expect {
         klass = Class.new(Thor::Group)
         klass.class_eval "def shell; end"
-      }.should raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as task/)
+      }.to raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as task/)
     end
   end
 
   describe "#all_tasks" do
     it "returns a list with all tasks defined in this class plus superclasses" do
-      MyChildScript.new.should respond_to("foo")
-      MyChildScript.all_tasks.keys.should include("foo")
+      expect(MyChildScript.new).to respond_to("foo")
+      expect(MyChildScript.all_tasks.keys).to include("foo")
     end
   end
 
   describe "#remove_task" do
     it "removes the task from its tasks hash" do
-      MyChildScript.tasks.keys.should_not include("bar")
-      MyChildScript.tasks.keys.should_not include("boom")
+      expect(MyChildScript.tasks.keys).not_to include("bar")
+      expect(MyChildScript.tasks.keys).not_to include("boom")
     end
 
     it "undefines the method if desired" do
-      MyChildScript.new.should_not respond_to("boom")
+      expect(MyChildScript.new).not_to respond_to("boom")
     end
   end
 
   describe "#from_superclass" do
     it "does not send a method to the superclass if the superclass does not respond to it" do
-      MyCounter.get_from_super.should == 13
+      expect(MyCounter.get_from_super).to eq(13)
     end
   end
 
@@ -235,9 +235,9 @@ describe Thor::Base do
     it "raises an error instead of rescueing if THOR_DEBUG=1 is given" do
       begin
         ENV["THOR_DEBUG"] = 1
-        lambda {
+        expect {
           MyScript.start ["what", "--debug"]
-        }.should raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
+        }.to raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
       rescue
         ENV["THOR_DEBUG"] = nil
       end
@@ -246,34 +246,34 @@ describe Thor::Base do
     it "does not steal args" do
       args = ["foo", "bar", "--force", "true"]
       MyScript.start(args)
-      args.should == ["foo", "bar", "--force", "true"]
+      expect(args).to eq(["foo", "bar", "--force", "true"])
     end
 
     it "checks unknown options" do
-      capture(:stderr) {
+      expect(capture(:stderr) {
         MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
-      }.strip.should == "Unknown switches '--unknown'"
+      }.strip).to eq("Unknown switches '--unknown'")
     end
 
     it "checks unknown options except specified" do
-      capture(:stderr) {
-        MyScript.start(["with_optional", "NAME", "--omg", "--invalid"]).should == ["NAME", {}, ["--omg", "--invalid"]]
-      }.strip.should be_empty
+      expect(capture(:stderr) {
+        expect(MyScript.start(["with_optional", "NAME", "--omg", "--invalid"])).to eq(["NAME", {}, ["--omg", "--invalid"]])
+      }.strip).to be_empty
     end
   end
 
   describe "attr_*" do
-    it "should not add attr_reader as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute"]) }.should =~ /Could not find/
+    it "does not add attr_reader as a task" do
+      expect(capture(:stderr){ MyScript.start(["another_attribute"]) }).to match(/Could not find/)
     end
 
-    it "should not add attr_writer as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }.should =~ /Could not find/
+    it "does not add attr_writer as a task" do
+      expect(capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }).to match(/Could not find/)
     end
 
-    it "should not add attr_accessor as a task" do
-      capture(:stderr){ MyScript.start(["some_attribute"]) }.should =~ /Could not find/
-      capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }.should =~ /Could not find/
+    it "does not add attr_accessor as a task" do
+      expect(capture(:stderr){ MyScript.start(["some_attribute"]) }).to match(/Could not find/)
+      expect(capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }).to match(/Could not find/)
     end
   end
 end