thor 0.17.0 → 0.18.0

data/lib/thor/{task.rb → command.rb}

@@ -1,5 +1,5 @@
 class Thor
-  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
     def initialize(name, description, long_description, usage, options=nil)
@@ -15,27 +15,27 @@ class Thor
       false
     end
 
-    # By default, a task invokes a method in the thor class. You can change this
-    # implementation to create custom tasks.
+    # By default, a command invokes a method in the thor class. You can change this
+    # implementation to create custom commands.
     def run(instance, args=[])
       arity = nil
 
       if private_method?(instance)
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       elsif public_method?(instance)
         arity = instance.method(name).arity
         instance.__send__(name, *args)
       elsif local_method?(instance, :method_missing)
         instance.__send__(:method_missing, name.to_sym, *args)
       else
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       end
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ?
-        instance.class.handle_argument_error(self, e, arity) : (raise e)
+        instance.class.handle_argument_error(self, e, args, arity) : (raise e)
     rescue NoMethodError => e
       handle_no_method_error?(instance, e, caller) ?
-        instance.class.handle_no_task_error(name) : (raise e)
+        instance.class.handle_no_command_error(name) : (raise e)
     end
 
     # Returns the formatted usage by injecting given required arguments
@@ -107,26 +107,30 @@ class Thor
         error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
     end
   end
+  Task = Command
 
-  # A task that is hidden in help messages but still invocable.
-  class HiddenTask < Task
+  # A command that is hidden in help messages but still invocable.
+  class HiddenCommand < Command
     def hidden?
       true
     end
   end
+  HiddenTask = HiddenCommand
 
-  # A dynamic task that handles method missing scenarios.
-  class DynamicTask < Task
+  # A dynamic command that handles method missing scenarios.
+  class DynamicCommand < Command
     def initialize(name, options=nil)
-      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
+      super(name.to_s, "A dynamically-generated command", name.to_s, name.to_s, options)
     end
 
     def run(instance, args=[])
       if (instance.methods & [name.to_s, name.to_sym]).empty?
         super
       else
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       end
     end
   end
+  DynamicTask = DynamicCommand
+
 end

data/lib/thor/core_ext/io_binary_read.rb

@@ -0,0 +1,12 @@
+class IO #:nodoc:
+  class << self
+
+    def binread(file, *args)
+      raise ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
+      File.open(file, 'rb') do |f|
+        f.read(*args)
+      end
+    end unless method_defined? :binread
+
+  end
+end

data/lib/thor/error.rb

@@ -5,17 +5,15 @@ class Thor
   # Errors that are caused by the developer, like declaring a method which
   # overwrites a thor keyword, it SHOULD NOT raise a Thor::Error. This way, we
   # ensure that developer errors are shown with full backtrace.
-  #
   class Error < StandardError
   end
 
-  # Raised when a task was not found.
-  #
-  class UndefinedTaskError < Error
+  # Raised when a command was not found.
+  class UndefinedCommandError < Error
   end
+  UndefinedTaskError = UndefinedCommandError
 
-  # Raised when a task was found, but not invoked properly.
-  #
+  # Raised when a command was found, but not invoked properly.
   class InvocationError < Error
   end
 
@@ -29,7 +27,6 @@ class Thor
   end
 
   # Raised when a user tries to call a private method encoded in templated filename.
-  #
   class PrivateMethodEncodedError < Error
   end
 end

data/lib/thor/group.rb

@@ -1,9 +1,9 @@
 require 'thor/base'
 
 # Thor has a special class called Thor::Group. The main difference to Thor class
-# is that it invokes all tasks at once. It also include some methods that allows
+# is that it invokes all commands at once. It also include some methods that allows
 # invocations to be done at the class method, which are not available to Thor
-# tasks.
+# commands.
 class Thor::Group
   class << self
     # The description for this Thor::Group. If none is provided, but a source root
@@ -48,7 +48,7 @@ class Thor::Group
     end
 
     # Invoke the given namespace or class given. It adds an instance
-    # method that will invoke the klass and task. You can give a block to
+    # method that will invoke the klass and command. You can give a block to
     # configure how it will be invoked.
     #
     # The namespace/class given will have its options showed on the help
@@ -64,12 +64,12 @@ class Thor::Group
 
         class_eval <<-METHOD, __FILE__, __LINE__
           def _invoke_#{name.to_s.gsub(/\W/, '_')}
-            klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
+            klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
 
             if klass
               say_status :invoke, #{name.inspect}, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(#{name.inspect} [not found]), :red
             end
@@ -100,7 +100,7 @@ class Thor::Group
     # In some cases you want to customize how a specified hook is going to be
     # invoked. You can do that by overwriting the class method
     # prepare_for_invocation. The class method must necessarily return a klass
-    # and an optional task.
+    # and an optional command.
     #
     # ==== Custom invocations
     #
@@ -127,12 +127,12 @@ class Thor::Group
 
             value = options[#{name.inspect}]
             value = #{name.inspect} if TrueClass === value
-            klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
+            klass, command = self.class.prepare_for_invocation(#{name.inspect}, value)
 
             if klass
               say_status :invoke, value, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(\#{value} [not found]), :red
             end
@@ -149,7 +149,7 @@ class Thor::Group
     #
     def remove_invocation(*names)
       names.each do |name|
-        remove_task(name)
+        remove_command(name)
         remove_class_option(name)
         invocations.delete(name)
         invocation_blocks.delete(name)
@@ -196,30 +196,26 @@ class Thor::Group
       end
     end
 
-    # Returns tasks ready to be printed.
-    def printable_tasks(*)
+    # Returns commands ready to be printed.
+    def printable_commands(*)
       item = []
       item << banner
       item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
       [item]
     end
+    alias printable_tasks printable_commands
 
-    def handle_argument_error(task, error, arity=nil) #:nodoc:
-      if arity > 0
-        msg = "#{basename} #{task.name} takes #{arity} argument"
-        msg << "s" if arity > 1
-        msg << ", but it should not."
-      else
-        msg = "You should not pass arguments to #{basename} #{task.name}."
-      end
-
+    def handle_argument_error(command, error, args, arity) #:nodoc:
+      msg = "#{basename} #{command.name} takes #{arity} argument"
+      msg << "s" if arity > 1
+      msg << ", but it should not."
       raise error, msg
     end
 
     protected
 
       # The method responsible for dispatching given the args.
-      def dispatch(task, given_args, given_opts, config) #:nodoc:
+      def dispatch(command, given_args, given_opts, config) #:nodoc:
         if Thor::HELP_MAPPINGS.include?(given_args.first)
           help(config[:shell])
           return
@@ -230,10 +226,9 @@ class Thor::Group
 
         instance = new(args, opts, config)
         yield instance if block_given?
-        args = instance.args
 
-        if task
-          instance.invoke_task(all_tasks[task])
+        if command
+          instance.invoke_command(all_commands[command])
         else
           instance.invoke_all
         end
@@ -242,22 +237,24 @@ class Thor::Group
       # The banner for this class. You can customize it if you are invoking the
       # thor class by another ways which is not the Thor::Runner.
       def banner
-        "#{basename} #{self_task.formatted_usage(self, false)}"
+        "#{basename} #{self_command.formatted_usage(self, false)}"
       end
 
-      # Represents the whole class as a task.
-      def self_task #:nodoc:
-        Thor::DynamicTask.new(self.namespace, class_options)
+      # Represents the whole class as a command.
+      def self_command #:nodoc:
+        Thor::DynamicCommand.new(self.namespace, class_options)
       end
+      alias self_task self_command
 
       def baseclass #:nodoc:
         Thor::Group
       end
 
-      def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
+      def create_command(meth) #:nodoc:
+        commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
         true
       end
+      alias create_task create_command
   end
 
   include Thor::Base
@@ -266,19 +263,19 @@ class Thor::Group
 
   # Shortcut to invoke with padding and block handling. Use internally by
   # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
+  def _invoke_for_class_method(klass, command=nil, *args, &block) #:nodoc:
     with_padding do
       if block
         case block.arity
         when 3
-          block.call(self, klass, task)
+          block.call(self, klass, command)
         when 2
           block.call(self, klass)
         when 1
           instance_exec(klass, &block)
         end
       else
-        invoke klass, task, *args
+        invoke klass, command, *args
       end
     end
   end

data/lib/thor/invocation.rb

@@ -6,12 +6,12 @@ class Thor
 
     module ClassMethods
       # This method is responsible for receiving a name and find the proper
-      # class and task for it. The key is an optional parameter which is
+      # class and command for it. The key is an optional parameter which is
       # available only in class methods invocations (i.e. in Thor::Group).
       def prepare_for_invocation(key, name) #:nodoc:
         case name
         when Symbol, String
-          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+          Thor::Util.find_class_and_command_by_namespace(name.to_s, !key)
         else
           name
         end
@@ -25,15 +25,15 @@ class Thor
       super
     end
 
-    # Receives a name and invokes it. The name can be a string (either "task" or
-    # "namespace:task"), a Thor::Task, a Class or a Thor instance. If the task
-    # cannot be guessed by name, it can also be supplied as second argument.
+    # Receives a name and invokes it. The name can be a string (either "command" or
+    # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+    # command cannot be guessed by name, it can also be supplied as second argument.
     #
     # You can also supply the arguments, options and configuration values for
-    # the task to be invoked, if none is given, the same values used to
+    # the command to be invoked, if none is given, the same values used to
     # initialize the invoker are used to initialize the invoked.
     #
-    # When no name is given, it will invoke the default task of the current class.
+    # When no name is given, it will invoke the default command of the current class.
     #
     # ==== Examples
     #
@@ -54,16 +54,16 @@ class Thor
     #     end
     #   end
     #
-    # You can notice that the method "foo" above invokes two tasks: "bar",
+    # You can notice that the method "foo" above invokes two commands: "bar",
     # which belongs to the same class and "hello" which belongs to the class B.
     #
-    # By using an invocation system you ensure that a task is invoked only once.
+    # By using an invocation system you ensure that a command is invoked only once.
     # In the example above, invoking "foo" will invoke "b:hello" just once, even
     # if it's invoked later by "bar" method.
     #
     # When class A invokes class B, all arguments used on A initialization are
     # supplied to B. This allows lazy parse of options. Let's suppose you have
-    # some rspec tasks:
+    # some rspec commands:
     #
     #   class Rspec < Thor::Group
     #     class_option :mock_framework, :type => :string, :default => :rr
@@ -100,30 +100,31 @@ class Thor
       end
 
       args.unshift(nil) if Array === args.first || NilClass === args.first
-      task, args, opts, config = args
+      command, args, opts, config = args
 
-      klass, task = _retrieve_class_and_task(name, task)
+      klass, command = _retrieve_class_and_command(name, command)
       raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
 
       args, opts, config = _parse_initialization_options(args, opts, config)
-      klass.send(:dispatch, task, args, opts, config) do |instance|
+      klass.send(:dispatch, command, args, opts, config) do |instance|
         instance.parent_options = options
       end
     end
 
-    # Invoke the given task if the given args.
-    def invoke_task(task, *args) #:nodoc:
+    # Invoke the given command if the given args.
+    def invoke_command(command, *args) #:nodoc:
       current = @_invocations[self.class]
 
-      unless current.include?(task.name)
-        current << task.name
-        task.run(self, *args)
+      unless current.include?(command.name)
+        current << command.name
+        command.run(self, *args)
       end
     end
+    alias invoke_task invoke_command
 
-    # Invoke all tasks for the current instance.
+    # Invoke all commands for the current instance.
     def invoke_all #:nodoc:
-      self.class.all_tasks.map { |_, task| invoke_task(task) }
+      self.class.all_commands.map { |_, command| invoke_command(command) }
     end
 
     # Invokes using shell padding.
@@ -138,21 +139,22 @@ class Thor
         { :invocations => @_invocations }
       end
 
-      # This method simply retrieves the class and task to be invoked.
-      # If the name is nil or the given name is a task in the current class,
+      # This method simply retrieves the class and command to be invoked.
+      # If the name is nil or the given name is a command in the current class,
       # use the given name and return self as class. Otherwise, call
       # prepare_for_invocation in the current class.
-      def _retrieve_class_and_task(name, sent_task=nil) #:nodoc:
+      def _retrieve_class_and_command(name, sent_command=nil) #:nodoc:
         case
         when name.nil?
           [self.class, nil]
-        when self.class.all_tasks[name.to_s]
+        when self.class.all_commands[name.to_s]
           [self.class, name.to_s]
         else
-          klass, task = self.class.prepare_for_invocation(nil, name)
-          [klass, task || sent_task]
+          klass, command = self.class.prepare_for_invocation(nil, name)
+          [klass, command || sent_command]
         end
       end
+      alias _retrieve_class_and_task _retrieve_class_and_command
 
       # Initialize klass using values stored in the @_initializer.
       def _parse_initialization_options(args, opts, config) #:nodoc:

data/lib/thor/parser/options.rb

@@ -46,7 +46,8 @@ class Thor
         @switches[option.switch_name] = option
 
         option.aliases.each do |short|
-          @shorts[short.to_s] ||= option.switch_name
+          name = short.to_s.sub(/^(?!\-)/, '-')
+          @shorts[name] ||= option.switch_name
         end
       end
     end
@@ -93,6 +94,7 @@ class Thor
             option = switch_option(switch)
             @assigns[option.human_name] = parse_peek(switch, option)
           elsif @stop_on_unknown
+            @parsing_options = false
             @extra << shifted
             @extra << shift while peek
             break

data/lib/thor/runner.rb

@@ -1,6 +1,6 @@
 require 'thor'
 require 'thor/group'
-require 'thor/core_ext/file_binary_read'
+require 'thor/core_ext/io_binary_read'
 
 require 'fileutils'
 require 'open-uri'
@@ -16,33 +16,33 @@ class Thor::Runner < Thor #:nodoc:
   def help(meth = nil)
     if meth && !self.respond_to?(meth)
       initialize_thorfiles(meth)
-      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-      self.class.handle_no_task_error(task, false) if klass.nil?
-      klass.start(["-h", task].compact, :shell => self.shell)
+      klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+      self.class.handle_no_command_error(command, false) if klass.nil?
+      klass.start(["-h", command].compact, :shell => self.shell)
     else
       super
     end
   end
 
-  # If a task is not found on Thor::Runner, method missing is invoked and
-  # Thor::Runner is then responsible for finding the task in all classes.
+  # If a command is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsible for finding the command in all classes.
   #
   def method_missing(meth, *args)
     meth = meth.to_s
     initialize_thorfiles(meth)
-    klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-    self.class.handle_no_task_error(task, false) if klass.nil?
-    args.unshift(task) if task
+    klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+    self.class.handle_no_command_error(command, false) if klass.nil?
+    args.unshift(command) if command
     klass.start(args, :shell => self.shell)
   end
 
-  desc "install NAME", "Install an optionally named Thor file into your system tasks"
+  desc "install NAME", "Install an optionally named Thor file into your system commands"
   method_options :as => :string, :relative => :boolean, :force => :boolean
   def install(name)
     initialize_thorfiles
 
     # If a directory name is provided as the argument, look for a 'main.thor'
-    # task in said directory.
+    # command in said directory.
     begin
       if File.directory?(File.expand_path(name))
         base, package = File.join(name, "main.thor"), :directory
@@ -143,14 +143,14 @@ class Thor::Runner < Thor #:nodoc:
     end
   end
 
-  desc "installed", "List the installed Thor modules and tasks"
+  desc "installed", "List the installed Thor modules and commands"
   method_options :internal => :boolean
   def installed
     initialize_thorfiles(nil, true)
     display_klasses(true, options["internal"])
   end
 
-  desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
+  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
   method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
   def list(search="")
     initialize_thorfiles
@@ -168,8 +168,8 @@ class Thor::Runner < Thor #:nodoc:
 
   private
 
-    def self.banner(task, all = false, subcommand = false)
-      "thor " + task.formatted_usage(self, all, subcommand)
+    def self.banner(command, all = false, subcommand = false)
+      "thor " + command.formatted_usage(self, all, subcommand)
     end
 
     def thor_root
@@ -276,25 +276,25 @@ class Thor::Runner < Thor #:nodoc:
     def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
       klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
 
-      raise Error, "No Thor tasks available" if klasses.empty?
+      raise Error, "No Thor commands available" if klasses.empty?
       show_modules if with_modules && !thor_yaml.empty?
 
       list = Hash.new { |h,k| h[k] = [] }
       groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
       # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
+      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
 
       # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_tasks(false).first }
+      groups.map! { |k| k.printable_commands(false).first }
       list["root"] = groups
 
       # Order namespaces with default coming first
       list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+      list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
     end
 
-    def display_tasks(namespace, list) #:nodoc:
+    def display_commands(namespace, list) #:nodoc:
       list.sort!{ |a,b| a[0] <=> b[0] }
 
       say shell.set_color(namespace, :blue, true)
@@ -303,6 +303,7 @@ class Thor::Runner < Thor #:nodoc:
       print_table(list, :truncate => true)
       say
     end
+    alias display_tasks display_commands
 
     def show_modules #:nodoc:
       info  = []