thor 0.16.0 → 1.2.1

data/lib/thor/command.rb

@@ -0,0 +1,142 @@
+class Thor
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
+    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
+
+    def initialize(name, description, long_description, usage, options = nil)
+      super(name.to_s, description, long_description, usage, options || {})
+    end
+
+    def initialize_copy(other) #:nodoc:
+      super(other)
+      self.options = other.options.dup if other.options
+    end
+
+    def hidden?
+      false
+    end
+
+    # 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_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_command_error(name)
+      end
+    rescue ArgumentError => e
+      handle_argument_error?(instance, e, caller) ? 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_command_error(name) : (raise e)
+    end
+
+    # Returns the formatted usage by injecting given required arguments
+    # and required options into the given usage.
+    def formatted_usage(klass, namespace = true, subcommand = false)
+      if ancestor_name
+        formatted = "#{ancestor_name} ".dup # add space
+      elsif namespace
+        namespace = klass.namespace
+        formatted = "#{namespace.gsub(/^(default)/, '')}:".dup
+      end
+      formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand
+
+      formatted ||= "".dup
+
+      Array(usage).map do |specific_usage|
+        formatted_specific_usage = formatted
+
+        formatted_specific_usage += required_arguments_for(klass, specific_usage)
+
+        # Add required options
+        formatted_specific_usage += " #{required_options}"
+
+        # Strip and go!
+        formatted_specific_usage.strip
+      end.join("\n")
+    end
+
+  protected
+
+    # Add usage with required arguments
+    def required_arguments_for(klass, usage)
+      if klass && !klass.arguments.empty?
+        usage.to_s.gsub(/^#{name}/) do |match|
+          match << " " << klass.arguments.map(&:usage).compact.join(" ")
+        end
+      else
+        usage.to_s
+      end
+    end
+
+    def not_debugging?(instance)
+      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+    end
+
+    def required_options
+      @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(" ")
+    end
+
+    # Given a target, checks if this class name is a public method.
+    def public_method?(instance) #:nodoc:
+      !(instance.public_methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def private_method?(instance)
+      !(instance.private_methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def local_method?(instance, name)
+      methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
+      !(methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def sans_backtrace(backtrace, caller) #:nodoc:
+      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) }
+      saned - caller
+    end
+
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && begin
+        saned = sans_backtrace(error.backtrace, caller)
+        saned.empty? || saned.size == 1
+      end
+    end
+
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) &&
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    end
+  end
+  Task = Command
+
+  # A command that is hidden in help messages but still invocable.
+  class HiddenCommand < Command
+    def hidden?
+      true
+    end
+  end
+  HiddenTask = HiddenCommand
+
+  # A dynamic command that handles method missing scenarios.
+  class DynamicCommand < Command
+    def initialize(name, options = nil)
+      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_command_error(name)
+      end
+    end
+  end
+  DynamicTask = DynamicCommand
+end

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -1,6 +1,5 @@
 class Thor
   module CoreExt #:nodoc:
-
     # A hash with indifferent access and magic predicates.
     #
     #   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
@@ -10,8 +9,7 @@ class Thor
     #   hash.foo?   #=> true
     #
     class HashWithIndifferentAccess < ::Hash #:nodoc:
-
-      def initialize(hash={})
+      def initialize(hash = {})
         super()
         hash.each do |key, value|
           self[convert_key(key)] = value
@@ -30,8 +28,22 @@ class Thor
         super(convert_key(key))
       end
 
+      def except(*keys)
+        dup.tap do |hash|
+          keys.each { |key| hash.delete(convert_key(key)) }
+        end
+      end
+
+      def fetch(key, *args)
+        super(convert_key(key), *args)
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
       def values_at(*indices)
-        indices.collect { |key| self[convert_key(key)] }
+        indices.map { |key| self[convert_key(key)] }
       end
 
       def merge(other)
@@ -45,31 +57,47 @@ class Thor
         self
       end
 
-      protected
+      def reverse_merge(other)
+        self.class.new(other).merge(self)
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge(other_hash))
+      end
 
-        def convert_key(key)
-          key.is_a?(Symbol) ? key.to_s : key
-        end
+      def replace(other_hash)
+        super(other_hash)
+      end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge!(self)
+      end
 
-        # Magic predicates. For instance:
-        #
-        #   options.force?                  # => !!options['force']
-        #   options.shebang                 # => "/usr/lib/local/ruby"
-        #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
-        #
-        def method_missing(method, *args, &block)
-          method = method.to_s
-          if method =~ /^(\w+)\?$/
-            if args.empty?
-              !!self[$1]
-            else
-              self[$1] == args.first
-            end
+    protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      # Magic predicates. For instance:
+      #
+      #   options.force?                  # => !!options['force']
+      #   options.shebang                 # => "/usr/lib/local/ruby"
+      #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+      #
+      def method_missing(method, *args)
+        method = method.to_s
+        if method =~ /^(\w+)\?$/
+          if args.empty?
+            !!self[$1]
           else
-            self[method]
+            self[$1] == args.first
           end
+        else
+          self[method]
         end
-
+      end
     end
   end
 end

data/lib/thor/error.rb

@@ -1,25 +1,98 @@
 class Thor
+  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable) # rubocop:disable Naming/ConstantName
+                  # In order to support versions of Ruby that don't have keyword
+                  # arguments, we need our own spell checker class that doesn't take key
+                  # words. Even though this code wouldn't be hit because of the check
+                  # above, it's still necessary because the interpreter would otherwise be
+                  # unable to parse the file.
+                  class NoKwargSpellChecker < DidYouMean::SpellChecker # :nodoc:
+                    def initialize(dictionary)
+                      @dictionary = dictionary
+                    end
+                  end
+
+                  DidYouMean::Correctable
+                end
+
   # Thor::Error is raised when it's caused by wrong usage of thor classes. Those
   # errors have their backtrace suppressed and are nicely shown to the user.
   #
   # 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
+  # overwrites a thor keyword, 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
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||= spell_checker.correct(error.command).map(&:inspect)
+      end
+
+      def spell_checker
+        NoKwargSpellChecker.new(error.all_commands)
+      end
+    end
+
+    attr_reader :command, :all_commands
+
+    def initialize(command, all_commands, namespace)
+      @command = command
+      @all_commands = all_commands
+
+      message = "Could not find command #{command.inspect}"
+      message = namespace ? "#{message} in #{namespace.inspect} namespace." : "#{message}."
+
+      super(message)
+    end
+
+    prepend Correctable if Correctable
   end
+  UndefinedTaskError = UndefinedCommandError
 
-  # Raised when a task was found, but not invoked properly.
-  #
+  class AmbiguousCommandError < Error
+  end
+  AmbiguousTaskError = AmbiguousCommandError
+
+  # Raised when a command was found, but not invoked properly.
   class InvocationError < Error
   end
 
   class UnknownArgumentError < Error
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||=
+          error.unknown.flat_map { |unknown| spell_checker.correct(unknown) }.uniq.map(&:inspect)
+      end
+
+      def spell_checker
+        @spell_checker ||= NoKwargSpellChecker.new(error.switches)
+      end
+    end
+
+    attr_reader :switches, :unknown
+
+    def initialize(switches, unknown)
+      @switches = switches
+      @unknown = unknown
+
+      super("Unknown switches #{unknown.map(&:inspect).join(', ')}")
+    end
+
+    prepend Correctable if Correctable
   end
 
   class RequiredArgumentMissingError < InvocationError
@@ -28,8 +101,15 @@ class Thor
   class MalformattedArgumentError < InvocationError
   end
 
-  # Raised when a user tries to call a private method encoded in templated filename.
-  #
-  class PrivateMethodEncodedError < Error
+  if Correctable
+    if DidYouMean.respond_to?(:correct_error)
+      DidYouMean.correct_error(Thor::UndefinedCommandError, UndefinedCommandError::SpellChecker)
+      DidYouMean.correct_error(Thor::UnknownArgumentError, UnknownArgumentError::SpellChecker)
+    else
+      DidYouMean::SPELL_CHECKERS.merge!(
+        'Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
+        'Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
+      )
+    end
   end
 end

data/lib/thor/group.rb

@@ -1,9 +1,9 @@
-require 'thor/base'
+require_relative "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
@@ -13,12 +13,11 @@ class Thor::Group
     # ==== Parameters
     # description<String>:: The description for this Thor::Group.
     #
-    def desc(description=nil)
-      case description
-        when nil
-          @desc ||= from_superclass(:desc, nil)
-        else
-          @desc = description
+    def desc(description = nil)
+      if description
+        @desc = description
+      else
+        @desc ||= from_superclass(:desc, nil)
       end
     end
 
@@ -32,7 +31,7 @@ class Thor::Group
       shell.say "  #{banner}\n"
       shell.say
       class_options_help(shell)
-      shell.say self.desc if self.desc
+      shell.say desc if desc
     end
 
     # Stores invocations for this class merging with superclass values.
@@ -48,7 +47,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
@@ -62,14 +61,14 @@ class Thor::Group
         invocations[name] = false
         invocation_blocks[name] = block if block_given?
 
-        class_eval <<-METHOD, __FILE__, __LINE__
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
           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 +99,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
     #
@@ -114,25 +113,25 @@ class Thor::Group
 
       names.each do |name|
         unless class_options.key?(name)
-          raise ArgumentError, "You have to define the option #{name.inspect} " <<
-                               "before setting invoke_from_option."
+          raise ArgumentError, "You have to define the option #{name.inspect} " \
+                              "before setting invoke_from_option."
         end
 
         invocations[name] = true
         invocation_blocks[name] = block if block_given?
 
-        class_eval <<-METHOD, __FILE__, __LINE__
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
           def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
             return unless options[#{name.inspect}]
 
             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 +148,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)
@@ -159,7 +158,7 @@ class Thor::Group
     # Overwrite class options help to allow invoked generators options to be
     # shown recursively when invoking a generator.
     #
-    def class_options_help(shell, groups={}) #:nodoc:
+    def class_options_help(shell, groups = {}) #:nodoc:
       get_options_from_invocations(groups, class_options) do |klass|
         klass.send(:get_options_from_invocations, groups, class_options)
       end
@@ -170,7 +169,7 @@ class Thor::Group
     # options are added to group_options hash. Options that already exists
     # in base_options are not added twice.
     #
-    def get_options_from_invocations(group_options, base_options) #:nodoc:
+    def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
       invocations.each do |name, from_option|
         value = if from_option
           option = class_options[name]
@@ -189,96 +188,93 @@ class Thor::Group
         group_options[human_name] ||= []
         group_options[human_name] += klass.class_options.values.select do |class_option|
           base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
-          !group_options.values.flatten.any? { |i| i.name == class_option.name }
+            !group_options.values.flatten.any? { |i| i.name == class_option.name }
         end
 
         yield klass if block_given?
       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 << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : "")
       [item]
     end
+    alias_method :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".dup
+      msg << "s" if arity > 1
+      msg << ", but it should not."
       raise error, msg
     end
 
-    protected
+  protected
 
-      # The method responsible for dispatching given the args.
-      def dispatch(task, given_args, given_opts, config) #:nodoc:
-        if Thor::HELP_MAPPINGS.include?(given_args.first)
-          help(config[:shell])
-          return
-        end
+    # The method responsible for dispatching given the args.
+    def dispatch(command, given_args, given_opts, config) #:nodoc:
+      if Thor::HELP_MAPPINGS.include?(given_args.first)
+        help(config[:shell])
+        return
+      end
 
-        args, opts = Thor::Options.split(given_args)
-        opts = given_opts || opts
+      args, opts = Thor::Options.split(given_args)
+      opts = given_opts || opts
 
-        instance = new(args, opts, config)
-        yield instance if block_given?
-        args = instance.args
+      instance = new(args, opts, config)
+      yield instance if block_given?
 
-        if task
-          instance.invoke_task(all_tasks[task])
-        else
-          instance.invoke_all
-        end
+      if command
+        instance.invoke_command(all_commands[command])
+      else
+        instance.invoke_all
       end
+    end
 
-      # 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)}"
-      end
+    # 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_command.formatted_usage(self, false)}"
+    end
 
-      # Represents the whole class as a task.
-      def self_task #:nodoc:
-        Thor::DynamicTask.new(self.namespace, class_options)
-      end
+    # Represents the whole class as a command.
+    def self_command #:nodoc:
+      Thor::DynamicCommand.new(namespace, class_options)
+    end
+    alias_method :self_task, :self_command
 
-      def baseclass #:nodoc:
-        Thor::Group
-      end
+    def baseclass #:nodoc:
+      Thor::Group
+    end
 
-      def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
-        true
-      end
+    def create_command(meth) #:nodoc:
+      commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
+      true
+    end
+    alias_method :create_task, :create_command
   end
 
   include Thor::Base
 
-  protected
+protected
 
   # 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)
+          yield(self, klass, command)
         when 2
-          block.call(self, klass)
+          yield(self, klass)
         when 1
           instance_exec(klass, &block)
         end
       else
-        invoke klass, task, *args
+        invoke klass, command, *args
       end
     end
   end