rubygems-update 3.4.21 → 3.5.0

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

@@ -24,9 +24,9 @@ class Bundler::Thor
 
   class << self
     def deprecation_warning(message) #:nodoc:
-      unless ENV['THOR_SILENCE_DEPRECATION']
+      unless ENV["THOR_SILENCE_DEPRECATION"]
         warn "Deprecation warning: #{message}\n" +
-          'You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION.'
+          "You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION."
       end
     end
   end
@@ -60,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 = {}
@@ -73,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]
 
@@ -310,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.
       #
@@ -506,7 +605,7 @@ 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
@@ -558,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
 
@@ -588,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, {:check_default_type => check_default_type}.merge!(options))
+        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
@@ -610,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."
@@ -618,7 +716,7 @@ 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)
@@ -694,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/bundler/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?
@@ -62,6 +63,14 @@ class Bundler::Thor
       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
@@ -127,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/bundler/lib/bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -38,6 +38,10 @@ class Bundler::Thor
         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/bundler/lib/bundler/vendor/thor/lib/thor/error.rb

@@ -1,18 +1,15 @@
 class Bundler::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
+    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.
@@ -37,7 +34,7 @@ class Bundler::Thor
       end
 
       def spell_checker
-        NoKwargSpellChecker.new(error.all_commands)
+        DidYouMean::SpellChecker.new(dictionary: error.all_commands)
       end
     end
 
@@ -79,7 +76,7 @@ class Bundler::Thor
       end
 
       def spell_checker
-        @spell_checker ||= NoKwargSpellChecker.new(error.switches)
+        @spell_checker ||= DidYouMean::SpellChecker.new(dictionary: error.switches)
       end
     end
 
@@ -101,15 +98,9 @@ class Bundler::Thor
   class MalformattedArgumentError < InvocationError
   end
 
-  if Correctable
-    if DidYouMean.respond_to?(:correct_error)
-      DidYouMean.correct_error(Bundler::Thor::UndefinedCommandError, UndefinedCommandError::SpellChecker)
-      DidYouMean.correct_error(Bundler::Thor::UnknownArgumentError, UnknownArgumentError::SpellChecker)
-    else
-      DidYouMean::SPELL_CHECKERS.merge!(
-        'Bundler::Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
-        'Bundler::Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
-      )
-    end
+  class ExclusiveArgumentError < InvocationError
+  end
+
+  class AtLeastOneRequiredArgumentError < InvocationError
   end
 end

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

@@ -169,7 +169,7 @@ class Bundler::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: # rubocop:disable MethodLength
+    def get_options_from_invocations(group_options, base_options) #:nodoc:
       invocations.each do |name, from_option|
         value = if from_option
           option = class_options[name]

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

@@ -143,7 +143,7 @@ class Bundler::Thor
 
     # Configuration values that are shared between invocations.
     def _shared_configuration #:nodoc:
-      {:invocations => @_invocations}
+      {invocations: @_invocations}
     end
 
     # This method simply retrieves the class and command to be invoked.

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

@@ -13,10 +13,10 @@ class Bundler::Thor
     end
 
     def entered?
-      @depth > 0
+      @depth.positive?
     end
 
-    private
+  private
 
     def push
       @depth += 1

data/bundler/lib/bundler/vendor/thor/lib/thor/parser/argument.rb

@@ -24,6 +24,17 @@ class Bundler::Thor
       validate! # Trigger specific validations
     end
 
+    def print_default
+      if @type == :array and @default.is_a?(Array)
+        @default.map { |x|
+          p = x.gsub('"','\\"')
+          "\"#{p}\""
+        }.join(" ")
+      else
+        @default
+      end
+    end
+
     def usage
       required? ? banner : "[#{banner}]"
     end
@@ -41,11 +52,19 @@ class Bundler::Thor
       end
     end
 
+    def enum_to_s
+      if enum.respond_to? :join
+        enum.join(", ")
+      else
+        "#{enum.first}..#{enum.last}"
+      end
+    end
+
   protected
 
     def validate!
       raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
-      raise ArgumentError, "An argument cannot have an enum other than an array." if @enum && !@enum.is_a?(Array)
+      raise ArgumentError, "An argument cannot have an enum other than an enumerable." if @enum && !@enum.is_a?(Enumerable)
     end
 
     def valid_type?(type)

data/bundler/lib/bundler/vendor/thor/lib/thor/parser/arguments.rb

@@ -1,5 +1,5 @@
 class Bundler::Thor
-  class Arguments #:nodoc: # rubocop:disable ClassLength
+  class Arguments #:nodoc:
     NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
@@ -30,11 +30,7 @@ class Bundler::Thor
 
       arguments.each do |argument|
         if !argument.default.nil?
-          begin
-            @assigns[argument.human_name] = argument.default.dup
-          rescue TypeError  # Compatibility shim for un-dup-able Fixnum in Ruby < 2.4
-            @assigns[argument.human_name] = argument.default
-          end
+          @assigns[argument.human_name] = argument.default.dup
         elsif argument.required?
           @non_assigned_required << argument
         end
@@ -121,8 +117,18 @@ class Bundler::Thor
     #
     def parse_array(name)
       return shift if peek.is_a?(Array)
+
       array = []
-      array << shift while current_is_value?
+
+      while current_is_value?
+        value = shift
+
+        if !value.empty?
+          validate_enum_value!(name, value, "Expected all values of '%s' to be one of %s; got %s")
+        end
+
+        array << value
+      end
       array
     end
 
@@ -138,11 +144,9 @@ class Bundler::Thor
       end
 
       value = $&.index(".") ? shift.to_f : shift.to_i
-      if @switches.is_a?(Hash) && switch = @switches[name]
-        if switch.enum && !switch.enum.include?(value)
-          raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
-        end
-      end
+
+      validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
+
       value
     end
 
@@ -156,15 +160,27 @@ class Bundler::Thor
         nil
       else
         value = shift
-        if @switches.is_a?(Hash) && switch = @switches[name]
-          if switch.enum && !switch.enum.include?(value)
-            raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
-          end
-        end
+
+        validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
+
         value
       end
     end
 
+    # Raises an error if the switch is an enum and the values aren't included on it.
+    #
+    def validate_enum_value!(name, value, message)
+      return unless @switches.is_a?(Hash)
+
+      switch = @switches[name]
+
+      return unless switch
+
+      if switch.enum && !switch.enum.include?(value)
+        raise MalformattedArgumentError, message % [name, switch.enum_to_s, value]
+      end
+    end
+
     # Raises an error if @non_assigned_required array is not empty.
     #
     def check_requirement!

data/bundler/lib/bundler/vendor/thor/lib/thor/parser/option.rb

@@ -11,7 +11,7 @@ class Bundler::Thor
       super
       @lazy_default   = options[:lazy_default]
       @group          = options[:group].to_s.capitalize if options[:group]
-      @aliases        = Array(options[:aliases])
+      @aliases        = normalize_aliases(options[:aliases])
       @hide           = options[:hide]
     end
 
@@ -58,7 +58,7 @@ class Bundler::Thor
         default = nil
         if VALID_TYPES.include?(value)
           value
-        elsif required = (value == :required) # rubocop:disable AssignmentInCondition
+        elsif required = (value == :required) # rubocop:disable Lint/AssignmentInCondition
           :string
         end
       when TrueClass, FalseClass
@@ -69,7 +69,7 @@ class Bundler::Thor
         value.class.name.downcase.to_sym
       end
 
-      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
+      new(name.to_s, required: required, type: type, default: default, aliases: aliases)
     end
 
     def switch_name
@@ -90,13 +90,26 @@ class Bundler::Thor
       sample = "[#{sample}]".dup unless required?
 
       if boolean?
-        sample << ", [#{dasherize('no-' + human_name)}]" unless (name == "force") || name.start_with?("no-")
+        sample << ", [#{dasherize('no-' + human_name)}]" unless (name == "force") || name.match(/\Ano[\-_]/)
       end
 
+      aliases_for_usage.ljust(padding) + sample
+    end
+
+    def aliases_for_usage
       if aliases.empty?
-        (" " * padding) << sample
+        ""
+      else
+        "#{aliases.join(', ')}, "
+      end
+    end
+
+    def show_default?
+      case default
+      when TrueClass, FalseClass
+        true
       else
-        "#{aliases.join(', ')}, #{sample}"
+        super
       end
     end
 
@@ -138,8 +151,8 @@ class Bundler::Thor
           raise ArgumentError, err
         elsif @check_default_type == nil
           Bundler::Thor.deprecation_warning "#{err}.\n" +
-            'This will be rejected in the future unless you explicitly pass the options `check_default_type: false`' +
-            ' or call `allow_incompatible_default_type!` in your code'
+            "This will be rejected in the future unless you explicitly pass the options `check_default_type: false`" +
+            " or call `allow_incompatible_default_type!` in your code"
         end
       end
     end
@@ -155,5 +168,11 @@ class Bundler::Thor
     def dasherize(str)
       (str.length > 1 ? "--" : "-") + str.tr("_", "-")
     end
+
+  private
+
+    def normalize_aliases(aliases)
+      Array(aliases).map { |short| short.to_s.sub(/^(?!\-)/, "-") }
+    end
   end
 end