bundler 2.4.22 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f18e076341154326f22050b2bf57d7aa5f82278331f38079b4cb9ea53a13350
-  data.tar.gz: 5edcf31c166b6e65530b57c535c9e593a1cc24be7234a74b07eedbe448d775bf
+  metadata.gz: 96c3a9a5a42642d473042853b90ec2e07a4be74e6e1b5aba5bfdc3bcc0ed8776
+  data.tar.gz: 5ccfc33ca9f1b86f30d896fc89db5e556b1dab1ec84361b1f2aa9bb65ff39769
 SHA512:
-  metadata.gz: 19f1201ce7d6a27379d5782373671a1fecfa6482bc699bdb89aa15ef9482f33659913874a5f22e8e3dece848350f411ebe96eb14f3fd3d6dc624455d85ba19de
-  data.tar.gz: 113401cf222bcf13bcda4424492b103f9bd9563c38f6dbdd7b7a7c4465e3971819a5ae77e1153987178d8353cf8d7aa79332484324bad00858a6f526b7f4a1b7
+  metadata.gz: f9822abc2d327f47a25c580b932e4cf3108ab8ecc41d8c206db8840c27779ec4943daa0a28c05e36503c1a04f5b3cb82f2b93a5f32538cf52e2a62c8fee5c11c
+  data.tar.gz: f6f4e921e4c606352f0b2d1e54b2674f999690dda1a8d932b3c78bb0f6561f4527e4bf88fbfadb1061bbeb097014225fae9609262f415d1c3e08d61581e7f387

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+# 2.5.0 (December 15, 2023)
+
+## Breaking changes:
+
+  - Drop ruby 2.6 and 2.7 support [#7116](https://github.com/rubygems/rubygems/pull/7116)
+  - The `:mswin`, `:mswin64`, `:mingw`, and `:x64_mingw` Gemfile `platform` values are soft-deprecated and aliased to `:windows` [#6391](https://github.com/rubygems/rubygems/pull/6391)
+
+## Features:
+
+  - Leverage ruby feature to warn when requiring default gems not included in the bundle that will be turned into bundled gems in the future [#6831](https://github.com/rubygems/rubygems/pull/6831)
+  - Introduce `bundle config set version` feature to choose the version of Bundler that should be used and potentially disable using the `lockfile` version by setting it to `system` [#6817](https://github.com/rubygems/rubygems/pull/6817)
+
+## Performance:
+
+  - Use match? when regexp match data is unused [#7263](https://github.com/rubygems/rubygems/pull/7263)
+  - Avoid some allocations when evaluating `ruby` Gemfile DSL [#7251](https://github.com/rubygems/rubygems/pull/7251)
+  - Reduce array allocations when loading definition [#7199](https://github.com/rubygems/rubygems/pull/7199)
+  - Avoid re-compiling static regexp in a loop [#7198](https://github.com/rubygems/rubygems/pull/7198)
+  - Reduce allocations when installing gems with bundler [#6977](https://github.com/rubygems/rubygems/pull/6977)
+  - Use a shared connection pool for fetching gems [#7079](https://github.com/rubygems/rubygems/pull/7079)
+  - Reduce allocations when parsing compact index [#6971](https://github.com/rubygems/rubygems/pull/6971)
+
+## Enhancements:
+
+  - Add 3.4 as a supported ruby version in Gemfile DSL [#7264](https://github.com/rubygems/rubygems/pull/7264)
+  - Improve install advice when some gems are not found [#7265](https://github.com/rubygems/rubygems/pull/7265)
+  - Vendor `net-http`, `net-protocol`, `resolv`, and `timeout` to reduce conflicts between Gemfile gems and internal dependencies [#6793](https://github.com/rubygems/rubygems/pull/6793)
+  - Allow `bundle pristine` to run in parallel [#6927](https://github.com/rubygems/rubygems/pull/6927)
+  - Make `bundle lock` always touch the lockfile in non-frozen mode [#7220](https://github.com/rubygems/rubygems/pull/7220)
+  - Use `Minitest::TestTask` in a template file for `minitest` [#7234](https://github.com/rubygems/rubygems/pull/7234)
+  - Add missing services to CI detection and make it consistent between RubyGems and Bundler [#7205](https://github.com/rubygems/rubygems/pull/7205)
+  - Allow auto-install to install missing git gems [#7197](https://github.com/rubygems/rubygems/pull/7197)
+  - Stop remembering cli flags like `--jobs` or `--retry` in configuration [#7191](https://github.com/rubygems/rubygems/pull/7191)
+  - Simplify remembered flags deprecation message [#7189](https://github.com/rubygems/rubygems/pull/7189)
+  - Make sure to `require "rubygems"` explicitly [#7139](https://github.com/rubygems/rubygems/pull/7139)
+  - Handle development dependencies duplicated in gemspec vs Gemfile [#6014](https://github.com/rubygems/rubygems/pull/6014)
+  - Make lockfiles generated on macOS include a lock for Linux by default [#5700](https://github.com/rubygems/rubygems/pull/5700)
+  - Only add a dummy bundler spec to the metadata source when necessary [#4443](https://github.com/rubygems/rubygems/pull/4443)
+
+## Bug fixes:
+
+  - Resolve `ruby file: ".ruby-version"` relative to containing Gemfile [#7250](https://github.com/rubygems/rubygems/pull/7250)
+  - Implement opaque ETag in Compact Index to avoid falling back to old index in servers with different etag implementations [#7122](https://github.com/rubygems/rubygems/pull/7122)
+  - Fix `bundle install --system` deprecation advice [#7190](https://github.com/rubygems/rubygems/pull/7190)
+  - Fix invalid platform removal missing adjacent platforms [#7170](https://github.com/rubygems/rubygems/pull/7170)
+
+## Documentation:
+
+  - Add missing --prefer-local to Synopsis in bundle-install.1.ronn [#7194](https://github.com/rubygems/rubygems/pull/7194)
+  - Update GitHub organization of Standard Ruby in `bundle gem` output and generated configuration [#6818](https://github.com/rubygems/rubygems/pull/6818)
+  - Replace "prior to" with "immediately after" in `bundle gem` generated README file [#6338](https://github.com/rubygems/rubygems/pull/6338)
+
 # 2.4.22 (November 9, 2023)
 
 ## Enhancements:
@@ -757,6 +809,7 @@
 
 ## Enhancements:
 
+  - Cancel deprecation of custom git sources [#5147](https://github.com/rubygems/rubygems/pull/5147)
   - Print warning when running Bundler on potentially problematic RubyGems & Ruby combinations [#5177](https://github.com/rubygems/rubygems/pull/5177)
   - Error tracing should be printed to stderr [#5179](https://github.com/rubygems/rubygems/pull/5179)
   - Add `github` and `ref` options to `bundle add` [#5159](https://github.com/rubygems/rubygems/pull/5159)

data/bundler.gemspec

@@ -29,8 +29,10 @@ Gem::Specification.new do |s|
     "source_code_uri" => "https://github.com/rubygems/rubygems/tree/master/bundler",
   }
 
-  s.required_ruby_version     = ">= 2.6.0"
-  s.required_rubygems_version = ">= 3.0.1"
+  s.required_ruby_version     = ">= 3.0.0"
+
+  # It should match the RubyGems version shipped with `required_ruby_version` above
+  s.required_rubygems_version = ">= 3.2.3"
 
   s.files = Dir.glob("lib/bundler{.rb,/**/*}", File::FNM_DOTMATCH).reject {|f| File.directory?(f) }
 

data/exe/bundle

@@ -15,15 +15,6 @@ end
 
 require "bundler"
 
-if Gem.rubygems_version < Gem::Version.new("3.2.3") && Gem.ruby_version < Gem::Version.new("2.7.a") && !ENV["BUNDLER_NO_OLD_RUBYGEMS_WARNING"]
-  Bundler.ui.warn \
-    "Your RubyGems version (#{Gem::VERSION}) has a bug that prevents " \
-    "`required_ruby_version` from working for Bundler. Any scripts that use " \
-    "`gem install bundler` will break as soon as Bundler drops support for " \
-    "your Ruby version. Please upgrade RubyGems to avoid future breakage " \
-    "and silence this warning by running `gem update --system 3.2.3`"
-end
-
 require "bundler/friendly_errors"
 
 Bundler.with_friendly_errors do
@@ -34,5 +25,5 @@ Bundler.with_friendly_errors do
   help_flag_used = ARGV.any? {|a| help_flags.include? a }
   args = help_flag_used ? Bundler::CLI.reformatted_help_args(ARGV) : ARGV
 
-  Bundler::CLI.start(args, :debug => true)
+  Bundler::CLI.start(args, debug: true)
 end

data/lib/bundler/build_metadata.rb

@@ -4,8 +4,8 @@ module Bundler
   # Represents metadata from when the Bundler gem was built.
   module BuildMetadata
     # begin ivars
-    @built_at = "2023-11-09".freeze
-    @git_commit_sha = "ec2089640".freeze
+    @built_at = "2023-12-15".freeze
+    @git_commit_sha = "58fdbff35a".freeze
     @release = true
     # end ivars
 
@@ -31,7 +31,7 @@ module Bundler
       # commit instance variable then we can't determine its commits SHA.
       git_dir = File.expand_path("../../../.git", __dir__)
       if File.directory?(git_dir)
-        return @git_commit_sha = IO.popen(%w[git rev-parse --short HEAD], { :chdir => git_dir }, &:read).strip.freeze
+        return @git_commit_sha = IO.popen(%w[git rev-parse --short HEAD], { chdir: git_dir }, &:read).strip.freeze
       end
 
       @git_commit_sha ||= "unknown"

data/lib/bundler/capistrano.rb

@@ -17,6 +17,6 @@ end
 
 Capistrano::Configuration.instance(:must_exist).load do
   before "deploy:finalize_update", "bundle:install"
-  Bundler::Deployment.define_task(self, :task, :except => { :no_release => true })
+  Bundler::Deployment.define_task(self, :task, except: { no_release: true })
   set :rake, lambda { "#{fetch(:bundle_cmd, "bundle")} exec rake" }
 end

data/lib/bundler/checksum.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Checksum
+    ALGO_SEPARATOR = "="
+    DEFAULT_ALGORITHM = "sha256"
+    private_constant :DEFAULT_ALGORITHM
+    DEFAULT_BLOCK_SIZE = 16_384
+    private_constant :DEFAULT_BLOCK_SIZE
+
+    class << self
+      def from_gem_package(gem_package, algo = DEFAULT_ALGORITHM)
+        return if Bundler.settings[:disable_checksum_validation]
+        return unless source = gem_package.instance_variable_get(:@gem)
+        return unless source.respond_to?(:with_read_io)
+
+        source.with_read_io do |io|
+          from_gem(io, source.path)
+        ensure
+          io.rewind
+        end
+      end
+
+      def from_gem(io, pathname, algo = DEFAULT_ALGORITHM)
+        digest = Bundler::SharedHelpers.digest(algo.upcase).new
+        buf = String.new(capacity: DEFAULT_BLOCK_SIZE)
+        digest << io.readpartial(DEFAULT_BLOCK_SIZE, buf) until io.eof?
+        Checksum.new(algo, digest.hexdigest!, Source.new(:gem, pathname))
+      end
+
+      def from_api(digest, source_uri, algo = DEFAULT_ALGORITHM)
+        return if Bundler.settings[:disable_checksum_validation]
+        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:api, source_uri))
+      end
+
+      def from_lock(lock_checksum, lockfile_location)
+        algo, digest = lock_checksum.strip.split(ALGO_SEPARATOR, 2)
+        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:lock, lockfile_location))
+      end
+
+      def to_hexdigest(digest, algo = DEFAULT_ALGORITHM)
+        return digest unless algo == DEFAULT_ALGORITHM
+        return digest if digest.match?(/\A[0-9a-f]{64}\z/i)
+        if digest.match?(%r{\A[-0-9a-z_+/]{43}={0,2}\z}i)
+          digest = digest.tr("-_", "+/") # fix urlsafe base64
+          return digest.unpack1("m0").unpack1("H*")
+        end
+        raise ArgumentError, "#{digest.inspect} is not a valid SHA256 hex or base64 digest"
+      end
+    end
+
+    attr_reader :algo, :digest, :sources
+
+    def initialize(algo, digest, source)
+      @algo = algo
+      @digest = digest
+      @sources = [source]
+    end
+
+    def ==(other)
+      match?(other) && other.sources == sources
+    end
+
+    alias_method :eql?, :==
+
+    def match?(other)
+      other.is_a?(self.class) && other.digest == digest && other.algo == algo
+    end
+
+    def hash
+      digest.hash
+    end
+
+    def to_s
+      "#{to_lock} (from #{sources.first}#{", ..." if sources.size > 1})"
+    end
+
+    def to_lock
+      "#{algo}#{ALGO_SEPARATOR}#{digest}"
+    end
+
+    def merge!(other)
+      return nil unless match?(other)
+      @sources.concat(other.sources).uniq!
+      self
+    end
+
+    def formatted_sources
+      sources.join("\n    and ").concat("\n")
+    end
+
+    def removable?
+      sources.all?(&:removable?)
+    end
+
+    def removal_instructions
+      msg = +""
+      i = 1
+      sources.each do |source|
+        msg << "  #{i}. #{source.removal}\n"
+        i += 1
+      end
+      msg << "  #{i}. run `bundle install`\n"
+    end
+
+    def inspect
+      abbr = "#{algo}#{ALGO_SEPARATOR}#{digest[0, 8]}"
+      from = "from #{sources.join(" and ")}"
+      "#<#{self.class}:#{object_id} #{abbr} #{from}>"
+    end
+
+    class Source
+      attr_reader :type, :location
+
+      def initialize(type, location)
+        @type = type
+        @location = location
+      end
+
+      def removable?
+        type == :lock || type == :gem
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.type == type && other.location == location
+      end
+
+      # phrased so that the usual string format is grammatically correct
+      #   rake (10.3.2) sha256=abc123 from #{to_s}
+      def to_s
+        case type
+        when :lock
+          "the lockfile CHECKSUMS at #{location}"
+        when :gem
+          "the gem at #{location}"
+        when :api
+          "the API at #{location}"
+        else
+          "#{location} (#{type})"
+        end
+      end
+
+      # A full sentence describing how to remove the checksum
+      def removal
+        case type
+        when :lock
+          "remove the matching checksum in #{location}"
+        when :gem
+          "remove the gem at #{location}"
+        when :api
+          "checksums from #{location} cannot be locally modified, you may need to update your sources"
+        else
+          "remove #{location} (#{type})"
+        end
+      end
+    end
+
+    class Store
+      attr_reader :store
+      protected :store
+
+      def initialize
+        @store = {}
+      end
+
+      def initialize_copy(other)
+        @store = {}
+        other.store.each do |lock_name, checksums|
+          store[lock_name] = checksums.dup
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} size=#{store.size}>"
+      end
+
+      def fetch(spec, algo = DEFAULT_ALGORITHM)
+        store[spec.name_tuple.lock_name]&.fetch(algo, nil)
+      end
+
+      # Replace when the new checksum is from the same source.
+      # The primary purpose of this registering checksums from gems where there are
+      # duplicates of the same gem (according to full_name) in the index.
+      # In particular, this is when 2 gems have two similar platforms, e.g.
+      # "darwin20" and "darwin-20", both of which resolve to darwin-20.
+      # In the Index, the later gem replaces the former, so we do that here.
+      #
+      # However, if the new checksum is from a different source, we register like normal.
+      # This ensures a mismatch error where there are multiple top level sources
+      # that contain the same gem with different checksums.
+      def replace(spec, checksum)
+        return unless checksum
+
+        lock_name = spec.name_tuple.lock_name
+        checksums = (store[lock_name] ||= {})
+        existing = checksums[checksum.algo]
+
+        # we assume only one source because this is used while building the index
+        if !existing || existing.sources.first == checksum.sources.first
+          checksums[checksum.algo] = checksum
+        else
+          register_checksum(lock_name, checksum)
+        end
+      end
+
+      def register(spec, checksum)
+        return unless checksum
+        register_checksum(spec.name_tuple.lock_name, checksum)
+      end
+
+      def merge!(other)
+        other.store.each do |lock_name, checksums|
+          checksums.each do |_algo, checksum|
+            register_checksum(lock_name, checksum)
+          end
+        end
+      end
+
+      def to_lock(spec)
+        lock_name = spec.name_tuple.lock_name
+        if checksums = store[lock_name]
+          "#{lock_name} #{checksums.values.map(&:to_lock).sort.join(",")}"
+        else
+          lock_name
+        end
+      end
+
+      private
+
+      def register_checksum(lock_name, checksum)
+        return unless checksum
+        checksums = (store[lock_name] ||= {})
+        existing = checksums[checksum.algo]
+
+        if !existing
+          checksums[checksum.algo] = checksum
+        elsif existing.merge!(checksum)
+          checksum
+        else
+          raise ChecksumMismatchError.new(lock_name, existing, checksum)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/ci_detector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bundler
+  module CIDetector
+    # NOTE: Any changes made here will need to be made to both lib/rubygems/ci_detector.rb and
+    # bundler/lib/bundler/ci_detector.rb (which are enforced duplicates).
+    # TODO: Drop that duplication once bundler drops support for RubyGems 3.4
+    #
+    # ## Recognized CI providers, their signifiers, and the relevant docs ##
+    #
+    # Travis CI   - CI, TRAVIS            https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+    # Cirrus CI   - CI, CIRRUS_CI         https://cirrus-ci.org/guide/writing-tasks/#environment-variables
+    # Circle CI   - CI, CIRCLECI          https://circleci.com/docs/variables/#built-in-environment-variables
+    # Gitlab CI   - CI, GITLAB_CI         https://docs.gitlab.com/ee/ci/variables/
+    # AppVeyor    - CI, APPVEYOR          https://www.appveyor.com/docs/environment-variables/
+    # CodeShip    - CI_NAME               https://docs.cloudbees.com/docs/cloudbees-codeship/latest/pro-builds-and-configuration/environment-variables#_default_environment_variables
+    # dsari       - CI, DSARI             https://github.com/rfinnie/dsari#running
+    # Jenkins     - BUILD_NUMBER          https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables
+    # TeamCity    - TEAMCITY_VERSION      https://www.jetbrains.com/help/teamcity/predefined-build-parameters.html#Predefined+Server+Build+Parameters
+    # Appflow     - CI_BUILD_ID           https://ionic.io/docs/appflow/automation/environments#predefined-environments
+    # TaskCluster - TASKCLUSTER_ROOT_URL  https://docs.taskcluster.net/docs/manual/design/env-vars
+    # Semaphore   - CI, SEMAPHORE         https://docs.semaphoreci.com/ci-cd-environment/environment-variables/
+    # BuildKite   - CI, BUILDKITE         https://buildkite.com/docs/pipelines/environment-variables
+    # GoCD        - GO_SERVER_URL         https://docs.gocd.org/current/faq/dev_use_current_revision_in_build.html
+    # GH Actions  - CI, GITHUB_ACTIONS    https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+    #
+    # ### Some "standard" ENVs that multiple providers may set ###
+    #
+    # * CI - this is set by _most_ (but not all) CI providers now; it's approaching a standard.
+    # * CI_NAME - Not as frequently used, but some providers set this to specify their own name
+
+    # Any of these being set is a reasonably reliable indicator that we are
+    # executing in a CI environment.
+    ENV_INDICATORS = [
+      "CI",
+      "CI_NAME",
+      "CONTINUOUS_INTEGRATION",
+      "BUILD_NUMBER",
+      "CI_APP_ID",
+      "CI_BUILD_ID",
+      "CI_BUILD_NUMBER",
+      "RUN_ID",
+      "TASKCLUSTER_ROOT_URL",
+    ].freeze
+
+    # For each CI, this env suffices to indicate that we're on _that_ CI's
+    # containers. (A few of them only supply a CI_NAME variable, which is also
+    # nice). And if they set "CI" but we can't tell which one they are, we also
+    # want to know that - a bare "ci" without another token tells us as much.
+    ENV_DESCRIPTORS = {
+      "TRAVIS" => "travis",
+      "CIRCLECI" => "circle",
+      "CIRRUS_CI" => "cirrus",
+      "DSARI" => "dsari",
+      "SEMAPHORE" => "semaphore",
+      "JENKINS_URL" => "jenkins",
+      "BUILDKITE" => "buildkite",
+      "GO_SERVER_URL" => "go",
+      "GITLAB_CI" => "gitlab",
+      "GITHUB_ACTIONS" => "github",
+      "TASKCLUSTER_ROOT_URL" => "taskcluster",
+      "CI" => "ci",
+    }.freeze
+
+    def self.ci?
+      ENV_INDICATORS.any? {|var| ENV.include?(var) }
+    end
+
+    def self.ci_strings
+      matching_names = ENV_DESCRIPTORS.select {|env, _| ENV[env] }.values
+      matching_names << ENV["CI_NAME"].downcase if ENV["CI_NAME"]
+      matching_names.reject(&:empty?).sort.uniq
+    end
+  end
+end

data/lib/bundler/cli/add.rb

@@ -28,9 +28,9 @@ module Bundler
       dependencies = gems.map {|g| Bundler::Dependency.new(g, version, options) }
 
       Injector.inject(dependencies,
-        :conservative_versioning => options[:version].nil?, # Perform conservative versioning only when version is not specified
-        :optimistic => options[:optimistic],
-        :strict => options[:strict])
+        conservative_versioning: options[:version].nil?, # Perform conservative versioning only when version is not specified
+        optimistic: options[:optimistic],
+        strict: options[:strict])
     end
 
     def validate_options!

data/lib/bundler/cli/binstubs.rb

@@ -17,9 +17,9 @@ module Bundler
       installer = Installer.new(Bundler.root, Bundler.definition)
 
       installer_opts = {
-        :force => options[:force],
-        :binstubs_cmd => true,
-        :all_platforms => options["all-platforms"],
+        force: options[:force],
+        binstubs_cmd: true,
+        all_platforms: options["all-platforms"],
       }
 
       if options[:all]
@@ -45,7 +45,7 @@ module Bundler
             next
           end
 
-          Bundler.settings.temporary(:path => (Bundler.settings[:path] || Bundler.root)) do
+          Bundler.settings.temporary(path: (Bundler.settings[:path] || Bundler.root)) do
             installer.generate_standalone_bundler_executable_stubs(spec, installer_opts)
           end
         else

data/lib/bundler/cli/cache.rb

@@ -19,7 +19,7 @@ module Bundler
       # TODO: move cache contents here now that all bundles are locked
       custom_path = Bundler.settings[:path] if options[:path]
 
-      Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do
+      Bundler.settings.temporary(cache_all_platforms: options["all-platforms"]) do
         Bundler.load.cache(custom_path)
       end
     end

data/lib/bundler/cli/check.rb

@@ -32,7 +32,7 @@ module Bundler
         Bundler.ui.error "This bundle has been frozen, but there is no #{SharedHelpers.relative_lockfile_path} present"
         exit 1
       else
-        Bundler.load.lock(:preserve_unknown_sections => true) unless options[:"dry-run"]
+        Bundler.load.lock(preserve_unknown_sections: true) unless options[:"dry-run"]
         Bundler.ui.info "The Gemfile's dependencies are satisfied"
       end
     end

data/lib/bundler/cli/common.rb

@@ -54,9 +54,12 @@ module Bundler
 
       Bundler.definition.specs.each do |spec|
         return spec if spec.name == name
-        specs << spec if regexp && spec.name =~ regexp
+        specs << spec if regexp && spec.name.match?(regexp)
       end
 
+      default_spec = default_gem_spec(name)
+      specs << default_spec if default_spec
+
       case specs.count
       when 0
         dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }
@@ -75,6 +78,11 @@ module Bundler
       raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
     end
 
+    def self.default_gem_spec(name)
+      gem_spec = Gem::Specification.find_all_by_name(name).last
+      gem_spec if gem_spec&.default_gem?
+    end
+
     def self.ask_for_spec_from(specs)
       specs.each_with_index do |spec, index|
         Bundler.ui.info "#{index.succ} : #{spec.name}", true

data/lib/bundler/cli/config.rb

@@ -2,17 +2,17 @@
 
 module Bundler
   class CLI::Config < Thor
-    class_option :parseable, :type => :boolean, :banner => "Use minimal formatting for more parseable output"
+    class_option :parseable, type: :boolean, banner: "Use minimal formatting for more parseable output"
 
     def self.scope_options
-      method_option :global, :type => :boolean, :banner => "Only change the global config"
-      method_option :local, :type => :boolean, :banner => "Only change the local config"
+      method_option :global, type: :boolean, banner: "Only change the global config"
+      method_option :local, type: :boolean, banner: "Only change the local config"
     end
     private_class_method :scope_options
 
-    desc "base NAME [VALUE]", "The Bundler 1 config interface", :hide => true
+    desc "base NAME [VALUE]", "The Bundler 1 config interface", hide: true
     scope_options
-    method_option :delete, :type => :boolean, :banner => "delete"
+    method_option :delete, type: :boolean, banner: "delete"
     def base(name = nil, *value)
       new_args =
         if ARGV.size == 1
@@ -25,8 +25,9 @@ module Bundler
           ["config", "get", ARGV[1]]
         end
 
-      SharedHelpers.major_deprecation 3,
-        "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
+      message = "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
+      removed_message = "Using the `config` command without a subcommand [list, get, set, unset] is has been removed. Use `bundle #{new_args.join(" ")}` instead."
+      SharedHelpers.major_deprecation 3, message, removed_message: removed_message
 
       Base.new(options, name, value, self).run
     end

data/lib/bundler/cli/console.rb

@@ -9,8 +9,9 @@ module Bundler
     end
 
     def run
-      Bundler::SharedHelpers.major_deprecation 2, "bundle console will be replaced " \
-                           "by `bin/console` generated by `bundle gem <name>`"
+      message = "bundle console will be replaced by `bin/console` generated by `bundle gem <name>`"
+      removed_message = "bundle console has been replaced by `bin/console` generated by `bundle gem <name>`"
+      Bundler::SharedHelpers.major_deprecation 2, message, removed_message: removed_message
 
       group ? Bundler.require(:default, *group.split(" ").map!(&:to_sym)) : Bundler.require
       ARGV.clear

data/lib/bundler/cli/doctor.rb

@@ -6,8 +6,8 @@ require "fiddle"
 
 module Bundler
   class CLI::Doctor
-    DARWIN_REGEX = /\s+(.+) \(compatibility /.freeze
-    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/.freeze
+    DARWIN_REGEX = /\s+(.+) \(compatibility /
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
 
     attr_reader :options
 

data/lib/bundler/cli/exec.rb

@@ -12,7 +12,7 @@ module Bundler
       @options = options
       @cmd = args.shift
       @args = args
-      @args << { :close_others => !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?
+      @args << { close_others: !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?
     end
 
     def run