bundler 1.16.1 → 1.17.3

data/lib/bundler/plugin/events.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Plugin
+    module Events
+      def self.define(const, event)
+        const = const.to_sym.freeze
+        if const_defined?(const) && const_get(const) != event
+          raise ArgumentError, "Attempting to reassign #{const} to a different value"
+        end
+        const_set(const, event) unless const_defined?(const)
+        @events ||= {}
+        @events[event] = const
+      end
+      private_class_method :define
+
+      def self.reset
+        @events.each_value do |const|
+          remove_const(const)
+        end
+        @events = nil
+      end
+      private_class_method :reset
+
+      # Check if an event has been defined
+      # @param event [String] An event to check
+      # @return [Boolean] A boolean indicating if the event has been defined
+      def self.defined_event?(event)
+        @events ||= {}
+        @events.key?(event)
+      end
+
+      # @!parse
+      #   A hook called before each individual gem is installed
+      #   Includes a Bundler::ParallelInstaller::SpecInstallation.
+      #   No state, error, post_install_message will be present as nothing has installed yet
+      #   GEM_BEFORE_INSTALL = "before-install"
+      define :GEM_BEFORE_INSTALL, "before-install"
+
+      # @!parse
+      #   A hook called after each individual gem is installed
+      #   Includes a Bundler::ParallelInstaller::SpecInstallation.
+      #     - If state is failed, an error will be present.
+      #     - If state is success, a post_install_message may be present.
+      #   GEM_AFTER_INSTALL = "after-install"
+      define :GEM_AFTER_INSTALL,  "after-install"
+
+      # @!parse
+      #   A hook called before any gems install
+      #   Includes an Array of Bundler::Dependency objects
+      #   GEM_BEFORE_INSTALL_ALL = "before-install-all"
+      define :GEM_BEFORE_INSTALL_ALL, "before-install-all"
+
+      # @!parse
+      #   A hook called after any gems install
+      #   Includes an Array of Bundler::Dependency objects
+      #   GEM_AFTER_INSTALL_ALL = "after-install-all"
+      define :GEM_AFTER_INSTALL_ALL,  "after-install-all"
+    end
+  end
+end

data/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/lib/bundler/plugin.rb

@@ -5,6 +5,7 @@ require "bundler/plugin/api"
 module Bundler
   module Plugin
     autoload :DSL,        "bundler/plugin/dsl"
+    autoload :Events,     "bundler/plugin/events"
     autoload :Index,      "bundler/plugin/index"
     autoload :Installer,  "bundler/plugin/installer"
     autoload :SourceList, "bundler/plugin/source_list"
@@ -66,7 +67,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
@@ -80,8 +81,8 @@ module Bundler
 
     # The directory root for all plugin related data
     #
-    # Points to root in app_config_path if ran in an app else points to the one
-    # in user_bundle_path
+    # If run in an app, points to local root, in app_config_path
+    # Otherwise, points to global root, in Bundler.user_bundle_path("plugin")
     def root
       @root ||= if SharedHelpers.in_bundle?
         local_root
@@ -96,7 +97,7 @@ module Bundler
 
     # The global directory root for all plugin related data
     def global_root
-      Bundler.user_bundle_path.join("plugin")
+      Bundler.user_bundle_path("plugin")
     end
 
     # The cache directory for plugin stuffs
@@ -155,6 +156,9 @@ module Bundler
     # To be called via the API to register a hooks and corresponding block that
     # will be called to handle the hook
     def add_hook(event, &block)
+      unless Events.defined_event?(event)
+        raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
+      end
       @hooks_by_event[event.to_s] << block
     end
 
@@ -166,6 +170,9 @@ module Bundler
     # @param [String] event
     def hook(event, *args, &arg_blk)
       return unless Bundler.feature_flag.plugins?
+      unless Events.defined_event?(event)
+        raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
+      end
 
       plugins = index.hook_plugins(event)
       return unless plugins.any?
@@ -264,7 +271,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/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/lib/bundler/resolver/spec_group.rb

@@ -14,7 +14,6 @@ module Bundler
         @version = exemplary_spec.version
         @source = exemplary_spec.source
 
-        @required_by = []
         @activated_platforms = []
         @dependencies = nil
         @specs        = Hash.new do |specs, platform|
@@ -55,10 +54,6 @@ module Bundler
         dependencies.concat(metadata_dependencies).flatten
       end
 
-      def platforms_for_dependency_named(dependency)
-        __dependencies.select {|_, deps| deps.map(&:name).include? dependency }.keys
-      end
-
       def ==(other)
         return unless other.is_a?(SpecGroup)
         name == other.name &&

data/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 = Bundler.feature_flag.use_gem_version_promoter_for_major_updates? || !@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|
@@ -135,7 +137,7 @@ module Bundler
         end
         # GVP handles major itself, but it's still a bit risky to trust it with it
         # until we get it settled with new behavior. For 2.x it can take over all cases.
-        if @gem_version_promoter.major?
+        if !@use_gvp
           spec_groups
         else
           @gem_version_promoter.sort_versions(dependency, spec_groups)
@@ -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
@@ -306,6 +304,9 @@ 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|

data/lib/bundler/ruby_version.rb

@@ -118,7 +118,7 @@ module Bundler
                             when "jruby"
                               JRUBY_VERSION.dup
                             else
-                              raise BundlerError, "RUBY_ENGINE value #{RUBY_ENGINE} is not recognized"
+                              RUBY_ENGINE_VERSION.dup
       end
       patchlevel = RUBY_PATCHLEVEL.to_s
 

data/lib/bundler/rubygems_gem_installer.rb

@@ -10,6 +10,13 @@ module Bundler
       end
     end
 
+    attr_reader :options
+
+    def initialize(gem, options = {})
+      @options = {}
+      super
+    end
+
     def check_executable_overwrite(filename)
       # Bundler needs to install gems regardless of binstub overwriting
     end

data/lib/bundler/rubygems_integration.rb

@@ -132,7 +132,11 @@ module Bundler
     end
 
     def inflate(obj)
-      Gem.inflate(obj)
+      if defined?(Gem::Util)
+        Gem::Util.inflate(obj)
+      else
+        Gem.inflate(obj)
+      end
     end
 
     def sources=(val)
@@ -570,8 +574,10 @@ module Bundler
       @replaced_methods.each do |(sym, klass), method|
         redefine_method(klass, sym, method)
       end
-      post_reset_hooks.reject! do |proc|
-        proc.binding.eval("__FILE__") == __FILE__
+      if Binding.public_method_defined?(:source_location)
+        post_reset_hooks.reject! {|proc| proc.binding.source_location[0] == __FILE__ }
+      else
+        post_reset_hooks.reject! {|proc| proc.binding.eval("__FILE__") == __FILE__ }
       end
       @replaced_methods.clear
     end

data/lib/bundler/runtime.rb

@@ -10,7 +10,7 @@ module Bundler
     end
 
     def setup(*groups)
-      @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.frozen?
+      @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.frozen_bundle?
 
       groups.map!(&:to_sym)
 
@@ -79,7 +79,7 @@ module Bundler
             required_file = file
             begin
               Kernel.require file
-            rescue => e
+            rescue RuntimeError => e
               raise e if e.is_a?(LoadError) # we handle this a little later
               raise Bundler::GemRequireError.new e,
                 "There was an error while trying to load the gem '#{file}'."
@@ -163,6 +163,7 @@ module Bundler
       gem_dirs             = Dir["#{Gem.dir}/gems/*"]
       gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
       gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
+      extension_dirs       = Dir["#{Gem.dir}/extensions/*/*/*"]
       spec_gem_paths       = []
       # need to keep git sources around
       spec_git_paths       = @definition.spec_git_paths
@@ -170,6 +171,7 @@ module Bundler
       spec_gem_executables = []
       spec_cache_paths     = []
       spec_gemspec_paths   = []
+      spec_extension_paths = []
       specs.each do |spec|
         spec_gem_paths << spec.full_gem_path
         # need to check here in case gems are nested like for the rails git repo
@@ -181,6 +183,7 @@ module Bundler
         end
         spec_cache_paths << spec.cache_file
         spec_gemspec_paths << spec.spec_file
+        spec_extension_paths << spec.extension_dir if spec.respond_to?(:extension_dir)
         spec_git_cache_dirs << spec.source.cache_path.to_s if spec.source.is_a?(Bundler::Source::Git)
       end
       spec_gem_paths.uniq!
@@ -192,6 +195,7 @@ module Bundler
       stale_gem_dirs       = gem_dirs - spec_gem_paths
       stale_gem_files      = gem_files - spec_cache_paths
       stale_gemspec_files  = gemspec_files - spec_gemspec_paths
+      stale_extension_dirs = extension_dirs - spec_extension_paths
 
       removed_stale_gem_dirs = stale_gem_dirs.collect {|dir| remove_dir(dir, dry_run) }
       removed_stale_git_dirs = stale_git_dirs.collect {|dir| remove_dir(dir, dry_run) }
@@ -204,8 +208,10 @@ module Bundler
             FileUtils.rm(file) if File.exist?(file)
           end
         end
-        stale_git_cache_dirs.each do |cache_dir|
-          SharedHelpers.filesystem_access(cache_dir) do |dir|
+
+        stale_dirs = stale_git_cache_dirs + stale_extension_dirs
+        stale_dirs.each do |stale_dir|
+          SharedHelpers.filesystem_access(stale_dir) do |dir|
             FileUtils.rm_rf(dir) if File.exist?(dir)
           end
         end

data/lib/bundler/settings/validator.rb

@@ -74,6 +74,29 @@ module Bundler
           fail!(key, value, "`#{other_key}` is current set to #{other_setting.inspect}", "the `#{conflicting.join("`, `")}` groups conflict")
         end
       end
+
+      rule %w[path], "relative paths are expanded relative to the current working directory" do |key, value, settings|
+        next if value.nil?
+
+        path = Pathname.new(value)
+        next if !path.relative? || !Bundler.feature_flag.path_relative_to_cwd?
+
+        path = path.expand_path
+
+        root = begin
+                 Bundler.root
+               rescue GemfileNotFound
+                 Pathname.pwd.expand_path
+               end
+
+        path = begin
+                 path.relative_path_from(root)
+               rescue ArgumentError
+                 path
+               end
+
+        set(settings, key, path.to_s)
+      end
     end
   end
 end

data/lib/bundler/settings.rb

@@ -14,6 +14,7 @@ module Bundler
       allow_offline_install
       auto_clean_without_path
       auto_install
+      auto_config_jobs
       cache_all
       cache_all_platforms
       cache_command_is_package
@@ -25,6 +26,7 @@ module Bundler
       disable_exec_load
       disable_local_branch_check
       disable_multisource
+      disable_platform_warnings
       disable_shared_gems
       disable_version_check
       error_on_stderr
@@ -33,6 +35,7 @@ module Bundler
       frozen
       gem.coc
       gem.mit
+      global_path_appends_ruby_scope
       global_gem_cache
       ignore_messages
       init_gems_rb
@@ -42,6 +45,7 @@ module Bundler
       no_install
       no_prune
       only_update_to_newer_versions
+      path_relative_to_cwd
       path.system
       plugins
       prefer_gems_rb
@@ -53,9 +57,12 @@ module Bundler
       suppress_install_using_messages
       unlock_source_unlocks_spec
       update_requires_all_flag
+      use_gem_version_promoter_for_major_updates
+      viz_command
     ].freeze
 
     NUMBER_KEYS = %w[
+      jobs
       redirect
       retry
       ssl_verify_mode
@@ -213,13 +220,13 @@ module Bundler
       locations
     end
 
-    # for legacy reasons, the ruby scope isnt appended when the setting comes from ENV or the global config,
+    # for legacy reasons, in Bundler 1, the ruby scope isnt appended when the setting comes from ENV or the global config,
     # nor do we respect :disable_shared_gems
     def path
       key  = key_for(:path)
       path = ENV[key] || @global_config[key]
       if path && !@temporary.key?(key) && !@local_config.key?(key)
-        return Path.new(path, false, false, false)
+        return Path.new(path, Bundler.feature_flag.global_path_appends_ruby_scope?, false, false)
       end
 
       system_path = self["path.system"] || (self[:disable_shared_gems] == false)
@@ -246,6 +253,20 @@ module Bundler
         path
       end
 
+      def base_path_relative_to_pwd
+        base_path = Pathname.new(self.base_path)
+        expanded_base_path = base_path.expand_path(Bundler.root)
+        relative_path = expanded_base_path.relative_path_from(Pathname.pwd)
+        if relative_path.to_s.start_with?("..")
+          relative_path = base_path if base_path.absolute?
+        else
+          relative_path = Pathname.new(File.join(".", relative_path))
+        end
+        relative_path
+      rescue ArgumentError
+        expanded_base_path
+      end
+
       def validate!
         return unless explicit_path && system_path
         path = Bundler.settings.pretty_values_for(:path)
@@ -374,7 +395,7 @@ module Bundler
         Pathname.new(ENV["BUNDLE_CONFIG"])
       else
         begin
-          Bundler.user_bundle_path.join("config")
+          Bundler.user_bundle_path("config")
         rescue PermissionError, GenericSystemCallError
           nil
         end

data/lib/bundler/shared_helpers.rb

@@ -197,10 +197,12 @@ module Bundler
     def pretty_dependency(dep, print_source = false)
       msg = String.new(dep.name)
       msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default
+
       if dep.is_a?(Bundler::Dependency)
         platform_string = dep.platforms.join(", ")
         msg << " " << platform_string if !platform_string.empty? && platform_string != Gem::Platform::RUBY
       end
+
       msg << " from the `#{dep.source}` source" if print_source && dep.source
       msg
     end
@@ -223,6 +225,10 @@ module Bundler
       Digest(name)
     end
 
+    def write_to_gemfile(gemfile_path, contents)
+      filesystem_access(gemfile_path) {|g| File.open(g, "w") {|file| file.puts contents } }
+    end
+
   private
 
     def validate_bundle_path
@@ -268,7 +274,15 @@ module Bundler
       until !File.directory?(current) || current == previous
         if ENV["BUNDLE_SPEC_RUN"]
           # avoid stepping above the tmp directory when testing
-          return nil if File.file?(File.join(current, "bundler.gemspec"))
+          gemspec = if ENV["BUNDLE_RUBY"] && ENV["BUNDLE_GEM"]
+            # for Ruby Core
+            "lib/bundler.gemspec"
+          else
+            "bundler.gemspec"
+          end
+
+          # avoid stepping above the tmp directory when testing
+          return nil if File.file?(File.join(current, gemspec))
         end
 
         names.each do |name|
@@ -293,9 +307,16 @@ module Bundler
 
     def set_bundle_variables
       begin
-        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
+        exe_file = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
+        unless File.exist?(exe_file)
+          exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+        end
+        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       rescue Gem::GemNotFoundException
-        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", File.expand_path("../../../exe/bundle", __FILE__)
+        exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+        # for Ruby core repository
+        exe_file = File.expand_path("../../../../bin/bundle", __FILE__) unless File.exist?(exe_file)
+        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       end
 
       # Set BUNDLE_GEMFILE
@@ -324,7 +345,7 @@ module Bundler
     end
 
     def bundler_ruby_lib
-      File.expand_path("../..", __FILE__)
+      resolve_path File.expand_path("../..", __FILE__)
     end
 
     def clean_load_path
@@ -336,12 +357,19 @@ module Bundler
       loaded_gem_paths = Bundler.rubygems.loaded_gem_paths
 
       $LOAD_PATH.reject! do |p|
-        next if File.expand_path(p).start_with?(bundler_lib)
+        next if resolve_path(p).start_with?(bundler_lib)
         loaded_gem_paths.delete(p)
       end
       $LOAD_PATH.uniq!
     end
 
+    def resolve_path(path)
+      expanded = File.expand_path(path)
+      return expanded unless File.respond_to?(:realpath) && File.exist?(expanded)
+
+      File.realpath(expanded)
+    end
+
     def prints_major_deprecations?
       require "bundler"
       deprecation_release = Bundler::VERSION.split(".").drop(1).include?("99")

data/lib/bundler/source/git/git_proxy.rb

@@ -131,7 +131,12 @@ module Bundler
           # method 2
           SharedHelpers.chdir(destination) do
             git_retry %(fetch --force --quiet --tags "#{path}")
-            git "reset --hard #{@revision}"
+
+            begin
+              git "reset --hard #{@revision}"
+            rescue GitCommandError
+              raise MissingGitRevisionError.new(@revision, URICredentialsFilter.credential_filtered_uri(uri))
+            end
 
             if submodules
               git_retry "submodule update --init --recursive"

data/lib/bundler/source/git.rb

@@ -21,6 +21,7 @@ module Bundler
         %w[ref branch tag revision].each {|k| options[k] = options[k].to_s if options[k] }
 
         @uri        = options["uri"] || ""
+        @safe_uri   = URICredentialsFilter.credential_filtered_uri(@uri)
         @branch     = options["branch"]
         @ref        = options["ref"] || options["branch"] || options["tag"] || "master"
         @submodules = options["submodules"]
@@ -77,7 +78,7 @@ module Bundler
                 nil
               end
 
-        "#{uri} (at #{at}#{rev})"
+        "#{@safe_uri} (at #{at}#{rev})"
       end
 
       def name

data/lib/bundler/source/metadata.rb

@@ -19,9 +19,8 @@ module Bundler
             # can't point to the actual gemspec or else the require paths will be wrong
             s.loaded_from = File.expand_path("..", __FILE__)
           end
-          if loaded_spec = nil && Bundler.rubygems.loaded_specs("bundler")
-            idx << loaded_spec # this has to come after the fake gemspec, to override it
-          elsif local_spec = Bundler.rubygems.find_name("bundler").find {|s| s.version.to_s == VERSION }
+
+          if local_spec = Bundler.rubygems.find_name("bundler").find {|s| s.version.to_s == VERSION }
             idx << local_spec
           end
 

data/lib/bundler/source/rubygems/remote.rb

@@ -25,7 +25,10 @@ module Bundler
 
             cache_uri = original_uri || uri
 
-            uri_parts = [cache_uri.host, cache_uri.user, cache_uri.port, cache_uri.path]
+            # URI::File of Ruby 2.6 returns empty string when given "file://".
+            host = defined?(URI::File) && cache_uri.is_a?(URI::File) ? nil : cache_uri.host
+
+            uri_parts = [host, cache_uri.user, cache_uri.port, cache_uri.path]
             uri_digest = SharedHelpers.digest(:MD5).hexdigest(uri_parts.compact.join("."))
 
             uri_parts[-1] = uri_digest

data/lib/bundler/source/rubygems.rb

@@ -138,6 +138,8 @@ module Bundler
             bin_path     = Bundler.system_bindir
           end
 
+          Bundler.mkdir_p bin_path, :no_sudo => true unless spec.executables.empty? || Bundler.rubygems.provides?(">= 2.7.5")
+
           installed_spec = nil
           Bundler.rubygems.preserve_paths do
             installed_spec = Bundler::RubyGemsGemInstaller.at(
@@ -336,7 +338,11 @@ module Bundler
       end
 
       def remove_auth(remote)
-        remote.dup.tap {|uri| uri.user = uri.password = nil }.to_s
+        if remote.user || remote.password
+          remote.dup.tap {|uri| uri.user = uri.password = nil }.to_s
+        else
+          remote.to_s
+        end
       end
 
       def installed_specs
@@ -477,7 +483,10 @@ module Bundler
         else
           uri = spec.remote.uri
           Bundler.ui.confirm("Fetching #{version_message(spec)}")
-          Bundler.rubygems.download_gem(spec, uri, download_path)
+          rubygems_local_path = Bundler.rubygems.download_gem(spec, uri, download_path)
+          if rubygems_local_path != local_path
+            FileUtils.mv(rubygems_local_path, local_path)
+          end
           cache_globally(spec, local_path)
         end
       end