rubygems-update 2.7.3 → 2.7.11

data/bundler/lib/bundler/dep_proxy.rb

@@ -10,11 +10,11 @@ module Bundler
     end
 
     def hash
-      @hash ||= dep.hash
+      @hash ||= [dep, __platform].hash
     end
 
     def ==(other)
-      return if other.nil?
+      return false if other.class != self.class
       dep == other.dep && __platform == other.__platform
     end
 

data/bundler/lib/bundler/dependency.rb

@@ -30,6 +30,7 @@ module Bundler
       :mri_24   => Gem::Platform::RUBY,
       :mri_25   => Gem::Platform::RUBY,
       :rbx      => Gem::Platform::RUBY,
+      :truffleruby => Gem::Platform::RUBY,
       :jruby    => Gem::Platform::JAVA,
       :jruby_18 => Gem::Platform::JAVA,
       :jruby_19 => Gem::Platform::JAVA,

data/bundler/lib/bundler/deprecate.rb

@@ -8,7 +8,8 @@ rescue LoadError
 end
 
 module Bundler
-  if defined? Bundler::Deprecate
+  # If Bundler::Deprecate is an autoload constant, we need to define it
+  if defined?(Bundler::Deprecate) && !autoload?(:Deprecate)
     # nothing to do!
   elsif defined? ::Deprecate
     Deprecate = ::Deprecate

data/bundler/lib/bundler/endpoint_specification.rb

@@ -123,7 +123,7 @@ module Bundler
           @required_ruby_version = Gem::Requirement.new(v)
         end
       end
-    rescue => e
+    rescue StandardError => e
       raise GemspecError, "There was an error parsing the metadata for the gem #{name} (#{version}): #{e.class}\n#{e}\nThe metadata was #{data.inspect}"
     end
 

data/bundler/lib/bundler/env.rb

@@ -61,10 +61,10 @@ module Bundler
     end
 
     def self.read_file(filename)
-      File.read(filename.to_s).strip
+      Bundler.read_file(filename.to_s).strip
     rescue Errno::ENOENT
       "<No #{filename} found>"
-    rescue => e
+    rescue RuntimeError => e
       "#{e.class}: #{e.message}"
     end
 
@@ -88,7 +88,7 @@ module Bundler
 
     def self.version_of(script)
       return "not installed" unless Bundler.which(script)
-      `#{script} --version`
+      `#{script} --version`.chomp
     end
 
     def self.chruby_version
@@ -110,11 +110,13 @@ module Bundler
       out << ["  Gem Path", ENV.fetch("GEM_PATH") { Gem.path.join(File::PATH_SEPARATOR) }]
       out << ["  User Path", Gem.user_dir]
       out << ["  Bin Dir", Gem.bindir]
-      out << ["OpenSSL"] if defined?(OpenSSL)
-      out << ["  Compiled", OpenSSL::OPENSSL_VERSION] if defined?(OpenSSL::OPENSSL_VERSION)
-      out << ["  Loaded", OpenSSL::OPENSSL_LIBRARY_VERSION] if defined?(OpenSSL::OPENSSL_LIBRARY_VERSION)
-      out << ["  Cert File", OpenSSL::X509::DEFAULT_CERT_FILE] if defined?(OpenSSL::X509::DEFAULT_CERT_FILE)
-      out << ["  Cert Dir", OpenSSL::X509::DEFAULT_CERT_DIR] if defined?(OpenSSL::X509::DEFAULT_CERT_DIR)
+      if defined?(OpenSSL)
+        out << ["OpenSSL"]
+        out << ["  Compiled", OpenSSL::OPENSSL_VERSION] if defined?(OpenSSL::OPENSSL_VERSION)
+        out << ["  Loaded", OpenSSL::OPENSSL_LIBRARY_VERSION] if defined?(OpenSSL::OPENSSL_LIBRARY_VERSION)
+        out << ["  Cert File", OpenSSL::X509::DEFAULT_CERT_FILE] if defined?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        out << ["  Cert Dir", OpenSSL::X509::DEFAULT_CERT_DIR] if defined?(OpenSSL::X509::DEFAULT_CERT_DIR)
+      end
       out << ["Tools"]
       out << ["  Git", git_version]
       out << ["  RVM", ENV.fetch("rvm_version") { version_of("rvm") }]

data/bundler/lib/bundler/fetcher.rb

@@ -96,11 +96,11 @@ module Bundler
 
       uri = URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
       if uri.scheme == "file"
-        Bundler.load_marshal Gem.inflate(Gem.read_binary(uri.path))
+        Bundler.load_marshal Bundler.rubygems.inflate(Gem.read_binary(uri.path))
       elsif cached_spec_path = gemspec_cached_path(spec_file_name)
         Bundler.load_gemspec(cached_spec_path)
       else
-        Bundler.load_marshal Gem.inflate(downloader.fetch(uri).body)
+        Bundler.load_marshal Bundler.rubygems.inflate(downloader.fetch(uri).body)
       end
     rescue MarshalError
       raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \
@@ -178,7 +178,7 @@ module Bundler
           # engine_version raises on unknown engines
           engine_version = begin
                              ruby.engine_versions
-                           rescue
+                           rescue RuntimeError
                              "???"
                            end
           agent << " #{ruby.engine}/#{ruby.versions_string(engine_version)}"

data/bundler/lib/bundler/fetcher/downloader.rb

@@ -11,10 +11,10 @@ module Bundler
         @redirect_limit = redirect_limit
       end
 
-      def fetch(uri, options = {}, counter = 0)
+      def fetch(uri, headers = {}, counter = 0)
         raise HTTPError, "Too many redirects" if counter >= redirect_limit
 
-        response = request(uri, options)
+        response = request(uri, headers)
         Bundler.ui.debug("HTTP #{response.code} #{response.message} #{uri}")
 
         case response
@@ -26,7 +26,12 @@ module Bundler
             new_uri.user = uri.user
             new_uri.password = uri.password
           end
-          fetch(new_uri, options, counter + 1)
+          fetch(new_uri, headers, counter + 1)
+        when Net::HTTPRequestedRangeNotSatisfiable
+          new_headers = headers.dup
+          new_headers.delete("Range")
+          new_headers["Accept-Encoding"] = "gzip"
+          fetch(uri, new_headers)
         when Net::HTTPRequestEntityTooLarge
           raise FallbackError, response.body
         when Net::HTTPUnauthorized
@@ -38,11 +43,11 @@ module Bundler
         end
       end
 
-      def request(uri, options)
+      def request(uri, headers)
         validate_uri_scheme!(uri)
 
         Bundler.ui.debug "HTTP GET #{uri}"
-        req = Net::HTTP::Get.new uri.request_uri, options
+        req = Net::HTTP::Get.new uri.request_uri, headers
         if uri.user
           user = CGI.unescape(uri.user)
           password = uri.password ? CGI.unescape(uri.password) : nil

data/bundler/lib/bundler/fetcher/index.rb

@@ -29,11 +29,11 @@ module Bundler
 
         uri = URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
         if uri.scheme == "file"
-          Bundler.load_marshal Gem.inflate(Gem.read_binary(uri.path))
+          Bundler.load_marshal Bundler.rubygems.inflate(Gem.read_binary(uri.path))
         elsif cached_spec_path = gemspec_cached_path(spec_file_name)
           Bundler.load_gemspec(cached_spec_path)
         else
-          Bundler.load_marshal Gem.inflate(downloader.fetch(uri).body)
+          Bundler.load_marshal Bundler.rubygems.inflate(downloader.fetch(uri).body)
         end
       rescue MarshalError
         raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \

data/bundler/lib/bundler/friendly_errors.rb

@@ -45,6 +45,8 @@ module Bundler
           "Alternatively, you can increase the amount of memory the JVM is able to use by running Bundler with jruby -J-Xmx1024m -S bundle (JRuby defaults to 500MB)."
       else request_issue_report_for(error)
       end
+    rescue
+      raise error
     end
 
     def exit_status(error)

data/bundler/lib/bundler/gem_helper.rb

@@ -153,7 +153,7 @@ module Bundler
       sh "git tag -m \"Version #{version}\" #{version_tag}"
       Bundler.ui.confirm "Tagged #{version_tag}."
       yield if block_given?
-    rescue
+    rescue RuntimeError
       Bundler.ui.error "Untagging #{version_tag} due to error."
       sh_with_code "git tag -d #{version_tag}"
       raise

data/bundler/lib/bundler/gem_version_promoter.rb

@@ -22,6 +22,8 @@ module Bundler
     # existing in the referenced source.
     attr_accessor :strict
 
+    attr_accessor :prerelease_specified
+
     # Given a list of locked_specs and a list of gems to unlock creates a
     # GemVersionPromoter instance.
     #
@@ -37,6 +39,7 @@ module Bundler
       @locked_specs = locked_specs
       @unlock_gems = unlock_gems
       @sort_versions = {}
+      @prerelease_specified = {}
     end
 
     # @param value [Symbol] One of three Symbols: :major, :minor or :patch.
@@ -121,6 +124,15 @@ module Bundler
       result = spec_groups.sort do |a, b|
         @a_ver = a.version
         @b_ver = b.version
+
+        unless @prerelease_specified[@gem_name]
+          a_pre = @a_ver.prerelease?
+          b_pre = @b_ver.prerelease?
+
+          next -1 if a_pre && !b_pre
+          next  1 if b_pre && !a_pre
+        end
+
         if major?
           @a_ver <=> @b_ver
         elsif either_version_older_than_locked

data/bundler/lib/bundler/injector.rb

@@ -12,8 +12,11 @@ module Bundler
       @options = options
     end
 
+    # @param [Pathname] gemfile_path The Gemfile in which to inject the new dependency.
+    # @param [Pathname] lockfile_path The lockfile in which to inject the new dependency.
+    # @return [Array]
     def inject(gemfile_path, lockfile_path)
-      if Bundler.frozen?
+      if Bundler.frozen_bundle?
         # ensure the lock and Gemfile are synced
         Bundler.definition.ensure_equivalent_gemfile_and_lockfile(true)
       end
@@ -72,7 +75,7 @@ module Bundler
         end
 
         if d.groups != Array(:default)
-          group = d.groups.size == 1 ? ", :group => #{d.groups.inspect}" : ", :groups => #{d.groups.inspect}"
+          group = d.groups.size == 1 ? ", :group => #{d.groups.first.inspect}" : ", :groups => #{d.groups.inspect}"
         end
 
         source = ", :source => \"#{d.source}\"" unless d.source.nil?
@@ -84,9 +87,6 @@ module Bundler
     def append_to(gemfile_path, new_gem_lines)
       gemfile_path.open("a") do |f|
         f.puts
-        if @options["timestamp"] || @options["timestamp"].nil?
-          f.puts "# Added at #{Time.now} by #{`whoami`.chomp}:"
-        end
         f.puts new_gem_lines
       end
     end

data/bundler/lib/bundler/installer.rb

@@ -70,7 +70,7 @@ module Bundler
       create_bundle_path
 
       ProcessLock.lock do
-        if Bundler.frozen?
+        if Bundler.frozen_bundle?
           @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
         end
 
@@ -90,7 +90,7 @@ module Bundler
         end
         install(options)
 
-        lock unless Bundler.frozen?
+        lock unless Bundler.frozen_bundle?
         Standalone.new(options[:standalone], @definition).generate if options[:standalone]
       end
     end
@@ -135,7 +135,11 @@ module Bundler
         end
 
         File.open(binstub_path, "w", 0o777 & ~File.umask) do |f|
-          f.puts ERB.new(template, nil, "-").result(binding)
+          if RUBY_VERSION >= "2.6"
+            f.puts ERB.new(template, :trim_mode => "-").result(binding)
+          else
+            f.puts ERB.new(template, nil, "-").result(binding)
+          end
         end
       end
 
@@ -171,7 +175,11 @@ module Bundler
         executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
         executable_path = executable_path
         File.open "#{bin_path}/#{executable}", "w", 0o755 do |f|
-          f.puts ERB.new(template, nil, "-").result(binding)
+          if RUBY_VERSION >= "2.6"
+            f.puts ERB.new(template, :trim_mode => "-").result(binding)
+          else
+            f.puts ERB.new(template, nil, "-").result(binding)
+          end
         end
       end
     end

data/bundler/lib/bundler/installer/gem_installer.rb

@@ -21,7 +21,7 @@ module Bundler
       raise
     rescue Errno::ENOSPC
       return false, out_of_space_message
-    rescue => e
+    rescue StandardError => e
       return false, specific_failure_message(e)
     end
 
@@ -44,7 +44,14 @@ module Bundler
     end
 
     def gem_install_message
-      "Make sure that `gem install #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+      source = spec.source
+      return unless source.respond_to?(:remotes)
+
+      if source.remotes.size == 1
+        "Make sure that `gem install #{spec.name} -v '#{spec.version}' --source '#{source.remotes.first}'` succeeds before bundling."
+      else
+        "Make sure that `gem install #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+      end
     end
 
     def spec_settings

data/bundler/lib/bundler/installer/parallel_installer.rb

@@ -160,7 +160,7 @@ module Bundler
       )
       success, message = begin
         gem_installer.install_from_spec
-      rescue => e
+      rescue RuntimeError => e
         raise e, "#{e}\n\n#{require_tree_for_spec(spec_install.spec)}"
       end
       if success

data/bundler/lib/bundler/lazy_specification.rb

@@ -80,7 +80,7 @@ module Bundler
             "To use the platform-specific version of the gem, run `bundle config specific_platform true` and install again."
           search = source.specs.search(self).last
         end
-        search.dependencies = dependencies if search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification)
+        search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
         search
       end
     end

data/bundler/lib/bundler/mirror.rb

@@ -152,7 +152,7 @@ module Bundler
             socket.connect_nonblock(address)
           rescue Errno::EINPROGRESS
             wait_for_writtable_socket(socket, address, timeout)
-          rescue # Connection failed somehow, again
+          rescue RuntimeError # Connection failed somehow, again
             false
           end
         end
@@ -172,7 +172,7 @@ module Bundler
         socket.connect_nonblock(address)
       rescue Errno::EISCONN
         true
-      rescue # Connection failed
+      rescue StandardError # Connection failed
         false
       end
     end

data/bundler/lib/bundler/plugin.rb

@@ -66,7 +66,7 @@ module Bundler
       installed_specs = Installer.new.install_definition(definition)
 
       save_plugins plugins, installed_specs, builder.inferred_plugins
-    rescue => e
+    rescue RuntimeError => e
       unless e.is_a?(GemfileError)
         Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
       end
@@ -264,7 +264,7 @@ module Bundler
       load path.join(PLUGIN_FILE_NAME)
 
       @loaded_plugin_names << name
-    rescue => e
+    rescue RuntimeError => e
       Bundler.ui.error "Failed loading plugin #{name}: #{e.message}"
       raise
     end

data/bundler/lib/bundler/plugin/index.rb

@@ -29,7 +29,12 @@ module Bundler
         @hooks = {}
         @load_paths = {}
 
-        load_index(global_index_file, true)
+        begin
+          load_index(global_index_file, true)
+        rescue GenericSystemCallError
+          # no need to fail when on a read-only FS, for example
+          nil
+        end
         load_index(local_index_file) if SharedHelpers.in_bundle?
       end
 
@@ -58,7 +63,7 @@ module Bundler
         @plugin_paths[name] = path
         @load_paths[name] = load_paths
         save_index
-      rescue
+      rescue StandardError
         @commands = old_commands
         raise
       end

data/bundler/lib/bundler/process_lock.rb

@@ -12,7 +12,7 @@ module Bundler
         yield
         f.flock(File::LOCK_UN)
       end
-    rescue Errno::EACCES, Errno::ENOLCK
+    rescue Errno::EACCES, Errno::ENOLCK, *[SharedHelpers.const_get_safely(:ENOTSUP, Errno)].compact
       # In the case the user does not have access to
       # create the lock file or is using NFS where
       # locks are not available we skip locking.

data/bundler/lib/bundler/resolver.rb

@@ -39,10 +39,11 @@ module Bundler
       @gem_version_promoter = gem_version_promoter
       @allow_bundler_dependency_conflicts = Bundler.feature_flag.allow_bundler_dependency_conflicts?
       @lockfile_uses_separate_rubygems_sources = Bundler.feature_flag.lockfile_uses_separate_rubygems_sources?
+      @use_gvp = !@gem_version_promoter.major?
     end
 
     def start(requirements)
-      @prerelease_specified = {}
+      @gem_version_promoter.prerelease_specified = @prerelease_specified = {}
       requirements.each {|dep| @prerelease_specified[dep.name] ||= dep.prerelease? }
 
       verify_gemfile_dependencies_are_found!(requirements)
@@ -104,16 +105,17 @@ module Bundler
         index = index_for(dependency)
         results = index.search(dependency, @base[dependency.name])
 
-        unless @prerelease_specified[dependency.name]
+        if vertex = @base_dg.vertex_named(dependency.name)
+          locked_requirement = vertex.payload.requirement
+        end
+
+        if !@prerelease_specified[dependency.name] && (!@use_gvp || locked_requirement.nil?)
           # Move prereleases to the beginning of the list, so they're considered
           # last during resolution.
           pre, results = results.partition {|spec| spec.version.prerelease? }
           results = pre + results
         end
 
-        if vertex = @base_dg.vertex_named(dependency.name)
-          locked_requirement = vertex.payload.requirement
-        end
         spec_groups = if results.any?
           nested = []
           results.each do |spec|
@@ -179,10 +181,6 @@ module Bundler
 
     def requirement_satisfied_by?(requirement, activated, spec)
       return false unless requirement.matches_spec?(spec) || spec.source.is_a?(Source::Gemspec)
-      if spec.version.prerelease? && !requirement.prerelease? && search_for(requirement).any? {|sg| !sg.version.prerelease? }
-        vertex = activated.vertex_named(spec.name)
-        return false if vertex.requirements.none?(&:prerelease?)
-      end
       spec.activate_platform!(requirement.__platform) if !@platforms || @platforms.include?(requirement.__platform)
       true
     end
@@ -245,7 +243,8 @@ module Bundler
           if all <= 1
             all - 1_000_000
           else
-            search = search_for(dependency).size
+            search = search_for(dependency)
+            search = @prerelease_specified[dependency.name] ? search.count : search.count {|s| !s.version.prerelease? }
             search - all
           end
         end
@@ -305,6 +304,11 @@ module Bundler
         :solver_name => "Bundler",
         :possibility_type => "gem",
         :reduce_trees => lambda do |trees|
+          # called first, because we want to reduce the amount of work required to find maximal empty sets
+          trees = trees.uniq {|t| t.flatten.map {|dep| [dep.name, dep.requirement] } }
+
+          # bail out if tree size is too big for Array#combination to make any sense
+          return trees if trees.size > 15
           maximal = 1.upto(trees.size).map do |size|
             trees.map(&:last).flatten(1).combination(size).to_a
           end.flatten(1).select do |deps|