thor 0.16.0 → 0.17.0

data/spec/invocation_spec.rb

@@ -4,97 +4,97 @@ require 'thor/base'
 describe Thor::Invocation do
   describe "#invoke" do
     it "invokes a task inside another task" do
-      capture(:stdout){ A.new.invoke(:two) }.should == "2\n3\n"
+      expect(capture(:stdout) { A.new.invoke(:two) }).to eq("2\n3\n")
     end
 
     it "invokes a task just once" do
-      capture(:stdout){ A.new.invoke(:one) }.should == "1\n2\n3\n"
+      expect(capture(:stdout) { A.new.invoke(:one) }).to eq("1\n2\n3\n")
     end
 
     it "invokes a task just once even if they belongs to different classes" do
-      capture(:stdout){ Defined.new.invoke(:one) }.should == "1\n2\n3\n4\n5\n"
+      expect(capture(:stdout) { Defined.new.invoke(:one) }).to eq("1\n2\n3\n4\n5\n")
     end
 
     it "invokes a task with arguments" do
-      A.new.invoke(:five, [5]).should be_true
-      A.new.invoke(:five, [7]).should be_false
+      expect(A.new.invoke(:five, [5])).to be_true
+      expect(A.new.invoke(:five, [7])).to be_false
     end
 
     it "invokes the default task if none is given to a Thor class" do
-      content = capture(:stdout){ A.new.invoke("b") }
-      content.should =~ /Tasks/
-      content.should =~ /LAST_NAME/
+      content = capture(:stdout) { A.new.invoke("b") }
+      expect(content).to match(/Tasks/)
+      expect(content).to match(/LAST_NAME/)
     end
 
     it "accepts a class as argument without a task to invoke" do
-      content = capture(:stdout){ A.new.invoke(B) }
-      content.should =~ /Tasks/
-      content.should =~ /LAST_NAME/
+      content = capture(:stdout) { A.new.invoke(B) }
+      expect(content).to match(/Tasks/)
+      expect(content).to match(/LAST_NAME/)
     end
 
     it "accepts a class as argument with a task to invoke" do
       base = A.new([], :last_name => "Valim")
-      base.invoke(B, :one, ["Jose"]).should == "Valim, Jose"
+      expect(base.invoke(B, :one, ["Jose"])).to eq("Valim, Jose")
     end
 
     it "allows customized options to be given" do
       base = A.new([], :last_name => "Wrong")
-      base.invoke(B, :one, ["Jose"], :last_name => "Valim").should == "Valim, Jose"
+      expect(base.invoke(B, :one, ["Jose"], :last_name => "Valim")).to eq("Valim, Jose")
     end
 
     it "reparses options in the new class" do
-      A.start(["invoker", "--last-name", "Valim"]).should == "Valim, Jose"
+      expect(A.start(["invoker", "--last-name", "Valim"])).to eq("Valim, Jose")
     end
 
     it "shares initialize options with invoked class" do
-      A.new([], :foo => :bar).invoke("b:two").should == { "foo" => :bar }
+      expect(A.new([], :foo => :bar).invoke("b:two")).to eq({ "foo" => :bar })
     end
 
     it "dump configuration values to be used in the invoked class" do
       base = A.new
-      base.invoke("b:three").shell.should == base.shell
+      expect(base.invoke("b:three").shell).to eq(base.shell)
     end
 
     it "allow extra configuration values to be given" do
       base, shell = A.new, Thor::Base.shell.new
-      base.invoke("b:three", [], {}, :shell => shell).shell.should == shell
+      expect(base.invoke("b:three", [], {}, :shell => shell).shell).to eq(shell)
     end
 
     it "invokes a Thor::Group and all of its tasks" do
-      capture(:stdout){ A.new.invoke(:c) }.should == "1\n2\n3\n"
+      expect(capture(:stdout) { A.new.invoke(:c) }).to eq("1\n2\n3\n")
     end
 
     it "does not invoke a Thor::Group twice" do
       base = A.new
       silence(:stdout){ base.invoke(:c) }
-      capture(:stdout){ base.invoke(:c) }.should be_empty
+      expect(capture(:stdout) { base.invoke(:c) }).to be_empty
     end
 
     it "does not invoke any of Thor::Group tasks twice" do
       base = A.new
       silence(:stdout){ base.invoke(:c) }
-      capture(:stdout){ base.invoke("c:one") }.should be_empty
+      expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
     end
 
     it "raises Thor::UndefinedTaskError if the task can't be found" do
-      lambda do
+      expect {
         A.new.invoke("foo:bar")
-      end.should raise_error(Thor::UndefinedTaskError)
+      }.to raise_error(Thor::UndefinedTaskError)
     end
 
     it "raises Thor::UndefinedTaskError if the task can't be found even if all tasks where already executed" do
       base = C.new
       silence(:stdout){ base.invoke_all }
 
-      lambda do
+      expect {
         base.invoke("foo:bar")
-      end.should raise_error(Thor::UndefinedTaskError)
+      }.to raise_error(Thor::UndefinedTaskError)
     end
 
     it "raises an error if a non Thor class is given" do
-      lambda do
+      expect {
         A.new.invoke(Object)
-      end.should raise_error(RuntimeError, "Expected Thor class, got Object")
+      }.to raise_error(RuntimeError, "Expected Thor class, got Object")
     end
   end
 end

data/spec/parser/argument_spec.rb

@@ -9,45 +9,45 @@ describe Thor::Argument do
 
   describe "errors" do
     it "raises an error if name is not supplied" do
-      lambda {
+      expect {
         argument(nil)
-      }.should raise_error(ArgumentError, "Argument name can't be nil.")
+      }.to raise_error(ArgumentError, "Argument name can't be nil.")
     end
 
     it "raises an error if type is unknown" do
-      lambda {
+      expect {
         argument(:task, :type => :unknown)
-      }.should raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+      }.to raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
     end
 
     it "raises an error if argument is required and have default values" do
-      lambda {
+      expect {
         argument(:task, :type => :string, :default => "bar", :required => true)
-      }.should raise_error(ArgumentError, "An argument cannot be required and have default value.")
+      }.to raise_error(ArgumentError, "An argument cannot be required and have default value.")
     end
 
     it "raises an error if enum isn't an array" do
-      lambda {
+      expect {
         argument(:task, :type => :string, :enum => "bar")
-      }.should raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
+      }.to raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
     end
   end
 
   describe "#usage" do
     it "returns usage for string types" do
-      argument(:foo, :type => :string).usage.should == "FOO"
+      expect(argument(:foo, :type => :string).usage).to eq("FOO")
     end
 
     it "returns usage for numeric types" do
-      argument(:foo, :type => :numeric).usage.should == "N"
+      expect(argument(:foo, :type => :numeric).usage).to eq("N")
     end
 
     it "returns usage for array types" do
-      argument(:foo, :type => :array).usage.should == "one two three"
+      expect(argument(:foo, :type => :array).usage).to eq("one two three")
     end
 
     it "returns usage for hash types" do
-      argument(:foo, :type => :hash).usage.should == "key:value"
+      expect(argument(:foo, :type => :hash).usage).to eq("key:value")
     end
   end
 end

data/spec/parser/arguments_spec.rb

@@ -19,48 +19,48 @@ describe Thor::Arguments do
   describe "#parse" do
     it "parses arguments in the given order" do
       create :string => nil, :numeric => nil
-      parse("name", "13")["string"].should == "name"
-      parse("name", "13")["numeric"].should == 13
+      expect(parse("name", "13")["string"]).to eq("name")
+      expect(parse("name", "13")["numeric"]).to eq(13)
     end
 
     it "accepts hashes" do
       create :string => nil, :hash => nil
-      parse("product", "title:string", "age:integer")["string"].should == "product"
-      parse("product", "title:string", "age:integer")["hash"].should == { "title" => "string", "age" => "integer"}
-      parse("product", "url:http://www.amazon.com/gp/product/123")["hash"].should == { "url" => "http://www.amazon.com/gp/product/123" }
+      expect(parse("product", "title:string", "age:integer")["string"]).to eq("product")
+      expect(parse("product", "title:string", "age:integer")["hash"]).to eq({ "title" => "string", "age" => "integer"})
+      expect(parse("product", "url:http://www.amazon.com/gp/product/123")["hash"]).to eq({ "url" => "http://www.amazon.com/gp/product/123" })
     end
 
     it "accepts arrays" do
       create :string => nil, :array => nil
-      parse("product", "title", "age")["string"].should == "product"
-      parse("product", "title", "age")["array"].should == %w(title age)
+      expect(parse("product", "title", "age")["string"]).to eq("product")
+      expect(parse("product", "title", "age")["array"]).to eq(%w(title age))
     end
 
     describe "with no inputs" do
       it "and no arguments returns an empty hash" do
         create
-        parse.should == {}
+        expect(parse).to eq({})
       end
 
       it "and required arguments raises an error" do
         create :string => nil, :numeric => nil
-        lambda { parse }.should raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
+        expect{ parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
       end
 
       it "and default arguments returns default values" do
         create :string => "name", :numeric => 13
-        parse.should == { "string" => "name", "numeric" => 13 }
+        expect(parse).to eq({ "string" => "name", "numeric" => 13 })
       end
     end
 
     it "returns the input if it's already parsed" do
       create :string => nil, :hash => nil, :array => nil, :numeric => nil
-      parse("", 0, {}, []).should == { "string" => "", "numeric" => 0, "hash" => {}, "array" => [] }
+      expect(parse("", 0, {}, [])).to eq({ "string" => "", "numeric" => 0, "hash" => {}, "array" => [] })
     end
 
     it "returns the default value if none is provided" do
       create :string => "foo", :numeric => 3.0
-      parse("bar").should == { "string" => "bar", "numeric" => 3.0 }
+      expect(parse("bar")).to eq({ "string" => "bar", "numeric" => 3.0 })
     end
   end
 end

data/spec/parser/option_spec.rb

@@ -15,187 +15,187 @@ describe Thor::Option do
     describe "with value as a symbol" do
       describe "and symbol is a valid type" do
         it "has type equals to the symbol" do
-          parse(:foo, :string).type.should == :string
-          parse(:foo, :numeric).type.should == :numeric
+          expect(parse(:foo, :string).type).to eq(:string)
+          expect(parse(:foo, :numeric).type).to eq(:numeric)
         end
 
         it "has not default value" do
-          parse(:foo, :string).default.should be_nil
-          parse(:foo, :numeric).default.should be_nil
+          expect(parse(:foo, :string).default).to be_nil
+          expect(parse(:foo, :numeric).default).to be_nil
         end
       end
 
       describe "equals to :required" do
         it "has type equals to :string" do
-          parse(:foo, :required).type.should == :string
+          expect(parse(:foo, :required).type).to eq(:string)
         end
 
         it "has no default value" do
-          parse(:foo, :required).default.should be_nil
+          expect(parse(:foo, :required).default).to be_nil
         end
       end
 
       describe "and symbol is not a reserved key" do
         it "has type equals to :string" do
-          parse(:foo, :bar).type.should == :string
+          expect(parse(:foo, :bar).type).to eq(:string)
         end
 
         it "has no default value" do
-          parse(:foo, :bar).default.should be_nil
+          expect(parse(:foo, :bar).default).to be_nil
         end
       end
     end
 
     describe "with value as hash" do
       it "has default type :hash" do
-        parse(:foo, :a => :b).type.should == :hash
+        expect(parse(:foo, :a => :b).type).to eq(:hash)
       end
 
       it "has default value equals to the hash" do
-        parse(:foo, :a => :b).default.should == { :a => :b }
+        expect(parse(:foo, :a => :b).default).to eq({ :a => :b })
       end
     end
 
     describe "with value as array" do
       it "has default type :array" do
-        parse(:foo, [:a, :b]).type.should == :array
+        expect(parse(:foo, [:a, :b]).type).to eq(:array)
       end
 
       it "has default value equals to the array" do
-        parse(:foo, [:a, :b]).default.should == [:a, :b]
+        expect(parse(:foo, [:a, :b]).default).to eq([:a, :b])
       end
     end
 
     describe "with value as string" do
       it "has default type :string" do
-        parse(:foo, "bar").type.should == :string
+        expect(parse(:foo, "bar").type).to eq(:string)
       end
 
       it "has default value equals to the string" do
-        parse(:foo, "bar").default.should == "bar"
+        expect(parse(:foo, "bar").default).to eq("bar")
       end
     end
 
     describe "with value as numeric" do
       it "has default type :numeric" do
-        parse(:foo, 2.0).type.should == :numeric
+        expect(parse(:foo, 2.0).type).to eq(:numeric)
       end
 
       it "has default value equals to the numeric" do
-        parse(:foo, 2.0).default.should == 2.0
+        expect(parse(:foo, 2.0).default).to eq(2.0)
       end
     end
 
     describe "with value as boolean" do
       it "has default type :boolean" do
-        parse(:foo, true).type.should == :boolean
-        parse(:foo, false).type.should == :boolean
+        expect(parse(:foo, true).type).to eq(:boolean)
+        expect(parse(:foo, false).type).to eq(:boolean)
       end
 
       it "has default value equals to the boolean" do
-        parse(:foo, true).default.should == true
-        parse(:foo, false).default.should == false
+        expect(parse(:foo, true).default).to eq(true)
+        expect(parse(:foo, false).default).to eq(false)
       end
     end
 
     describe "with key as a symbol" do
       it "sets the name equals to the key" do
-        parse(:foo, true).name.should == "foo"
+        expect(parse(:foo, true).name).to eq("foo")
       end
     end
 
     describe "with key as an array" do
       it "sets the first items in the array to the name" do
-        parse([:foo, :bar, :baz], true).name.should == "foo"
+        expect(parse([:foo, :bar, :baz], true).name).to eq("foo")
       end
 
       it "sets all other items as aliases" do
-        parse([:foo, :bar, :baz], true).aliases.should == [:bar, :baz]
+        expect(parse([:foo, :bar, :baz], true).aliases).to eq([:bar, :baz])
       end
     end
   end
 
   it "returns the switch name" do
-    option("foo").switch_name.should == "--foo"
-    option("--foo").switch_name.should == "--foo"
+    expect(option("foo").switch_name).to eq("--foo")
+    expect(option("--foo").switch_name).to eq("--foo")
   end
 
   it "returns the human name" do
-    option("foo").human_name.should == "foo"
-    option("--foo").human_name.should == "foo"
+    expect(option("foo").human_name).to eq("foo")
+    expect(option("--foo").human_name).to eq("foo")
   end
 
   it "converts underscores to dashes" do
-    option("foo_bar").switch_name.should == "--foo-bar"
+    expect(option("foo_bar").switch_name).to eq("--foo-bar")
   end
 
   it "can be required and have default values" do
     option = option("foo", :required => true, :type => :string, :default => "bar")
-    option.default.should == "bar"
-    option.should be_required
+    expect(option.default).to eq("bar")
+    expect(option).to be_required
   end
 
   it "cannot be required and have type boolean" do
-    lambda {
+    expect {
       option("foo", :required => true, :type => :boolean)
-    }.should raise_error(ArgumentError, "An option cannot be boolean and required.")
+    }.to raise_error(ArgumentError, "An option cannot be boolean and required.")
   end
 
   it "allows type predicates" do
-    parse(:foo, :string).should be_string
-    parse(:foo, :boolean).should be_boolean
-    parse(:foo, :numeric).should be_numeric
+    expect(parse(:foo, :string)).to be_string
+    expect(parse(:foo, :boolean)).to be_boolean
+    expect(parse(:foo, :numeric)).to be_numeric
   end
 
   it "raises an error on method missing" do
-    lambda {
+    expect {
       parse(:foo, :string).unknown?
-    }.should raise_error(NoMethodError)
+    }.to raise_error(NoMethodError)
   end
 
   describe "#usage" do
 
     it "returns usage for string types" do
-      parse(:foo, :string).usage.should == "[--foo=FOO]"
+      expect(parse(:foo, :string).usage).to eq("[--foo=FOO]")
     end
 
     it "returns usage for numeric types" do
-      parse(:foo, :numeric).usage.should == "[--foo=N]"
+      expect(parse(:foo, :numeric).usage).to eq("[--foo=N]")
     end
 
     it "returns usage for array types" do
-      parse(:foo, :array).usage.should == "[--foo=one two three]"
+      expect(parse(:foo, :array).usage).to eq("[--foo=one two three]")
     end
 
     it "returns usage for hash types" do
-      parse(:foo, :hash).usage.should == "[--foo=key:value]"
+      expect(parse(:foo, :hash).usage).to eq("[--foo=key:value]")
     end
 
     it "returns usage for boolean types" do
-      parse(:foo, :boolean).usage.should == "[--foo]"
+      expect(parse(:foo, :boolean).usage).to eq("[--foo]")
     end
 
     it "uses padding when no aliases is given" do
-      parse(:foo, :boolean).usage(4).should == "    [--foo]"
+      expect(parse(:foo, :boolean).usage(4)).to eq("    [--foo]")
     end
 
     it "uses banner when supplied" do
-      option(:foo, :required => false, :type => :string, :banner => "BAR").usage.should == "[--foo=BAR]"
+      expect(option(:foo, :required => false, :type => :string, :banner => "BAR").usage).to eq("[--foo=BAR]")
     end
 
     it "checkes when banner is an empty string" do
-      option(:foo, :required => false, :type => :string, :banner => "").usage.should == "[--foo]"
+      expect(option(:foo, :required => false, :type => :string, :banner => "").usage).to eq("[--foo]")
     end
 
     describe "with required values" do
       it "does not show the usage between brackets" do
-        parse(:foo, :required).usage.should == "--foo=FOO"
+        expect(parse(:foo, :required).usage).to eq("--foo=FOO")
       end
     end
 
     describe "with aliases" do
       it "does not show the usage between brackets" do
-        parse([:foo, "-f", "-b"], :required).usage.should == "-f, -b, --foo=FOO"
+        expect(parse([:foo, "-f", "-b"], :required).usage).to eq("-f, -b, --foo=FOO")
       end
     end
   end