bundler 4.0.23 → 4.1.0.beta1

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

@@ -430,7 +430,7 @@ module Bundler
         def configured_uri
           @configured_uri ||= if /https?:/.match?(uri)
             remote = Gem::URI(uri)
-            config_auth = Bundler.settings[remote.to_s] || Bundler.settings[remote.host]
+            config_auth = Bundler.settings.credentials_for(remote)
             remote.userinfo ||= config_auth
             remote.to_s
           else
@@ -507,15 +507,7 @@ module Bundler
 
           return ["git", *opts, *cmd] unless dir
 
-          # With safe.bareRepository=explicit, git refuses to discover a bare
-          # repository from -C, so the cache clone is named with --git-dir.
-          # Working trees, like a local override, still go through -C.
-          location = bare_repo?(dir) ? "--git-dir" : "-C"
-          ["git", location, dir.to_s, *opts, *cmd]
-        end
-
-        def bare_repo?(dir)
-          File.exist?(File.join(dir, "objects")) && File.exist?(File.join(dir, "HEAD"))
+          ["git", "-C", dir.to_s, *opts, *cmd]
         end
 
         def extra_clone_args

data/lib/bundler/source/git.rb

@@ -30,6 +30,7 @@ module Bundler
 
         @copied     = false
         @local      = false
+        @cached_app_cache_path = nil
       end
 
       def remote!
@@ -191,8 +192,13 @@ module Bundler
         set_cache_path!(app_cache_path) if use_app_cache?
 
         if requires_checkout? && !@copied
-          fetch unless use_app_cache?
-          checkout
+          Plugin.hook(Plugin::Events::GIT_BEFORE_FETCH, self)
+          begin
+            fetch unless use_app_cache?
+            checkout
+          ensure
+            Plugin.hook(Plugin::Events::GIT_AFTER_FETCH, self)
+          end
         end
 
         local_specs
@@ -272,6 +278,11 @@ module Bundler
 
         app_cache_path = app_cache_path(custom_path)
 
+        # When several gems share a single git source, this is called once per
+        # gem. Copying the repository is expensive for large repos, so skip it
+        # if we already populated this cache during the same command.
+        return if @cached_app_cache_path == app_cache_path
+
         migrate = try_migrate ? bare_repo?(app_cache_path) : false
 
         set_cache_path!(nil) if migrate
@@ -283,6 +294,8 @@ module Bundler
         git_proxy.checkout if migrate || requires_checkout?
         git_proxy.copy_to(app_cache_path, @submodules)
         serialize_gemspecs_in(app_cache_path)
+
+        @cached_app_cache_path = app_cache_path
       end
 
       def checkout
@@ -405,10 +418,6 @@ module Bundler
         options["revision"]
       end
 
-      def cached?
-        cache_path.exist?
-      end
-
       def git_proxy
         @git_proxy ||= GitProxy.new(cache_path, uri, options, locked_revision, self)
       end

data/lib/bundler/source/path/installer.rb

@@ -24,7 +24,7 @@ module Bundler
         def post_install
           run_hooks(:pre_install)
 
-          unless @disable_extensions
+          unless @disable_extensions || Bundler.settings[:no_build_extension]
             build_extensions
             run_hooks(:post_build)
           end

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

@@ -18,12 +18,17 @@ module Bundler
         end
 
         # Returns the cooldown days that apply to this remote, resolving the
-        # precedence CLI > config > Gemfile per-source. Returns nil if no
-        # cooldown applies.
+        # precedence CLI > config > Gemfile per-source and then raising the
+        # result to RubyGems' own setting. Returns nil if no cooldown applies.
+        #
+        # The resolver asks once per candidate spec, so the settings lookup is
+        # memoized. That snapshots the value: a Remote created before a
+        # settings change keeps the old one. Nothing in Bundler changes the
+        # cooldown setting after the sources are built (the CLI flag is applied
+        # before the Definition exists), so build a new Remote if you need to.
         def effective_cooldown
-          override = Bundler.settings[:cooldown]
-          return override if override
-          @cooldown
+          return @effective_cooldown if defined?(@effective_cooldown)
+          @effective_cooldown = Bundler.settings.cooldown_for(@cooldown)
         end
 
         MAX_CACHE_SLUG_HOST_SIZE = 255 - 1 - 32 # 255 minus dot minus MD5 length

data/lib/bundler/source/rubygems.rb

@@ -25,6 +25,7 @@ module Bundler
         @checksum_store = Checksum::Store.new
         @gem_installers = {}
         @gem_installers_mutex = Mutex.new
+        @remote_spec_for_mutex = Mutex.new
         @remote_specs_mutex = Mutex.new
 
         cooldown = options["cooldown"]
@@ -196,6 +197,8 @@ module Bundler
              "the security policy didn't allow it, with the message: #{e.message}"
           end
 
+          s.content_address = spec.content_address if spec.content_address
+
           spec.__swap__(s)
         end
 
@@ -230,8 +233,12 @@ module Bundler
         spec.post_install_message
       end
 
+      def uncached?(spec)
+        caches.none? {|cache| File.exist?(package_path(cache, spec)) }
+      end
+
       def cache(spec, custom_path = nil)
-        cached_path = Bundler.settings[:cache_all_platforms] ? fetch_gem_if_possible(spec) : cached_gem(spec)
+        cached_path = fetch_gem_if_possible(spec)
         raise GemNotFound, "Missing gem file '#{spec.file_name}'." unless cached_path
         return if File.dirname(cached_path) == Bundler.app_cache.to_s
         Bundler.ui.info "  * #{File.basename(cached_path)}"
@@ -437,12 +444,14 @@ module Bundler
       # Looks up a single spec in the remote sources, fetching only its own
       # name when the full remote index is not already materialized.
       def remote_spec_for(spec)
-        return remote_specs.search(spec).first if @remote_specs || api_fetchers.empty?
+        @remote_spec_for_mutex.synchronize do
+          return remote_specs.search(spec).first if @remote_specs || api_fetchers.empty?
 
-        index = Index.build do |idx|
-          fetch_names(api_fetchers, [spec.name], idx)
+          index = Index.build do |idx|
+            fetch_names(api_fetchers, [spec.name], idx)
+          end
+          index.search(spec).first
         end
-        index.search(spec).first
       end
 
       def fetch_names(fetchers, dependency_names, index)
@@ -462,10 +471,24 @@ module Bundler
         if spec.remote
           fetch_gem(spec, previous_spec)
         else
-          cached_gem(spec)
+          cached_gem(spec) || refetch_gem(spec, previous_spec)
         end
       end
 
+      # An installed gem materializes without a remote, so a reinstall forced by
+      # `--redownload` has to look the gem up in the remote index again before it
+      # can download the archive that the cache no longer holds.
+      def refetch_gem(spec, previous_spec = nil)
+        return unless @allow_remote
+
+        remote_spec = remote_spec_for(spec)
+        return unless remote_spec && remote_spec.full_name == spec.full_name
+
+        path = fetch_gem(remote_spec, previous_spec)
+        spec.remote = remote_spec.remote
+        path
+      end
+
       def fetch_gem(spec, previous_spec = nil)
         spec.fetch_platform
 
@@ -545,8 +568,13 @@ module Bundler
         Bundler.ui.confirm("Fetching #{version_message(spec, previous_spec)}")
         gem_remote_fetcher = remote_fetchers.fetch(spec.remote).gem_remote_fetcher
 
-        Gem.time("Downloaded #{spec.name} in", 0, true) do
-          Bundler.rubygems.download_gem(spec, uri, download_cache_path, gem_remote_fetcher)
+        Plugin.hook(Plugin::Events::GEM_BEFORE_FETCH, spec)
+        begin
+          Gem.time("Downloaded #{spec.name} in", 0, true) do
+            Bundler.rubygems.download_gem(spec, uri, download_cache_path, gem_remote_fetcher)
+          end
+        ensure
+          Plugin.hook(Plugin::Events::GEM_AFTER_FETCH, spec)
         end
       end
 
@@ -566,7 +594,12 @@ module Bundler
         return unless remote = spec.remote
         return unless cache_slug = remote.cache_slug
 
-        Bundler.user_cache.join("gems", cache_slug)
+        if Gem.respond_to?(:global_gem_cache_path)
+          Pathname.new(Gem.global_gem_cache_path).join(cache_slug)
+        else
+          # Fall back to old location for older RubyGems versions
+          Bundler.user_cache.join("gems", cache_slug)
+        end
       end
 
       def extension_cache_slug(spec)
@@ -574,11 +607,11 @@ module Bundler
         remote.cache_slug
       end
 
-      # We are using a mutex to reaed and write from/to the hash.
+      # We are using a mutex to read and write from/to the hash.
       # The reason this double synchronization was added is for performance
       # and to lock the mutex for the shortest possible amount of time. Otherwise,
       # all threads are fighting over this mutex and when it gets acquired it gets locked
-      # until a threads finishes downloading a gem, leaving the other threads waiting
+      # until a thread finishes downloading a gem, leaving the other threads waiting
       # doing nothing.
       def rubygems_gem_installer(spec, options)
         @gem_installers_mutex.synchronize { @gem_installers[spec.name] } || begin
@@ -589,6 +622,7 @@ module Bundler
 
           installer = Bundler::RubyGemsGemInstaller.at(
             path,
+            content_address: (spec.content_address if Gem::ContentAddress.content_addressed?(spec, validate_ruby_abi: false)),
             security_policy: Bundler.rubygems.security_policies[Bundler.settings["trust-policy"]],
             install_dir: rubygems_dir.to_s,
             bin_dir: Bundler.system_bindir.to_s,
@@ -596,7 +630,9 @@ module Bundler
             wrappers: true,
             env_shebang: true,
             build_args: options[:build_args],
-            bundler_extension_cache_path: extension_cache_path(spec)
+            bundler_extension_cache_path: extension_cache_path(spec),
+            build_extension: Bundler.settings[:no_build_extension] ? false : nil,
+            install_plugin: Bundler.settings[:no_install_plugin] ? false : nil
           )
           @gem_installers_mutex.synchronize { @gem_installers[spec.name] ||= installer }
         end

data/lib/bundler/spec_set.rb

@@ -178,7 +178,7 @@ module Bundler
     end
 
     def find_by_name_and_platform(name, platform)
-      @specs.detect {|spec| spec.name == name && spec.installable_on_platform?(platform) }
+      lookup[name]&.detect {|spec| spec.installable_on_platform?(platform) }
     end
 
     def specs_with_additional_variants_from(other)
@@ -274,13 +274,25 @@ module Bundler
 
       valid_platform = lookup.all? do |_, specs|
         spec = specs.first
+        # The matching candidates returned by source.specs.search are remote
+        # specs that do not carry the override list themselves. Borrow it from
+        # the LazySpec we are validating so platform-variant validation honors
+        # the same overrides the install/resolve path already applies.
+        overrides = spec.is_a?(LazySpecification) ? Array(spec.overrides) : []
         matching_specs = spec.source.specs.search([spec.name, spec.version])
         platform_spec = MatchPlatform.select_best_platform_match(matching_specs, platform).find do |s|
-          valid?(s)
+          s.matches_current_metadata_with_overrides?(overrides) && valid_dependencies?(s)
         end
 
         if platform_spec
-          new_specs << LazySpecification.from_spec(platform_spec) unless specs.include?(platform_spec)
+          unless specs.include?(platform_spec)
+            new_lazy = LazySpecification.from_spec(platform_spec)
+            # Carry the overrides forward so a follow-up complete_platform
+            # call that picks this synthesized variant as its exemplar still
+            # honors the user's override list.
+            new_lazy.overrides = overrides if overrides.any?
+            new_specs << new_lazy
+          end
           true
         else
           false
@@ -314,7 +326,7 @@ module Bundler
     end
 
     def sorted
-      @sorted ||= ([@specs.find {|s| s.name == "rake" }] + tsort).compact.uniq
+      @sorted ||= ([lookup["rake"]&.first] + tsort).compact.uniq
     rescue Gem::TSort::Cyclic => error
       cgems = extract_circular_gems(error)
       raise CyclicDependencyError, "Your bundle requires gems that depend" \

data/lib/bundler/stub_specification.rb

@@ -4,7 +4,8 @@ module Bundler
   class StubSpecification < RemoteSpecification
     def self.from_stub(stub)
       return stub if stub.is_a?(Bundler::StubSpecification)
-      spec = new(stub.name, stub.version, stub.platform, nil)
+      content_address = stub.content_address
+      spec = new(stub.name, stub.version, stub.platform, nil, content_address: content_address)
       spec.stub = stub
       spec
     end

data/lib/bundler/templates/newgem/Gemfile.tt

@@ -6,19 +6,19 @@ source "https://rubygems.org"
 gemspec
 
 gem "irb"
-gem "rake", "~> 13.0"
+gem "rake", ">= 13.0"
 <%- if config[:ext] -%>
 
 gem "rake-compiler"
 <%- end -%>
 <%- if config[:test] -%>
 
-gem "<%= config[:test] %>", "~> <%= config[:test_framework_version] %>"
+gem "<%= config[:test] %>"
 <%- end -%>
 <%- if config[:linter] == "rubocop" -%>
 
-gem "rubocop", "~> <%= config[:linter_version] %>"
+gem "rubocop"
 <%- elsif config[:linter] == "standard" -%>
 
-gem "standard", "~> <%= config[:linter_version] %>"
+gem "standard"
 <%- end -%>

data/lib/bundler/templates/newgem/ext/newgem/Cargo.toml.tt

@@ -12,7 +12,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.9" }
+magnus = { version = "0.8.2" }
 rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
 
 [build-dependencies]

data/lib/bundler/templates/newgem/newgem.gemspec.tt

@@ -45,12 +45,12 @@ Gem::Specification.new do |spec|
 <%- end -%>
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  # spec.add_dependency "example-gem", ">= 1.0"
 <%- if config[:ext] == 'rust' -%>
-  spec.add_dependency "rb_sys", "~> 0.9.128"
+  spec.add_dependency "rb_sys", ">= 0.9.128"
 <%- end -%>
 <%- if config[:ext] == 'go' -%>
-  spec.add_dependency "go_gem", "~> 0.2"
+  spec.add_dependency "go_gem", ">= 0.2"
 <%- end -%>
 
   # For more information and examples about making a new gem, check out our

data/lib/bundler/templates/newgem/spec/newgem_spec.rb.tt

@@ -9,7 +9,7 @@ RSpec.describe <%= config[:constant_name] %> do
   it "can call into Rust" do
     result = <%= config[:constant_name] %>.hello("world")
 
-    expect(result).to be("Hello earth, from Rust!")
+    expect(result).to eq("Hello world, from Rust!")
   end
 <%- else -%>
   it "does something useful" do

data/lib/bundler/templates/newgem/test/minitest/test_newgem.rb.tt

@@ -9,7 +9,7 @@ class <%= config[:minitest_constant_name] %> < Minitest::Test
 
 <%- if config[:ext] == 'rust' -%>
   def test_hello_world
-    assert_equal "Hello earth, from Rust!", <%= config[:constant_name] %>.hello("world")
+    assert_equal "Hello world, from Rust!", <%= config[:constant_name] %>.hello("world")
   end
 <%- else -%>
   def test_it_does_something_useful

data/lib/bundler/ui/shell.rb

@@ -76,10 +76,6 @@ module Bundler
         level("debug")
       end
 
-      def quiet?
-        level("quiet")
-      end
-
       def ask(msg)
         @shell.ask(msg, :green)
       end

data/lib/bundler/ui/silent.rb

@@ -45,10 +45,6 @@ module Bundler
         false
       end
 
-      def quiet?
-        false
-      end
-
       def warn?
         false
       end

data/lib/bundler/vendor/fileutils/lib/fileutils.rb

@@ -181,7 +181,7 @@ end
 #
 module Bundler::FileUtils
   # The version number.
-  VERSION = "1.8.1"
+  VERSION = "1.8.0"
 
   def self.private_module_function(name)   #:nodoc:
     module_function name
@@ -279,67 +279,38 @@ module Bundler::FileUtils
   end
   private_module_function :remove_trailing_slash
 
-  # :markup: markdown
   #
-  # call-seq:
-  #   Bundler::FileUtils.mkdir(*paths, mode: 0775, noop: nil, verbose: nil) -> array_of_paths or nil
-  #
-  # Argument `paths` may be one path or an array of paths;
-  # each must be {interpretable as a path}[rdoc-ref:FileUtils@Path+Arguments].
-  #
-  # By default, creates a directory entry at each of the given `paths`;
-  # each directory has permissions `0775`;
-  # returns an array of the paths:
-  #
-  # ```ruby
-  # Bundler::FileUtils.mkdir('foo')                 # => ["foo"]
-  # Bundler::FileUtils.mkdir(%w[bar baz])           # => ["bar", "baz"]
-  # File.stat(Dir.new('foo')).mode.to_s(8) # => "40775"
-  # File.stat(Dir.new('bar')).mode.to_s(8) # => "40775"
-  # File.stat(Dir.new('baz')).mode.to_s(8) # => "40775"
-  # Bundler::FileUtils.rmdir(%w[foo bar baz])       # => ["foo", "bar", "baz"]
-  # ```
-  #
-  # Raises an exception if for any reason a directory cannot be created;
-  # a common reason is that the directory already exists.
+  # Creates directories at the paths in the given +list+
+  # (a single path or an array of paths);
+  # returns +list+ if it is an array, <tt>[list]</tt> otherwise.
   #
-  # With keyword argument `mode` given,
-  # creates directories with the given permissions:
+  # Argument +list+ or its elements
+  # should be {interpretable as paths}[rdoc-ref:FileUtils@Path+Arguments].
   #
-  # ```ruby
-  # Bundler::FileUtils.mkdir('bar', mode: 0664)
-  # File.stat(Dir.new('bar')).mode.to_s(8) # => "40664"
-  # Bundler::FileUtils.rmdir('bar')
-  # ```
+  # With no keyword arguments, creates a directory at each +path+ in +list+
+  # by calling: <tt>Dir.mkdir(path, mode)</tt>;
+  # see {Dir.mkdir}[https://docs.ruby-lang.org/en/master/Dir.html#method-c-mkdir]:
   #
-  # With keyword argument `noop` given as `true`,
-  # does not create directories;
-  # returns `nil`
+  #   Bundler::FileUtils.mkdir(%w[tmp0 tmp1]) # => ["tmp0", "tmp1"]
+  #   Bundler::FileUtils.mkdir('tmp4')        # => ["tmp4"]
   #
-  # ```ruby
-  # Bundler::FileUtils.mkdir('foo', noop: true) # => nil
-  # Dir.exist?('foo')                  # => false
-  # ```
+  # Keyword arguments:
   #
-  # With keyword argument `verbose` given as `true`,
-  # prints a shell command:
+  # - <tt>mode: <i>mode</i></tt> - also calls <tt>File.chmod(mode, path)</tt>;
+  #   see {File.chmod}[https://docs.ruby-lang.org/en/master/File.html#method-c-chmod].
+  # - <tt>noop: true</tt> - does not create directories.
+  # - <tt>verbose: true</tt> - prints an equivalent command:
   #
-  # ```ruby
-  # Bundler::FileUtils.mkdir('foo', verbose: true)
-  # Bundler::FileUtils.mkdir(%w[bar baz], mode: 0644, verbose: true)
-  # Bundler::FileUtils.mkdir(%w[bar baz], mode: 0644, verbose: true, noop: true)
-  # ```
+  #     Bundler::FileUtils.mkdir(%w[tmp0 tmp1], verbose: true)
+  #     Bundler::FileUtils.mkdir(%w[tmp2 tmp3], mode: 0700, verbose: true)
   #
-  # Output:
+  #   Output:
   #
-  # ```text
-  # mkdir foo
-  # mkdir -m 644 bar baz
-  # mkdir -m 644 bar baz
-  # ```
+  #     mkdir tmp0 tmp1
+  #     mkdir -m 700 tmp2 tmp3
   #
-  # Note that in the last call above (containing `noop: true`)
-  # the existence of the directory is not checked.
+  # Raises an exception if any path points to an existing
+  # file or directory, or if for any reason a directory cannot be created.
   #
   # Related: Bundler::FileUtils.mkdir_p.
   #
@@ -715,7 +686,7 @@ module Bundler::FileUtils
   # Keyword arguments:
   #
   # - <tt>force: true</tt> - overwrites +dest+ if it exists.
-  # - <tt>relative: true</tt> - create links relative to +dest+.
+  # - <tt>relative: false</tt> - create links relative to +dest+.
   # - <tt>noop: true</tt> - does not create links.
   # - <tt>verbose: true</tt> - prints an equivalent command:
   #
@@ -783,7 +754,7 @@ module Bundler::FileUtils
         n = real_ddirs.size - i
         n -= 1 unless target_directory
         link2 = fu_clean_components(*Array.new([n, 0].max, '..'), *real_sdirs[i..-1])
-        link1 = link2 if !link2.empty? and link1.size > link2.size
+        link1 = link2 if link1.size > link2.size
       end
       s = File.join(link1)
       fu_output_message [cmd, s, d].flatten.join(' ') if verbose
@@ -2066,6 +2037,10 @@ module Bundler::FileUtils
       def fu_windows?; false end #:nodoc:
     end
 
+    def fu_copy_stream0(src, dest, blksize = nil)   #:nodoc:
+      IO.copy_stream(src, dest)
+    end
+
     def fu_stream_blksize(*streams) #:nodoc:
       streams.each do |s|
         next unless s.respond_to?(:stat)

data/lib/bundler/vendored_pub_grub.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
-module Bundler; end
-require_relative "vendor/pub_grub/lib/pub_grub"
+# Reuse RubyGems' vendored PubGrub (Gem::PubGrub). The Bundler gem ships a copy
+# under lib/rubygems/vendor, so this resolves even on RubyGems versions that
+# predate it.
+
+require "rubygems/vendor/pub_grub/lib/pub_grub"

data/lib/bundler/vendored_securerandom.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-# Use RubyGems vendored copy when available. Otherwise fallback to Bundler
-# vendored copy. The vendored copy in Bundler can be removed once support for
-# RubyGems 3.5.18 is dropped.
+# Reuse RubyGems' vendored SecureRandom (Gem::SecureRandom). The Bundler gem
+# ships a copy under lib/rubygems/vendor, so this resolves even on RubyGems
+# versions that predate it. Fall back to the stdlib only when no vendored copy
+# is available at all.
 
-begin
-  require "rubygems/vendored_securerandom"
-rescue LoadError
-  require_relative "vendor/securerandom/lib/securerandom"
-  Gem::SecureRandom = Bundler::SecureRandom
+unless defined?(Gem::SecureRandom)
+  begin
+    require "rubygems/vendor/securerandom/lib/securerandom"
+  rescue LoadError
+    require "securerandom"
+    Gem::SecureRandom = SecureRandom
+  end
 end

data/lib/bundler/vendored_uri.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-module Bundler; end
+# Reuse RubyGems' vendored URI (Gem::URI). The Bundler gem ships a copy under
+# lib/rubygems/vendor, so this resolves even on RubyGems versions that predate
+# it. Fall back to the stdlib only when no vendored copy is available at all.
 
-# Use RubyGems vendored copy when available. Otherwise fallback to Bundler
-# vendored copy. The vendored copy in Bundler can be removed once support for
-# RubyGems 3.5 is dropped.
+unless defined?(Gem::URI)
+  begin
+    require "rubygems/vendor/uri/lib/uri"
+  rescue LoadError
+    require "uri"
+    Gem::URI = URI
 
-begin
-  require "rubygems/vendor/uri/lib/uri"
-rescue LoadError
-  require_relative "vendor/uri/lib/uri"
-  Gem::URI = Bundler::URI
-
-  module Gem
-    def URI(uri) # rubocop:disable Naming/MethodName
-      Bundler::URI(uri)
+    module Gem
+      def URI(uri) # rubocop:disable Naming/MethodName
+        Kernel.URI(uri)
+      end
+      module_function :URI
     end
-    module_function :URI
   end
 end

data/lib/bundler/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: false
 
 module Bundler
-  VERSION = "4.0.23".freeze
+  VERSION = "4.1.0.beta1".freeze
 
   def self.bundler_major_version
     @bundler_major_version ||= gem_version.segments.first

data/lib/bundler/worker.rb

@@ -19,11 +19,12 @@ module Bundler
     # @param size [Integer] Size of pool
     # @param name [String] name the name of the worker
     # @param func [Proc] job to run in inside the worker pool
-    def initialize(size, name, func)
+    # @param response_queue [Thread::Queue] queue that receives completed jobs
+    def initialize(size, name, func, response_queue: Thread::Queue.new)
       @name = name
       @request_queue = Thread::Queue.new
       @request_queue_with_priority = Thread::Queue.new
-      @response_queue = Thread::Queue.new
+      @response_queue = response_queue
       @func = func
       @size = size
       @threads = nil

data/lib/bundler.rb

@@ -41,7 +41,6 @@ module Bundler
   autoload :Checksum,               File.expand_path("bundler/checksum", __dir__)
   autoload :CLI,                    File.expand_path("bundler/cli", __dir__)
   autoload :CIDetector,             File.expand_path("bundler/ci_detector", __dir__)
-  autoload :CompactIndexClient,     File.expand_path("bundler/compact_index_client", __dir__)
   autoload :Definition,             File.expand_path("bundler/definition", __dir__)
   autoload :Dependency,             File.expand_path("bundler/dependency", __dir__)
   autoload :Deprecate,              File.expand_path("bundler/deprecate", __dir__)
@@ -62,6 +61,7 @@ module Bundler
   autoload :MatchRemoteMetadata,    File.expand_path("bundler/match_remote_metadata", __dir__)
   autoload :Materialization,        File.expand_path("bundler/materialization", __dir__)
   autoload :NULL,                   File.expand_path("bundler/constants", __dir__)
+  autoload :Override,               File.expand_path("bundler/override", __dir__)
   autoload :ProcessLock,            File.expand_path("bundler/process_lock", __dir__)
   autoload :RemoteSpecification,    File.expand_path("bundler/remote_specification", __dir__)
   autoload :Resolver,               File.expand_path("bundler/resolver", __dir__)
@@ -119,7 +119,9 @@ module Bundler
     def bin_path
       @bin_path ||= begin
         path = Bundler.settings[:bin] || "bin"
-        Pathname.new(path).expand_path(root).expand_path
+        path = Pathname.new(path).expand_path(root).expand_path
+        mkdir_p(path)
+        path
       end
     end