rubygems-update 3.3.18 → 3.6.2

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/securerandom/.document

@@ -0,0 +1 @@
+# Vendored files do not need to be documented

data/bundler/lib/bundler/vendor/securerandom/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/bundler/lib/bundler/vendor/securerandom/lib/securerandom.rb

@@ -0,0 +1,102 @@
+# -*- coding: us-ascii -*-
+# frozen_string_literal: true
+
+require 'random/formatter'
+
+# == Secure random number generator interface.
+#
+# This library is an interface to secure random number generators which are
+# suitable for generating session keys in HTTP cookies, etc.
+#
+# You can use this library in your application by requiring it:
+#
+#   require 'bundler/vendor/securerandom/lib/securerandom'
+#
+# It supports the following secure random number generators:
+#
+# * openssl
+# * /dev/urandom
+# * Win32
+#
+# Bundler::SecureRandom is extended by the Random::Formatter module which
+# defines the following methods:
+#
+# * alphanumeric
+# * base64
+# * choose
+# * gen_random
+# * hex
+# * rand
+# * random_bytes
+# * random_number
+# * urlsafe_base64
+# * uuid
+#
+# These methods are usable as class methods of Bundler::SecureRandom such as
+# +Bundler::SecureRandom.hex+.
+#
+# If a secure random number generator is not available,
+# +NotImplementedError+ is raised.
+
+module Bundler::SecureRandom
+
+  # The version
+  VERSION = "0.4.1"
+
+  class << self
+    # Returns a random binary string containing +size+ bytes.
+    #
+    # See Random.bytes
+    def bytes(n)
+      return gen_random(n)
+    end
+
+    # Compatibility methods for Ruby 3.2, we can remove this after dropping to support Ruby 3.2
+    def alphanumeric(n = nil, chars: ALPHANUMERIC)
+      n = 16 if n.nil?
+      choose(chars, n)
+    end if RUBY_VERSION < '3.3'
+
+    private
+
+    # :stopdoc:
+
+    # Implementation using OpenSSL
+    def gen_random_openssl(n)
+      return OpenSSL::Random.random_bytes(n)
+    end
+
+    # Implementation using system random device
+    def gen_random_urandom(n)
+      ret = Random.urandom(n)
+      unless ret
+        raise NotImplementedError, "No random device"
+      end
+      unless ret.length == n
+        raise NotImplementedError, "Unexpected partial read from random device: only #{ret.length} for #{n} bytes"
+      end
+      ret
+    end
+
+    begin
+      # Check if Random.urandom is available
+      Random.urandom(1)
+      alias gen_random gen_random_urandom
+    rescue RuntimeError
+      begin
+        require 'openssl'
+      rescue NoMethodError
+        raise NotImplementedError, "No random device"
+      else
+        alias gen_random gen_random_openssl
+      end
+    end
+
+    # :startdoc:
+
+    # Generate random data bytes for Random::Formatter
+    public :gen_random
+  end
+end
+
+Bundler::SecureRandom.extend(Random::Formatter)

data/bundler/lib/bundler/vendor/thor/.document

@@ -0,0 +1 @@
+# Vendored files do not need to be documented

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

@@ -43,7 +43,8 @@ class Bundler::Thor
       # Boolean:: true if it is identical, false otherwise.
       #
       def identical?
-        exists? && File.binread(destination) == render
+        # binread uses ASCII-8BIT, so to avoid false negatives, the string must use the same
+        exists? && File.binread(destination) == String.new(render).force_encoding("ASCII-8BIT")
       end
 
       # Holds the content to be added to the file.
@@ -60,7 +61,7 @@ class Bundler::Thor
         invoke_with_conflict_check do
           require "fileutils"
           FileUtils.mkdir_p(File.dirname(destination))
-          File.open(destination, "wb") { |f| f.write render }
+          File.open(destination, "wb", config[:perm]) { |f| f.write render }
         end
         given_destination
       end

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

@@ -58,7 +58,7 @@ class Bundler::Thor
       def initialize(base, source, destination = nil, config = {}, &block)
         @source = File.expand_path(Dir[Util.escape_globs(base.find_in_source_paths(source.to_s))].first)
         @block  = block
-        super(base, destination, {:recursive => true}.merge(config))
+        super(base, destination, {recursive: true}.merge(config))
       end
 
       def invoke!

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

@@ -33,7 +33,7 @@ class Bundler::Thor
       #
       def initialize(base, destination, config = {})
         @base = base
-        @config = {:verbose => true}.merge(config)
+        @config = {verbose: true}.merge(config)
         self.destination = destination
       end
 

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

@@ -10,7 +10,6 @@ class Bundler::Thor
     # destination<String>:: the relative path to the destination root.
     # config<Hash>:: give :verbose => false to not log the status, and
     #                :mode => :preserve, to preserve the file mode from the source.
-
     #
     # ==== Examples
     #
@@ -66,12 +65,15 @@ class Bundler::Thor
     # ==== Parameters
     # source<String>:: the address of the given content.
     # destination<String>:: the relative path to the destination root.
-    # config<Hash>:: give :verbose => false to not log the status.
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :http_headers => <Hash> to add headers to an http request.
     #
     # ==== Examples
     #
     #   get "http://gist.github.com/103208", "doc/README"
     #
+    #   get "http://gist.github.com/103208", "doc/README", :http_headers => {"Content-Type" => "application/json"}
+    #
     #   get "http://gist.github.com/103208" do |content|
     #     content.split("\n").first
     #   end
@@ -82,10 +84,10 @@ class Bundler::Thor
 
       render = if source =~ %r{^https?\://}
         require "open-uri"
-        URI.send(:open, source) { |input| input.binmode.read }
+        URI.send(:open, source, config.fetch(:http_headers, {})) { |input| input.binmode.read }
       else
         source = File.expand_path(find_in_source_paths(source.to_s))
-        open(source) { |input| input.binmode.read }
+        File.open(source) { |input| input.binmode.read }
       end
 
       destination ||= if block_given?
@@ -120,12 +122,7 @@ class Bundler::Thor
       context = config.delete(:context) || instance_eval("binding")
 
       create_file destination, nil, config do
-        match = ERB.version.match(/(\d+\.\d+\.\d+)/)
-        capturable_erb = if match && match[1] >= "2.2.0" # Ruby 2.6+
-          CapturableERB.new(::File.binread(source), :trim_mode => "-", :eoutvar => "@output_buffer")
-        else
-          CapturableERB.new(::File.binread(source), nil, "-", "@output_buffer")
-        end
+        capturable_erb = CapturableERB.new(::File.binread(source), trim_mode: "-", eoutvar: "@output_buffer")
         content = capturable_erb.tap do |erb|
           erb.filename = source
         end.result(context)
@@ -252,7 +249,7 @@ class Bundler::Thor
     # 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, and
-    #                :force => true, to force the replacement regardles of runner behavior.
+    #                :force => true, to force the replacement regardless of runner behavior.
     #
     # ==== Example
     #
@@ -277,9 +274,8 @@ class Bundler::Thor
       end
     end
 
-    # Uncomment all lines matching a given regex.  It will leave the space
-    # which existed before the comment hash in tact but will remove any spacing
-    # between the comment hash and the beginning of the line.
+    # Uncomment all lines matching a given regex. Preserves indentation before
+    # the comment hash and removes the hash and any immediate following space.
     #
     # ==== Parameters
     # path<String>:: path of the file to be changed
@@ -293,7 +289,7 @@ class Bundler::Thor
     def uncomment_lines(path, flag, *args)
       flag = flag.respond_to?(:source) ? flag.source : flag
 
-      gsub_file(path, /^(\s*)#[[:blank:]]*(.*#{flag})/, '\1\2', *args)
+      gsub_file(path, /^(\s*)#[[:blank:]]?(.*#{flag})/, '\1\2', *args)
     end
 
     # Comment all lines matching a given regex.  It will leave the space

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

@@ -21,7 +21,7 @@ class Bundler::Thor
     #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
     #   end
     #
-    WARNINGS = { unchanged_no_flag: 'File unchanged! The supplied flag value not found!' }
+    WARNINGS = {unchanged_no_flag: "File unchanged! Either the supplied flag value not found or the content has already been inserted!"}
 
     def insert_into_file(destination, *args, &block)
       data = block_given? ? block : args.shift
@@ -37,7 +37,7 @@ class Bundler::Thor
       attr_reader :replacement, :flag, :behavior
 
       def initialize(base, destination, data, config)
-        super(base, destination, {:verbose => true}.merge(config))
+        super(base, destination, {verbose: true}.merge(config))
 
         @behavior, @flag = if @config.key?(:after)
           [:after, @config.delete(:after)]
@@ -59,6 +59,8 @@ class Bundler::Thor
         if exists?
           if replace!(/#{flag}/, content, config[:force])
             say_status(:invoke)
+          elsif replacement_present?
+            say_status(:unchanged, color: :blue)
           else
             say_status(:unchanged, warning: WARNINGS[:unchanged_no_flag], color: :red)
           end
@@ -96,6 +98,8 @@ class Bundler::Thor
           end
         elsif warning
           warning
+        elsif behavior == :unchanged
+          :unchanged
         else
           :subtract
         end
@@ -103,11 +107,18 @@ class Bundler::Thor
         super(status, (color || config[:verbose]))
       end
 
+      def content
+        @content ||= File.read(destination)
+      end
+
+      def replacement_present?
+        content.include?(replacement)
+      end
+
       # Adds the content to the file.
       #
       def replace!(regexp, string, force)
-        content = File.read(destination)
-        if force || !content.include?(replacement)
+        if force || !replacement_present?
           success = content.gsub!(regexp, string)
 
           File.open(destination, "wb") { |file| file.write(content) } unless pretend?

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

@@ -46,17 +46,17 @@ class Bundler::Thor
       # Add runtime options that help actions execution.
       #
       def add_runtime_options!
-        class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
-                             :desc => "Overwrite files that already exist"
+        class_option :force, type: :boolean, aliases: "-f", group: :runtime,
+                             desc: "Overwrite files that already exist"
 
-        class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
-                               :desc => "Run but do not make any changes"
+        class_option :pretend, type: :boolean, aliases: "-p", group: :runtime,
+                               desc: "Run but do not make any changes"
 
-        class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
-                             :desc => "Suppress status output"
+        class_option :quiet, type: :boolean, aliases: "-q", group: :runtime,
+                             desc: "Suppress status output"
 
-        class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
-                            :desc => "Skip files that already exist"
+        class_option :skip, type: :boolean, aliases: "-s", group: :runtime,
+                            desc: "Skip files that already exist"
       end
     end
 
@@ -113,9 +113,9 @@ class Bundler::Thor
     #
     def relative_to_original_destination_root(path, remove_dot = true)
       root = @destination_stack[0]
-      if path.start_with?(root) && [File::SEPARATOR, File::ALT_SEPARATOR, nil, ''].include?(path[root.size..root.size])
+      if path.start_with?(root) && [File::SEPARATOR, File::ALT_SEPARATOR, nil, ""].include?(path[root.size..root.size])
         path = path.dup
-        path[0...root.size] = '.'
+        path[0...root.size] = "."
         remove_dot ? (path[2..-1] || "") : path
       else
         path
@@ -175,7 +175,7 @@ class Bundler::Thor
       shell.padding += 1 if verbose
       @destination_stack.push File.expand_path(dir, destination_root)
 
-      # If the directory doesnt exist and we're not pretending
+      # If the directory doesn't exist and we're not pretending
       if !File.exist?(destination_root) && !pretend
         require "fileutils"
         FileUtils.mkdir_p(destination_root)
@@ -225,7 +225,7 @@ class Bundler::Thor
         require "open-uri"
         URI.open(path, "Accept" => "application/x-thor-template", &:read)
       else
-        open(path, &:read)
+        File.open(path, &:read)
       end
 
       instance_eval(contents, path)
@@ -284,7 +284,7 @@ class Bundler::Thor
     #
     def run_ruby_script(command, config = {})
       return unless behavior == :invoke
-      run command, config.merge(:with => Bundler::Thor::Util.ruby_command)
+      run command, config.merge(with: Bundler::Thor::Util.ruby_command)
     end
 
     # Run a thor command. A hash of options can be given and it's converted to
@@ -315,7 +315,7 @@ class Bundler::Thor
       args.push Bundler::Thor::Options.to_switches(config)
       command = args.join(" ").strip
 
-      run command, :with => :thor, :verbose => verbose, :pretend => pretend, :capture => capture
+      run command, with: :thor, verbose: verbose, pretend: pretend, capture: capture
     end
 
   protected
@@ -323,7 +323,7 @@ class Bundler::Thor
     # Allow current root to be shared between invocations.
     #
     def _shared_configuration #:nodoc:
-      super.merge!(:destination_root => destination_root)
+      super.merge!(destination_root: destination_root)
     end
 
     def _cleanup_options_and_set(options, key) #:nodoc: