thor 0.17.0 → 0.18.0

data/spec/thor_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'helper'
 
 describe Thor do
   describe "#method_option" do
@@ -48,44 +48,44 @@ describe Thor do
     end
 
     describe "when :for is supplied" do
-      it "updates an already defined task" do
+      it "updates an already defined command" do
         args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
         expect(options[:other]).to eq("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"]
+        it "updates an already defined command" do
+          args = ["example_default_command", "my_param", "--new-option=verified"]
           options = Scripts::MyScript.start(args)
           expect(options[:new_option]).to eq("verified")
         end
 
-        it "adds a task to the tasks list if the updated task is on the parent class" do
-          expect(Scripts::MyScript.tasks["example_default_task"]).to be
+        it "adds a command to the command list if the updated command is on the parent class" do
+          expect(Scripts::MyScript.commands["example_default_command"]).to be
         end
 
-        it "clones the parent task" do
-          expect(Scripts::MyScript.tasks["example_default_task"]).not_to eq(MyChildScript.tasks["example_default_task"])
+        it "clones the parent command" do
+          expect(Scripts::MyScript.commands["example_default_command"]).not_to eq(MyChildScript.commands["example_default_command"])
         end
       end
     end
   end
 
-  describe "#default_task" do
-    it "sets a default task" do
-      expect(MyScript.default_task).to eq("example_default_task")
+  describe "#default_command" do
+    it "sets a default command" do
+      expect(MyScript.default_command).to eq("example_default_command")
     end
 
-    it "invokes the default task if no command is specified" do
-      expect(MyScript.start([])).to eq("default task")
+    it "invokes the default command if no command is specified" do
+      expect(MyScript.start([])).to eq("default command")
     end
 
-    it "invokes the default task if no command is specified even if switches are given" do
+    it "invokes the default command if no command is specified even if switches are given" do
       expect(MyScript.start(["--with", "option"])).to eq({"with"=>"option"})
     end
 
-    it "inherits the default task from parent" do
-      expect(MyChildScript.default_task).to eq("example_default_task")
+    it "inherits the default command from parent" do
+      expect(MyChildScript.default_command).to eq("example_default_command")
     end
   end
 
@@ -101,17 +101,17 @@ describe Thor do
         return options, args
       end
 
-      desc "boring", "An ordinary task"
+      desc "boring", "An ordinary command"
       def boring(*args)
         return options, args
       end
     end
 
-    it "passes remaining args to task when it encounters a non-option" do
+    it "passes remaining args to command when it encounters a non-option" do
       expect(my_script.start(%w[exec command --verbose])).to eq [{}, ["command", "--verbose"]]
     end
 
-    it "passes remaining args to task when it encounters an unknown option" do
+    it "passes remaining args to command when it encounters an unknown option" do
       expect(my_script.start(%w[exec --foo command --bar])).to eq [{}, ["--foo", "command", "--bar"]]
     end
 
@@ -123,19 +123,19 @@ describe Thor do
       expect(my_script.start(%w[exec --mode rashly command])).to eq [{"mode" => "rashly"}, ["command"]]
     end
 
-    it "still passes everything after -- to task" do
+    it "still passes everything after -- to command" do
       expect(my_script.start(%w[exec -- --verbose])).to eq [{}, ["--verbose"]]
     end
 
-    it "does not affect ordinary tasks"  do
+    it "does not affect ordinary commands"  do
       expect(my_script.start(%w[boring command --verbose])).to eq [{"verbose" => true}, ["command"]]
     end
 
-    context "when provided with multiple task names" do
+    context "when provided with multiple command names" do
       klass = Class.new(Thor) do
         stop_on_unknown_option! :foo, :bar
       end
-      it "affects all specified tasks" do
+      it "affects all specified commands" do
         expect(klass.stop_on_unknown_option?(mock :name => "foo")).to be_true
         expect(klass.stop_on_unknown_option?(mock :name => "bar")).to be_true
         expect(klass.stop_on_unknown_option?(mock :name => "baz")).to be_false
@@ -147,7 +147,7 @@ describe Thor do
         stop_on_unknown_option! :foo
         stop_on_unknown_option! :bar
       end
-      it "affects all specified tasks" do
+      it "affects all specified commands" do
         expect(klass.stop_on_unknown_option?(mock :name => "foo")).to be_true
         expect(klass.stop_on_unknown_option?(mock :name => "bar")).to be_true
         expect(klass.stop_on_unknown_option?(mock :name => "baz")).to be_false
@@ -166,12 +166,25 @@ describe Thor do
     end
 
     it "inherits all mappings from parent" do
-      expect(MyChildScript.default_task).to eq("example_default_task")
+      expect(MyChildScript.default_command).to eq("example_default_command")
+    end
+  end
+
+  describe "#package_name" do
+    it "provides a proper description for a command when the package_name is assigned" do
+      content = capture(:stdout) { PackageNameScript.start(["help"]) }
+      expect(content).to match(/Baboon commands:/m)
+    end
+
+    # TODO: remove this, might be redundant, just wanted to prove full coverage
+    it "provides a proper description for a command when the package_name is NOT assigned" do
+      content = capture(:stdout) { MyScript.start(["help"]) }
+      expect(content).to match(/Commands:/m)
     end
   end
 
   describe "#desc" do
-    it "provides description for a task" do
+    it "provides description for a command" do
       content = capture(:stdout) { MyScript.start(["help"]) }
       expect(content).to match(/thor my_script:zoo\s+# zoo around/m)
     end
@@ -187,17 +200,17 @@ describe Thor do
     end
 
     describe "when :for is supplied" do
-      it "overwrites a previous defined task" do
+      it "overwrites a previous defined command" do
         expect(capture(:stdout) { MyChildScript.start(["help"]) }).to match(/animal KIND \s+# fish around/m)
       end
     end
 
     describe "when :hide is supplied" do
-      it "does not show the task in help" do
+      it "does not show the command in help" do
         expect(capture(:stdout) { MyScript.start(["help"]) }).not_to match(/this is hidden/m)
       end
 
-      it "but the task is still invokcable not show the task in help" do
+      it "but the command is still invokcable not show the command in help" do
         expect(MyScript.start(["hidden", "yesyes"])).to eq(["yesyes"])
       end
     end
@@ -237,12 +250,21 @@ describe Thor do
       expect(MyScript.start(["with_optional", "--all"])).to eq([nil, { "all" => true }, []])
     end
 
-    it "raises an error if a required param is not provided" do
-      expect(capture(:stderr) { MyScript.start(["animal"]) }.strip).to eq('thor animal requires at least 1 argument: "thor my_script:animal TYPE".')
+    it "raises an error if the wrong number of params are provided" do
+      arity_asserter = lambda do |args, msg|
+        stderr = capture(:stderr) { Scripts::Arities.start(args) }
+        expect(stderr.strip).to eq(msg)
+      end
+      arity_asserter.call ["zero_args",    "one"         ], %Q'ERROR: thor zero_args was called with arguments ["one"]\nUsage: "thor scripts:arities:zero_args".'
+      arity_asserter.call ["one_arg"                     ], %Q'ERROR: thor one_arg was called with no arguments\nUsage: "thor scripts:arities:one_arg ARG".'
+      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: thor one_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG".'
+      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: thor one_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG".'
+      arity_asserter.call ["two_args",     "one"         ], %Q'ERROR: thor two_args was called with arguments ["one"]\nUsage: "thor scripts:arities:two_args ARG1 ARG2".'
+      arity_asserter.call ["optional_arg", "one", "two"  ], %Q'ERROR: thor optional_arg was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:optional_arg [ARG]".'
     end
 
-    it "raises an error if the invoked task does not exist" do
-      expect(capture(:stderr) { Amazing.start(["animal"]) }.strip).to eq('Could not find task "animal" in "amazing" namespace.')
+    it "raises an error if the invoked command does not exist" do
+      expect(capture(:stderr) { Amazing.start(["animal"]) }.strip).to eq('Could not find command "animal" in "amazing" namespace.')
     end
 
     it "calls method_missing if an unknown method is passed in" do
@@ -250,15 +272,15 @@ describe Thor do
     end
 
     it "does not call a private method no matter what" do
-      expect(capture(:stderr) { MyScript.start(["what"]) }.strip).to eq('Could not find task "what" in "my_script" namespace.')
+      expect(capture(:stderr) { MyScript.start(["what"]) }.strip).to eq('Could not find command "what" in "my_script" namespace.')
     end
 
-    it "uses task default options" do
+    it "uses command default options" do
       options = MyChildScript.start(["animal", "fish"]).last
       expect(options).to eq({ "other" => "method default" })
     end
 
-    it "raises when an exception happens within the task call" do
+    it "raises when an exception happens within the command call" do
       expect{ MyScript.start(["call_myself_with_wrong_arity"]) }.to raise_error(ArgumentError)
     end
 
@@ -267,8 +289,8 @@ describe Thor do
         expect(MyScript.start(["z"])).to eq(MyScript.start(["zoo"]))
       end
 
-      it "invokes a command, even when there's an alias the resolves to the same command" do
-        expect(MyScript.start(["hi"])).to eq(MyScript.start(["hidden"]))
+      it "invokes a command, even when there's an alias it resolves to the same command" do
+        expect(MyScript.start(["hi", "arg"])).to eq(MyScript.start(["hidden", "arg"]))
       end
 
       it "invokes an alias" do
@@ -278,35 +300,16 @@ describe Thor do
 
     context "when the user enters an ambiguous substring of a command" do
       it "raises an exception that explains the ambiguity" do
-        expect{ MyScript.start(["call"]) }.to raise_error(ArgumentError, 'Ambiguous task call matches [call_myself_with_wrong_arity, call_unexistent_method]')
+        expect{ MyScript.start(["call"]) }.to raise_error(ArgumentError, 'Ambiguous command call matches [call_myself_with_wrong_arity, call_unexistent_method]')
       end
 
       it "raises an exception when there is an alias" do
-        expect{ MyScript.start(["f"]) }.to raise_error(ArgumentError, 'Ambiguous task f matches [foo, fu]')
+        expect{ MyScript.start(["f"]) }.to raise_error(ArgumentError, 'Ambiguous command f matches [foo, fu]')
       end
     end
 
   end
 
-  describe "#subcommand" do
-    it "maps a given subcommand to another Thor subclass" do
-      barn_help = capture(:stdout) { Scripts::MyDefaults.start(["barn"]) }
-      expect(barn_help).to include("barn help [COMMAND]  # Describe subcommands or one specific subcommand")
-    end
-
-    it "passes commands to subcommand classes" do
-      expect(capture(:stdout) { Scripts::MyDefaults.start(["barn", "open"]) }.strip).to eq("Open sesame!")
-    end
-
-    it "passes arguments to subcommand classes" do
-      expect(capture(:stdout) { Scripts::MyDefaults.start(["barn", "open", "shotgun"]) }.strip).to eq("That's going to leave a mark.")
-    end
-
-    it "ignores unknown options (the subcommand class will handle them)" do
-      expect(capture(:stdout) { Scripts::MyDefaults.start(["barn", "paint", "blue", "--coats", "4"])}.strip).to eq("4 coats of blue paint")
-    end
-  end
-
   describe "#help" do
     def shell
       @shell ||= Thor::Base.shell.new
@@ -318,24 +321,24 @@ describe Thor do
       end
 
       it "provides useful help info for the help method itself" do
-        expect(@content).to match(/help \[TASK\]\s+# Describe available tasks/)
+        expect(@content).to match(/help \[COMMAND\]\s+# Describe available commands/)
       end
 
       it "provides useful help info for a method with params" do
         expect(@content).to match(/animal TYPE\s+# horse around/)
       end
 
-      it "uses the maximum terminal size to show tasks" do
+      it "uses the maximum terminal size to show commands" do
         @shell.should_receive(:terminal_width).and_return(80)
         content = capture(:stdout) { MyScript.help(shell) }
         expect(content).to match(/aaa\.\.\.$/)
       end
 
-      it "provides description for tasks from classes in the same namespace" do
+      it "provides description for commands from classes in the same namespace" do
         expect(@content).to match(/baz\s+# do some bazing/)
       end
 
-      it "shows superclass tasks" do
+      it "shows superclass commands" do
         content = capture(:stdout) { MyChildScript.help(shell) }
         expect(content).to match(/foo BAR \s+# do some fooing/)
       end
@@ -352,9 +355,9 @@ describe Thor do
       end
     end
 
-    describe "for a specific task" do
-      it "provides full help info when talking about a specific task" do
-        expect(capture(:stdout) { MyScript.task_help(shell, "foo") }).to eq(<<-END)
+    describe "for a specific command" do
+      it "provides full help info when talking about a specific command" do
+        expect(capture(:stdout) { MyScript.command_help(shell, "foo") }).to eq(<<-END)
 Usage:
   thor my_script:foo BAR
 
@@ -367,18 +370,18 @@ do some fooing
 END
       end
 
-      it "raises an error if the task can't be found" do
+      it "raises an error if the command can't be found" do
         expect {
-          MyScript.task_help(shell, "unknown")
-        }.to raise_error(Thor::UndefinedTaskError, 'Could not find task "unknown" in "my_script" namespace.')
+          MyScript.command_help(shell, "unknown")
+        }.to raise_error(Thor::UndefinedCommandError, 'Could not find command "unknown" in "my_script" namespace.')
       end
 
       it "normalizes names before claiming they don't exist" do
-        expect(capture(:stdout) { MyScript.task_help(shell, "name-with-dashes") }).to match(/thor my_script:name-with-dashes/)
+        expect(capture(:stdout) { MyScript.command_help(shell, "name-with-dashes") }).to match(/thor my_script:name-with-dashes/)
       end
 
       it "uses the long description if it exists" do
-        expect(capture(:stdout) { MyScript.task_help(shell, "long_description") }).to eq(<<-HELP)
+        expect(capture(:stdout) { MyScript.command_help(shell, "long_description") }).to eq(<<-HELP)
 Usage:
   thor my_script:long_description
 
@@ -389,16 +392,16 @@ Description:
 HELP
       end
 
-      it "doesn't assign the long description to the next task without one" do
+      it "doesn't assign the long description to the next command without one" do
         expect(capture(:stdout) {
-          MyScript.task_help(shell, "name_with_dashes")
+          MyScript.command_help(shell, "name_with_dashes")
         }).not_to match(/so very long/i)
       end
     end
 
     describe "instance method" do
       it "calls the class method" do
-        expect(capture(:stdout) { MyScript.start(["help"]) }).to match(/Tasks:/)
+        expect(capture(:stdout) { MyScript.start(["help"]) }).to match(/Commands:/)
       end
 
       it "calls the class method" do
@@ -407,15 +410,15 @@ HELP
     end
   end
 
-  describe "when creating tasks" do
+  describe "when creating commands" do
     it "prints a warning if a public method is created without description or usage" do
       expect(capture(:stdout) {
         klass = Class.new(Thor)
         klass.class_eval "def hello_from_thor; end"
-      }).to match(/\[WARNING\] Attempted to create task "hello_from_thor" without usage or description/)
+      }).to match(/\[WARNING\] Attempted to create command "hello_from_thor" without usage or description/)
     end
 
-    it "does not print if overwriting a previous task" do
+    it "does not print if overwriting a previous command" do
       expect(capture(:stdout) {
         klass = Class.new(Thor)
         klass.class_eval "def help; end"
@@ -481,7 +484,7 @@ HELP
       expect(klass.start(["unknown", "foo", "--bar", "baz"])).to eq(["foo"])
     end
 
-    it "send as a task name" do
+    it "send as a command name" do
       expect(MyScript.start(["send"])).to eq(true)
     end
   end

data/spec/util_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'helper'
 
 module Thor::Util
   def self.clear_user_home!
@@ -30,7 +30,7 @@ describe Thor::Util do
   end
 
   describe "#namespace_from_thor_class" do
-    it "replaces constant nesting with task namespacing" do
+    it "replaces constant nesting with command namespacing" do
       expect(Thor::Util.namespace_from_thor_class("Foo::Bar::Baz")).to eq("foo:bar:baz")
     end
 
@@ -87,27 +87,27 @@ describe Thor::Util do
     end
   end
 
-  describe "#find_class_and_task_by_namespace" do
+  describe "#find_class_and_command_by_namespace" do
     it "returns a Thor::Group class if full namespace matches" do
-      expect(Thor::Util.find_class_and_task_by_namespace("my_counter")).to eq([MyCounter, nil])
+      expect(Thor::Util.find_class_and_command_by_namespace("my_counter")).to eq([MyCounter, nil])
     end
 
     it "returns a Thor class if full namespace matches" do
-      expect(Thor::Util.find_class_and_task_by_namespace("thor")).to eq([Thor, nil])
+      expect(Thor::Util.find_class_and_command_by_namespace("thor")).to eq([Thor, nil])
     end
 
-    it "returns a Thor class and the task name" do
-      expect(Thor::Util.find_class_and_task_by_namespace("thor:help")).to eq([Thor, "help"])
+    it "returns a Thor class and the command name" do
+      expect(Thor::Util.find_class_and_command_by_namespace("thor:help")).to eq([Thor, "help"])
     end
 
-    it "falls back in the namespace:task look up even if a full namespace does not match" do
+    it "falls back in the namespace:command look up even if a full namespace does not match" do
       Thor.const_set(:Help, Module.new)
-      expect(Thor::Util.find_class_and_task_by_namespace("thor:help")).to eq([Thor, "help"])
+      expect(Thor::Util.find_class_and_command_by_namespace("thor:help")).to eq([Thor, "help"])
       Thor.send :remove_const, :Help
     end
 
     it "falls back on the default namespace class if nothing else matches" do
-      expect(Thor::Util.find_class_and_task_by_namespace("test")).to eq([Scripts::MyDefaults, "test"])
+      expect(Thor::Util.find_class_and_command_by_namespace("test")).to eq([Scripts::MyDefaults, "test"])
     end
   end
 

data/thor.gemspec

@@ -1,20 +1,24 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/thor/version', __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'thor/version'
 
-Gem::Specification.new do |s|
-  s.authors = ['Yehuda Katz', 'José Valim']
-  s.description = %q{A scripting framework that replaces rake, sake and rubigen}
-  s.email = 'ruby-thor@googlegroups.com'
-  s.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
-  s.extra_rdoc_files = ['CHANGELOG.rdoc', 'LICENSE.md', 'README.md', 'Thorfile']
-  s.files = `git ls-files`.split("\n")
-  s.homepage = 'http://whatisthor.com/'
-  s.licenses = ['MIT']
-  s.name = 'thor'
-  s.rdoc_options = ['--charset=UTF-8']
-  s.require_paths = ['lib']
-  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-  s.summary = s.description
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.version = Thor::VERSION
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.authors = ['Yehuda Katz', 'José Valim']
+  spec.description = %q{A scripting framework that replaces rake, sake and rubigen}
+  spec.email = 'ruby-thor@googlegroups.com'
+  spec.executables = %w(thor)
+  spec.files = %w(.document CHANGELOG.md LICENSE.md README.md Thorfile thor.gemspec)
+  spec.files += Dir.glob("bin/**/*")
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("spec/**/*")
+  spec.homepage = 'http://whatisthor.com/'
+  spec.licenses = ['MIT']
+  spec.name = 'thor'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.6'
+  spec.summary = spec.description
+  spec.test_files = Dir.glob("spec/**/*")
+  spec.version = Thor::VERSION
 end