bundler 1.17.3 → 2.6.3

data/lib/bundler/vendor/thor/lib/thor/base.rb

@@ -1,17 +1,17 @@
-require "bundler/vendor/thor/lib/thor/command"
-require "bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access"
-require "bundler/vendor/thor/lib/thor/core_ext/ordered_hash"
-require "bundler/vendor/thor/lib/thor/error"
-require "bundler/vendor/thor/lib/thor/invocation"
-require "bundler/vendor/thor/lib/thor/parser"
-require "bundler/vendor/thor/lib/thor/shell"
-require "bundler/vendor/thor/lib/thor/line_editor"
-require "bundler/vendor/thor/lib/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 Bundler::Thor
-  autoload :Actions,    "bundler/vendor/thor/lib/thor/actions"
-  autoload :RakeCompat, "bundler/vendor/thor/lib/thor/rake_compat"
-  autoload :Group,      "bundler/vendor/thor/lib/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)
@@ -22,6 +22,15 @@ class Bundler::Thor
 
   TEMPLATE_EXTNAME = ".tt"
 
+  class << self
+    def deprecation_warning(message) #:nodoc:
+      unless ENV["THOR_SILENCE_DEPRECATION"]
+        warn "Deprecation warning: #{message}\n" +
+          "You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION."
+      end
+    end
+  end
+
   module Base
     attr_accessor :options, :parent_options, :args
 
@@ -51,6 +60,7 @@ class Bundler::Thor
 
       command_options = config.delete(:command_options) # hook for start
       parse_options = parse_options.merge(command_options) if command_options
+
       if local_options.is_a?(Array)
         array_options = local_options
         hash_options = {}
@@ -64,9 +74,24 @@ class Bundler::Thor
       # Let Bundler::Thor::Options parse the options first, so it can remove
       # 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]
-      disable_required_check = self.class.disable_required_check? config[:current_command]
-      opts = Bundler::Thor::Options.new(parse_options, hash_options, stop_on_unknown, disable_required_check)
+      current_command = config[:current_command]
+      stop_on_unknown = self.class.stop_on_unknown_option? current_command
+
+      # Give a relation of options.
+      # After parsing, Bundler::Thor::Options check whether right relations are kept
+      relations = if current_command.nil?
+        {exclusive_option_names: [], at_least_one_option_names: []}
+      else
+        current_command.options_relation
+      end
+
+      self.class.class_exclusive_option_names.map { |n| relations[:exclusive_option_names] << n }
+      self.class.class_at_least_one_option_names.map { |n| relations[:at_least_one_option_names] << n }
+
+      disable_required_check = self.class.disable_required_check? current_command
+
+      opts = Bundler::Thor::Options.new(parse_options, hash_options, stop_on_unknown, disable_required_check, relations)
+
       self.options = opts.parse(array_options)
       self.options = config[:class_options].merge(options) if config[:class_options]
 
@@ -89,6 +114,7 @@ class Bundler::Thor
 
     class << self
       def included(base) #:nodoc:
+        super(base)
         base.extend ClassMethods
         base.send :include, Invocation
         base.send :include, Shell
@@ -113,7 +139,7 @@ class Bundler::Thor
       end
 
       # Whenever a class inherits from Bundler::Thor or Bundler::Thor::Group, we should track the
-      # class and the file on Bundler::Thor::Base. This is the method responsable for it.
+      # class and the file on Bundler::Thor::Base. This is the method responsible for it.
       #
       def register_klass_file(klass) #:nodoc:
         file = caller[1].match(/(.*):\d+/)[1]
@@ -153,17 +179,20 @@ class Bundler::Thor
 
       # If you want to raise an error when the default value of an option does not match
       # the type call check_default_type!
-      # This is disabled by default for compatibility.
+      # This will be the default; for compatibility a deprecation warning is issued if necessary.
       def check_default_type!
         @check_default_type = true
       end
 
-      def check_default_type #:nodoc:
-        @check_default_type ||= from_superclass(:check_default_type, false)
+      # 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
+      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
@@ -297,9 +326,92 @@ class Bundler::Thor
       # :hide::     -- If you want to hide this option from the help.
       #
       def class_option(name, options = {})
+        unless [ Symbol, String ].any? { |klass| name.is_a?(klass) }
+          raise ArgumentError, "Expected a Symbol or String, got #{name.inspect}"
+        end
         build_option(name, options, class_options)
       end
 
+      # Adds and declares option group for exclusive options in the
+      # block and arguments. You can declare options as the outside of the block.
+      #
+      # ==== Parameters
+      # Array[Bundler::Thor::Option.name]
+      #
+      # ==== Examples
+      #
+      #   class_exclusive do
+      #     class_option :one
+      #     class_option :two
+      #    end
+      #
+      # Or
+      #
+      #   class_option :one
+      #   class_option :two
+      #   class_exclusive :one, :two
+      #
+      # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+      # will be raised.
+      #
+      def class_exclusive(*args, &block)
+        register_options_relation_for(:class_options,
+                                      :class_exclusive_option_names, *args, &block)
+      end
+
+      # Adds and declares option group for required at least one of options in the
+      # block and arguments. You can declare options as the outside of the block.
+      #
+      # ==== Examples
+      #
+      #   class_at_least_one do
+      #     class_option :one
+      #     class_option :two
+      #    end
+      #
+      # Or
+      #
+      #   class_option :one
+      #   class_option :two
+      #   class_at_least_one :one, :two
+      #
+      # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+      # will be raised.
+      #
+      # You can use class_at_least_one and class_exclusive at the same time.
+      #
+      #    class_exclusive do
+      #      class_at_least_one do
+      #        class_option :one
+      #        class_option :two
+      #      end
+      #    end
+      #
+      # Then it is required either only one of "--one" or "--two".
+      #
+      def class_at_least_one(*args, &block)
+        register_options_relation_for(:class_options,
+                                      :class_at_least_one_option_names, *args, &block)
+      end
+
+      # Returns this class exclusive options array set, looking up in the ancestors chain.
+      #
+      # ==== Returns
+      # Array[Array[Bundler::Thor::Option.name]]
+      #
+      def class_exclusive_option_names
+        @class_exclusive_option_names ||= from_superclass(:class_exclusive_option_names, [])
+      end
+
+      # Returns this class at least one of required options array set, looking up in the ancestors chain.
+      #
+      # ==== Returns
+      # Array[Array[Bundler::Thor::Option.name]]
+      #
+      def class_at_least_one_option_names
+        @class_at_least_one_option_names ||= from_superclass(:class_at_least_one_option_names, [])
+      end
+
       # Removes a previous defined argument. If :undefine is given, undefine
       # accessors as well.
       #
@@ -353,22 +465,22 @@ class Bundler::Thor
       # Returns the commands for this Bundler::Thor class.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Bundler::Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Bundler::Thor::Command
+      #        objects as values.
       #
       def commands
-        @commands ||= Bundler::Thor::CoreExt::OrderedHash.new
+        @commands ||= Hash.new
       end
       alias_method :tasks, :commands
 
       # Returns the commands for this Bundler::Thor class and all subclasses.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with commands names as keys and Bundler::Thor::Command
-      #               objects as values.
+      # Hash:: An ordered hash with commands names as keys and Bundler::Thor::Command
+      #        objects as values.
       #
       def all_commands
-        @all_commands ||= from_superclass(:all_commands, Bundler::Thor::CoreExt::OrderedHash.new)
+        @all_commands ||= from_superclass(:all_commands, Hash.new)
         @all_commands.merge!(commands)
       end
       alias_method :all_tasks, :all_commands
@@ -415,14 +527,20 @@ class Bundler::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 Bundler::Thor or Bundler::Thor::Group class. By default the
       # namespace is retrieved from the class name. If your Bundler::Thor class is named
       # Scripts::MyScript, the help method, for example, will be called as:
@@ -466,13 +584,13 @@ class Bundler::Thor
         dispatch(nil, given_args.dup, nil, config)
       rescue Bundler::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.
@@ -487,14 +605,13 @@ class Bundler::Thor
       #
       def public_command(*names)
         names.each do |name|
-          class_eval "def #{name}(*); super end"
+          class_eval "def #{name}(*); super end", __FILE__, __LINE__
         end
       end
       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
 
@@ -503,10 +620,16 @@ class Bundler::Thor
         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?
+        Bundler::Thor.deprecation_warning "Bundler::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
@@ -534,20 +657,19 @@ class Bundler::Thor
         return if options.empty?
 
         list = []
-        padding = options.map { |o| o.aliases.size }.max.to_i * 4
-
+        padding = options.map { |o| o.aliases_for_usage.size }.max.to_i
         options.each do |option|
           next if option.hide
           item = [option.usage(padding)]
           item.push(option.description ? "# #{option.description}" : "")
 
           list << item
-          list << ["", "# Default: #{option.default}"] if option.show_default?
-          list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
+          list << ["", "# Default: #{option.print_default}"] if option.show_default?
+          list << ["", "# Possible values: #{option.enum_to_s}"] if option.enum
         end
 
         shell.say(group_name ? "#{group_name} options:" : "Options:")
-        shell.print_table(list, :indent => 2)
+        shell.print_table(list, indent: 2)
         shell.say ""
       end
 
@@ -564,7 +686,7 @@ class Bundler::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] = Bundler::Thor::Option.new(name, options.merge(:check_default_type => check_default_type?))
+        scope[name] = Bundler::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
@@ -586,7 +708,7 @@ class Bundler::Thor
       def find_and_refresh_command(name) #:nodoc:
         if commands[name.to_s]
           commands[name.to_s]
-        elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
+        elsif command = all_commands[name.to_s] # rubocop:disable Lint/AssignmentInCondition
           commands[name.to_s] = command.clone
         else
           raise ArgumentError, "You supplied :for => #{name.inspect}, but the command #{name.inspect} could not be found."
@@ -594,16 +716,18 @@ class Bundler::Thor
       end
       alias_method :find_and_refresh_task, :find_and_refresh_command
 
-      # Everytime someone inherits from a Bundler::Thor class, register the klass
+      # Every time someone inherits from a Bundler::Thor class, register the klass
       # and file into baseclass.
       def inherited(klass)
+        super(klass)
         Bundler::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"
@@ -614,8 +738,7 @@ class Bundler::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)
         Bundler::Thor::Base.register_klass_file(self)
@@ -642,11 +765,6 @@ class Bundler::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.
       #
@@ -674,6 +792,34 @@ class Bundler::Thor
       def dispatch(command, given_args, given_opts, config) #:nodoc:
         raise NotImplementedError
       end
+
+      # Register a relation of options for target(method_option/class_option)
+      # by args and block.
+      def register_options_relation_for(target, relation, *args, &block) # :nodoc:
+        opt = args.pop if args.last.is_a? Hash
+        opt ||= {}
+        names = args.map{ |arg| arg.to_s }
+        names += built_option_names(target, opt, &block) if block_given?
+        command_scope_member(relation, opt) << names
+      end
+
+      # Get target(method_options or class_options) options
+      # of before and after by block evaluation.
+      def built_option_names(target, opt = {}, &block) # :nodoc:
+        before = command_scope_member(target, opt).map{ |k,v| v.name }
+        instance_eval(&block)
+        after  = command_scope_member(target, opt).map{ |k,v| v.name }
+        after - before
+      end
+
+      # Get command scope member by name.
+      def command_scope_member(name, options = {}) # :nodoc:
+        if options[:for]
+          find_and_refresh_command(options[:for]).send(name)
+        else
+          send(name)
+        end
+      end
     end
   end
 end

data/lib/bundler/vendor/thor/lib/thor/command.rb

@@ -1,14 +1,15 @@
 class Bundler::Thor
-  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
+  class Command < Struct.new(:name, :description, :long_description, :wrap_long_description, :usage, :options, :options_relation, :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 || {})
+    def initialize(name, description, long_description, wrap_long_description, usage, options = nil, options_relation = nil)
+      super(name.to_s, description, long_description, wrap_long_description, usage, options || {}, options_relation || {})
     end
 
     def initialize_copy(other) #:nodoc:
       super(other)
       self.options = other.options.dup if other.options
+      self.options_relation = other.options_relation.dup if other.options_relation
     end
 
     def hidden?
@@ -49,24 +50,40 @@ class Bundler::Thor
 
       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
+
+    def method_exclusive_option_names #:nodoc:
+      self.options_relation[:exclusive_option_names] || []
+    end
+
+    def method_at_least_one_option_names #:nodoc:
+      self.options_relation[:at_least_one_option_names] || []
     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
@@ -97,8 +114,7 @@ class Bundler::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
 
@@ -120,7 +136,7 @@ class Bundler::Thor
   # 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)
+      super(name.to_s, "A dynamically-generated command", name.to_s, nil, name.to_s, options)
     end
 
     def run(instance, args = [])

data/lib/bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -28,10 +28,20 @@ class Bundler::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 slice(*keys)
+        super(*keys.map{ |key| convert_key(key) })
+      end
+
       def key?(key)
         super(convert_key(key))
       end

data/lib/bundler/vendor/thor/lib/thor/error.rb

@@ -1,4 +1,16 @@
 class Bundler::Thor
+  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable) # rubocop:disable Naming/ConstantName
+    Module.new do
+      def to_s
+        super + DidYouMean.formatter.message_for(corrections)
+      end
+
+      def corrections
+        @corrections ||= self.class.const_get(:SpellChecker).new(self).corrections
+      end
+    end
+  end
+
   # Bundler::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 +22,35 @@ class Bundler::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
+        DidYouMean::SpellChecker.new(dictionary: 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 +63,33 @@ class Bundler::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 ||= DidYouMean::SpellChecker.new(dictionary: 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 +97,10 @@ class Bundler::Thor
 
   class MalformattedArgumentError < InvocationError
   end
+
+  class ExclusiveArgumentError < InvocationError
+  end
+
+  class AtLeastOneRequiredArgumentError < InvocationError
+  end
 end