thor 0.14.4 → 0.14.5

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.must == 1
-      base.second.must == 2
+      base.first.should == 1
+      base.second.should == 2
     end
 
     it "sets arguments default values" do
       base = MyCounter.new [1]
-      base.second.must == 2
+      base.second.should == 2
     end
 
     it "sets options default values" do
       base = MyCounter.new [1, 2]
-      base.options[:third].must == 3
+      base.options[:third].should == 3
     end
 
     it "allows options to be given as symbols or strings" do
       base = MyCounter.new [1, 2], :third => 4
-      base.options[:third].must == 4
+      base.options[:third].should == 4
 
       base = MyCounter.new [1, 2], "third" => 4
-      base.options[:third].must == 4
+      base.options[:third].should == 4
     end
 
     it "creates options with indifferent access" do
       base = MyCounter.new [1, 2], :third => 3
-      base.options['third'].must == 3
+      base.options['third'].should == 3
     end
 
     it "creates options with magic predicates" do
       base = MyCounter.new [1, 2], :third => 3
-      base.options.third.must == 3
+      base.options.third.should == 3
     end
   end
 
   describe "#no_tasks" do
     it "avoids methods being added as tasks" do
-      MyScript.tasks.keys.must include("animal")
-      MyScript.tasks.keys.must_not include("this_is_not_a_task")
+      MyScript.tasks.keys.should include("animal")
+      MyScript.tasks.keys.should_not 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].must == 1
-      Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"]).must == "my_special_param"
+      MyCounter.start(["1", "2", "--third", "3"])[0].should == 1
+      Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"]).should == "my_special_param"
     end
 
     it "does not set a value in the options hash" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[0].must be_nil
+      BrokenCounter.start(["1", "2", "--third", "3"])[0].should be_nil
     end
   end
 
   describe "#arguments" do
     it "returns the arguments for the class" do
-      MyCounter.arguments.must have(2).items
+      MyCounter.arguments.should have(2).items
     end
   end
 
   describe "#class_option" do
     it "sets options class wise" do
-      MyCounter.start(["1", "2", "--third", "3"])[2].must == 3
+      MyCounter.start(["1", "2", "--third", "3"])[2].should == 3
     end
 
     it "does not create an accessor for it" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[3].must be_false
+      BrokenCounter.start(["1", "2", "--third", "3"])[3].should be_false
     end
   end
 
   describe "#class_options" do
     it "sets default options overwriting superclass definitions" do
       options = Scripts::MyScript.class_options
-      options[:force].must_not be_required
+      options[:force].should_not be_required
     end
   end
 
   describe "#remove_argument" do
     it "removes previous defined arguments from class" do
-      ClearCounter.arguments.must be_empty
+      ClearCounter.arguments.should be_empty
     end
 
     it "undefine accessors if required" do
-      ClearCounter.new.must_not respond_to(:first)
-      ClearCounter.new.must_not respond_to(:second)
+      ClearCounter.new.should_not respond_to(:first)
+      ClearCounter.new.should_not respond_to(:second)
     end
   end
 
   describe "#remove_class_option" do
     it "removes previous defined class option" do
-      ClearCounter.class_options[:third].must be_nil
+      ClearCounter.class_options[:third].should be_nil
     end
   end
 
@@ -109,73 +109,73 @@ describe Thor::Base do
     end
 
     it "shows options description" do
-      @content.must =~ /# The third argument/
+      @content.should =~ /# The third argument/
     end
 
     it "shows usage with banner content" do
-      @content.must =~ /\[\-\-third=THREE\]/
+      @content.should =~ /\[\-\-third=THREE\]/
     end
 
     it "shows default values below description" do
-      @content.must =~ /# Default: 3/
+      @content.should =~ /# Default: 3/
     end
 
     it "shows options in different groups" do
-      @content.must =~ /Options\:/
-      @content.must =~ /Runtime options\:/
-      @content.must =~ /\-p, \[\-\-pretend\]/
+      @content.should =~ /Options\:/
+      @content.should =~ /Runtime options\:/
+      @content.should =~ /\-p, \[\-\-pretend\]/
     end
 
     it "use padding in options that does not have aliases" do
-      @content.must =~ /^  -t, \[--third/
-      @content.must =~ /^      \[--fourth/
+      @content.should =~ /^  -t, \[--third/
+      @content.should =~ /^      \[--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.must =~ /Foo options\:/
-      content.must =~ /--last-name=LAST_NAME/
+      content.should =~ /Foo options\:/
+      content.should =~ /--last-name=LAST_NAME/
     end
   end
 
   describe "#namespace" do
     it "returns the default class namespace" do
-      Scripts::MyScript.namespace.must == "scripts:my_script"
+      Scripts::MyScript.namespace.should == "scripts:my_script"
     end
 
     it "sets a namespace to the class" do
-      Scripts::MyDefaults.namespace.must == "default"
+      Scripts::MyDefaults.namespace.should == "default"
     end
   end
 
   describe "#group" do
     it "sets a group" do
-      MyScript.group.must == "script"
+      MyScript.group.should == "script"
     end
 
     it "inherits the group from parent" do
-      MyChildScript.group.must == "script"
+      MyChildScript.group.should == "script"
     end
 
     it "defaults to standard if no group is given" do
-      Amazing.group.must == "standard"
+      Amazing.group.should == "standard"
     end
   end
 
   describe "#subclasses" do
     it "tracks its subclasses in an Array" do
-      Thor::Base.subclasses.must include(MyScript)
-      Thor::Base.subclasses.must include(MyChildScript)
-      Thor::Base.subclasses.must include(Scripts::MyScript)
+      Thor::Base.subclasses.should include(MyScript)
+      Thor::Base.subclasses.should include(MyChildScript)
+      Thor::Base.subclasses.should 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)].must == [
+      Thor::Base.subclass_files[File.expand_path(thorfile)].should == [
         MyScript, MyScript::AnotherScript, MyChildScript, Barn,
         Scripts::MyScript, Scripts::MyDefaults, Scripts::ChildDefault
       ]
@@ -183,46 +183,46 @@ describe Thor::Base do
 
     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)].must include(Amazing)
-      Thor::Base.subclass_files[File.expand_path(__FILE__)].must include(Amazing)
+      Thor::Base.subclass_files[File.expand_path(thorfile)].should include(Amazing)
+      Thor::Base.subclass_files[File.expand_path(__FILE__)].should include(Amazing)
     end
   end
 
   describe "#tasks" do
     it "returns a list with all tasks defined in this class" do
-      MyChildScript.new.must respond_to("animal")
-      MyChildScript.tasks.keys.must include("animal")
+      MyChildScript.new.should respond_to("animal")
+      MyChildScript.tasks.keys.should include("animal")
     end
 
     it "raises an error if a task with reserved word is defined" do
       lambda {
         klass = Class.new(Thor::Group)
         klass.class_eval "def shell; end"
-      }.must raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as task/)
+      }.should 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.must respond_to("foo")
-      MyChildScript.all_tasks.keys.must include("foo")
+      MyChildScript.new.should respond_to("foo")
+      MyChildScript.all_tasks.keys.should include("foo")
     end
   end
 
   describe "#remove_task" do
     it "removes the task from its tasks hash" do
-      MyChildScript.tasks.keys.must_not include("bar")
-      MyChildScript.tasks.keys.must_not include("boom")
+      MyChildScript.tasks.keys.should_not include("bar")
+      MyChildScript.tasks.keys.should_not include("boom")
     end
 
     it "undefines the method if desired" do
-      MyChildScript.new.must_not respond_to("boom")
+      MyChildScript.new.should_not 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.must == 13
+      MyCounter.get_from_super.should == 13
     end
   end
 
@@ -230,40 +230,40 @@ describe Thor::Base do
     it "raises an error instead of rescueing if --debug is given" do
       lambda {
         MyScript.start ["what", "--debug"]
-      }.must raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
+      }.should raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
     end
 
     it "does not steal args" do
       args = ["foo", "bar", "--force", "true"]
       MyScript.start(args)
-      args.must == ["foo", "bar", "--force", "true"]
+      args.should == ["foo", "bar", "--force", "true"]
     end
 
     it "checks unknown options" do
       capture(:stderr) {
         MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
-      }.strip.must == "Unknown switches '--unknown'"
+      }.strip.should == "Unknown switches '--unknown'"
     end
 
     it "checks unknown options except specified" do
       capture(:stderr) {
-        MyScript.start(["with_optional", "NAME", "--omg", "--invalid"]).must == ["NAME", {}]
-      }.strip.must be_empty
+        MyScript.start(["with_optional", "NAME", "--omg", "--invalid"]).should == ["NAME", {}]
+      }.strip.should be_empty
     end
   end
 
   describe "attr_*" do
     it "should not add attr_reader as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute"]) }.must =~ /Could not find/
+      capture(:stderr){ MyScript.start(["another_attribute"]) }.should =~ /Could not find/
     end
 
     it "should not add attr_writer as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }.must =~ /Could not find/
+      capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }.should =~ /Could not find/
     end
 
     it "should not add attr_accessor as a task" do
-      capture(:stderr){ MyScript.start(["some_attribute"]) }.must =~ /Could not find/
-      capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }.must =~ /Could not find/
+      capture(:stderr){ MyScript.start(["some_attribute"]) }.should =~ /Could not find/
+      capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }.should =~ /Could not find/
     end
   end
 end

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -7,37 +7,37 @@ describe Thor::CoreExt::HashWithIndifferentAccess do
   end
 
   it "has values accessible by either strings or symbols" do
-    @hash['foo'].must == 'bar'
-    @hash[:foo].must  == 'bar'
+    @hash['foo'].should == 'bar'
+    @hash[:foo].should  == 'bar'
 
-    @hash.values_at(:foo, :baz).must == ['bar', 'bee']
-    @hash.delete(:foo).must == 'bar'
+    @hash.values_at(:foo, :baz).should == ['bar', 'bee']
+    @hash.delete(:foo).should == 'bar'
   end
 
   it "handles magic boolean predicates" do
-    @hash.force?.must be_true
-    @hash.foo?.must be_true
-    @hash.nothing?.must be_false
+    @hash.force?.should be_true
+    @hash.foo?.should be_true
+    @hash.nothing?.should be_false
   end
 
   it "handles magic comparisions" do
-    @hash.foo?('bar').must be_true
-    @hash.foo?('bee').must be_false
+    @hash.foo?('bar').should be_true
+    @hash.foo?('bee').should be_false
   end
 
   it "maps methods to keys" do
-    @hash.foo.must == @hash['foo']
+    @hash.foo.should == @hash['foo']
   end
 
   it "merges keys independent if they are symbols or strings" do
     @hash.merge!('force' => false, :baz => "boom")
-    @hash[:force].must == false
-    @hash[:baz].must == "boom"
+    @hash[:force].should == false
+    @hash[:baz].should == "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].must == false
-    other[:baz].must == "boom"
+    other[:force].should == false
+    other[:baz].should == "boom"
   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"].must be_nil
+      @hash["foo"].should 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.must be_empty
-      @hash.values.must be_empty
+      @hash.keys.should be_empty
+      @hash.values.should be_empty
     end
 
     it "must be empty" do
-      @hash.must be_empty
+      @hash.should be_empty
     end
   end
 
@@ -35,15 +35,15 @@ describe Thor::CoreExt::OrderedHash do
     end
 
     it "returns nil for an undefined key" do
-      @hash[:boom].must be_nil
+      @hash[:boom].should be_nil
     end
 
     it "returns the value for each key" do
-      @hash[:foo].must == "Foo!"
-      @hash[:bar].must == "Bar!"
-      @hash[:baz].must == "Baz!"
-      @hash[:bop].must == "Bop!"
-      @hash[:bat].must == "Bat!"
+      @hash[:foo].should == "Foo!"
+      @hash[:bar].should == "Bar!"
+      @hash[:baz].should == "Baz!"
+      @hash[:bop].should == "Bop!"
+      @hash[:bat].should == "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.must == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
+      arr.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
                      [:bop, "Bop!"], [:bat, "Bat!"]]
     end
 
     it "returns the keys in order of insertion" do
-      @hash.keys.must == [:foo, :bar, :baz, :bop, :bat]
+      @hash.keys.should == [:foo, :bar, :baz, :bop, :bat]
     end
 
     it "returns the values in order of insertion" do
-      @hash.values.must == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"]
+      @hash.values.should == ["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.must == ["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"]
+      @hash.values.should == ["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"]
 
       @hash[:foo] = "Bip!"
-      @hash.values.must == ["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"]
+      @hash.values.should == ["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"]
 
       @hash[:bat] = "Bip!"
-      @hash.values.must == ["Bip!", "Bar!", "Bip!", "Bop!", "Bip!"]
+      @hash.values.should == ["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.must == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!", "one", "two", "three"]
+      @hash.merge(other_hash).values.should == ["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].must == "bar"
-      @hash[:bar].must == "Bar!"
+      @hash.merge(other_hash)[:bar].should == "bar"
+      @hash[:bar].should == "Bar!"
     end
 
     it "converts to an array" do
-      @hash.to_a.must == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]]
+      @hash.to_a.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]]
     end
 
     it "must not be empty" do
-      @hash.must_not be_empty
+      @hash.should_not be_empty
     end
 
     it "deletes values from hash" do
-      @hash.delete(:baz).must == "Baz!"
-      @hash.values.must == ["Foo!", "Bar!", "Bop!", "Bat!"]
+      @hash.delete(:baz).should == "Baz!"
+      @hash.values.should == ["Foo!", "Bar!", "Bop!", "Bat!"]
 
-      @hash.delete(:foo).must == "Foo!"
-      @hash.values.must == ["Bar!", "Bop!", "Bat!"]
+      @hash.delete(:foo).should == "Foo!"
+      @hash.values.should == ["Bar!", "Bop!", "Bat!"]
 
-      @hash.delete(:bat).must == "Bat!"
-      @hash.values.must == ["Bar!", "Bop!"]
+      @hash.delete(:bat).should == "Bat!"
+      @hash.values.should == ["Bar!", "Bop!"]
     end
 
     it "returns nil if the value to be deleted can't be found" do
-      @hash.delete(:nothing).must be_nil
+      @hash.delete(:nothing).should be_nil
     end
   end
 end