rubygems-update 4.0.21 → 4.1.0.beta1

data/{bundler/lib → lib}/bundler/rubygems_integration.rb

@@ -111,7 +111,7 @@ module Bundler
 
     def spec_cache_dirs
       @spec_cache_dirs ||= begin
-        dirs = gem_path.map {|dir| File.join(dir, "specifications") }
+        dirs = gem_path.flat_map {|dir| Gem::SpecificationRecord.dirs_from([dir]) }
         dirs << Gem.spec_cache_dir
         dirs.uniq.select {|dir| File.directory? dir }
       end
@@ -144,7 +144,12 @@ module Bundler
 
     def spec_from_gem(path)
       require "rubygems/package"
-      Gem::Package.new(path).spec
+      package = Gem::Package.new(path)
+      spec = package.spec
+      if package.respond_to?(:content_address)
+        spec.content_address = package.content_address
+      end
+      spec
     end
 
     def build_gem(gem_dir, spec)

data/{bundler/lib → lib}/bundler/runtime.rb

@@ -4,6 +4,8 @@ module Bundler
   class Runtime
     include SharedHelpers
 
+    PRUNE_CATEGORIES = [:cache, :git].freeze
+
     def initialize(root, definition)
       @root = root
       @definition = definition
@@ -146,7 +148,7 @@ module Bundler
         FileUtils.touch(File.expand_path("../.bundlecache", git_dir))
       end
 
-      prune_cache(cache_path) unless Bundler.settings[:no_prune]
+      prune_cache(cache_path) unless Bundler.settings[:keep_outdated_cache]
     end
 
     def prune_cache(cache_path)
@@ -164,7 +166,9 @@ module Bundler
       git_cache_dirs       = SharedHelpers.glob_files_in_dir("cache/bundler/git/*", Gem.dir)
       gem_dirs             = SharedHelpers.glob_files_in_dir("gems/*", Gem.dir)
       gem_files            = SharedHelpers.glob_files_in_dir("cache/*.gem", Gem.dir)
-      gemspec_files        = SharedHelpers.glob_files_in_dir("specifications/*.gemspec", Gem.dir)
+      gemspec_files        = Gem::SpecificationRecord.dirs_from([Gem.dir]).flat_map do |dir|
+        SharedHelpers.glob_files_in_dir("*.gemspec", dir)
+      end
       extension_dirs       = SharedHelpers.glob_files_in_dir("extensions/*/*/*", Gem.dir) + SharedHelpers.glob_files_in_dir("bundler/gems/extensions/*/*/*", Gem.dir)
       spec_gem_paths       = []
       # need to keep git sources around
@@ -229,8 +233,71 @@ module Bundler
       output
     end
 
+    # Removes the artifacts Bundler keeps for its own bookkeeping and can rebuild
+    # from the lockfile. Gem contents are never touched.
+    def prune(categories)
+      categories = expand_prune_categories(categories)
+      return if categories.empty?
+
+      # Without a bundle path the cache is shared with RubyGems, so it holds gem
+      # files Bundler never put there.
+      if Bundler.use_system_gems?
+        Bundler.ui.warn "The `prune` setting was ignored because this bundle installs into the system gem " \
+                        "directory, which Bundler shares with RubyGems. Run " \
+                        "`bundle config set --local path vendor/bundle` to prune.", wrap: true
+        return
+      end
+
+      # Git metadata first, because resolving a checkout's install path can need
+      # the mirror that pruning the cache removes.
+      prune_git_metadata if categories.include?(:git)
+      prune_download_cache if categories.include?(:cache)
+    end
+
     private
 
+    # Anything that is not a category name is read as a boolean with Bundler's
+    # usual vocabulary, so `BUNDLE_PRUNE=1` selects every category and keeps
+    # doing so as categories are added. That way a tool can set the flag without
+    # tracking this list.
+    def expand_prune_categories(categories)
+      Array(categories).flat_map do |category|
+        name = category.to_s
+        next name.to_sym if PRUNE_CATEGORIES.include?(name.to_sym)
+
+        Settings.to_bool(name) ? PRUNE_CATEGORIES : []
+      end.uniq
+    end
+
+    def prune_download_cache
+      cache_path = File.join(Bundler.bundle_path, "cache")
+      return unless File.exist?(cache_path)
+
+      Bundler.ui.info "Removing the download cache at #{cache_path}"
+      SharedHelpers.filesystem_access(cache_path) do |p|
+        FileUtils.rm_rf(p)
+      end
+    end
+
+    def prune_git_metadata
+      owned = "#{Bundler.install_path}#{File::SEPARATOR}"
+      git_dirs = @definition.sources.git_sources.reject(&:local?).filter_map do |source|
+        install_path = source.install_path.to_s
+        next unless install_path.start_with?(owned)
+
+        git_dir = File.join(install_path, ".git")
+        git_dir if File.exist?(git_dir)
+      end
+      return if git_dirs.empty?
+
+      Bundler.ui.info "Removing git metadata from checked out git gems"
+      git_dirs.each do |git_dir|
+        SharedHelpers.filesystem_access(git_dir) do |p|
+          FileUtils.rm_rf(p)
+        end
+      end
+    end
+
     def prune_gem_cache(resolve, cache_path)
       cached = SharedHelpers.glob_files_in_dir("*.gem", cache_path.to_s)
 

data/{bundler/lib → lib}/bundler/self_manager.rb

@@ -30,8 +30,8 @@ module Bundler
       install_and_restart_with(restart_version)
     end
 
-    def update_bundler_and_restart_with_it_if_needed(target, pre: false)
-      spec = resolve_update_version_from(target, pre: pre)
+    def update_bundler_and_restart_with_it_if_needed(target)
+      spec = resolve_update_version_from(target)
       return unless spec
 
       version = spec.version
@@ -108,9 +108,9 @@ module Bundler
         lockfile_version
     end
 
-    def resolve_update_version_from(target, pre: false)
+    def resolve_update_version_from(target)
       requirement = Gem::Requirement.new(target)
-      update_candidate = find_latest_matching_spec(requirement, pre: pre)
+      update_candidate = find_latest_matching_spec(requirement)
 
       if update_candidate.nil?
         raise InvalidOption, "The `bundle update --bundler` target version (#{target}) does not exist"
@@ -137,24 +137,18 @@ module Bundler
       end
     end
 
-    def find_latest_matching_spec(requirement, pre: false)
+    def find_latest_matching_spec(requirement)
       Bundler.configure
-      # A bare `bundle update --bundler` must stay on releases, like `gem update
-      # --system`, so only `--pre` or a prerelease requirement opts into one.
-      allow_prerelease = pre || requirement.prerelease?
-
-      local_result = find_latest_matching_spec_from_collection(local_specs, requirement, allow_prerelease)
+      local_result = find_latest_matching_spec_from_collection(local_specs, requirement)
       return local_result if local_result && requirement.specific?
 
-      remote_result = find_latest_matching_spec_from_collection(remote_specs, requirement, allow_prerelease)
+      remote_result = find_latest_matching_spec_from_collection(remote_specs, requirement)
       return remote_result if local_result.nil?
 
-      [local_result, remote_result].compact.max
+      [local_result, remote_result].max
     end
 
-    def find_latest_matching_spec_from_collection(specs, requirement, allow_prerelease)
-      specs = specs.reject {|spec| spec.version.prerelease? } unless allow_prerelease
-
+    def find_latest_matching_spec_from_collection(specs, requirement)
       specs.sort.reverse_each.find {|spec| requirement.satisfied_by?(spec.version) }
     end