thor 0.19.4 → 1.0.0

data/lib/thor/actions/inject_into_file.rb

@@ -1,4 +1,4 @@
-require "thor/actions/empty_directory"
+require_relative "empty_directory"
 
 class Thor
   module Actions
@@ -21,9 +21,14 @@ class Thor
     #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
     #   end
     #
+    WARNINGS = { unchanged_no_flag: 'File unchanged! The supplied flag value not found!' }
+
     def insert_into_file(destination, *args, &block)
       data = block_given? ? block : args.shift
-      config = args.shift
+
+      config = args.shift || {}
+      config[:after] = /\z/ unless config.key?(:before) || config.key?(:after)
+
       action InjectIntoFile.new(self, destination, data, config)
     end
     alias_method :inject_into_file, :insert_into_file
@@ -45,15 +50,23 @@ class Thor
       end
 
       def invoke!
-        say_status :invoke
-
         content = if @behavior == :after
           '\0' + replacement
         else
           replacement + '\0'
         end
 
-        replace!(/#{flag}/, content, config[:force])
+        if exists?
+          if replace!(/#{flag}/, content, config[:force])
+            say_status(:invoke)
+          else
+            say_status(:unchanged, warning: WARNINGS[:unchanged_no_flag], color: :red)
+          end
+        else
+          unless pretend?
+            raise Thor::Error, "The file #{ destination } does not appear to exist"
+          end
+        end
       end
 
       def revoke!
@@ -72,7 +85,7 @@ class Thor
 
     protected
 
-      def say_status(behavior)
+      def say_status(behavior, warning: nil, color: nil)
         status = if behavior == :invoke
           if flag == /\A/
             :prepend
@@ -81,21 +94,25 @@ class Thor
           else
             :insert
           end
+        elsif warning
+          warning
         else
           :subtract
         end
 
-        super(status, config[:verbose])
+        super(status, (color || config[:verbose]))
       end
 
       # Adds the content to the file.
       #
       def replace!(regexp, string, force)
-        return if base.options[:pretend]
-        content = File.binread(destination)
+        return if pretend?
+        content = File.read(destination)
         if force || !content.include?(replacement)
-          content.gsub!(regexp, string)
+          success = content.gsub!(regexp, string)
+
           File.open(destination, "wb") { |file| file.write(content) }
+          success
         end
       end
     end

data/lib/thor/base.rb

@@ -1,17 +1,17 @@
-require "thor/command"
-require "thor/core_ext/hash_with_indifferent_access"
-require "thor/core_ext/ordered_hash"
-require "thor/error"
-require "thor/invocation"
-require "thor/parser"
-require "thor/shell"
-require "thor/line_editor"
-require "thor/util"
+require_relative "command"
+require_relative "core_ext/hash_with_indifferent_access"
+require_relative "error"
+require_relative "invocation"
+require_relative "nested_context"
+require_relative "parser"
+require_relative "shell"
+require_relative "line_editor"
+require_relative "util"
 
 class Thor
-  autoload :Actions,    "thor/actions"
-  autoload :RakeCompat, "thor/rake_compat"
-  autoload :Group,      "thor/group"
+  autoload :Actions,    File.expand_path("actions", __dir__)
+  autoload :RakeCompat, File.expand_path("rake_compat", __dir__)
+  autoload :Group,      File.expand_path("group", __dir__)
 
   # Shortcuts for help.
   HELP_MAPPINGS       = %w(-h -? --help -D)
@@ -42,7 +42,7 @@ class Thor
     # config<Hash>:: Configuration for this Thor class.
     #
     def initialize(args = [], local_options = {}, config = {})
-      parse_options = config[:current_command] && config[:current_command].disable_class_options ? {} : self.class.class_options
+      parse_options = self.class.class_options
 
       # The start method splits inbound arguments at the first argument
       # that looks like an option (starts with - or --). It then calls
@@ -65,7 +65,8 @@ class Thor
       # declared options from the array. This will leave us with
       # a list of arguments that weren't declared.
       stop_on_unknown = self.class.stop_on_unknown_option? config[:current_command]
-      opts = Thor::Options.new(parse_options, hash_options, stop_on_unknown)
+      disable_required_check = self.class.disable_required_check? config[:current_command]
+      opts = Thor::Options.new(parse_options, hash_options, stop_on_unknown, disable_required_check)
       self.options = opts.parse(array_options)
       self.options = config[:class_options].merge(options) if config[:class_options]
 
@@ -88,6 +89,7 @@ class Thor
 
     class << self
       def included(base) #:nodoc:
+        super(base)
         base.extend ClassMethods
         base.send :include, Invocation
         base.send :include, Shell
@@ -112,7 +114,7 @@ class Thor
       end
 
       # Whenever a class inherits from Thor or Thor::Group, we should track the
-      # class and the file on Thor::Base. This is the method responsable for it.
+      # class and the file on Thor::Base. This is the method responsible for it.
       #
       def register_klass_file(klass) #:nodoc:
         file = caller[1].match(/(.*):\d+/)[1]
@@ -150,6 +152,24 @@ class Thor
         !!check_unknown_options
       end
 
+      # If you want to raise an error when the default value of an option does not match
+      # the type call check_default_type!
+      # This will be the default; for compatibility a deprecation warning is issued if necessary.
+      def check_default_type!
+        @check_default_type = true
+      end
+
+      # If you want to use defaults that don't match the type of an option,
+      # either specify `check_default_type: false` or call `allow_incompatible_default_type!`
+      def allow_incompatible_default_type!
+        @check_default_type = false
+      end
+
+      def check_default_type #:nodoc:
+        @check_default_type = from_superclass(:check_default_type, nil) unless defined?(@check_default_type)
+        @check_default_type
+      end
+
       # If true, option parsing is suspended as soon as an unknown option or a
       # regular argument is encountered.  All remaining arguments are passed to
       # the command as regular arguments.
@@ -157,6 +177,12 @@ class Thor
         false
       end
 
+      # If true, option set will not suspend the execution of the command when
+      # a required option is not provided.
+      def disable_required_check?(command_name) #:nodoc:
+        false
+      end
+
       # If you want only strict string args (useful when cascading thor classes),
       # call strict_args_position! This is disabled by default to allow dynamic
       # invocations.
@@ -331,22 +357,22 @@ class Thor
       # Returns the commands for this Thor class.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Thor::Command
+      #        objects as values.
       #
       def commands
-        @commands ||= Thor::CoreExt::OrderedHash.new
+        @commands ||= Hash.new
       end
       alias_method :tasks, :commands
 
       # Returns the commands for this Thor class and all subclasses.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Thor::Command
+      #        objects as values.
       #
       def all_commands
-        @all_commands ||= from_superclass(:all_commands, Thor::CoreExt::OrderedHash.new)
+        @all_commands ||= from_superclass(:all_commands, Hash.new)
         @all_commands.merge!(commands)
       end
       alias_method :all_tasks, :all_commands
@@ -393,14 +419,20 @@ class Thor
       #     remove_command :this_is_not_a_command
       #   end
       #
-      def no_commands
-        @no_commands = true
-        yield
-      ensure
-        @no_commands = false
+      def no_commands(&block)
+        no_commands_context.enter(&block)
       end
+
       alias_method :no_tasks, :no_commands
 
+      def no_commands_context
+        @no_commands_context ||= NestedContext.new
+      end
+
+      def no_commands?
+        no_commands_context.entered?
+      end
+
       # Sets the namespace for the Thor or Thor::Group class. By default the
       # namespace is retrieved from the class name. If your Thor class is named
       # Scripts::MyScript, the help method, for example, will be called as:
@@ -444,13 +476,13 @@ class Thor
         dispatch(nil, given_args.dup, nil, config)
       rescue Thor::Error => e
         config[:debug] || ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
-        exit(1) if exit_on_failure?
+        exit(false) if exit_on_failure?
       rescue Errno::EPIPE
         # This happens if a thor command is piped to something like `head`,
         # which closes the pipe when it's done reading. This will also
         # mean that if the pipe is closed, further unnecessary
         # computation will not occur.
-        exit(0)
+        exit(true)
       end
 
       # Allows to use private methods from parent in child classes as commands.
@@ -471,19 +503,25 @@ class Thor
       alias_method :public_task, :public_command
 
       def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
-        raise UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace." if has_namespace
-        raise UndefinedCommandError, "Could not find command #{command.inspect}."
+        raise UndefinedCommandError.new(command, all_commands.keys, (namespace if has_namespace))
       end
       alias_method :handle_no_task_error, :handle_no_command_error
 
       def handle_argument_error(command, error, args, arity) #:nodoc:
-        msg = "ERROR: \"#{basename} #{command.name}\" was called with "
+        name = [command.ancestor_name, command.name].compact.join(" ")
+        msg = "ERROR: \"#{basename} #{name}\" was called with ".dup
         msg << "no arguments"               if     args.empty?
         msg << "arguments " << args.inspect unless args.empty?
-        msg << "\nUsage: #{banner(command).inspect}"
+        msg << "\nUsage: \"#{banner(command).split("\n").join("\"\n       \"")}\""
         raise InvocationError, msg
       end
 
+      # A flag that makes the process exit with status 1 if any error happens.
+      def exit_on_failure?
+        Thor.deprecation_warning "Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `#{self.name}`"
+        false
+      end
+
     protected
 
       # Prints the class options per group. If an option does not belong to
@@ -541,7 +579,7 @@ class Thor
       # options<Hash>:: Described in both class_option and method_option.
       # scope<Hash>:: Options hash that is being built up
       def build_option(name, options, scope) #:nodoc:
-        scope[name] = Thor::Option.new(name, options)
+        scope[name] = Thor::Option.new(name, {:check_default_type => check_default_type}.merge!(options))
       end
 
       # Receives a hash of options, parse them and add to the scope. This is a
@@ -574,13 +612,15 @@ class Thor
       # Everytime someone inherits from a Thor class, register the klass
       # and file into baseclass.
       def inherited(klass)
+        super(klass)
         Thor::Base.register_klass_file(klass)
-        klass.instance_variable_set(:@no_commands, false)
+        klass.instance_variable_set(:@no_commands, 0)
       end
 
       # Fire this callback whenever a method is added. Added methods are
       # tracked as commands by invoking the create_command method.
       def method_added(meth)
+        super(meth)
         meth = meth.to_s
 
         if meth == "initialize"
@@ -591,8 +631,7 @@ class Thor
         # Return if it's not a public instance method
         return unless public_method_defined?(meth.to_sym)
 
-        @no_commands ||= false
-        return if @no_commands || !create_command(meth)
+        return if no_commands? || !create_command(meth)
 
         is_thor_reserved_word?(meth, :command)
         Thor::Base.register_klass_file(self)
@@ -619,11 +658,6 @@ class Thor
         end
       end
 
-      # A flag that makes the process exit with status 1 if any error happens.
-      def exit_on_failure?
-        false
-      end
-
       #
       # The basename of the program invoking the thor class.
       #

data/lib/thor/command.rb

@@ -1,9 +1,9 @@
 class Thor
-  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :disable_class_options)
+  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, disable_class_options = false)
-      super(name.to_s, description, long_description, usage, options || {}, disable_class_options)
+    def initialize(name, description, long_description, usage, options = nil)
+      super(name.to_s, description, long_description, usage, options || {})
     end
 
     def initialize_copy(other) #:nodoc:
@@ -39,32 +39,42 @@ class Thor
     # 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 namespace
+      if ancestor_name
+        formatted = "#{ancestor_name} ".dup # add space
+      elsif namespace
         namespace = klass.namespace
-        formatted = "#{namespace.gsub(/^(default)/, '')}:"
+        formatted = "#{namespace.gsub(/^(default)/, '')}:".dup
       end
-      formatted = "#{klass.namespace.split(':').last} " if subcommand
+      formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand
 
-      formatted ||= ""
+      formatted ||= "".dup
 
-      # Add usage with required arguments
-      formatted << 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
+      Array(usage).map do |specific_usage|
+        formatted_specific_usage = formatted
 
-      # Add required options
-      formatted << " #{required_options}"
+        formatted_specific_usage += required_arguments_for(klass, specific_usage)
 
-      # Strip and go!
-      formatted.strip
+        # 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
@@ -95,8 +105,7 @@ class Thor
     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)
-        # Ruby 1.9 always include the called method in the backtrace
-        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
+        saned.empty? || saned.size == 1
       end
     end
 

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -51,6 +51,18 @@ class Thor
         self
       end
 
+      def reverse_merge(other)
+        self.class.new(other).merge(self)
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge(other_hash))
+      end
+
+      def replace(other_hash)
+        super(other_hash)
+      end
+
       # Convert to a Hash with String keys.
       def to_hash
         Hash.new(default).merge!(self)

data/lib/thor/error.rb

@@ -1,4 +1,19 @@
 class Thor
+  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable)
+                  # 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.
   #
@@ -10,6 +25,35 @@ class Thor
 
   # 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
 
@@ -22,6 +66,33 @@ class Thor
   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
@@ -29,4 +100,11 @@ class Thor
 
   class MalformattedArgumentError < InvocationError
   end
+
+  if Correctable
+    DidYouMean::SPELL_CHECKERS.merge!(
+      'Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
+      'Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
+    )
+  end
 end