rubygems-update 3.4.21 → 3.5.0

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

@@ -0,0 +1,49 @@
+module LCSDiff
+protected
+
+  # Overwrite show_diff to show diff with colors if Diff::LCS is
+  # available.
+  def show_diff(destination, content) #:nodoc:
+    if diff_lcs_loaded? && ENV["THOR_DIFF"].nil? && ENV["RAILS_DIFF"].nil?
+      actual  = File.binread(destination).to_s.split("\n")
+      content = content.to_s.split("\n")
+
+      Diff::LCS.sdiff(actual, content).each do |diff|
+        output_diff_line(diff)
+      end
+    else
+      super
+    end
+  end
+
+private
+
+  def output_diff_line(diff) #:nodoc:
+    case diff.action
+    when "-"
+      say "- #{diff.old_element.chomp}", :red, true
+    when "+"
+      say "+ #{diff.new_element.chomp}", :green, true
+    when "!"
+      say "- #{diff.old_element.chomp}", :red, true
+      say "+ #{diff.new_element.chomp}", :green, true
+    else
+      say "  #{diff.old_element.chomp}", nil, true
+    end
+  end
+
+  # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+  # for diff.
+  def diff_lcs_loaded? #:nodoc:
+    return true if defined?(Diff::LCS)
+    return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
+
+    @diff_lcs_loaded = begin
+      require "diff/lcs"
+      true
+    rescue LoadError
+      false
+    end
+  end
+
+end

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

@@ -0,0 +1,134 @@
+require_relative "column_printer"
+require_relative "terminal"
+
+class Bundler::Thor
+  module Shell
+    class TablePrinter < ColumnPrinter
+      BORDER_SEPARATOR = :separator
+
+      def initialize(stdout, options = {})
+        super
+        @formats = []
+        @maximas = []
+        @colwidth = options[:colwidth]
+        @truncate = options[:truncate] == true ? Terminal.terminal_width : options[:truncate]
+        @padding = 1
+      end
+
+      def print(array)
+        return if array.empty?
+
+        prepare(array)
+
+        print_border_separator if options[:borders]
+
+        array.each do |row|
+          if options[:borders] && row == BORDER_SEPARATOR
+            print_border_separator
+            next
+          end
+
+          sentence = "".dup
+
+          row.each_with_index do |column, index|
+            sentence << format_cell(column, row.size, index)
+          end
+
+          sentence = truncate(sentence)
+          sentence << "|" if options[:borders]
+          stdout.puts indentation + sentence
+
+        end
+        print_border_separator if options[:borders]
+      end
+
+    private
+
+      def prepare(array)
+        array = array.reject{|row| row == BORDER_SEPARATOR }
+
+        @formats << "%-#{@colwidth + 2}s".dup if @colwidth
+        start = @colwidth ? 1 : 0
+
+        colcount = array.max { |a, b| a.size <=> b.size }.size
+
+        start.upto(colcount - 1) do |index|
+          maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
+
+          @maximas << maxima
+          @formats << if options[:borders]
+             "%-#{maxima}s".dup
+          elsif index == colcount - 1
+            # Don't output 2 trailing spaces when printing the last column
+            "%-s".dup
+          else
+            "%-#{maxima + 2}s".dup
+          end
+        end
+
+        @formats << "%s"
+      end
+
+      def format_cell(column, row_size, index)
+        maxima = @maximas[index]
+
+        f = if column.is_a?(Numeric)
+          if options[:borders]
+            # With borders we handle padding separately
+            "%#{maxima}s"
+          elsif 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
+
+        cell = "".dup
+        cell << "|" + " " * @padding if options[:borders]
+        cell << f % column.to_s
+        cell << " " * @padding if options[:borders]
+        cell
+      end
+
+      def print_border_separator
+        separator = @maximas.map do |maxima|
+          "+" + "-" * (maxima + 2 * @padding)
+        end
+        stdout.puts indentation + separator.join + "+"
+      end
+
+      def truncate(string)
+        return string unless @truncate
+        as_unicode do
+          chars = string.chars.to_a
+          if chars.length <= @truncate
+            chars.join
+          else
+            chars[0, @truncate - 3 - @indent].join + "..."
+          end
+        end
+      end
+
+      def indentation
+        " " * @indent
+      end
+
+      if "".respond_to?(:encode)
+        def as_unicode
+          yield
+        end
+      else
+        def as_unicode
+          old = $KCODE # rubocop:disable Style/GlobalVars
+          $KCODE = "U" # rubocop:disable Style/GlobalVars
+          yield
+        ensure
+          $KCODE = old # rubocop:disable Style/GlobalVars
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+class Bundler::Thor
+  module Shell
+    module Terminal
+      DEFAULT_TERMINAL_WIDTH = 80
+
+      class << self
+        # 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
+
+        def unix?
+          RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris)/i
+        end
+
+      private
+
+        # 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
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require_relative "column_printer"
+require_relative "terminal"
+
+class Bundler::Thor
+  module Shell
+    class WrappedPrinter < ColumnPrinter
+      def print(message)
+        width = Terminal.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
+      end
+    end
+  end
+end
+

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

@@ -75,7 +75,7 @@ class Bundler::Thor
     # Allow shell to be shared between invocations.
     #
     def _shared_configuration #:nodoc:
-      super.merge!(:shell => shell)
+      super.merge!(shell: shell)
     end
   end
 end

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

@@ -90,7 +90,7 @@ class Bundler::Thor
       def snake_case(str)
         return str.downcase if str =~ /^[A-Z_]+$/
         str.gsub(/\B[A-Z]/, '_\&').squeeze("_") =~ /_*(.*)/
-        $+.downcase
+        Regexp.last_match(-1).downcase
       end
 
       # Receives a string and convert it to camel case. camel_case returns CamelCase.
@@ -130,9 +130,10 @@ class Bundler::Thor
       #
       def find_class_and_command_by_namespace(namespace, fallback = true)
         if namespace.include?(":") # look for a namespaced command
-          pieces  = namespace.split(":")
-          command = pieces.pop
-          klass   = Bundler::Thor::Util.find_by_namespace(pieces.join(":"))
+          *pieces, command  = namespace.split(":")
+          namespace = pieces.join(":")
+          namespace = "default" if namespace.empty?
+          klass = Bundler::Thor::Base.subclasses.detect { |thor| thor.namespace == namespace && thor.commands.keys.include?(command) }
         end
         unless klass # look for a Bundler::Thor::Group with the right name
           klass = Bundler::Thor::Util.find_by_namespace(namespace)
@@ -150,7 +151,7 @@ class Bundler::Thor
       # inside the sandbox to avoid namespacing conflicts.
       #
       def load_thorfile(path, content = nil, debug = false)
-        content ||= File.binread(path)
+        content ||= File.read(path)
 
         begin
           Bundler::Thor::Sandbox.class_eval(content, path)
@@ -189,7 +190,7 @@ class Bundler::Thor
       # Returns the root where thor files are located, depending on the OS.
       #
       def thor_root
-        File.join(user_home, ".thor").tr('\\', "/")
+        File.join(user_home, ".thor").tr("\\", "/")
       end
 
       # Returns the files in the thor root. On Windows thor_root will be something
@@ -236,7 +237,7 @@ class Bundler::Thor
                 # symlink points to 'ruby_install_name'
                 ruby = alternate_ruby if linked_ruby == ruby_name || linked_ruby == ruby
               end
-            rescue NotImplementedError # rubocop:disable HandleExceptions
+            rescue NotImplementedError # rubocop:disable Lint/HandleExceptions
               # just ignore on windows
             end
           end

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

@@ -1,3 +1,3 @@
 class Bundler::Thor
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

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

@@ -65,8 +65,15 @@ class Bundler::Thor
 
     # Defines the long description of the next command.
     #
+    # Long description is by default indented, line-wrapped and repeated whitespace merged.
+    # In order to print long description verbatim, with indentation and spacing exactly
+    # as found in the code, use the +wrap+ option
+    #
+    #   long_desc 'your very long description', wrap: false
+    #
     # ==== Parameters
     # long description<String>
+    # options<Hash>
     #
     def long_desc(long_description, options = {})
       if options[:for]
@@ -74,6 +81,7 @@ class Bundler::Thor
         command.long_description = long_description if long_description
       else
         @long_desc = long_description
+        @long_desc_wrap = options[:wrap] != false
       end
     end
 
@@ -133,7 +141,7 @@ class Bundler::Thor
     #     # magic
     #   end
     #
-    #   method_option :foo => :bar, :for => :previous_command
+    #   method_option :foo, :for => :previous_command
     #
     #   def next_command
     #     # magic
@@ -153,6 +161,9 @@ class Bundler::Thor
     # :hide     - If you want to hide this option from the help.
     #
     def method_option(name, options = {})
+      unless [ Symbol, String ].any? { |klass| name.is_a?(klass) }
+        raise ArgumentError, "Expected a Symbol or String, got #{name.inspect}"
+      end
       scope = if options[:for]
         find_and_refresh_command(options[:for]).options
       else
@@ -163,6 +174,81 @@ class Bundler::Thor
     end
     alias_method :option, :method_option
 
+    # Adds and declares option group for exclusive options in the
+    # block and arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Bundler::Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   exclusive do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   exclusive :one, :two
+    #
+    # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+    # will be raised.
+    #
+    def method_exclusive(*args, &block)
+      register_options_relation_for(:method_options,
+                                    :method_exclusive_option_names, *args, &block)
+    end
+    alias_method :exclusive, :method_exclusive
+
+    # Adds and declares option group for required at least one of options in the
+    # block of arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Bundler::Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   at_least_one do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   at_least_one :one, :two
+    #
+    # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+    # will be raised.
+    #
+    # You can use at_least_one and exclusive at the same time.
+    #
+    #    exclusive do
+    #      at_least_one do
+    #        option :one
+    #        option :two
+    #      end
+    #    end
+    #
+    # Then it is required either only one of "--one" or "--two".
+    #
+    def method_at_least_one(*args, &block)
+      register_options_relation_for(:method_options,
+                                    :method_at_least_one_option_names, *args, &block)
+    end
+    alias_method :at_least_one, :method_at_least_one
+
     # Prints help information for the given command.
     #
     # ==== Parameters
@@ -178,9 +264,16 @@ class Bundler::Thor
       shell.say "  #{banner(command).split("\n").join("\n  ")}"
       shell.say
       class_options_help(shell, nil => command.options.values)
+      print_exclusive_options(shell, command)
+      print_at_least_one_required_options(shell, command)
+
       if command.long_description
         shell.say "Description:"
-        shell.print_wrapped(command.long_description, :indent => 2)
+        if command.wrap_long_description
+          shell.print_wrapped(command.long_description, indent: 2)
+        else
+          shell.say command.long_description
+        end
       else
         shell.say command.description
       end
@@ -197,7 +290,7 @@ class Bundler::Thor
       Bundler::Thor::Util.thor_classes_in(self).each do |klass|
         list += klass.printable_commands(false)
       end
-      list.sort! { |a, b| a[0] <=> b[0] }
+      sort_commands!(list)
 
       if defined?(@package_name) && @package_name
         shell.say "#{@package_name} commands:"
@@ -205,9 +298,11 @@ class Bundler::Thor
         shell.say "Commands:"
       end
 
-      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.print_table(list, indent: 2, truncate: true)
       shell.say
       class_options_help(shell)
+      print_exclusive_options(shell)
+      print_at_least_one_required_options(shell)
     end
 
     # Returns commands ready to be printed.
@@ -238,7 +333,7 @@ class Bundler::Thor
 
       define_method(subcommand) do |*args|
         args, opts = Bundler::Thor::Arguments.split(args)
-        invoke_args = [args, opts, {:invoked_via_subcommand => true, :class_options => options}]
+        invoke_args = [args, opts, {invoked_via_subcommand: true, class_options: options}]
         invoke_args.unshift "help" if opts.delete("--help") || opts.delete("-h")
         invoke subcommand_class, *invoke_args
       end
@@ -346,6 +441,24 @@ class Bundler::Thor
 
   protected
 
+    # Returns this class exclusive options array set.
+    #
+    # ==== Returns
+    # Array[Array[Bundler::Thor::Option.name]]
+    #
+    def method_exclusive_option_names #:nodoc:
+      @method_exclusive_option_names ||= []
+    end
+
+    # Returns this class at least one of required options array set.
+    #
+    # ==== Returns
+    # Array[Array[Bundler::Thor::Option.name]]
+    #
+    def method_at_least_one_option_names #:nodoc:
+      @method_at_least_one_option_names ||= []
+    end
+
     def stop_on_unknown_option #:nodoc:
       @stop_on_unknown_option ||= []
     end
@@ -355,8 +468,30 @@ class Bundler::Thor
       @disable_required_check ||= [:help]
     end
 
+    def print_exclusive_options(shell, command = nil) # :nodoc:
+      opts = []
+      opts  = command.method_exclusive_option_names unless command.nil?
+      opts += class_exclusive_option_names
+      unless opts.empty?
+        shell.say "Exclusive Options:"
+        shell.print_table(opts.map{ |ex| ex.map{ |e| "--#{e}"}}, indent: 2 )
+        shell.say
+      end
+    end
+
+    def print_at_least_one_required_options(shell, command = nil) # :nodoc:
+      opts = []
+      opts = command.method_at_least_one_option_names unless command.nil?
+      opts += class_at_least_one_option_names
+      unless opts.empty?
+        shell.say "Required At Least One:"
+        shell.print_table(opts.map{ |ex| ex.map{ |e| "--#{e}"}}, indent: 2 )
+        shell.say
+      end
+    end
+
     # The method responsible for dispatching given the args.
-    def dispatch(meth, given_args, given_opts, config) #:nodoc: # rubocop:disable MethodLength
+    def dispatch(meth, given_args, given_opts, config) #:nodoc:
       meth ||= retrieve_command_name(given_args)
       command = all_commands[normalize_command_name(meth)]
 
@@ -415,12 +550,16 @@ class Bundler::Thor
       @usage ||= nil
       @desc ||= nil
       @long_desc ||= nil
+      @long_desc_wrap ||= nil
       @hide ||= nil
 
       if @usage && @desc
         base_class = @hide ? Bundler::Thor::HiddenCommand : Bundler::Thor::Command
-        commands[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
-        @usage, @desc, @long_desc, @method_options, @hide = nil
+        relations = {exclusive_option_names: method_exclusive_option_names,
+          at_least_one_option_names: method_at_least_one_option_names}
+        commands[meth] = base_class.new(meth, @desc, @long_desc, @long_desc_wrap, @usage, method_options, relations)
+        @usage, @desc, @long_desc, @long_desc_wrap, @method_options, @hide = nil
+        @method_exclusive_option_names, @method_at_least_one_option_names = nil
         true
       elsif all_commands[meth] || meth == "method_missing"
         true
@@ -495,6 +634,14 @@ class Bundler::Thor
 "
     end
     alias_method :subtask_help, :subcommand_help
+
+    # Sort the commands, lexicographically by default.
+    #
+    # Can be overridden in the subclass to change the display order of the
+    # commands.
+    def sort_commands!(list)
+      list.sort! { |a, b| a[0] <=> b[0] }
+    end
   end
 
   include Bundler::Thor::Base

data/bundler/lib/bundler/vendor/tsort/lib/tsort.rb

@@ -122,6 +122,9 @@
 #
 
 module Bundler::TSort
+
+  VERSION = "0.2.0"
+
   class Cyclic < StandardError
   end