rubygems-update 3.1.6 → 3.4.10

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/version_union.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Bundler::PubGrub
+  class VersionUnion
+    attr_reader :ranges
+
+    def self.normalize_ranges(ranges)
+      ranges = ranges.flat_map do |range|
+        range.ranges
+      end
+
+      ranges.reject!(&:empty?)
+
+      return [] if ranges.empty?
+
+      mins, ranges = ranges.partition { |r| !r.min }
+      original_ranges = mins + ranges.sort_by { |r| [r.min, r.include_min ? 0 : 1] }
+      ranges = [original_ranges.shift]
+      original_ranges.each do |range|
+        if ranges.last.contiguous_to?(range)
+          ranges << ranges.pop.span(range)
+        else
+          ranges << range
+        end
+      end
+
+      ranges
+    end
+
+    def self.union(ranges, normalize: true)
+      ranges = normalize_ranges(ranges) if normalize
+
+      if ranges.size == 0
+        VersionRange.empty
+      elsif ranges.size == 1
+        ranges[0]
+      else
+        new(ranges)
+      end
+    end
+
+    def initialize(ranges)
+      raise ArgumentError unless ranges.all? { |r| r.instance_of?(VersionRange) }
+      @ranges = ranges
+    end
+
+    def hash
+      ranges.hash
+    end
+
+    def eql?(other)
+      ranges.eql?(other.ranges)
+    end
+
+    def include?(version)
+      !!ranges.bsearch {|r| r.compare_version(version) }
+    end
+
+    def select_versions(all_versions)
+      versions = []
+      ranges.inject(all_versions) do |acc, range|
+        _, matching, higher = range.partition_versions(acc)
+        versions.concat matching
+        higher
+      end
+      versions
+    end
+
+    def intersects?(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        if my_range.intersects?(other_range)
+          return true
+        end
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+    end
+    alias_method :allows_any?, :intersects?
+
+    def allows_all?(other)
+      my_ranges = ranges.dup
+
+      my_range = my_ranges.shift
+
+      other.ranges.all? do |other_range|
+        while my_range
+          break if my_range.allows_all?(other_range)
+          my_range = my_ranges.shift
+        end
+
+        !!my_range
+      end
+    end
+
+    def empty?
+      false
+    end
+
+    def any?
+      false
+    end
+
+    def intersect(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+      new_ranges = []
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        new_ranges << my_range.intersect(other_range)
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+      new_ranges.reject!(&:empty?)
+      VersionUnion.union(new_ranges, normalize: false)
+    end
+
+    def upper_invert
+      ranges.last.upper_invert
+    end
+
+    def invert
+      ranges.map(&:invert).inject(:intersect)
+    end
+
+    def union(other)
+      VersionUnion.union([self, other])
+    end
+
+    def to_s
+      output = []
+
+      ranges = self.ranges.dup
+      while !ranges.empty?
+        ne = []
+        range = ranges.shift
+        while !ranges.empty? && ranges[0].min.to_s == range.max.to_s
+          ne << range.max
+          range = range.span(ranges.shift)
+        end
+
+        ne.map! {|x| "!= #{x}" }
+        if ne.empty?
+          output << range.to_s
+        elsif range.any?
+          output << ne.join(', ')
+        else
+          output << "#{range}, #{ne.join(', ')}"
+        end
+      end
+
+      output.join(" OR ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.ranges == other.ranges
+    end
+  end
+end

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub.rb

@@ -0,0 +1,31 @@
+require_relative "pub_grub/package"
+require_relative "pub_grub/static_package_source"
+require_relative "pub_grub/term"
+require_relative "pub_grub/version_range"
+require_relative "pub_grub/version_constraint"
+require_relative "pub_grub/version_union"
+require_relative "pub_grub/version_solver"
+require_relative "pub_grub/incompatibility"
+require_relative 'pub_grub/solve_failure'
+require_relative 'pub_grub/failure_writer'
+require_relative 'pub_grub/version'
+
+module Bundler::PubGrub
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger || default_logger
+    end
+
+    private
+
+    def default_logger
+      require "logger"
+
+      logger = ::Logger.new(STDERR)
+      logger.level = $DEBUG ? ::Logger::DEBUG : ::Logger::WARN
+      @logger = logger
+    end
+  end
+end

data/bundler/lib/bundler/vendor/thor/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -33,7 +33,8 @@ class Bundler::Thor
       # Boolean:: true if it is identical, false otherwise.
       #
       def identical?
-        exists? && File.identical?(render, destination)
+        source = File.expand_path(render, File.dirname(destination))
+        exists? && File.identical?(source, destination)
       end
 
       def invoke!

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

@@ -210,9 +210,9 @@ class Bundler::Thor
     #
     # ==== Examples
     #
-    #   inject_into_class "app/controllers/application_controller.rb", ApplicationController, "  filter_parameter :password\n"
+    #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController", "  filter_parameter :password\n"
     #
-    #   inject_into_class "app/controllers/application_controller.rb", ApplicationController do
+    #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
     #     "  filter_parameter :password\n"
     #   end
     #
@@ -233,9 +233,9 @@ class Bundler::Thor
     #
     # ==== Examples
     #
-    #   inject_into_module "app/helpers/application_helper.rb", ApplicationHelper, "  def help; 'help'; end\n"
+    #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", "  def help; 'help'; end\n"
     #
-    #   inject_into_module "app/helpers/application_helper.rb", ApplicationHelper do
+    #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
     #     "  def help; 'help'; end\n"
     #   end
     #
@@ -251,7 +251,8 @@ class Bundler::Thor
     # path<String>:: path of the file to be changed
     # flag<Regexp|String>:: the regexp or string to be replaced
     # replacement<String>:: the replacement, can be also given as a block
-    # config<Hash>:: give :verbose => false to not log the status.
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :force => true, to force the replacement regardles of runner behavior.
     #
     # ==== Example
     #
@@ -262,9 +263,10 @@ class Bundler::Thor
     #   end
     #
     def gsub_file(path, flag, *args, &block)
-      return unless behavior == :invoke
       config = args.last.is_a?(Hash) ? args.pop : {}
 
+      return unless behavior == :invoke || config.fetch(:force, false)
+
       path = File.expand_path(path, destination_root)
       say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
 
@@ -329,7 +331,7 @@ class Bundler::Thor
       path = File.expand_path(path, destination_root)
 
       say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
-      if !options[:pretend] && File.exist?(path)
+      if !options[:pretend] && (File.exist?(path) || File.symlink?(path))
         require "fileutils"
         ::FileUtils.rm_rf(path)
       end

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

@@ -106,12 +106,11 @@ class Bundler::Thor
       # Adds the content to the file.
       #
       def replace!(regexp, string, force)
-        return if pretend?
         content = File.read(destination)
         if force || !content.include?(replacement)
           success = content.gsub!(regexp, string)
 
-          File.open(destination, "wb") { |file| file.write(content) }
+          File.open(destination, "wb") { |file| file.write(content) } unless pretend?
           success
         end
       end

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

@@ -161,6 +161,8 @@ class Bundler::Thor
     # to the block you provide. The path is set back to the previous path when
     # the method exits.
     #
+    # Returns the value yielded by the block.
+    #
     # ==== Parameters
     # dir<String>:: the directory to move to.
     # config<Hash>:: give :verbose => true to log and use padding.
@@ -179,16 +181,18 @@ class Bundler::Thor
         FileUtils.mkdir_p(destination_root)
       end
 
+      result = nil
       if pretend
         # In pretend mode, just yield down to the block
-        block.arity == 1 ? yield(destination_root) : yield
+        result = block.arity == 1 ? yield(destination_root) : yield
       else
         require "fileutils"
-        FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+        FileUtils.cd(destination_root) { result = block.arity == 1 ? yield(destination_root) : yield }
       end
 
       @destination_stack.pop
       shell.padding -= 1 if verbose
+      result
     end
 
     # Goes to the root and execute the given block.
@@ -219,7 +223,7 @@ class Bundler::Thor
 
       contents = if is_uri
         require "open-uri"
-        open(path, "Accept" => "application/x-thor-template", &:read)
+        URI.open(path, "Accept" => "application/x-thor-template", &:read)
       else
         open(path, &:read)
       end

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

@@ -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
 

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

@@ -28,6 +28,12 @@ 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

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

@@ -1,5 +1,5 @@
 class Bundler::Thor
-  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable)
+  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
@@ -102,9 +102,14 @@ class Bundler::Thor
   end
 
   if Correctable
-    DidYouMean::SPELL_CHECKERS.merge!(
-      'Bundler::Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
-      'Bundler::Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
-    )
+    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
   end
 end

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

@@ -30,7 +30,11 @@ class Bundler::Thor
 
       arguments.each do |argument|
         if !argument.default.nil?
-          @assigns[argument.human_name] = argument.default
+          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
         elsif argument.required?
           @non_assigned_required << argument
         end

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

@@ -45,6 +45,7 @@ class Bundler::Thor
       @switches = {}
       @extra = []
       @stopped_parsing_after_extra_index = nil
+      @is_treated_as_value = false
 
       options.each do |option|
         @switches[option.switch_name] = option
@@ -74,8 +75,19 @@ class Bundler::Thor
       end
     end
 
+    def shift
+      @is_treated_as_value = false
+      super
+    end
+
+    def unshift(arg, is_value: false)
+      @is_treated_as_value = is_value
+      super(arg)
+    end
+
     def parse(args) # rubocop:disable MethodLength
       @pile = args.dup
+      @is_treated_as_value = false
       @parsing_options = true
 
       while peek
@@ -88,7 +100,10 @@ class Bundler::Thor
             when SHORT_SQ_RE
               unshift($1.split("").map { |f| "-#{f}" })
               next
-            when EQ_RE, SHORT_NUM
+            when EQ_RE
+              unshift($2, is_value: true)
+              switch = $1
+            when SHORT_NUM
               unshift($2)
               switch = $1
             when LONG_RE, SHORT_RE
@@ -133,20 +148,22 @@ class Bundler::Thor
 
   protected
 
-  def assign_result!(option, result)
-    if option.repeatable && option.type == :hash
-      (@assigns[option.human_name] ||= {}).merge!(result)
-    elsif option.repeatable
-      (@assigns[option.human_name] ||= []) << result
-    else
-      @assigns[option.human_name] = result
+    def assign_result!(option, result)
+      if option.repeatable && option.type == :hash
+        (@assigns[option.human_name] ||= {}).merge!(result)
+      elsif option.repeatable
+        (@assigns[option.human_name] ||= []) << result
+      else
+        @assigns[option.human_name] = result
+      end
     end
-  end
+
     # Check if the current value in peek is a registered switch.
     #
     # Two booleans are returned.  The first is true if the current value
     # starts with a hyphen; the second is true if it is a registered switch.
     def current_is_switch?
+      return [false, false] if @is_treated_as_value
       case peek
       when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
         [true, switch?($1)]
@@ -158,6 +175,7 @@ class Bundler::Thor
     end
 
     def current_is_switch_formatted?
+      return false if @is_treated_as_value
       case peek
       when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
         true
@@ -167,6 +185,7 @@ class Bundler::Thor
     end
 
     def current_is_value?
+      return true if @is_treated_as_value
       peek && (!parsing_options? || super)
     end
 

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

@@ -94,6 +94,8 @@ class Bundler::Thor
       # say("I know you knew that.")
       #
       def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
+        return if quiet?
+
         buffer = prepare_message(message, *color)
         buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
 
@@ -101,6 +103,23 @@ class Bundler::Thor
         stdout.flush
       end
 
+      # Say (print) an error to the user. If the sentence ends with a whitespace
+      # or tab character, a new line is not appended (print + flush). Otherwise
+      # are passed straight to puts (behavior got from Highline).
+      #
+      # ==== Example
+      # say_error("error: something went wrong")
+      #
+      def say_error(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
+        return if quiet?
+
+        buffer = prepare_message(message, *color)
+        buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
+
+        stderr.print(buffer)
+        stderr.flush
+      end
+
       # Say a status with the given color and appends the message. Since this
       # method is used frequently by actions, it allows nil or false to be given
       # in log_status, avoiding the message from being shown. If a Symbol is
@@ -109,13 +128,14 @@ class Bundler::Thor
       def say_status(status, message, log_status = true)
         return if quiet? || log_status == false
         spaces = "  " * (padding + 1)
-        color  = log_status.is_a?(Symbol) ? log_status : :green
-
         status = status.to_s.rjust(12)
+        margin = " " * status.length + spaces
+
+        color  = log_status.is_a?(Symbol) ? log_status : :green
         status = set_color status, color, true if color
 
-        buffer = "#{status}#{spaces}#{message}"
-        buffer = "#{buffer}\n" unless buffer.end_with?("\n")
+        message = message.to_s.chomp.gsub(/(?<!\A)^/, margin)
+        buffer = "#{status}#{spaces}#{message}\n"
 
         stdout.print(buffer)
         stdout.flush
@@ -230,8 +250,9 @@ class Bundler::Thor
         paras = message.split("\n\n")
 
         paras.map! do |unwrapped|
-          counter = 0
-          unwrapped.split(" ").inject do |memo, word|
+          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
@@ -404,7 +425,7 @@ class Bundler::Thor
       end
 
       def unix?
-        RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+        RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris)/i
       end
 
       def truncate(string, width)

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

@@ -97,7 +97,11 @@ class Bundler::Thor
     protected
 
       def can_display_colors?
-        stdout.tty? && !are_colors_disabled?
+        are_colors_supported? && !are_colors_disabled?
+      end
+
+      def are_colors_supported?
+        stdout.tty? && ENV["TERM"] != "dumb"
       end
 
       def are_colors_disabled?

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

@@ -21,7 +21,7 @@ class Bundler::Thor
   end
 
   module Shell
-    SHELL_DELEGATED_METHODS = [:ask, :error, :set_color, :yes?, :no?, :say, :say_status, :print_in_columns, :print_table, :print_wrapped, :file_collision, :terminal_width]
+    SHELL_DELEGATED_METHODS = [:ask, :error, :set_color, :yes?, :no?, :say, :say_error, :say_status, :print_in_columns, :print_table, :print_wrapped, :file_collision, :terminal_width]
     attr_writer :shell
 
     autoload :Basic, File.expand_path("shell/basic", __dir__)

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

@@ -211,7 +211,7 @@ class Bundler::Thor
       #
       def globs_for(path)
         path = escape_globs(path)
-        ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+        ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/**/*.thor"]
       end
 
       # Return the path to the ruby interpreter taking into account multiple

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

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

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

@@ -1,7 +1,7 @@
-require "set"
 require_relative "thor/base"
 
 class Bundler::Thor
+  $thor_runner ||= false
   class << self
     # Allows for custom "Command" package naming.
     #
@@ -323,7 +323,7 @@ class Bundler::Thor
     # ==== Parameters
     # Symbol ...:: A list of commands that should be affected.
     def stop_on_unknown_option!(*command_names)
-      stop_on_unknown_option.merge(command_names)
+      @stop_on_unknown_option = stop_on_unknown_option | command_names
     end
 
     def stop_on_unknown_option?(command) #:nodoc:
@@ -337,29 +337,22 @@ class Bundler::Thor
     # ==== Parameters
     # Symbol ...:: A list of commands that should be affected.
     def disable_required_check!(*command_names)
-      disable_required_check.merge(command_names)
+      @disable_required_check = disable_required_check | command_names
     end
 
     def disable_required_check?(command) #:nodoc:
       command && disable_required_check.include?(command.name.to_sym)
     end
 
-    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
-
   protected
 
     def stop_on_unknown_option #:nodoc:
-      @stop_on_unknown_option ||= Set.new
+      @stop_on_unknown_option ||= []
     end
 
     # help command has the required check disabled by default.
     def disable_required_check #:nodoc:
-      @disable_required_check ||= Set.new([:help])
+      @disable_required_check ||= [:help]
     end
 
     # The method responsible for dispatching given the args.
@@ -405,7 +398,6 @@ class Bundler::Thor
     # the namespace should be displayed as arguments.
     #
     def banner(command, namespace = nil, subcommand = false)
-      $thor_runner ||= false
       command.formatted_usage(self, $thor_runner, subcommand).split("\n").map do |formatted_usage|
         "#{basename} #{formatted_usage}"
       end.join("\n")