bundler 2.3.25 → 2.4.4

data/lib/bundler/cli.rb

@@ -10,6 +10,7 @@ module Bundler
 
     AUTO_INSTALL_CMDS = %w[show binstubs outdated exec open console licenses clean].freeze
     PARSEABLE_COMMANDS = %w[check config help exec platform show version].freeze
+    EXTENSIONS = ["c", "rust"].freeze
 
     COMMAND_ALIASES = {
       "check" => "c",
@@ -22,6 +23,8 @@ module Bundler
     }.freeze
 
     def self.start(*)
+      check_deprecated_ext_option(ARGV) if ARGV.include?("--ext")
+
       super
     ensure
       Bundler::SharedHelpers.print_major_deprecations!
@@ -292,6 +295,8 @@ module Bundler
       "Prefer updating only to next minor version"
     method_option "major", :type => :boolean, :banner =>
       "Prefer updating to next major version (default)"
+    method_option "pre", :type => :boolean, :banner =>
+      "Always choose the highest allowed version when updating gems, regardless of prerelease status"
     method_option "strict", :type => :boolean, :banner =>
       "Do not allow any gem to be updated past latest --patch | --minor | --major"
     method_option "conservative", :type => :boolean, :banner =>
@@ -504,6 +509,7 @@ module Bundler
     subcommand "config", Config
 
     desc "open GEM", "Opens the source directory of the given bundled gem"
+    method_option "path", :type => :string, :lazy_default => "", :banner => "Open relative path of the gem source."
     def open(name)
       require_relative "cli/open"
       Open.new(options, name).run
@@ -574,7 +580,7 @@ module Bundler
     method_option :edit, :type => :string, :aliases => "-e", :required => false, :banner => "EDITOR",
                          :lazy_default => [ENV["BUNDLER_EDITOR"], ENV["VISUAL"], ENV["EDITOR"]].find {|e| !e.nil? && !e.empty? },
                          :desc => "Open generated gemspec in the specified editor (defaults to $EDITOR or $BUNDLER_EDITOR)"
-    method_option :ext, :type => :boolean, :default => false, :desc => "Generate the boilerplate for C extension code"
+    method_option :ext, :type => :string, :desc => "Generate the boilerplate for C extension code.", :enum => EXTENSIONS
     method_option :git, :type => :boolean, :default => true, :desc => "Initialize a git repo inside your library."
     method_option :mit, :type => :boolean, :desc => "Generate an MIT license file. Set a default with `bundle config set --global gem.mit true`."
     method_option :rubocop, :type => :boolean, :desc => "Add rubocop to the generated Rakefile and gemspec. Set a default with `bundle config set --global gem.rubocop true`."
@@ -582,7 +588,7 @@ module Bundler
     method_option :test, :type => :string, :lazy_default => Bundler.settings["gem.test"] || "", :aliases => "-t", :banner => "Use the specified test framework for your library",
                          :desc => "Generate a test directory for your library, either rspec, minitest or test-unit. Set a default with `bundle config set --global gem.test (rspec|minitest|test-unit)`."
     method_option :ci, :type => :string, :lazy_default => Bundler.settings["gem.ci"] || "",
-                       :desc => "Generate CI configuration, either GitHub Actions, Travis CI, GitLab CI or CircleCI. Set a default with `bundle config set --global gem.ci (github|travis|gitlab|circle)`"
+                       :desc => "Generate CI configuration, either GitHub Actions, GitLab CI or CircleCI. Set a default with `bundle config set --global gem.ci (github|gitlab|circle)`"
     method_option :linter, :type => :string, :lazy_default => Bundler.settings["gem.linter"] || "",
                            :desc => "Add a linter and code formatter, either RuboCop or Standard. Set a default with `bundle config set --global gem.linter (rubocop|standard)`"
     method_option :github_username, :type => :string, :default => Bundler.settings["gem.github_username"], :banner => "Set your username on GitHub", :desc => "Fill in GitHub username on README so that you don't have to do it manually. Set a default with `bundle config set --global gem.github_username <your_username>`."
@@ -620,7 +626,7 @@ module Bundler
     method_option "dry-run", :type => :boolean, :default => false, :banner =>
       "Only print out changes, do not clean gems"
     method_option "force", :type => :boolean, :default => false, :banner =>
-      "Forces clean even if --path is not set"
+      "Forces cleaning up unused gems even if Bundler is configured to use globally installed gems. As a consequence, removes all system gems except for the ones in the current application."
     def clean
       require_relative "cli/clean"
       Clean.new(options.dup).run
@@ -668,10 +674,14 @@ module Bundler
       "If updating, prefer updating only to next minor version"
     method_option "major", :type => :boolean, :banner =>
       "If updating, prefer updating to next major version (default)"
+    method_option "pre", :type => :boolean, :banner =>
+      "If updating, always choose the highest allowed version, regardless of prerelease status"
     method_option "strict", :type => :boolean, :banner =>
       "If updating, do not allow any gem to be updated past latest --patch | --minor | --major"
     method_option "conservative", :type => :boolean, :banner =>
       "If updating, use bundle install conservative update behavior and do not allow shared dependencies to be updated"
+    method_option "bundler", :type => :string, :lazy_default => "> 0.a", :banner =>
+      "Update the locked version of bundler"
     def lock
       require_relative "cli/lock"
       Lock.new(options).run
@@ -749,6 +759,38 @@ module Bundler
       end
     end
 
+    def self.check_deprecated_ext_option(arguments)
+      # when deprecated version of `--ext` is called
+      # print out deprecation warning and pretend `--ext=c` was provided
+      if deprecated_ext_value?(arguments)
+        SharedHelpers.major_deprecation 2, "Extensions can now be generated using C or Rust, so `--ext` with no arguments has been deprecated. Please select a language, e.g. `--ext=rust` to generate a Rust extension. This gem will now be generated as if `--ext=c` was used."
+        arguments[arguments.index("--ext")] = "--ext=c"
+      end
+    end
+
+    def self.deprecated_ext_value?(arguments)
+      index = arguments.index("--ext")
+      next_argument = arguments[index+1]
+
+      # it is ok when --ext is followed with valid extension value
+      # for example `bundle gem hello --ext c`
+      return false if EXTENSIONS.include?(next_argument)
+
+      # deprecated call when --ext is called with no value in last position
+      # for example `bundle gem hello_gem --ext`
+      return true if next_argument.nil?
+
+      # deprecated call when --ext is followed by other parameter
+      # for example `bundle gem --ext --no-ci hello_gem`
+      return true if next_argument.start_with?("-")
+
+      # deprecated call when --ext is followed by gem name
+      # for example `bundle gem --ext hello_gem`
+      return true if next_argument
+
+      false
+    end
+
     private
 
     # Automatically invoke `bundle install` and resume if

data/lib/bundler/compact_index_client/cache.rb

@@ -68,7 +68,7 @@ module Bundler
 
       def info_path(name)
         name = name.to_s
-        if name =~ /[^a-z0-9_-]/
+        if /[^a-z0-9_-]/.match?(name)
           name += "-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}"
           info_roots.last.join(name)
         else

data/lib/bundler/compact_index_client/updater.rb

@@ -20,63 +20,64 @@ module Bundler
 
       def initialize(fetcher)
         @fetcher = fetcher
-        require_relative "../vendored_tmpdir"
       end
 
       def update(local_path, remote_path, retrying = nil)
         headers = {}
 
-        Bundler::Dir.mktmpdir("bundler-compact-index-") do |local_temp_dir|
-          local_temp_path = Pathname.new(local_temp_dir).join(local_path.basename)
-
-          # first try to fetch any new bytes on the existing file
-          if retrying.nil? && local_path.file?
-            copy_file local_path, local_temp_path
-
-            headers["If-None-Match"] = etag_for(local_temp_path)
-            headers["Range"] =
-              if local_temp_path.size.nonzero?
-                # Subtract a byte to ensure the range won't be empty.
-                # Avoids 416 (Range Not Satisfiable) responses.
-                "bytes=#{local_temp_path.size - 1}-"
-              else
-                "bytes=#{local_temp_path.size}-"
-              end
-          end
+        local_temp_path = local_path.sub(/$/, ".#{$$}")
+        local_temp_path = local_temp_path.sub(/$/, ".retrying") if retrying
+        local_temp_path = local_temp_path.sub(/$/, ".tmp")
 
-          response = @fetcher.call(remote_path, headers)
-          return nil if response.is_a?(Net::HTTPNotModified)
+        # first try to fetch any new bytes on the existing file
+        if retrying.nil? && local_path.file?
+          copy_file local_path, local_temp_path
 
-          content = response.body
+          headers["If-None-Match"] = etag_for(local_temp_path)
+          headers["Range"] =
+            if local_temp_path.size.nonzero?
+              # Subtract a byte to ensure the range won't be empty.
+              # Avoids 416 (Range Not Satisfiable) responses.
+              "bytes=#{local_temp_path.size - 1}-"
+            else
+              "bytes=#{local_temp_path.size}-"
+            end
+        end
 
-          etag = (response["ETag"] || "").gsub(%r{\AW/}, "")
-          correct_response = SharedHelpers.filesystem_access(local_temp_path) do
-            if response.is_a?(Net::HTTPPartialContent) && local_temp_path.size.nonzero?
-              local_temp_path.open("a") {|f| f << slice_body(content, 1..-1) }
+        response = @fetcher.call(remote_path, headers)
+        return nil if response.is_a?(Net::HTTPNotModified)
 
-              etag_for(local_temp_path) == etag
-            else
-              local_temp_path.open("wb") {|f| f << content }
+        content = response.body
 
-              etag.length.zero? || etag_for(local_temp_path) == etag
-            end
-          end
+        etag = (response["ETag"] || "").gsub(%r{\AW/}, "")
+        correct_response = SharedHelpers.filesystem_access(local_temp_path) do
+          if response.is_a?(Net::HTTPPartialContent) && local_temp_path.size.nonzero?
+            local_temp_path.open("a") {|f| f << slice_body(content, 1..-1) }
 
-          if correct_response
-            SharedHelpers.filesystem_access(local_path) do
-              FileUtils.mv(local_temp_path, local_path)
-            end
-            return nil
+            etag_for(local_temp_path) == etag
+          else
+            local_temp_path.open("wb") {|f| f << content }
+
+            etag.length.zero? || etag_for(local_temp_path) == etag
           end
+        end
 
-          if retrying
-            raise MisMatchedChecksumError.new(remote_path, etag, etag_for(local_temp_path))
+        if correct_response
+          SharedHelpers.filesystem_access(local_path) do
+            FileUtils.mv(local_temp_path, local_path)
           end
+          return nil
+        end
 
-          update(local_path, remote_path, :retrying)
+        if retrying
+          raise MisMatchedChecksumError.new(remote_path, etag, etag_for(local_temp_path))
         end
+
+        update(local_path, remote_path, :retrying)
       rescue Zlib::GzipFile::Error
         raise Bundler::HTTPError
+      ensure
+        FileUtils.remove_file(local_temp_path) if File.exist?(local_temp_path)
       end
 
       def etag_for(path)

data/lib/bundler/constants.rb

@@ -2,6 +2,6 @@
 
 module Bundler
   WINDOWS = RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
-  FREEBSD = RbConfig::CONFIG["host_os"] =~ /bsd/
+  FREEBSD = RbConfig::CONFIG["host_os"].to_s.include?("bsd")
   NULL    = WINDOWS ? "NUL" : "/dev/null"
 end

data/lib/bundler/definition.rb

@@ -16,7 +16,6 @@ module Bundler
       :locked_deps,
       :locked_gems,
       :platforms,
-      :requires,
       :ruby_version,
       :lockfile,
       :gemfiles
@@ -80,6 +79,7 @@ module Bundler
       @locked_bundler_version = nil
       @locked_ruby_version    = nil
       @new_platform = nil
+      @removed_platform = nil
 
       if lockfile && File.exist?(lockfile)
         @lockfile_contents = Bundler.read_file(lockfile)
@@ -130,7 +130,7 @@ module Bundler
       end
       @unlocking ||= @unlock[:ruby] ||= (!@locked_ruby_version ^ !@ruby_version)
 
-      add_current_platform unless current_ruby_platform_locked? || Bundler.frozen_bundle?
+      add_current_platform unless Bundler.frozen_bundle?
 
       converge_path_sources_to_gemspec_sources
       @path_changes = converge_paths
@@ -146,11 +146,11 @@ module Bundler
       @dependency_changes = converge_dependencies
       @local_changes = converge_locals
 
-      @requires = compute_requires
+      @incomplete_lockfile = check_missing_lockfile_specs
     end
 
     def gem_version_promoter
-      @gem_version_promoter ||= GemVersionPromoter.new(@originally_locked_specs, @unlock[:gems])
+      @gem_version_promoter ||= GemVersionPromoter.new
     end
 
     def resolve_only_locally!
@@ -159,13 +159,6 @@ module Bundler
       resolve
     end
 
-    def resolve_prefering_local!
-      @prefer_local = true
-      @remote = true
-      sources.remote!
-      resolve
-    end
-
     def resolve_with_cache!
       sources.cached!
       resolve
@@ -177,6 +170,23 @@ module Bundler
       resolve
     end
 
+    def resolution_mode=(options)
+      if options["local"]
+        @remote = false
+      else
+        @remote = true
+        @prefer_local = options["prefer-local"]
+      end
+    end
+
+    def setup_sources_for_resolve
+      if @remote == false
+        sources.cached!
+      else
+        sources.remote!
+      end
+    end
+
     # For given dependency list returns a SpecSet with Gemspec of all the required
     # dependencies.
     #  1. The method first resolves the dependencies specified in Gemfile
@@ -264,19 +274,19 @@ module Bundler
         @locked_specs
       elsif !unlocking? && nothing_changed?
         if deleted_deps.any?
-          Bundler.ui.debug("Some dependencies were deleted, using a subset of the resolution from the lockfile")
+          Bundler.ui.debug "Some dependencies were deleted, using a subset of the resolution from the lockfile"
           SpecSet.new(filter_specs(@locked_specs, @dependencies - deleted_deps))
         else
-          Bundler.ui.debug("Found no changes, using resolution from the lockfile")
-          if @locked_gems.may_include_redundant_platform_specific_gems?
+          Bundler.ui.debug "Found no changes, using resolution from the lockfile"
+          if @removed_platform || @locked_gems.may_include_redundant_platform_specific_gems?
             SpecSet.new(filter_specs(@locked_specs, @dependencies))
           else
             @locked_specs
           end
         end
       else
-        Bundler.ui.debug("Found changes from the lockfile, re-resolving dependencies because #{change_reason}")
-        resolver.start(expanded_dependencies)
+        Bundler.ui.debug "Found changes from the lockfile, re-resolving dependencies because #{change_reason}"
+        start_resolution
       end
     end
 
@@ -295,11 +305,11 @@ module Bundler
 
       # Convert to \r\n if the existing lock has them
       # i.e., Windows with `git config core.autocrlf=true`
-      contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n")
+      contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match?("\r\n")
 
       if @locked_bundler_version
         locked_major = @locked_bundler_version.segments.first
-        current_major = Gem::Version.create(Bundler::VERSION).segments.first
+        current_major = Bundler.gem_version.segments.first
 
         updating_major = locked_major < current_major
       end
@@ -447,7 +457,9 @@ module Bundler
     end
 
     def remove_platform(platform)
-      return if @platforms.delete(Gem::Platform.new(platform))
+      removed_platform = @platforms.delete(Gem::Platform.new(platform))
+      @removed_platform ||= removed_platform
+      return if removed_platform
       raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"
     end
 
@@ -461,7 +473,7 @@ module Bundler
     private :sources
 
     def nothing_changed?
-      !@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes
+      !@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes && !@incomplete_lockfile
     end
 
     def unlocking?
@@ -471,17 +483,22 @@ module Bundler
     private
 
     def resolver
-      @resolver ||= begin
-        last_resolve = converge_locked_specs
-        remove_ruby_from_platforms_if_necessary!(current_dependencies)
-        Resolver.new(source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve(last_resolve), platforms)
-      end
+      @resolver ||= Resolver.new(resolution_packages, gem_version_promoter)
     end
 
     def expanded_dependencies
       @expanded_dependencies ||= dependencies + metadata_dependencies
     end
 
+    def resolution_packages
+      @resolution_packages ||= begin
+        last_resolve = converge_locked_specs
+        remove_ruby_from_platforms_if_necessary!(current_dependencies)
+        packages = Resolver::Base.new(source_requirements, expanded_dependencies, last_resolve, @platforms, :locked_specs => @originally_locked_specs, :unlock => @unlock[:gems], :prerelease => gem_version_promoter.pre?)
+        additional_base_requirements_for_resolve(packages, last_resolve)
+      end
+    end
+
     def filter_specs(specs, deps)
       SpecSet.new(specs).for(deps, false, platforms)
     end
@@ -507,21 +524,38 @@ module Bundler
         raise GemNotFound, "Could not find #{missing_specs_list.join(" nor ")}"
       end
 
+      incomplete_specs = specs.incomplete_specs
       loop do
-        incomplete_specs = specs.incomplete_specs
         break if incomplete_specs.empty?
 
         Bundler.ui.debug("The lockfile does not have all gems needed for the current platform though, Bundler will still re-resolve dependencies")
-        @resolve = resolver.start(expanded_dependencies, :exclude_specs => incomplete_specs)
+        setup_sources_for_resolve
+        resolution_packages.delete(incomplete_specs)
+        @resolve = start_resolution
         specs = resolve.materialize(dependencies)
+
+        still_incomplete_specs = specs.incomplete_specs
+
+        if still_incomplete_specs == incomplete_specs
+          package = resolution_packages.get_package(incomplete_specs.first.name)
+          resolver.raise_not_found! package
+        end
+
+        incomplete_specs = still_incomplete_specs
       end
 
-      bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last
+      bundler = sources.metadata_source.specs.search(["bundler", Bundler.gem_version]).last
       specs["bundler"] = bundler
 
       specs
     end
 
+    def start_resolution
+      result = resolver.start(expanded_dependencies)
+
+      SpecSet.new(SpecSet.new(result).for(dependencies, false, @platforms))
+    end
+
     def precompute_source_requirements_for_indirect_dependencies?
       @remote && sources.non_global_rubygems_sources.all?(&:dependency_api_available?) && !sources.aggregate_global_source?
     end
@@ -553,6 +587,8 @@ module Bundler
     end
 
     def add_current_platform
+      return if current_ruby_platform_locked?
+
       add_platform(local_platform)
     end
 
@@ -574,6 +610,7 @@ module Bundler
         [@new_platform, "you added a new platform to your gemfile"],
         [@path_changes, "the gemspecs for path gems changed"],
         [@local_changes, "the gemspecs for git local gems changed"],
+        [@incomplete_lockfile, "your lock file is missing some gems"],
       ].select(&:first).map(&:last).join(", ")
     end
 
@@ -628,6 +665,14 @@ module Bundler
       !sources_with_changes.each {|source| @unlock[:sources] << source.name }.empty?
     end
 
+    def check_missing_lockfile_specs
+      all_locked_specs = @locked_specs.map(&:name) << "bundler"
+
+      @locked_specs.any? do |s|
+        s.dependencies.any? {|dep| !all_locked_specs.include?(dep.name) }
+      end
+    end
+
     def converge_paths
       sources.path_sources.any? do |source|
         specs_changed?(source)
@@ -766,12 +811,13 @@ module Bundler
           end
 
           new_spec = new_specs[s].first
-
-          # If the spec is no longer in the path source, unlock it. This
-          # commonly happens if the version changed in the gemspec
-          next unless new_spec
-
-          s.dependencies.replace(new_spec.dependencies)
+          if new_spec
+            s.dependencies.replace(new_spec.dependencies)
+          else
+            # If the spec is no longer in the path source, unlock it. This
+            # commonly happens if the version changed in the gemspec
+            @unlock[:gems] << s.name
+          end
         end
 
         if dep.nil? && requested_dependencies.find {|d| s.name == d.name }
@@ -839,22 +885,12 @@ module Bundler
       current == proposed
     end
 
-    def compute_requires
-      dependencies.reduce({}) do |requires, dep|
-        next requires unless dep.should_include?
-        requires[dep.name] = Array(dep.autorequire || dep.name).map do |file|
-          # Allow `require: true` as an alias for `require: <name>`
-          file == true ? dep.name : file
-        end
-        requires
+    def additional_base_requirements_for_resolve(resolution_packages, last_resolve)
+      return resolution_packages unless @locked_gems && unlocking? && !sources.expired_sources?(@locked_gems.sources)
+      converge_specs(@originally_locked_specs - last_resolve).each do |locked_spec|
+        resolution_packages.base_requirements[locked_spec.name] = Gem::Requirement.new(">= #{locked_spec.version}")
       end
-    end
-
-    def additional_base_requirements_for_resolve(last_resolve)
-      return [] unless @locked_gems && unlocking? && !sources.expired_sources?(@locked_gems.sources)
-      converge_specs(@originally_locked_specs - last_resolve).map do |locked_spec|
-        Dependency.new(locked_spec.name, ">= #{locked_spec.version}")
-      end.uniq
+      resolution_packages
     end
 
     def remove_ruby_from_platforms_if_necessary!(dependencies)

data/lib/bundler/dependency.rb

@@ -7,20 +7,20 @@ require_relative "rubygems_ext"
 module Bundler
   class Dependency < Gem::Dependency
     attr_reader :autorequire
-    attr_reader :groups, :platforms, :gemfile, :path, :git, :github, :branch, :ref, :force_ruby_platform
+    attr_reader :groups, :platforms, :gemfile, :path, :git, :github, :branch, :ref
 
     ALL_RUBY_VERSIONS = ((18..27).to_a + (30..31).to_a).freeze
     PLATFORM_MAP = {
-      :ruby        => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
-      :mri         => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
-      :rbx         => [Gem::Platform::RUBY],
+      :ruby => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
+      :mri => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
+      :rbx => [Gem::Platform::RUBY],
       :truffleruby => [Gem::Platform::RUBY],
-      :jruby       => [Gem::Platform::JAVA, [18, 19]],
-      :windows     => [Gem::Platform::WINDOWS, ALL_RUBY_VERSIONS],
-      :mswin       => [Gem::Platform::MSWIN,     ALL_RUBY_VERSIONS],
-      :mswin64     => [Gem::Platform::MSWIN64,   ALL_RUBY_VERSIONS - [18]],
-      :mingw       => [Gem::Platform::MINGW,     ALL_RUBY_VERSIONS],
-      :x64_mingw   => [Gem::Platform::X64_MINGW, ALL_RUBY_VERSIONS - [18, 19]],
+      :jruby => [Gem::Platform::JAVA, [18, 19]],
+      :windows => [Gem::Platform::WINDOWS, ALL_RUBY_VERSIONS],
+      :mswin => [Gem::Platform::MSWIN,     ALL_RUBY_VERSIONS],
+      :mswin64 => [Gem::Platform::MSWIN64, ALL_RUBY_VERSIONS - [18]],
+      :mingw => [Gem::Platform::MINGW, ALL_RUBY_VERSIONS],
+      :x64_mingw => [Gem::Platform::X64_MINGW, ALL_RUBY_VERSIONS - [18, 19]],
     }.each_with_object({}) do |(platform, spec), hash|
       hash[platform] = spec[0]
       spec[1]&.each {|version| hash[:"#{platform}_#{version}"] = spec[0] }
@@ -42,7 +42,7 @@ module Bundler
       @env            = options["env"]
       @should_include = options.fetch("should_include", true)
       @gemfile        = options["gemfile"]
-      @force_ruby_platform = options["force_ruby_platform"]
+      @force_ruby_platform = options["force_ruby_platform"] if options.key?("force_ruby_platform")
 
       @autorequire = Array(options["require"] || []) if options.key?("require")
     end
@@ -50,6 +50,7 @@ module Bundler
     # Returns the platforms this dependency is valid for, in the same order as
     # passed in the `valid_platforms` parameter
     def gem_platforms(valid_platforms)
+      return [Gem::Platform::RUBY] if force_ruby_platform
       return valid_platforms if @platforms.empty?
 
       valid_platforms.select {|p| expanded_platforms.include?(GemHelpers.generic(p)) }

data/lib/bundler/digest.rb

@@ -43,7 +43,7 @@ module Bundler
               f = (b ^ c ^ d)
               k = 0xCA62C1D6
             end
-            t = SHA1_MASK & (SHA1_MASK & rotate(a, 5) + f + e + k + w[i])
+            t = SHA1_MASK & rotate(a, 5) + f + e + k + w[i]
             a, b, c, d, e = t, a, SHA1_MASK & rotate(b, 30), c, d # rubocop:disable Style/ParallelAssignment
           end
           mutated = [a, b, c, d, e]

data/lib/bundler/dsl.rb

@@ -277,8 +277,8 @@ module Bundler
         if repo_name =~ GITHUB_PULL_REQUEST_URL
           {
             "git" => "https://github.com/#{$1}.git",
-            "branch" => "refs/pull/#{$2}/head",
-            "ref" => nil,
+            "branch" => nil,
+            "ref" => "refs/pull/#{$2}/head",
             "tag" => nil,
           }
         else
@@ -324,7 +324,7 @@ module Bundler
       if name.is_a?(Symbol)
         raise GemfileError, %(You need to specify gem names as Strings. Use 'gem "#{name}"' instead)
       end
-      if name =~ /\s/
+      if /\s/.match?(name)
         raise GemfileError, %('#{name}' is not a valid gem name because it contains whitespace)
       end
       raise GemfileError, %(an empty gem name is not valid) if name.empty?

data/lib/bundler/env.rb

@@ -75,7 +75,7 @@ module Bundler
     end
 
     def self.git_version
-      Bundler::Source::Git::GitProxy.new(nil, nil, nil).full_version
+      Bundler::Source::Git::GitProxy.new(nil, nil).full_version
     rescue Bundler::Source::Git::GitNotInstalledError
       "not installed"
     end

data/lib/bundler/environment_preserver.rb

@@ -7,6 +7,7 @@ module Bundler
       BUNDLE_BIN_PATH
       BUNDLE_GEMFILE
       BUNDLER_VERSION
+      BUNDLER_SETUP
       GEM_HOME
       GEM_PATH
       MANPATH

data/lib/bundler/errors.rb

@@ -21,16 +21,7 @@ module Bundler
   class InstallError < BundlerError; status_code(5); end
 
   # Internal error, should be rescued
-  class VersionConflict < BundlerError
-    attr_reader :conflicts
-
-    def initialize(conflicts, msg = nil)
-      super(msg)
-      @conflicts = conflicts
-    end
-
-    status_code(6)
-  end
+  class SolveFailure < BundlerError; status_code(6); end
 
   class GemNotFound < BundlerError; status_code(7); end
   class InstallHookError < BundlerError; status_code(8); end
@@ -55,7 +46,6 @@ module Bundler
   class CyclicDependencyError < BundlerError; status_code(21); end
   class GemfileLockNotFound < BundlerError; status_code(22); end
   class PluginError < BundlerError; status_code(29); end
-  class SudoNotPermittedError < BundlerError; status_code(30); end
   class ThreadCreationError < BundlerError; status_code(33); end
   class APIResponseMismatchError < BundlerError; status_code(34); end
   class APIResponseInvalidDependenciesError < BundlerError; status_code(35); end