thor 0.14.4 → 0.14.5

data/spec/thor_spec.rb

@@ -5,67 +5,67 @@ describe Thor do
     it "sets options to the next method to be invoked" do
       args = ["foo", "bar", "--force"]
       arg, options = MyScript.start(args)
-      options.must == { "force" => true }
+      options.should == { "force" => true }
     end
 
     describe ":lazy_default" do
       it "is absent when option is not specified" do
         arg, options = MyScript.start(["with_optional"])
-        options.must == {}
+        options.should == {}
       end
 
       it "sets a default that can be overridden for strings" do
         arg, options = MyScript.start(["with_optional", "--lazy"])
-        options.must == { "lazy" => "yes" }
+        options.should == { "lazy" => "yes" }
 
         arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
-        options.must == { "lazy" => "yesyes!" }
+        options.should == { "lazy" => "yesyes!" }
       end
 
       it "sets a default that can be overridden for numerics" do
         arg, options = MyScript.start(["with_optional", "--lazy-numeric"])
-        options.must == { "lazy_numeric" => 42 }
+        options.should == { "lazy_numeric" => 42 }
 
         arg, options = MyScript.start(["with_optional", "--lazy-numeric", 20000])
-        options.must == { "lazy_numeric" => 20000 }
+        options.should == { "lazy_numeric" => 20000 }
       end
 
       it "sets a default that can be overridden for arrays" do
         arg, options = MyScript.start(["with_optional", "--lazy-array"])
-        options.must == { "lazy_array" => %w[eat at joes] }
+        options.should == { "lazy_array" => %w[eat at joes] }
 
         arg, options = MyScript.start(["with_optional", "--lazy-array", "hello", "there"])
-        options.must == { "lazy_array" => %w[hello there] }
+        options.should == { "lazy_array" => %w[hello there] }
       end
 
       it "sets a default that can be overridden for hashes" do
         arg, options = MyScript.start(["with_optional", "--lazy-hash"])
-        options.must == { "lazy_hash" => {'swedish' => 'meatballs'} }
+        options.should == { "lazy_hash" => {'swedish' => 'meatballs'} }
 
         arg, options = MyScript.start(["with_optional", "--lazy-hash", "polish:sausage"])
-        options.must == { "lazy_hash" => {'polish' => 'sausage'} }
+        options.should == { "lazy_hash" => {'polish' => 'sausage'} }
       end
     end
 
     describe "when :for is supplied" do
       it "updates an already defined task" do
         args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
-        options[:other].must == "fish"
+        options[:other].should == "fish"
       end
 
       describe "and the target is on the parent class" do
         it "updates an already defined task" do
           args = ["example_default_task", "my_param", "--new-option=verified"]
           options = Scripts::MyScript.start(args)
-          options[:new_option].must == "verified"
+          options[:new_option].should == "verified"
         end
 
         it "adds a task to the tasks list if the updated task is on the parent class" do
-          Scripts::MyScript.tasks["example_default_task"].must_not be_nil
+          Scripts::MyScript.tasks["example_default_task"].should_not be_nil
         end
 
         it "clones the parent task" do
-          Scripts::MyScript.tasks["example_default_task"].must_not == MyChildScript.tasks["example_default_task"]
+          Scripts::MyScript.tasks["example_default_task"].should_not == MyChildScript.tasks["example_default_task"]
         end
       end
     end
@@ -73,48 +73,48 @@ describe Thor do
 
   describe "#default_task" do
     it "sets a default task" do
-      MyScript.default_task.must == "example_default_task"
+      MyScript.default_task.should == "example_default_task"
     end
 
     it "invokes the default task if no command is specified" do
-      MyScript.start([]).must == "default task"
+      MyScript.start([]).should == "default task"
     end
 
     it "invokes the default task if no command is specified even if switches are given" do
-      MyScript.start(["--with", "option"]).must == {"with"=>"option"}
+      MyScript.start(["--with", "option"]).should == {"with"=>"option"}
     end
 
     it "inherits the default task from parent" do
-      MyChildScript.default_task.must == "example_default_task"
+      MyChildScript.default_task.should == "example_default_task"
     end
   end
 
   describe "#map" do
     it "calls the alias of a method if one is provided" do
-      MyScript.start(["-T", "fish"]).must == ["fish"]
+      MyScript.start(["-T", "fish"]).should == ["fish"]
     end
 
     it "calls the alias of a method if several are provided via .map" do
-      MyScript.start(["-f", "fish"]).must == ["fish", {}]
-      MyScript.start(["--foo", "fish"]).must == ["fish", {}]
+      MyScript.start(["-f", "fish"]).should == ["fish", {}]
+      MyScript.start(["--foo", "fish"]).should == ["fish", {}]
     end
 
     it "inherits all mappings from parent" do
-      MyChildScript.default_task.must == "example_default_task"
+      MyChildScript.default_task.should == "example_default_task"
     end
   end
 
   describe "#desc" do
     it "provides description for a task" do
       content = capture(:stdout) { MyScript.start(["help"]) }
-      content.must =~ /thor my_script:zoo\s+# zoo around/m
+      content.should =~ /thor my_script:zoo\s+# zoo around/m
     end
 
     it "provides no namespace if $thor_runner is false" do
       begin
         $thor_runner = false
         content = capture(:stdout) { MyScript.start(["help"]) }
-        content.must =~ /thor zoo\s+# zoo around/m
+        content.should =~ /thor zoo\s+# zoo around/m
       ensure
         $thor_runner = true
       end
@@ -122,17 +122,17 @@ describe Thor do
 
     describe "when :for is supplied" do
       it "overwrites a previous defined task" do
-        capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \s+# fish around/m
+        capture(:stdout) { MyChildScript.start(["help"]) }.should =~ /animal KIND \s+# fish around/m
       end
     end
 
     describe "when :hide is supplied" do
       it "does not show the task in help" do
-        capture(:stdout) { MyScript.start(["help"]) }.must_not =~ /this is hidden/m
+        capture(:stdout) { MyScript.start(["help"]) }.should_not =~ /this is hidden/m
       end
 
       it "but the task is still invokcable not show the task in help" do
-        MyScript.start(["hidden", "yesyes"]).must == ["yesyes"]
+        MyScript.start(["hidden", "yesyes"]).should == ["yesyes"]
       end
     end
   end
@@ -140,79 +140,79 @@ describe Thor do
   describe "#method_options" do
     it "sets default options if called before an initializer" do
       options = MyChildScript.class_options
-      options[:force].type.must == :boolean
-      options[:param].type.must == :numeric
+      options[:force].type.should == :boolean
+      options[:param].type.should == :numeric
     end
 
     it "overwrites default options if called on the method scope" do
       args = ["zoo", "--force", "--param", "feathers"]
       options = MyChildScript.start(args)
-      options.must == { "force" => true, "param" => "feathers" }
+      options.should == { "force" => true, "param" => "feathers" }
     end
 
     it "allows default options to be merged with method options" do
       args = ["animal", "bird", "--force", "--param", "1.0", "--other", "tweets"]
       arg, options = MyChildScript.start(args)
-      arg.must == 'bird'
-      options.must == { "force"=>true, "param"=>1.0, "other"=>"tweets" }
+      arg.should == 'bird'
+      options.should == { "force"=>true, "param"=>1.0, "other"=>"tweets" }
     end
   end
 
   describe "#start" do
     it "calls a no-param method when no params are passed" do
-      MyScript.start(["zoo"]).must == true
+      MyScript.start(["zoo"]).should == true
     end
 
     it "calls a single-param method when a single param is passed" do
-      MyScript.start(["animal", "fish"]).must == ["fish"]
+      MyScript.start(["animal", "fish"]).should == ["fish"]
     end
 
     it "does not set options in attributes" do
-      MyScript.start(["with_optional", "--all"]).must == [nil, { "all" => true }]
+      MyScript.start(["with_optional", "--all"]).should == [nil, { "all" => true }]
     end
 
     it "raises an error if a required param is not provided" do
-      capture(:stderr) { MyScript.start(["animal"]) }.strip.must == '"animal" was called incorrectly. Call as "thor my_script:animal TYPE".'
+      capture(:stderr) { MyScript.start(["animal"]) }.strip.should == '"animal" was called incorrectly. Call as "thor my_script:animal TYPE".'
     end
 
     it "raises an error if the invoked task does not exist" do
-      capture(:stderr) { Amazing.start(["animal"]) }.strip.must == 'Could not find task "animal" in "amazing" namespace.'
+      capture(:stderr) { Amazing.start(["animal"]) }.strip.should == 'Could not find task "animal" in "amazing" namespace.'
     end
 
     it "calls method_missing if an unknown method is passed in" do
-      MyScript.start(["unk", "hello"]).must == [:unk, ["hello"]]
+      MyScript.start(["unk", "hello"]).should == [:unk, ["hello"]]
     end
 
     it "does not call a private method no matter what" do
-      capture(:stderr) { MyScript.start(["what"]) }.strip.must == 'Could not find task "what" in "my_script" namespace.'
+      capture(:stderr) { MyScript.start(["what"]) }.strip.should == 'Could not find task "what" in "my_script" namespace.'
     end
 
     it "uses task default options" do
       options = MyChildScript.start(["animal", "fish"]).last
-      options.must == { "other" => "method default" }
+      options.should == { "other" => "method default" }
     end
 
     it "raises when an exception happens within the task call" do
-      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.must raise_error(ArgumentError)
+      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.should raise_error(ArgumentError)
     end
   end
 
   describe "#subcommand" do
     it "maps a given subcommand to another Thor subclass" do
       barn_help = capture(:stdout){ Scripts::MyDefaults.start(["barn"]) }
-      barn_help.must include("barn help [COMMAND]  # Describe subcommands or one specific subcommand")
+      barn_help.should include("barn help [COMMAND]  # Describe subcommands or one specific subcommand")
     end
 
     it "passes commands to subcommand classes" do
-      capture(:stdout){ Scripts::MyDefaults.start(["barn", "open"]) }.strip.must == "Open sesame!"
+      capture(:stdout){ Scripts::MyDefaults.start(["barn", "open"]) }.strip.should == "Open sesame!"
     end
 
     it "passes arguments to subcommand classes" do
-      capture(:stdout){ Scripts::MyDefaults.start(["barn", "open", "shotgun"]) }.strip.must == "That's going to leave a mark."
+      capture(:stdout){ Scripts::MyDefaults.start(["barn", "open", "shotgun"]) }.strip.should == "That's going to leave a mark."
     end
 
     it "ignores unknown options (the subcommand class will handle them)" do
-      capture(:stdout){ Scripts::MyDefaults.start(["barn", "paint", "blue", "--coats", "4"])}.strip.must == "4 coats of blue paint"
+      capture(:stdout){ Scripts::MyDefaults.start(["barn", "paint", "blue", "--coats", "4"])}.strip.should == "4 coats of blue paint"
     end
   end
 
@@ -227,43 +227,43 @@ describe Thor do
       end
 
       it "provides useful help info for the help method itself" do
-        @content.must =~ /help \[TASK\]\s+# Describe available tasks/
+        @content.should =~ /help \[TASK\]\s+# Describe available tasks/
       end
 
       it "provides useful help info for a method with params" do
-        @content.must =~ /animal TYPE\s+# horse around/
+        @content.should =~ /animal TYPE\s+# horse around/
       end
 
       it "uses the maximum terminal size to show tasks" do
         @shell.should_receive(:terminal_width).and_return(80)
         content = capture(:stdout){ MyScript.help(shell) }
-        content.must =~ /aaa\.\.\.$/
+        content.should =~ /aaa\.\.\.$/
       end
 
       it "provides description for tasks from classes in the same namespace" do
-        @content.must =~ /baz\s+# do some bazing/
+        @content.should =~ /baz\s+# do some bazing/
       end
 
       it "shows superclass tasks" do
         content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /foo BAR \s+# do some fooing/
+        content.should =~ /foo BAR \s+# do some fooing/
       end
 
       it "shows class options information" do
         content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /Options\:/
-        content.must =~ /\[\-\-param=N\]/
+        content.should =~ /Options\:/
+        content.should =~ /\[\-\-param=N\]/
       end
 
       it "injects class arguments into default usage" do
         content = capture(:stdout){ Scripts::MyScript.help(shell) }
-        content.must =~ /zoo ACCESSOR \-\-param\=PARAM/
+        content.should =~ /zoo ACCESSOR \-\-param\=PARAM/
       end
     end
 
     describe "for a specific task" do
       it "provides full help info when talking about a specific task" do
-        capture(:stdout) { MyScript.task_help(shell, "foo") }.must == <<-END
+        capture(:stdout) { MyScript.task_help(shell, "foo") }.should == <<-END
 Usage:
   thor my_script:foo BAR
 
@@ -279,15 +279,15 @@ END
       it "raises an error if the task can't be found" do
         lambda {
           MyScript.task_help(shell, "unknown")
-        }.must raise_error(Thor::UndefinedTaskError, 'Could not find task "unknown" in "my_script" namespace.')
+        }.should raise_error(Thor::UndefinedTaskError, 'Could not find task "unknown" in "my_script" namespace.')
       end
 
       it "normalizes names before claiming they don't exist" do
-        capture(:stdout) { MyScript.task_help(shell, "name-with-dashes") }.must =~ /thor my_script:name-with-dashes/
+        capture(:stdout) { MyScript.task_help(shell, "name-with-dashes") }.should =~ /thor my_script:name-with-dashes/
       end
 
       it "uses the long description if it exists" do
-        capture(:stdout) { MyScript.task_help(shell, "long_description") }.must == <<-HELP
+        capture(:stdout) { MyScript.task_help(shell, "long_description") }.should == <<-HELP
 Usage:
   thor my_script:long_description
 
@@ -301,17 +301,17 @@ HELP
       it "doesn't assign the long description to the next task without one" do
         capture(:stdout) do
           MyScript.task_help(shell, "name_with_dashes")
-        end.must_not =~ /so very long/i
+        end.should_not =~ /so very long/i
       end
     end
 
     describe "instance method" do
       it "calls the class method" do
-        capture(:stdout){ MyScript.start(["help"]) }.must =~ /Tasks:/
+        capture(:stdout){ MyScript.start(["help"]) }.should =~ /Tasks:/
       end
 
       it "calls the class method" do
-        capture(:stdout){ MyScript.start(["help", "foo"]) }.must =~ /Usage:/
+        capture(:stdout){ MyScript.start(["help", "foo"]) }.should =~ /Usage:/
       end
     end
   end
@@ -321,14 +321,14 @@ HELP
       capture(:stdout) {
         klass = Class.new(Thor)
         klass.class_eval "def hello_from_thor; end"
-      }.must =~ /\[WARNING\] Attempted to create task "hello_from_thor" without usage or description/
+      }.should =~ /\[WARNING\] Attempted to create task "hello_from_thor" without usage or description/
     end
 
     it "does not print if overwriting a previous task" do
       capture(:stdout) {
         klass = Class.new(Thor)
         klass.class_eval "def help; end"
-      }.must be_empty
+      }.should be_empty
     end
   end
 end

data/spec/util_spec.rb

@@ -9,112 +9,112 @@ end
 describe Thor::Util do
   describe "#find_by_namespace" do
     it "returns 'default' if no namespace is given" do
-      Thor::Util.find_by_namespace('').must == Scripts::MyDefaults
+      Thor::Util.find_by_namespace('').should == Scripts::MyDefaults
     end
 
     it "adds 'default' if namespace starts with :" do
-      Thor::Util.find_by_namespace(':child').must == Scripts::ChildDefault
+      Thor::Util.find_by_namespace(':child').should == Scripts::ChildDefault
     end
 
     it "returns nil if the namespace can't be found" do
-      Thor::Util.find_by_namespace('thor:core_ext:ordered_hash').must be_nil
+      Thor::Util.find_by_namespace('thor:core_ext:ordered_hash').should be_nil
     end
 
     it "returns a class if it matches the namespace" do
-      Thor::Util.find_by_namespace('app:broken:counter').must == BrokenCounter
+      Thor::Util.find_by_namespace('app:broken:counter').should == BrokenCounter
     end
 
     it "matches classes default namespace" do
-      Thor::Util.find_by_namespace('scripts:my_script').must == Scripts::MyScript
+      Thor::Util.find_by_namespace('scripts:my_script').should == Scripts::MyScript
     end
   end
 
   describe "#namespace_from_thor_class" do
     it "replaces constant nesting with task namespacing" do
-      Thor::Util.namespace_from_thor_class("Foo::Bar::Baz").must == "foo:bar:baz"
+      Thor::Util.namespace_from_thor_class("Foo::Bar::Baz").should == "foo:bar:baz"
     end
 
     it "snake-cases component strings" do
-      Thor::Util.namespace_from_thor_class("FooBar::BarBaz::BazBoom").must == "foo_bar:bar_baz:baz_boom"
+      Thor::Util.namespace_from_thor_class("FooBar::BarBaz::BazBoom").should == "foo_bar:bar_baz:baz_boom"
     end
 
     it "accepts class and module objects" do
-      Thor::Util.namespace_from_thor_class(Thor::CoreExt::OrderedHash).must == "thor:core_ext:ordered_hash"
-      Thor::Util.namespace_from_thor_class(Thor::Util).must == "thor:util"
+      Thor::Util.namespace_from_thor_class(Thor::CoreExt::OrderedHash).should == "thor:core_ext:ordered_hash"
+      Thor::Util.namespace_from_thor_class(Thor::Util).should == "thor:util"
     end
 
     it "removes Thor::Sandbox namespace" do
-      Thor::Util.namespace_from_thor_class("Thor::Sandbox::Package").must == "package"
+      Thor::Util.namespace_from_thor_class("Thor::Sandbox::Package").should == "package"
     end
   end
 
   describe "#namespaces_in_content" do
     it "returns an array of names of constants defined in the string" do
       list = Thor::Util.namespaces_in_content("class Foo; class Bar < Thor; end; end; class Baz; class Bat; end; end")
-      list.must include("foo:bar")
-      list.must_not include("bar:bat")
+      list.should include("foo:bar")
+      list.should_not include("bar:bat")
     end
 
     it "doesn't put the newly-defined constants in the enclosing namespace" do
       Thor::Util.namespaces_in_content("class Blat; end")
-      defined?(Blat).must_not be
-      defined?(Thor::Sandbox::Blat).must be
+      defined?(Blat).should_not be
+      defined?(Thor::Sandbox::Blat).should be
     end
   end
 
   describe "#snake_case" do
     it "preserves no-cap strings" do
-      Thor::Util.snake_case("foo").must == "foo"
-      Thor::Util.snake_case("foo_bar").must == "foo_bar"
+      Thor::Util.snake_case("foo").should == "foo"
+      Thor::Util.snake_case("foo_bar").should == "foo_bar"
     end
 
     it "downcases all-caps strings" do
-      Thor::Util.snake_case("FOO").must == "foo"
-      Thor::Util.snake_case("FOO_BAR").must == "foo_bar"
+      Thor::Util.snake_case("FOO").should == "foo"
+      Thor::Util.snake_case("FOO_BAR").should == "foo_bar"
     end
 
     it "downcases initial-cap strings" do
-      Thor::Util.snake_case("Foo").must == "foo"
+      Thor::Util.snake_case("Foo").should == "foo"
     end
 
     it "replaces camel-casing with underscores" do
-      Thor::Util.snake_case("FooBarBaz").must == "foo_bar_baz"
-      Thor::Util.snake_case("Foo_BarBaz").must == "foo_bar_baz"
+      Thor::Util.snake_case("FooBarBaz").should == "foo_bar_baz"
+      Thor::Util.snake_case("Foo_BarBaz").should == "foo_bar_baz"
     end
 
     it "places underscores between multiple capitals" do
-      Thor::Util.snake_case("ABClass").must == "a_b_class"
+      Thor::Util.snake_case("ABClass").should == "a_b_class"
     end
   end
 
   describe "#find_class_and_task_by_namespace" do
     it "returns a Thor::Group class if full namespace matches" do
-      Thor::Util.find_class_and_task_by_namespace("my_counter").must == [MyCounter, nil]
+      Thor::Util.find_class_and_task_by_namespace("my_counter").should == [MyCounter, nil]
     end
 
     it "returns a Thor class if full namespace matches" do
-      Thor::Util.find_class_and_task_by_namespace("thor").must == [Thor, nil]
+      Thor::Util.find_class_and_task_by_namespace("thor").should == [Thor, nil]
     end
 
     it "returns a Thor class and the task name" do
-      Thor::Util.find_class_and_task_by_namespace("thor:help").must == [Thor, "help"]
+      Thor::Util.find_class_and_task_by_namespace("thor:help").should == [Thor, "help"]
     end
 
     it "falls back in the namespace:task look up even if a full namespace does not match" do
       Thor.const_set(:Help, Module.new)
-      Thor::Util.find_class_and_task_by_namespace("thor:help").must == [Thor, "help"]
+      Thor::Util.find_class_and_task_by_namespace("thor:help").should == [Thor, "help"]
       Thor.send :remove_const, :Help
     end
 
     it "falls back on the default namespace class if nothing else matches" do
-      Thor::Util.find_class_and_task_by_namespace("test").must == [Scripts::MyDefaults, "test"]
+      Thor::Util.find_class_and_task_by_namespace("test").should == [Scripts::MyDefaults, "test"]
     end
   end
 
   describe "#thor_classes_in" do
     it "returns thor classes inside the given class" do
-      Thor::Util.thor_classes_in(MyScript).must == [MyScript::AnotherScript]
-      Thor::Util.thor_classes_in(MyScript::AnotherScript).must be_empty
+      Thor::Util.thor_classes_in(MyScript).should == [MyScript::AnotherScript]
+      Thor::Util.thor_classes_in(MyScript::AnotherScript).should be_empty
     end
   end
 
@@ -125,14 +125,14 @@ describe Thor::Util do
     end
 
     it "returns the user path if none variable is set on the environment" do
-      Thor::Util.user_home.must == File.expand_path("~")
+      Thor::Util.user_home.should == File.expand_path("~")
     end
 
     it "returns the *unix system path if file cannot be expanded and separator does not exist" do
       File.should_receive(:expand_path).with("~").and_raise(RuntimeError)
       previous_value = File::ALT_SEPARATOR
       capture(:stderr){ File.const_set(:ALT_SEPARATOR, false) }
-      Thor::Util.user_home.must == "/"
+      Thor::Util.user_home.should == "/"
       capture(:stderr){ File.const_set(:ALT_SEPARATOR, previous_value) }
     end
 
@@ -140,24 +140,24 @@ describe Thor::Util do
       File.should_receive(:expand_path).with("~").and_raise(RuntimeError)
       previous_value = File::ALT_SEPARATOR
       capture(:stderr){ File.const_set(:ALT_SEPARATOR, true) }
-      Thor::Util.user_home.must == "C:/"
+      Thor::Util.user_home.should == "C:/"
       capture(:stderr){ File.const_set(:ALT_SEPARATOR, previous_value) }
     end
 
     it "returns HOME/.thor if set" do
       ENV.stub!(:[]).with("HOME").and_return("/home/user/")
-      Thor::Util.user_home.must == "/home/user/"
+      Thor::Util.user_home.should == "/home/user/"
     end
 
     it "returns path with HOMEDRIVE and HOMEPATH if set" do
       ENV.stub!(:[]).with("HOMEDRIVE").and_return("D:/")
       ENV.stub!(:[]).with("HOMEPATH").and_return("Documents and Settings/James")
-      Thor::Util.user_home.must == "D:/Documents and Settings/James"
+      Thor::Util.user_home.should == "D:/Documents and Settings/James"
     end
 
     it "returns APPDATA/.thor if set" do
       ENV.stub!(:[]).with("APPDATA").and_return("/home/user/")
-      Thor::Util.user_home.must == "/home/user/"
+      Thor::Util.user_home.should == "/home/user/"
     end
   end
 end