thor 0.16.0 → 0.17.0

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -7,37 +7,42 @@ describe Thor::CoreExt::HashWithIndifferentAccess do
   end
 
   it "has values accessible by either strings or symbols" do
-    @hash['foo'].should == 'bar'
-    @hash[:foo].should  == 'bar'
+    expect(@hash['foo']).to eq('bar')
+    expect(@hash[:foo]).to eq('bar')
 
-    @hash.values_at(:foo, :baz).should == ['bar', 'bee']
-    @hash.delete(:foo).should == 'bar'
+    expect(@hash.values_at(:foo, :baz)).to eq(['bar', 'bee'])
+    expect(@hash.delete(:foo)).to eq('bar')
   end
 
   it "handles magic boolean predicates" do
-    @hash.force?.should be_true
-    @hash.foo?.should be_true
-    @hash.nothing?.should be_false
+    expect(@hash.force?).to be_true
+    expect(@hash.foo?).to be_true
+    expect(@hash.nothing?).to be_false
   end
 
   it "handles magic comparisions" do
-    @hash.foo?('bar').should be_true
-    @hash.foo?('bee').should be_false
+    expect(@hash.foo?('bar')).to be_true
+    expect(@hash.foo?('bee')).to be_false
   end
 
   it "maps methods to keys" do
-    @hash.foo.should == @hash['foo']
+    expect(@hash.foo).to eq(@hash['foo'])
   end
 
   it "merges keys independent if they are symbols or strings" do
     @hash.merge!('force' => false, :baz => "boom")
-    @hash[:force].should == false
-    @hash[:baz].should == "boom"
+    expect(@hash[:force]).to eq(false)
+    expect(@hash[:baz]).to eq("boom")
   end
 
   it "creates a new hash by merging keys independent if they are symbols or strings" do
     other = @hash.merge('force' => false, :baz => "boom")
-    other[:force].should == false
-    other[:baz].should == "boom"
+    expect(other[:force]).to eq(false)
+    expect(other[:baz]).to eq("boom")
+  end
+
+  it "converts to a traditional hash" do
+    expect(@hash.to_hash.class).to eq(Hash)
+    expect(@hash).to eq({ 'foo' => 'bar', 'baz' => 'bee', 'force' => true })
   end
 end

data/spec/core_ext/ordered_hash_spec.rb

@@ -8,7 +8,7 @@ describe Thor::CoreExt::OrderedHash do
 
   describe "without any items" do
     it "returns nil for an undefined key" do
-      @hash["foo"].should be_nil
+      expect(@hash["foo"]).to be_nil
     end
 
     it "doesn't iterate through any items" do
@@ -16,12 +16,12 @@ describe Thor::CoreExt::OrderedHash do
     end
 
     it "has an empty key and values list" do
-      @hash.keys.should be_empty
-      @hash.values.should be_empty
+      expect(@hash.keys).to be_empty
+      expect(@hash.values).to be_empty
     end
 
     it "must be empty" do
-      @hash.should be_empty
+      expect(@hash).to be_empty
     end
   end
 
@@ -35,15 +35,15 @@ describe Thor::CoreExt::OrderedHash do
     end
 
     it "returns nil for an undefined key" do
-      @hash[:boom].should be_nil
+      expect(@hash[:boom]).to be_nil
     end
 
     it "returns the value for each key" do
-      @hash[:foo].should == "Foo!"
-      @hash[:bar].should == "Bar!"
-      @hash[:baz].should == "Baz!"
-      @hash[:bop].should == "Bop!"
-      @hash[:bat].should == "Bat!"
+      expect(@hash[:foo]).to eq("Foo!")
+      expect(@hash[:bar]).to eq("Bar!")
+      expect(@hash[:baz]).to eq("Baz!")
+      expect(@hash[:bop]).to eq("Bop!")
+      expect(@hash[:bat]).to eq("Bat!")
     end
 
     it "iterates through the keys and values in order of assignment" do
@@ -51,27 +51,27 @@ describe Thor::CoreExt::OrderedHash do
       @hash.each do |key, value|
         arr << [key, value]
       end
-      arr.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
-                     [:bop, "Bop!"], [:bat, "Bat!"]]
+      expect(arr).to eq([[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
+                     [:bop, "Bop!"], [:bat, "Bat!"]])
     end
 
     it "returns the keys in order of insertion" do
-      @hash.keys.should == [:foo, :bar, :baz, :bop, :bat]
+      expect(@hash.keys).to eq([:foo, :bar, :baz, :bop, :bat])
     end
 
     it "returns the values in order of insertion" do
-      @hash.values.should == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"]
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"])
     end
 
     it "does not move an overwritten node to the end of the ordering" do
       @hash[:baz] = "Bip!"
-      @hash.values.should == ["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"]
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"])
 
       @hash[:foo] = "Bip!"
-      @hash.values.should == ["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"]
+      expect(@hash.values).to eq(["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"])
 
       @hash[:bat] = "Bip!"
-      @hash.values.should == ["Bip!", "Bar!", "Bip!", "Bop!", "Bip!"]
+      expect(@hash.values).to eq(["Bip!", "Bar!", "Bip!", "Bop!", "Bip!"])
     end
 
     it "appends another ordered hash while preserving ordering" do
@@ -79,37 +79,37 @@ describe Thor::CoreExt::OrderedHash do
       other_hash[1] = "one"
       other_hash[2] = "two"
       other_hash[3] = "three"
-      @hash.merge(other_hash).values.should == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!", "one", "two", "three"]
+      expect(@hash.merge(other_hash).values).to eq(["Foo!", "Bar!", "Baz!", "Bop!", "Bat!", "one", "two", "three"])
     end
 
     it "overwrites hash keys with matching appended keys" do
       other_hash = Thor::CoreExt::OrderedHash.new
       other_hash[:bar] = "bar"
-      @hash.merge(other_hash)[:bar].should == "bar"
-      @hash[:bar].should == "Bar!"
+      expect(@hash.merge(other_hash)[:bar]).to eq("bar")
+      expect(@hash[:bar]).to eq("Bar!")
     end
 
     it "converts to an array" do
-      @hash.to_a.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]]
+      expect(@hash.to_a).to eq([[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]])
     end
 
     it "must not be empty" do
-      @hash.should_not be_empty
+      expect(@hash).not_to be_empty
     end
 
     it "deletes values from hash" do
-      @hash.delete(:baz).should == "Baz!"
-      @hash.values.should == ["Foo!", "Bar!", "Bop!", "Bat!"]
+      expect(@hash.delete(:baz)).to eq("Baz!")
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Bop!", "Bat!"])
 
-      @hash.delete(:foo).should == "Foo!"
-      @hash.values.should == ["Bar!", "Bop!", "Bat!"]
+      expect(@hash.delete(:foo)).to eq("Foo!")
+      expect(@hash.values).to eq(["Bar!", "Bop!", "Bat!"])
 
-      @hash.delete(:bat).should == "Bat!"
-      @hash.values.should == ["Bar!", "Bop!"]
+      expect(@hash.delete(:bat)).to eq("Bat!")
+      expect(@hash.values).to eq(["Bar!", "Bop!"])
     end
 
     it "returns nil if the value to be deleted can't be found" do
-      @hash.delete(:nothing).should be_nil
+      expect(@hash.delete(:nothing)).to be_nil
     end
   end
 end

data/spec/exit_condition_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'thor/base'
 
 describe "Exit conditions" do
-  it "should exit 0, not bubble up EPIPE, if EPIPE is raised" do
+  it "exits 0, not bubble up EPIPE, if EPIPE is raised" do
     epiped = false
 
     task = Class.new(Thor) do
@@ -13,7 +13,7 @@ describe "Exit conditions" do
       end
     end
 
-    lambda { task.start(["my_action"]) }.should raise_error(SystemExit)
-    epiped.should == true
+    expect{ task.start(["my_action"]) }.to raise_error(SystemExit)
+    expect(epiped).to eq(true)
   end
 end

data/spec/fixtures/preserve/script.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exit 0

data/spec/fixtures/script.thor

@@ -93,6 +93,11 @@ END
     end
   end
 
+  desc "send", "send as a task name"
+  def send
+    true
+  end
+
   private
 
     def method_missing(meth, *args)

data/spec/group_spec.rb

@@ -3,36 +3,36 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe Thor::Group do
   describe "task" do
     it "allows to use private methods from parent class as tasks" do
-      ChildGroup.start.should == ["bar", "foo", "baz"]
-      ChildGroup.new.baz("bar").should == "bar"
+      expect(ChildGroup.start).to eq(["bar", "foo", "baz"])
+      expect(ChildGroup.new.baz("bar")).to eq("bar")
     end
   end
 
   describe "#start" do
     it "invokes all the tasks under the Thor group" do
-      MyCounter.start(["1", "2", "--third", "3"]).should == [ 1, 2, 3 ]
+      expect(MyCounter.start(["1", "2", "--third", "3"])).to eq([ 1, 2, 3 ])
     end
 
     it "uses argument default value" do
-      MyCounter.start(["1", "--third", "3"]).should == [ 1, 2, 3 ]
+      expect(MyCounter.start(["1", "--third", "3"])).to eq([ 1, 2, 3 ])
     end
 
     it "invokes all the tasks in the Thor group and his parents" do
-      BrokenCounter.start(["1", "2", "--third", "3"]).should == [ nil, 2, 3, false, 5 ]
+      expect(BrokenCounter.start(["1", "2", "--third", "3"])).to eq([ nil, 2, 3, false, 5 ])
     end
 
     it "raises an error if a required argument is added after a non-required" do
-      lambda {
+      expect {
         MyCounter.argument(:foo, :type => :string)
-      }.should raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
+      }.to raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
     end
 
     it "raises when an exception happens within the task call" do
-      lambda { BrokenCounter.start(["1", "2", "--fail"]) }.should raise_error
+      expect{ BrokenCounter.start(["1", "2", "--fail"]) }.to raise_error
     end
 
     it "raises an error when a Thor group task expects arguments" do
-      lambda { WhinyGenerator.start }.should raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+      expect{ WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
     end
 
     it "invokes help message if any of the shortcuts is given" do
@@ -43,135 +43,135 @@ describe Thor::Group do
 
   describe "#desc" do
     it "sets the description for a given class" do
-      MyCounter.desc.should == "Description:\n  This generator runs three tasks: one, two and three.\n"
+      expect(MyCounter.desc).to eq("Description:\n  This generator runs three tasks: one, two and three.\n")
     end
 
     it "can be inherited" do
-      BrokenCounter.desc.should == "Description:\n  This generator runs three tasks: one, two and three.\n"
+      expect(BrokenCounter.desc).to eq("Description:\n  This generator runs three tasks: one, two and three.\n")
     end
 
     it "can be nil" do
-      WhinyGenerator.desc.should be_nil
+      expect(WhinyGenerator.desc).to be_nil
     end
   end
 
   describe "#help" do
     before do
-      @content = capture(:stdout){ MyCounter.help(Thor::Base.shell.new) }
+      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
     end
 
     it "provides usage information" do
-      @content.should =~ /my_counter N \[N\]/
+      expect(@content).to match(/my_counter N \[N\]/)
     end
 
     it "shows description" do
-      @content.should =~ /Description:/
-      @content.should =~ /This generator runs three tasks: one, two and three./
+      expect(@content).to match(/Description:/)
+      expect(@content).to match(/This generator runs three tasks: one, two and three./)
     end
 
     it "shows options information" do
-      @content.should =~ /Options/
-      @content.should =~ /\[\-\-third=THREE\]/
+      expect(@content).to match(/Options/)
+      expect(@content).to match(/\[\-\-third=THREE\]/)
     end
   end
 
   describe "#invoke" do
     before do
-      @content = capture(:stdout){ E.start }
+      @content = capture(:stdout) { E.start }
     end
 
     it "allows to invoke a class from the class binding" do
-      @content.should =~ /1\n2\n3\n4\n5\n/
+      expect(@content).to match(/1\n2\n3\n4\n5\n/)
     end
 
     it "shows invocation information to the user" do
-      @content.should =~ /invoke  Defined/
+      expect(@content).to match(/invoke  Defined/)
     end
 
     it "uses padding on status generated by the invoked class" do
-      @content.should =~ /finished    counting/
+      expect(@content).to match(/finished    counting/)
     end
 
     it "allows invocation to be configured with blocks" do
       capture(:stdout) do
-        F.start.should == ["Valim, Jose"]
+        expect(F.start).to eq(["Valim, Jose"])
       end
     end
 
     it "shows invoked options on help" do
-      content = capture(:stdout){ E.help(Thor::Base.shell.new) }
-      content.should =~ /Defined options:/
-      content.should =~ /\[--unused\]/
-      content.should =~ /# This option has no use/
+      content = capture(:stdout) { E.help(Thor::Base.shell.new) }
+      expect(content).to match(/Defined options:/)
+      expect(content).to match(/\[--unused\]/)
+      expect(content).to match(/# This option has no use/)
     end
   end
 
   describe "#invoke_from_option" do
     describe "with default type" do
       before do
-        @content = capture(:stdout){ G.start }
+        @content = capture(:stdout) { G.start }
       end
 
       it "allows to invoke a class from the class binding by a default option" do
-        @content.should =~ /1\n2\n3\n4\n5\n/
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
       end
 
       it "does not invoke if the option is nil" do
-        capture(:stdout){ G.start(["--skip-invoked"]) }.should_not =~ /invoke/
+        expect(capture(:stdout) { G.start(["--skip-invoked"]) }).not_to match(/invoke/)
       end
 
       it "prints a message if invocation cannot be found" do
-        content = capture(:stdout){ G.start(["--invoked", "unknown"]) }
-        content.should =~ /error  unknown \[not found\]/
+        content = capture(:stdout) { G.start(["--invoked", "unknown"]) }
+        expect(content).to match(/error  unknown \[not found\]/)
       end
 
       it "allows to invoke a class from the class binding by the given option" do
-        content = capture(:stdout){ G.start(["--invoked", "e"]) }
-        content.should =~ /invoke  e/
+        content = capture(:stdout) { G.start(["--invoked", "e"]) }
+        expect(content).to match(/invoke  e/)
       end
 
       it "shows invocation information to the user" do
-        @content.should =~ /invoke  defined/
+        expect(@content).to match(/invoke  defined/)
       end
 
       it "uses padding on status generated by the invoked class" do
-        @content.should =~ /finished    counting/
+        expect(@content).to match(/finished    counting/)
       end
 
       it "shows invoked options on help" do
-        content = capture(:stdout){ G.help(Thor::Base.shell.new) }
-        content.should =~ /defined options:/
-        content.should =~ /\[--unused\]/
-        content.should =~ /# This option has no use/
+        content = capture(:stdout) { G.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# This option has no use/)
       end
     end
 
     describe "with boolean type" do
       before do
-        @content = capture(:stdout){ H.start }
+        @content = capture(:stdout) { H.start }
       end
 
       it "allows to invoke a class from the class binding by a default option" do
-        @content.should =~ /1\n2\n3\n4\n5\n/
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
       end
 
       it "does not invoke if the option is false" do
-        capture(:stdout){ H.start(["--no-defined"]) }.should_not =~ /invoke/
+        expect(capture(:stdout) { H.start(["--no-defined"]) }).not_to match(/invoke/)
       end
 
       it "shows invocation information to the user" do
-        @content.should =~ /invoke  defined/
+        expect(@content).to match(/invoke  defined/)
       end
 
       it "uses padding on status generated by the invoked class" do
-        @content.should =~ /finished    counting/
+        expect(@content).to match(/finished    counting/)
       end
 
       it "shows invoked options on help" do
-        content = capture(:stdout){ H.help(Thor::Base.shell.new) }
-        content.should =~ /defined options:/
-        content.should =~ /\[--unused\]/
-        content.should =~ /# This option has no use/
+        content = capture(:stdout) { H.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# This option has no use/)
       end
     end
   end
@@ -189,9 +189,9 @@ describe Thor::Group do
         end
       end
 
-      klass.start(["jose"]).should == ["Hi jose"]
-      klass.start(["jose", "--loud"]).should == ["Hi JOSE"]
-      klass.start(["--loud", "jose"]).should == ["Hi JOSE"]
+      expect(klass.start(["jose"])).to eq(["Hi jose"])
+      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
+      expect(klass.start(["--loud", "jose"])).to eq(["Hi JOSE"])
     end
 
     it "provides extra args as `args`" do
@@ -208,9 +208,9 @@ describe Thor::Group do
         end
       end
 
-      klass.start(["jose"]).should == ["Hi jose"]
-      klass.start(["jose", "--loud"]).should == ["Hi JOSE"]
-      klass.start(["--loud", "jose"]).should == ["Hi JOSE"]
+      expect(klass.start(["jose"])).to eq(["Hi jose"])
+      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
+      expect(klass.start(["--loud", "jose"])).to eq(["Hi JOSE"])
     end
   end
 end