rubygems-update 3.4.20 → 3.4.22

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

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

@@ -1,5 +1,5 @@
 class Bundler::Thor
-  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
+  class Options < Arguments #:nodoc:
     LONG_RE     = /^(--\w+(?:-\w+)*)$/
     SHORT_RE    = /^(-[a-z])$/i
     EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
@@ -29,8 +29,10 @@ class Bundler::Thor
     #
     # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
     # an unknown option or a regular argument.
-    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false)
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false, relations = {})
       @stop_on_unknown = stop_on_unknown
+      @exclusives = (relations[:exclusive_option_names] || []).select{|array| !array.empty?}
+      @at_least_ones = (relations[:at_least_one_option_names] || []).select{|array| !array.empty?}
       @disable_required_check = disable_required_check
       options = hash_options.values
       super(options)
@@ -50,8 +52,7 @@ class Bundler::Thor
       options.each do |option|
         @switches[option.switch_name] = option
 
-        option.aliases.each do |short|
-          name = short.to_s.sub(/^(?!\-)/, "-")
+        option.aliases.each do |name|
           @shorts[name] ||= option.switch_name
         end
       end
@@ -85,7 +86,7 @@ class Bundler::Thor
       super(arg)
     end
 
-    def parse(args) # rubocop:disable MethodLength
+    def parse(args) # rubocop:disable Metrics/MethodLength
       @pile = args.dup
       @is_treated_as_value = false
       @parsing_options = true
@@ -132,12 +133,38 @@ class Bundler::Thor
       end
 
       check_requirement! unless @disable_required_check
+      check_exclusive!
+      check_at_least_one!
 
       assigns = Bundler::Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
       assigns.freeze
       assigns
     end
 
+    def check_exclusive!
+      opts = @assigns.keys
+      # When option A and B are exclusive, if A and B are given at the same time,
+      # the diffrence of argument array size will decrease.
+      found = @exclusives.find{ |ex| (ex - opts).size < ex.size - 1 }
+      if found
+        names = names_to_switch_names(found & opts).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail ExclusiveArgumentError, "Found exclusive #{class_name} #{names.join(", ")}"
+      end
+    end
+
+    def check_at_least_one!
+      opts = @assigns.keys
+      # When at least one is required of the options A and B,
+      # if the both options were not given, none? would be true.
+      found = @at_least_ones.find{ |one_reqs| one_reqs.none?{ |o| opts.include? o} }
+      if found
+        names = names_to_switch_names(found).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail AtLeastOneRequiredArgumentError, "Not found at least one of required #{class_name} #{names.join(", ")}"
+      end
+    end
+
     def check_unknown!
       to_check = @stopped_parsing_after_extra_index ? @extra[0...@stopped_parsing_after_extra_index] : @extra
 
@@ -148,6 +175,17 @@ class Bundler::Thor
 
   protected
 
+    # Option names changes to swith name or human name
+    def names_to_switch_names(names = [])
+      @switches.map do |_, o|
+        if names.include? o.name
+          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+        else
+          nil
+        end
+      end.compact
+    end
+
     def assign_result!(option, result)
       if option.repeatable && option.type == :hash
         (@assigns[option.human_name] ||= {}).merge!(result)
@@ -194,7 +232,7 @@ class Bundler::Thor
     end
 
     def switch_option(arg)
-      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
+      if match = no_or_skip?(arg) # rubocop:disable Lint/AssignmentInCondition
         @switches[arg] || @switches["--#{match}"]
       else
         @switches[arg]

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

@@ -41,7 +41,7 @@ instance_eval do
   def task(*)
     task = super
 
-    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
+    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
       non_namespaced_name = task.name.split(":").last
 
       description = non_namespaced_name
@@ -59,7 +59,7 @@ instance_eval do
   end
 
   def namespace(name)
-    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
+    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
       const_name = Bundler::Thor::Util.camel_case(name.to_s).to_sym
       klass.const_set(const_name, Class.new(Bundler::Thor))
       new_klass = klass.const_get(const_name)

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

@@ -2,12 +2,10 @@ require_relative "../thor"
 require_relative "group"
 
 require "yaml"
-require "digest/md5"
+require "digest/sha2"
 require "pathname"
 
-class Bundler::Thor::Runner < Bundler::Thor #:nodoc: # rubocop:disable ClassLength
-  autoload :OpenURI, "open-uri"
-
+class Bundler::Thor::Runner < Bundler::Thor #:nodoc:
   map "-T" => :list, "-i" => :install, "-u" => :update, "-v" => :version
 
   def self.banner(command, all = false, subcommand = false)
@@ -25,7 +23,7 @@ class Bundler::Thor::Runner < Bundler::Thor #:nodoc: # rubocop:disable ClassLeng
       initialize_thorfiles(meth)
       klass, command = Bundler::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 => shell)
+      klass.start(["-h", command].compact, shell: shell)
     else
       super
     end
@@ -40,30 +38,42 @@ class Bundler::Thor::Runner < Bundler::Thor #:nodoc: # rubocop:disable ClassLeng
     klass, command = Bundler::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 => shell)
+    klass.start(args, shell: shell)
   end
 
   desc "install NAME", "Install an optionally named Bundler::Thor file into your system commands"
-  method_options :as => :string, :relative => :boolean, :force => :boolean
-  def install(name) # rubocop:disable MethodLength
+  method_options as: :string, relative: :boolean, force: :boolean
+  def install(name) # rubocop:disable Metrics/MethodLength
     initialize_thorfiles
 
-    # If a directory name is provided as the argument, look for a 'main.thor'
-    # command in said directory.
-    begin
-      if File.directory?(File.expand_path(name))
-        base = File.join(name, "main.thor")
-        package = :directory
-        contents = open(base, &:read)
-      else
-        base = name
-        package = :file
-        contents = open(name, &:read)
+    is_uri  = name =~ %r{^https?\://}
+
+    if is_uri
+      base = name
+      package = :file
+      require "open-uri"
+      begin
+        contents = URI.open(name, &:read)
+      rescue OpenURI::HTTPError
+        raise Error, "Error opening URI '#{name}'"
+      end
+    else
+      # If a directory name is provided as the argument, look for a 'main.thor'
+      # command in said directory.
+      begin
+        if File.directory?(File.expand_path(name))
+          base = File.join(name, "main.thor")
+          package = :directory
+          contents = File.open(base, &:read)
+        else
+          base = name
+          package = :file
+          require "open-uri"
+          contents = URI.open(name, &:read)
+        end
+      rescue Errno::ENOENT
+        raise Error, "Error opening file '#{name}'"
       end
-    rescue OpenURI::HTTPError
-      raise Error, "Error opening URI '#{name}'"
-    rescue Errno::ENOENT
-      raise Error, "Error opening file '#{name}'"
     end
 
     say "Your Thorfile contains:"
@@ -84,16 +94,16 @@ class Bundler::Thor::Runner < Bundler::Thor #:nodoc: # rubocop:disable ClassLeng
       as = basename if as.empty?
     end
 
-    location = if options[:relative] || name =~ %r{^https?://}
+    location = if options[:relative] || is_uri
       name
     else
       File.expand_path(name)
     end
 
     thor_yaml[as] = {
-      :filename   => Digest::MD5.hexdigest(name + as),
-      :location   => location,
-      :namespaces => Bundler::Thor::Util.namespaces_in_content(contents, base)
+      filename: Digest::SHA256.hexdigest(name + as),
+      location: location,
+      namespaces: Bundler::Thor::Util.namespaces_in_content(contents, base)
     }
 
     save_yaml(thor_yaml)
@@ -154,14 +164,14 @@ class Bundler::Thor::Runner < Bundler::Thor #:nodoc: # rubocop:disable ClassLeng
   end
 
   desc "installed", "List the installed Bundler::Thor modules and commands"
-  method_options :internal => :boolean
+  method_options internal: :boolean
   def installed
     initialize_thorfiles(nil, true)
     display_klasses(true, options["internal"])
   end
 
   desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
-  method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
+  method_options substring: :boolean, group: :string, all: :boolean, debug: :boolean
   def list(search = "")
     initialize_thorfiles
 
@@ -303,7 +313,7 @@ private
     say shell.set_color(namespace, :blue, true)
     say "-" * namespace.size
 
-    print_table(list, :truncate => true)
+    print_table(list, truncate: true)
     say
   end
   alias_method :display_tasks, :display_commands

data/bundler/lib/bundler/vendor/thor/lib/thor/shell/basic.rb

@@ -1,8 +1,10 @@
+require_relative "column_printer"
+require_relative "table_printer"
+require_relative "wrapped_printer"
+
 class Bundler::Thor
   module Shell
     class Basic
-      DEFAULT_TERMINAL_WIDTH = 80
-
       attr_accessor :base
       attr_reader   :padding
 
@@ -145,14 +147,14 @@ class Bundler::Thor
       # "yes".
       #
       def yes?(statement, color = nil)
-        !!(ask(statement, color, :add_to_history => false) =~ is?(:yes))
+        !!(ask(statement, color, add_to_history: false) =~ is?(:yes))
       end
 
       # Make a question the to user and returns true if the user replies "n" or
       # "no".
       #
       def no?(statement, color = nil)
-        !!(ask(statement, color, :add_to_history => false) =~ is?(:no))
+        !!(ask(statement, color, add_to_history: false) =~ is?(:no))
       end
 
       # Prints values in columns
@@ -161,16 +163,8 @@ class Bundler::Thor
       # Array[String, String, ...]
       #
       def print_in_columns(array)
-        return if array.empty?
-        colwidth = (array.map { |el| el.to_s.size }.max || 0) + 2
-        array.each_with_index do |value, index|
-          # Don't output trailing spaces when printing the last column
-          if ((((index + 1) % (terminal_width / colwidth))).zero? && !index.zero?) || index + 1 == array.length
-            stdout.puts value
-          else
-            stdout.printf("%-#{colwidth}s", value)
-          end
-        end
+        printer = ColumnPrinter.new(stdout)
+        printer.print(array)
       end
 
       # Prints a table.
@@ -181,58 +175,11 @@ class Bundler::Thor
       # ==== Options
       # indent<Integer>:: Indent the first column by indent value.
       # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+      # borders<Boolean>:: Adds ascii borders.
       #
-      def print_table(array, options = {}) # rubocop:disable MethodLength
-        return if array.empty?
-
-        formats = []
-        indent = options[:indent].to_i
-        colwidth = options[:colwidth]
-        options[:truncate] = terminal_width if options[:truncate] == true
-
-        formats << "%-#{colwidth + 2}s".dup if colwidth
-        start = colwidth ? 1 : 0
-
-        colcount = array.max { |a, b| a.size <=> b.size }.size
-
-        maximas = []
-
-        start.upto(colcount - 1) do |index|
-          maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
-          maximas << maxima
-          formats << if index == colcount - 1
-                       # Don't output 2 trailing spaces when printing the last column
-                       "%-s".dup
-                     else
-                       "%-#{maxima + 2}s".dup
-                     end
-        end
-
-        formats[0] = formats[0].insert(0, " " * indent)
-        formats << "%s"
-
-        array.each do |row|
-          sentence = "".dup
-
-          row.each_with_index do |column, index|
-            maxima = maximas[index]
-
-            f = if column.is_a?(Numeric)
-              if index == row.size - 1
-                # Don't output 2 trailing spaces when printing the last column
-                "%#{maxima}s"
-              else
-                "%#{maxima}s  "
-              end
-            else
-              formats[index]
-            end
-            sentence << f % column.to_s
-          end
-
-          sentence = truncate(sentence, options[:truncate]) if options[:truncate]
-          stdout.puts sentence
-        end
+      def print_table(array, options = {}) # rubocop:disable Metrics/MethodLength
+        printer = TablePrinter.new(stdout, options)
+        printer.print(array)
       end
 
       # Prints a long string, word-wrapping the text to the current width of the
@@ -245,33 +192,8 @@ class Bundler::Thor
       # indent<Integer>:: Indent each line of the printed paragraph by indent value.
       #
       def print_wrapped(message, options = {})
-        indent = options[:indent] || 0
-        width = terminal_width - indent
-        paras = message.split("\n\n")
-
-        paras.map! do |unwrapped|
-          words = unwrapped.split(" ")
-          counter = words.first.length
-          words.inject do |memo, word|
-            word = word.gsub(/\n\005/, "\n").gsub(/\005/, "\n")
-            counter = 0 if word.include? "\n"
-            if (counter + word.length + 1) < width
-              memo = "#{memo} #{word}"
-              counter += (word.length + 1)
-            else
-              memo = "#{memo}\n#{word}"
-              counter = word.length
-            end
-            memo
-          end
-        end.compact!
-
-        paras.each do |para|
-          para.split("\n").each do |line|
-            stdout.puts line.insert(0, " " * indent)
-          end
-          stdout.puts unless para == paras.last
-        end
+        printer = WrappedPrinter.new(stdout, options)
+        printer.print(message)
       end
 
       # Deals with file collision and returns true if the file should be
@@ -289,7 +211,7 @@ class Bundler::Thor
         loop do
           answer = ask(
             %[Overwrite #{destination}? (enter "h" for help) #{options}],
-            :add_to_history => false
+            add_to_history: false
           )
 
           case answer
@@ -316,24 +238,11 @@ class Bundler::Thor
 
             say "Please specify merge tool to `THOR_MERGE` env."
           else
-            say file_collision_help
+            say file_collision_help(block_given?)
           end
         end
       end
 
-      # This code was copied from Rake, available under MIT-LICENSE
-      # Copyright (c) 2003, 2004 Jim Weirich
-      def terminal_width
-        result = if ENV["THOR_COLUMNS"]
-          ENV["THOR_COLUMNS"].to_i
-        else
-          unix? ? dynamic_width : DEFAULT_TERMINAL_WIDTH
-        end
-        result < 10 ? DEFAULT_TERMINAL_WIDTH : result
-      rescue
-        DEFAULT_TERMINAL_WIDTH
-      end
-
       # Called if something goes wrong during the execution. This is used by Bundler::Thor
       # internally and should not be used inside your scripts. If something went
       # wrong, you can always raise an exception. If you raise a Bundler::Thor::Error, it
@@ -384,16 +293,21 @@ class Bundler::Thor
         end
       end
 
-      def file_collision_help #:nodoc:
-        <<-HELP
+      def file_collision_help(block_given) #:nodoc:
+        help = <<-HELP
         Y - yes, overwrite
         n - no, do not overwrite
         a - all, overwrite this and all others
         q - quit, abort
-        d - diff, show the differences between the old and the new
         h - help, show this help
-        m - merge, run merge tool
         HELP
+        if block_given
+          help << <<-HELP
+        d - diff, show the differences between the old and the new
+        m - merge, run merge tool
+          HELP
+        end
+        help
       end
 
       def show_diff(destination, content) #:nodoc:
@@ -411,46 +325,8 @@ class Bundler::Thor
         mute? || (base && base.options[:quiet])
       end
 
-      # Calculate the dynamic width of the terminal
-      def dynamic_width
-        @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
-      end
-
-      def dynamic_width_stty
-        `stty size 2>/dev/null`.split[1].to_i
-      end
-
-      def dynamic_width_tput
-        `tput cols 2>/dev/null`.to_i
-      end
-
       def unix?
-        RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris)/i
-      end
-
-      def truncate(string, width)
-        as_unicode do
-          chars = string.chars.to_a
-          if chars.length <= width
-            chars.join
-          else
-            chars[0, width - 3].join + "..."
-          end
-        end
-      end
-
-      if "".respond_to?(:encode)
-        def as_unicode
-          yield
-        end
-      else
-        def as_unicode
-          old = $KCODE
-          $KCODE = "U"
-          yield
-        ensure
-          $KCODE = old
-        end
+        Terminal.unix?
       end
 
       def ask_simply(statement, color, options)