bundler 2.3.22 → 2.3.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57a888ea873d637d14016b9e9ba7aab35e1421c3f24b9c1b024ccab52c8137eb
-  data.tar.gz: 767816ae891334d340fadfcce3984622b7b80706b6a46a9e389ac1998a53e825
+  metadata.gz: 93ffee8ad1f220af763c61669d7c2d3c3418a739e9dbba73ba044a0c98ea3c22
+  data.tar.gz: 5c78c181609081cc9bea18f9adea9afc4700cf4a063fdd671cc612dd1c54bafb
 SHA512:
-  metadata.gz: f70a84e9f3fa6d2e0b88a18b1c66907817e9806e40fc28cb96838e5f07d83176333ce66ba3a03d3a0e5516e03e256fcf520de33a89dceb99080e521cecb853f2
-  data.tar.gz: 014bf59ac564877632a885c2c6c197bb71d16fdff3e1c5f81c8e3716b940b11def6b77de85b2acde7174425fd6439ddfefab73c661f7d8ff8398bbe483fd6b7a
+  metadata.gz: 8ed7a7e5a517df4814a6be035c193e82d28c349adbd100d5e327fb0093a061175bd089ef5a97c5da502f5040135d7585da30daae59d125cd0cec7f96642eb2a6
+  data.tar.gz: 5a48f92f2c763d8ed20f6a341f946fc6e1ef8c3ce266d47332714459ea09eb78ac349f281fe7b20350c8f43d9c0ec71d32ee11fe288415beb41f18e4570ffa4d

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+# 2.3.24 (October 17, 2022)
+
+## Enhancements:
+
+  - Only add extra resolver spec group for Ruby platform when needed [#5698](https://github.com/rubygems/rubygems/pull/5698)
+  - Fix little UI issue when bundler shows duplicated gems in a list [#5965](https://github.com/rubygems/rubygems/pull/5965)
+
+## Bug fixes:
+
+  - Fix incorrect materialization on Windows [#5975](https://github.com/rubygems/rubygems/pull/5975)
+
+# 2.3.23 (October 5, 2022)
+
+## Enhancements:
+
+  - Update GitLab CI template with new one [#5944](https://github.com/rubygems/rubygems/pull/5944)
+
+## Bug fixes:
+
+  - Fix `bundle init` not respecting umask in generated gem's Gemfile [#5947](https://github.com/rubygems/rubygems/pull/5947)
+
+## Performance:
+
+  - Further speed up Bundler by not sorting specs unnecessarily [#5868](https://github.com/rubygems/rubygems/pull/5868)
+
+## Documentation:
+
+  - Update Bundler new feature instructions [#5912](https://github.com/rubygems/rubygems/pull/5912)
+
 # 2.3.22 (September 7, 2022)
 
 ## Enhancements:

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 = "2022-09-07".freeze
-    @git_commit_sha = "44fb4c9ef5".freeze
+    @built_at = "2022-10-17".freeze
+    @git_commit_sha = "b835c7ea15".freeze
     @release = true
     # end ivars
 

data/lib/bundler/cli/init.rb

@@ -32,7 +32,11 @@ module Bundler
           file << spec.to_gemfile
         end
       else
-        FileUtils.cp(File.expand_path("../templates/#{gemfile}", __dir__), gemfile)
+        File.open(File.expand_path("../templates/#{gemfile}", __dir__), "r") do |template|
+          File.open(gemfile, "wb") do |destination|
+            IO.copy_stream(template, destination)
+          end
+        end
       end
 
       puts "Writing new #{gemfile} to #{SharedHelpers.pwd}/#{gemfile}"

data/lib/bundler/definition.rb

@@ -106,6 +106,7 @@ module Bundler
         @locked_gems    = nil
         @locked_deps    = {}
         @locked_specs   = SpecSet.new([])
+        @originally_locked_specs = @locked_specs
         @locked_sources = []
         @locked_platforms = []
       end
@@ -138,8 +139,8 @@ module Bundler
       if @unlock[:conservative]
         @unlock[:gems] ||= @dependencies.map(&:name)
       else
-        eager_unlock = expand_dependencies(@unlock[:gems] || [], true)
-        @unlock[:gems] = @locked_specs.for(eager_unlock, false, platforms).map(&:name)
+        eager_unlock = (@unlock[:gems] || []).map {|name| Dependency.new(name, ">= 0") }
+        @unlock[:gems] = @locked_specs.for(eager_unlock, false, platforms).map(&:name).uniq
       end
 
       @dependency_changes = converge_dependencies
@@ -149,18 +150,7 @@ module Bundler
     end
 
     def gem_version_promoter
-      @gem_version_promoter ||= begin
-        locked_specs =
-          if unlocking? && @locked_specs.empty? && !@lockfile_contents.empty?
-            # Definition uses an empty set of locked_specs to indicate all gems
-            # are unlocked, but GemVersionPromoter needs the locked_specs
-            # for conservative comparison.
-            Bundler::SpecSet.new(@locked_gems.specs)
-          else
-            @locked_specs
-          end
-        GemVersionPromoter.new(locked_specs, @unlock[:gems])
-      end
+      @gem_version_promoter ||= GemVersionPromoter.new(@originally_locked_specs, @unlock[:gems])
     end
 
     def resolve_only_locally!
@@ -234,7 +224,7 @@ module Bundler
 
     def current_dependencies
       dependencies.select do |d|
-        d.should_include? && !d.gem_platforms(@platforms).empty?
+        d.should_include? && !d.gem_platforms([generic_local_platform]).empty?
       end
     end
 
@@ -258,10 +248,9 @@ module Bundler
 
     def dependencies_for(groups)
       groups.map!(&:to_sym)
-      deps = current_dependencies.reject do |d|
+      current_dependencies.reject do |d|
         (d.groups & groups).empty?
       end
-      expand_dependencies(deps)
     end
 
     # Resolve all the dependencies specified in Gemfile. It ensures that
@@ -484,17 +473,17 @@ module Bundler
     def resolver
       @resolver ||= begin
         last_resolve = converge_locked_specs
-        remove_ruby_from_platforms_if_necessary!(dependencies)
+        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
     end
 
     def expanded_dependencies
-      @expanded_dependencies ||= expand_dependencies(dependencies + metadata_dependencies, true)
+      @expanded_dependencies ||= dependencies + metadata_dependencies
     end
 
     def filter_specs(specs, deps)
-      SpecSet.new(specs).for(expand_dependencies(deps, true), false, platforms)
+      SpecSet.new(specs).for(deps, false, platforms)
     end
 
     def materialize(dependencies)
@@ -588,8 +577,8 @@ module Bundler
       ].select(&:first).map(&:last).join(", ")
     end
 
-    def pretty_dep(dep, source = false)
-      SharedHelpers.pretty_dependency(dep, source)
+    def pretty_dep(dep)
+      SharedHelpers.pretty_dependency(dep)
     end
 
     # Check if the specs of the given source changed
@@ -802,23 +791,6 @@ module Bundler
       ]
     end
 
-    def expand_dependencies(dependencies, remote = false)
-      deps = []
-      dependencies.each do |dep|
-        dep = Dependency.new(dep, ">= 0") unless dep.respond_to?(:name)
-        next unless remote || dep.current_platform?
-        target_platforms = dep.gem_platforms(remote ? @platforms : [generic_local_platform])
-        deps += expand_dependency_with_platforms(dep, target_platforms)
-      end
-      deps
-    end
-
-    def expand_dependency_with_platforms(dep, platforms)
-      platforms.map do |p|
-        DepProxy.get_proxy(dep, p)
-      end
-    end
-
     def source_requirements
       # Record the specs available in each gem's source, so that those
       # specs will be available later when the resolver knows where to
@@ -890,7 +862,7 @@ module Bundler
                 Bundler.local_platform == Gem::Platform::RUBY ||
                 !platforms.include?(Gem::Platform::RUBY) ||
                 (@new_platform && platforms.last == Gem::Platform::RUBY) ||
-                !@originally_locked_specs.incomplete_ruby_specs?(expand_dependencies(dependencies))
+                !@originally_locked_specs.incomplete_ruby_specs?(dependencies)
 
       remove_platform(Gem::Platform::RUBY)
       add_current_platform

data/lib/bundler/dsl.rb

@@ -67,7 +67,6 @@ module Bundler
 
       gemspecs = Gem::Util.glob_files_in_dir("{,*}.gemspec", expanded_path).map {|g| Bundler.load_gemspec(g) }.compact
       gemspecs.reject! {|s| s.name != name } if name
-      Index.sort_specs(gemspecs)
       specs_by_name_and_version = gemspecs.group_by {|s| [s.name, s.version] }
 
       case specs_by_name_and_version.size

data/lib/bundler/endpoint_specification.rb

@@ -26,6 +26,10 @@ module Bundler
       @platform
     end
 
+    def identifier
+      @__identifier ||= [name, version, platform.to_s]
+    end
+
     # needed for standalone, load required_paths from local gemspec
     # after the gem is installed
     def require_paths

data/lib/bundler/gem_helpers.rb

@@ -5,7 +5,6 @@ module Bundler
     GENERIC_CACHE = { Gem::Platform::RUBY => Gem::Platform::RUBY } # rubocop:disable Style/MutableConstant
     GENERICS = [
       [Gem::Platform.new("java"), Gem::Platform.new("java")],
-      [Gem::Platform.new("universal-java"), Gem::Platform.new("java")],
       [Gem::Platform.new("mswin32"), Gem::Platform.new("mswin32")],
       [Gem::Platform.new("mswin64"), Gem::Platform.new("mswin64")],
       [Gem::Platform.new("universal-mingw32"), Gem::Platform.new("universal-mingw32")],

data/lib/bundler/gem_version_promoter.rb

@@ -116,15 +116,14 @@ module Bundler
     end
 
     def sort_dep_specs(spec_groups, locked_spec)
-      return spec_groups unless locked_spec
-      @gem_name = locked_spec.name
-      @locked_version = locked_spec.version
+      @locked_version = locked_spec&.version
+      @gem_name = locked_spec&.name
 
       result = spec_groups.sort do |a, b|
         @a_ver = a.version
         @b_ver = b.version
 
-        unless @prerelease_specified[@gem_name]
+        unless @gem_name && @prerelease_specified[@gem_name]
           a_pre = @a_ver.prerelease?
           b_pre = @b_ver.prerelease?
 
@@ -148,7 +147,7 @@ module Bundler
     end
 
     def either_version_older_than_locked
-      @a_ver < @locked_version || @b_ver < @locked_version
+      @locked_version && (@a_ver < @locked_version || @b_ver < @locked_version)
     end
 
     def segments_do_not_match(level)
@@ -157,7 +156,7 @@ module Bundler
     end
 
     def unlocking_gem?
-      unlock_gems.empty? || unlock_gems.include?(@gem_name)
+      unlock_gems.empty? || (@gem_name && unlock_gems.include?(@gem_name))
     end
 
     # Specific version moves can't always reliably be done during sorting
@@ -165,7 +164,7 @@ module Bundler
     def post_sort(result)
       # default :major behavior in Bundler does not do this
       return result if major?
-      if unlocking_gem?
+      if unlocking_gem? || @locked_version.nil?
         result
       else
         move_version_to_end(result, @locked_version)

data/lib/bundler/index.rb

@@ -57,36 +57,13 @@ module Bundler
     # Search this index's specs, and any source indexes that this index knows
     # about, returning all of the results.
     def search(query)
-      sort_specs(unsorted_search(query))
-    end
-
-    def unsorted_search(query)
       results = local_search(query)
-
-      seen = results.map(&:full_name).uniq unless @sources.empty?
+      return results unless @sources.any?
 
       @sources.each do |source|
-        source.unsorted_search(query).each do |spec|
-          next if seen.include?(spec.full_name)
-
-          seen << spec.full_name
-          results << spec
-        end
+        results.concat(source.search(query))
       end
-
-      results
-    end
-    protected :unsorted_search
-
-    def self.sort_specs(specs)
-      specs.sort_by do |s|
-        platform_string = s.platform.to_s
-        [s.version, platform_string == RUBY ? NULL : platform_string]
-      end
-    end
-
-    def sort_specs(specs)
-      self.class.sort_specs(specs)
+      results.uniq(&:full_name)
     end
 
     def local_search(query)
@@ -94,7 +71,6 @@ module Bundler
       when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
       when String then specs_by_name(query)
       when Gem::Dependency then search_by_dependency(query)
-      when DepProxy then search_by_dependency(query.dep)
       else
         raise "You can't search for a #{query.inspect}."
       end

data/lib/bundler/injector.rb

@@ -70,7 +70,7 @@ module Bundler
 
         show_warning("No gems were removed from the gemfile.") if deps.empty?
 
-        deps.each {|dep| Bundler.ui.confirm "#{SharedHelpers.pretty_dependency(dep, false)} was removed." }
+        deps.each {|dep| Bundler.ui.confirm "#{SharedHelpers.pretty_dependency(dep)} was removed." }
       end
 
       # Invalidate the cached Bundler.definition.

data/lib/bundler/lazy_specification.rb

@@ -77,7 +77,7 @@ module Bundler
       source.local!
 
       candidates = if source.is_a?(Source::Path) || !ruby_platform_materializes_to_ruby_platform?
-        target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : Bundler.local_platform
+        target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : local_platform
 
         source.specs.search(Dependency.new(name, version)).select do |spec|
           MatchPlatform.platforms_match?(spec.platform, target_platform)
@@ -120,7 +120,7 @@ module Bundler
     end
 
     def identifier
-      @__identifier ||= [name, version, platform_string]
+      @__identifier ||= [name, version, platform.to_s]
     end
 
     def git_version
@@ -128,13 +128,6 @@ module Bundler
       " #{source.revision[0..6]}"
     end
 
-    protected
-
-    def platform_string
-      platform_string = platform.to_s
-      platform_string == Index::RUBY ? Index::NULL : platform_string
-    end
-
     private
 
     def to_ary
@@ -151,7 +144,8 @@ module Bundler
 
     #
     # For backwards compatibility with existing lockfiles, if the most specific
-    # locked platform is RUBY, we keep the previous behaviour of resolving the
+    # locked platform is not a specific platform like x86_64-linux or
+    # universal-java-11, then we keep the previous behaviour of resolving the
     # best platform variant at materiliazation time. For previous bundler
     # versions (before 2.2.0) this was always the case (except when the lockfile
     # only included non-ruby platforms), but we're also keeping this behaviour
@@ -159,7 +153,9 @@ module Bundler
     # explicitly add a more specific platform.
     #
     def ruby_platform_materializes_to_ruby_platform?
-      !Bundler.most_specific_locked_platform?(generic_local_platform) || force_ruby_platform || Bundler.settings[:force_ruby_platform]
+      generic_platform = generic_local_platform == Gem::Platform::JAVA ? Gem::Platform::JAVA : Gem::Platform::RUBY
+
+      !Bundler.most_specific_locked_platform?(generic_platform) || force_ruby_platform || Bundler.settings[:force_ruby_platform]
     end
   end
 end

data/lib/bundler/remote_specification.rb

@@ -29,11 +29,15 @@ module Bundler
       @platform = _remote_specification.platform
     end
 
+    def identifier
+      @__identifier ||= [name, version, @platform.to_s]
+    end
+
     def full_name
-      if @original_platform == Gem::Platform::RUBY
+      if @platform == Gem::Platform::RUBY
         "#{@name}-#{@version}"
       else
-        "#{@name}-#{@version}-#{@original_platform}"
+        "#{@name}-#{@version}-#{@platform}"
       end
     end
 

data/lib/bundler/resolver/base.rb

@@ -40,7 +40,7 @@ module Bundler
         base_requirements = {}
         @base.each do |ls|
           dep = Dependency.new(ls.name, ls.version)
-          base_requirements[ls.name] = DepProxy.get_proxy(dep, ls.platform)
+          base_requirements[ls.name] = dep
         end
         @additional_base_requirements.each {|d| base_requirements[d.name] = d }
         base_requirements

data/lib/bundler/resolver/spec_group.rb

@@ -6,40 +6,23 @@ module Bundler
       attr_accessor :name, :version, :source
       attr_accessor :activated_platforms, :force_ruby_platform
 
-      def self.create_for(specs, all_platforms, specific_platform)
-        specific_platform_specs = specs[specific_platform]
-        return unless specific_platform_specs.any?
-
-        platforms = all_platforms.select {|p| specs[p].any? }
-
-        new(specific_platform_specs.first, specs, platforms)
-      end
-
-      def initialize(exemplary_spec, specs, relevant_platforms)
-        @exemplary_spec = exemplary_spec
-        @name = exemplary_spec.name
-        @version = exemplary_spec.version
-        @source = exemplary_spec.source
+      def initialize(specs, relevant_platforms)
+        @exemplary_spec = specs.first
+        @name = @exemplary_spec.name
+        @version = @exemplary_spec.version
+        @source = @exemplary_spec.source
 
         @activated_platforms = relevant_platforms
-        @dependencies = Hash.new do |dependencies, platforms|
-          dependencies[platforms] = dependencies_for(platforms)
-        end
         @specs = specs
       end
 
       def to_specs
-        activated_platforms.map do |p|
-          specs = @specs[p]
-          next unless specs.any?
-
-          specs.map do |s|
-            lazy_spec = LazySpecification.new(name, version, s.platform, source)
-            lazy_spec.force_ruby_platform = force_ruby_platform
-            lazy_spec.dependencies.replace s.dependencies
-            lazy_spec
-          end
-        end.flatten.compact.uniq
+        @specs.map do |s|
+          lazy_spec = LazySpecification.new(name, version, s.platform, source)
+          lazy_spec.force_ruby_platform = force_ruby_platform
+          lazy_spec.dependencies.replace s.dependencies
+          lazy_spec
+        end
       end
 
       def to_s
@@ -48,7 +31,9 @@ module Bundler
       end
 
       def dependencies_for_activated_platforms
-        @dependencies[activated_platforms]
+        @dependencies_for_activated_platforms ||= @specs.map do |spec|
+          __dependencies(spec) + metadata_dependencies(spec)
+        end.flatten.uniq
       end
 
       def ==(other)
@@ -79,35 +64,28 @@ module Bundler
 
       private
 
-      def dependencies_for(platforms)
-        platforms.map do |platform|
-          __dependencies(platform) + metadata_dependencies(platform)
-        end.flatten
-      end
-
-      def __dependencies(platform)
+      def __dependencies(spec)
         dependencies = []
-        @specs[platform].first.dependencies.each do |dep|
+        spec.dependencies.each do |dep|
           next if dep.type == :development
-          dependencies << DepProxy.get_proxy(Dependency.new(dep.name, dep.requirement), platform)
+          dependencies << Dependency.new(dep.name, dep.requirement)
         end
         dependencies
       end
 
-      def metadata_dependencies(platform)
-        spec = @specs[platform].first
+      def metadata_dependencies(spec)
         return [] if spec.is_a?(LazySpecification)
 
         [
-          metadata_dependency("Ruby", spec.required_ruby_version, platform),
-          metadata_dependency("RubyGems", spec.required_rubygems_version, platform),
+          metadata_dependency("Ruby", spec.required_ruby_version),
+          metadata_dependency("RubyGems", spec.required_rubygems_version),
         ].compact
       end
 
-      def metadata_dependency(name, requirement, platform)
+      def metadata_dependency(name, requirement)
         return if requirement.nil? || requirement.none?
 
-        DepProxy.get_proxy(Dependency.new("#{name}\0", requirement), platform)
+        Dependency.new("#{name}\0", requirement)
       end
     end
   end

data/lib/bundler/resolver.rb

@@ -8,22 +8,6 @@ module Bundler
 
     include GemHelpers
 
-    # Figures out the best possible configuration of gems that satisfies
-    # the list of passed dependencies and any child dependencies without
-    # causing any gem activation errors.
-    #
-    # ==== Parameters
-    # *dependencies<Gem::Dependency>:: The list of dependencies to resolve
-    #
-    # ==== Returns
-    # <GemBundle>,nil:: If the list of dependencies can be resolved, a
-    #   collection of gemspecs is returned. Otherwise, nil is returned.
-    def self.resolve(requirements, source_requirements = {}, base = [], gem_version_promoter = GemVersionPromoter.new, additional_base_requirements = [], platforms = nil)
-      base = SpecSet.new(base) unless base.is_a?(SpecSet)
-      resolver = new(source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
-      resolver.start(requirements)
-    end
-
     def initialize(source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
       @source_requirements = source_requirements
       @base = Resolver::Base.new(base, additional_base_requirements)
@@ -42,8 +26,7 @@ module Bundler
         remove_from_candidates(spec)
       end
 
-      @gem_version_promoter.prerelease_specified = @prerelease_specified = {}
-      requirements.each {|dep| @prerelease_specified[dep.name] ||= dep.prerelease? }
+      requirements.each {|dep| prerelease_specified[dep.name] ||= dep.prerelease? }
 
       verify_gemfile_dependencies_are_found!(requirements)
       result = @resolver.resolve(requirements).
@@ -117,48 +100,35 @@ module Bundler
       specification.dependencies_for_activated_platforms
     end
 
-    def search_for(dependency_proxy)
-      platform = dependency_proxy.__platform
-      dependency = dependency_proxy.dep
-      name = dependency.name
-      @search_for[dependency_proxy] ||= begin
+    def search_for(dependency)
+      @search_for[dependency] ||= begin
+        name = dependency.name
         locked_results = @base[name].select {|spec| requirement_satisfied_by?(dependency, nil, spec) }
         locked_requirement = base_requirements[name]
         results = results_for(dependency) + locked_results
         results = results.select {|spec| requirement_satisfied_by?(locked_requirement, nil, spec) } if locked_requirement
+        dep_platforms = dependency.gem_platforms(@platforms)
 
-        if !@prerelease_specified[name] && locked_results.empty?
-          # 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 results.any?
-          results = @gem_version_promoter.sort_versions(dependency, results)
-
-          results.group_by(&:version).reduce([]) do |groups, (_, specs)|
-            next groups unless specs.any? {|spec| spec.match_platform(platform) }
+        @gem_version_promoter.sort_versions(dependency, results).group_by(&:version).reduce([]) do |groups, (_, specs)|
+          relevant_platforms = dep_platforms.select {|platform| specs.any? {|spec| spec.match_platform(platform) } }
+          next groups unless relevant_platforms.any?
 
-            specs_by_platform = Hash.new do |current_specs, current_platform|
-              current_specs[current_platform] = select_best_platform_match(specs, current_platform)
-            end
+          ruby_specs = select_best_platform_match(specs, Gem::Platform::RUBY)
+          if ruby_specs.any?
+            spec_group_ruby = SpecGroup.new(ruby_specs, [Gem::Platform::RUBY])
+            spec_group_ruby.force_ruby_platform = dependency.force_ruby_platform
+            groups << spec_group_ruby
+          end
 
-            spec_group_ruby = SpecGroup.create_for(specs_by_platform, [Gem::Platform::RUBY], Gem::Platform::RUBY)
-            if spec_group_ruby
-              spec_group_ruby.force_ruby_platform = dependency.force_ruby_platform
-              groups << spec_group_ruby
-            end
+          next groups if @resolving_only_for_ruby || dependency.force_ruby_platform
 
-            next groups if @resolving_only_for_ruby || dependency.force_ruby_platform
+          platform_specs = relevant_platforms.flat_map {|platform| select_best_platform_match(specs, platform) }
+          next groups if platform_specs == ruby_specs
 
-            spec_group = SpecGroup.create_for(specs_by_platform, @platforms, platform)
-            groups << spec_group
+          spec_group = SpecGroup.new(platform_specs, relevant_platforms)
+          groups << spec_group
 
-            groups
-          end
-        else
-          []
+          groups
         end
       end
     end
@@ -189,10 +159,6 @@ module Bundler
       requirement.matches_spec?(spec) || spec.source.is_a?(Source::Gemspec)
     end
 
-    def dependencies_equal?(dependencies, other_dependencies)
-      dependencies.map(&:dep) == other_dependencies.map(&:dep)
-    end
-
     def sort_dependencies(dependencies, activated, conflicts)
       dependencies.sort_by do |dependency|
         name = name_for(dependency)
@@ -204,23 +170,20 @@ module Bundler
           amount_constrained(dependency),
           conflicts[name] ? 0 : 1,
           vertex.payload ? 0 : search_for(dependency).count,
-          self.class.platform_sort_key(dependency.__platform),
         ]
       end
     end
 
-    def self.platform_sort_key(platform)
-      # Prefer specific platform to not specific platform
-      return ["99-LAST", "", "", ""] if Gem::Platform::RUBY == platform
-      ["00", *platform.to_a.map {|part| part || "" }]
-    end
-
     private
 
     def base_requirements
       @base.base_requirements
     end
 
+    def prerelease_specified
+      @gem_version_promoter.prerelease_specified
+    end
+
     def remove_from_candidates(spec)
       @base.delete(spec)
 
@@ -255,7 +218,7 @@ module Bundler
           all - 1_000_000
         else
           search = search_for(dependency)
-          search = @prerelease_specified[dependency.name] ? search.count : search.count {|s| !s.version.prerelease? }
+          search = prerelease_specified[dependency.name] ? search.count : search.count {|s| !s.version.prerelease? }
           search - all
         end
       end
@@ -265,26 +228,16 @@ module Bundler
       requirements.map! do |requirement|
         name = requirement.name
         next requirement if name == "bundler"
+        next if requirement.gem_platforms(@platforms).empty?
         next requirement unless search_for(requirement).empty?
         next unless requirement.current_platform?
 
-        if (base = @base[name]) && !base.empty?
-          version = base.first.version
-          message = "You have requested:\n" \
-            "  #{name} #{requirement.requirement}\n\n" \
-            "The bundle currently has #{name} locked at #{version}.\n" \
-            "Try running `bundle update #{name}`\n\n" \
-            "If you are updating multiple gems in your Gemfile at once,\n" \
-            "try passing them all to `bundle update`"
-        else
-          message = gem_not_found_message(name, requirement, source_for(name))
-        end
-        raise GemNotFound, message
+        raise GemNotFound, gem_not_found_message(name, requirement, source_for(name))
       end.compact!
     end
 
     def gem_not_found_message(name, requirement, source, extra_message = "")
-      specs = source.specs.search(name)
+      specs = source.specs.search(name).sort_by {|s| [s.version, s.platform.to_s] }
       matching_part = name
       requirement_label = SharedHelpers.pretty_dependency(requirement)
       cache_message = begin
@@ -297,7 +250,9 @@ module Bundler
       if specs_matching_requirement.any?
         specs = specs_matching_requirement
         matching_part = requirement_label
-        requirement_label = "#{requirement_label}' with platform '#{requirement.__platform}"
+        platforms = requirement.gem_platforms(@platforms)
+        platform_label = platforms.size == 1 ? "platform '#{platforms.first}" : "platforms '#{platforms.join("', '")}"
+        requirement_label = "#{requirement_label}' with #{platform_label}"
       end
 
       message = String.new("Could not find gem '#{requirement_label}'#{extra_message} in #{source}#{cache_message}.\n")

data/lib/bundler/rubygems_ext.rb

@@ -261,10 +261,21 @@ module Gem
           # version
           (
             (@os != "linux" && (@version.nil? || other.version.nil?)) ||
-            (@os == "linux" && (other.version == "gnu#{@version}" || other.version == "musl#{@version}" || @version == "gnu#{other.version}")) ||
+            (@os == "linux" && (normalized_linux_version_ext == other.normalized_linux_version_ext || ["musl#{@version}", "musleabi#{@version}", "musleabihf#{@version}"].include?(other.version))) ||
             @version == other.version
           )
       end
+
+      # This is a copy of RubyGems 3.3.23 or higher `normalized_linux_method`.
+      # Once only 3.3.23 is supported, we can use the method in RubyGems.
+      def normalized_linux_version_ext
+        return nil unless @version
+
+        without_gnu_nor_abi_modifiers = @version.sub(/\Agnu/, "").sub(/eabi(hf)?\Z/, "")
+        return nil if without_gnu_nor_abi_modifiers.empty?
+
+        without_gnu_nor_abi_modifiers
+      end
     end
   end
 

data/lib/bundler/shared_helpers.rb

@@ -163,7 +163,7 @@ module Bundler
         "\nEither installing with `--full-index` or running `bundle update #{spec.name}` should fix the problem."
     end
 
-    def pretty_dependency(dep, print_source = false)
+    def pretty_dependency(dep)
       msg = String.new(dep.name)
       msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default
 
@@ -172,7 +172,6 @@ module Bundler
         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
 

data/lib/bundler/spec_set.rb

@@ -176,7 +176,7 @@ module Bundler
     def lookup
       @lookup ||= begin
         lookup = Hash.new {|h, k| h[k] = [] }
-        Index.sort_specs(@specs).reverse_each do |s|
+        @specs.each do |s|
           lookup[s.name] << s
         end
         lookup

data/lib/bundler/templates/newgem/gitlab-ci.yml.tt

@@ -1,8 +1,9 @@
-image: ruby:<%= RUBY_VERSION %>
+default:
+  image: ruby:<%= RUBY_VERSION %>
 
-before_script:
-  - gem install bundler -v <%= Bundler::VERSION %>
-  - bundle install
+  before_script:
+    - gem install bundler -v <%= Bundler::VERSION %>
+    - bundle install
 
 example_job:
   script:

data/lib/bundler/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: false
 
 module Bundler
-  VERSION = "2.3.22".freeze
+  VERSION = "2.3.24".freeze
 
   def self.bundler_major_version
     @bundler_major_version ||= VERSION.split(".").first.to_i

data/lib/bundler.rb

@@ -41,7 +41,6 @@ module Bundler
 
   autoload :Definition,             File.expand_path("bundler/definition", __dir__)
   autoload :Dependency,             File.expand_path("bundler/dependency", __dir__)
-  autoload :DepProxy,               File.expand_path("bundler/dep_proxy", __dir__)
   autoload :Deprecate,              File.expand_path("bundler/deprecate", __dir__)
   autoload :Digest,                 File.expand_path("bundler/digest", __dir__)
   autoload :Dsl,                    File.expand_path("bundler/dsl", __dir__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundler
 version: !ruby/object:Gem::Version
-  version: 2.3.22
+  version: 2.3.24
 platform: ruby
 authors:
 - André Arko
@@ -22,7 +22,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-07 00:00:00.000000000 Z
+date: 2022-10-17 00:00:00.000000000 Z
 dependencies: []
 description: Bundler manages an application's dependencies through its entire life,
   across many machines, systematically and repeatably
@@ -80,7 +80,6 @@ files:
 - lib/bundler/constants.rb
 - lib/bundler/current_ruby.rb
 - lib/bundler/definition.rb
-- lib/bundler/dep_proxy.rb
 - lib/bundler/dependency.rb
 - lib/bundler/deployment.rb
 - lib/bundler/deprecate.rb
@@ -380,7 +379,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.5.2
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.24
 signing_key:
 specification_version: 4
 summary: The best way to manage your application's dependencies

data/lib/bundler/dep_proxy.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class DepProxy
-    attr_reader :__platform, :dep
-
-    @proxies = {}
-
-    def self.get_proxy(dep, platform)
-      @proxies[[dep, platform]] ||= new(dep, platform).freeze
-    end
-
-    def initialize(dep, platform)
-      @dep = dep
-      @__platform = platform
-    end
-
-    private_class_method :new
-
-    alias_method :eql?, :==
-
-    def type
-      @dep.type
-    end
-
-    def name
-      @dep.name
-    end
-
-    def requirement
-      @dep.requirement
-    end
-
-    def to_s
-      s = name.dup
-      s << " (#{requirement})" unless requirement == Gem::Requirement.default
-      s << " #{__platform}" unless __platform == Gem::Platform::RUBY
-      s
-    end
-
-    def dup
-      raise NoMethodError.new("DepProxy cannot be duplicated")
-    end
-
-    def clone
-      raise NoMethodError.new("DepProxy cannot be cloned")
-    end
-
-    private
-
-    def method_missing(*args, &blk)
-      @dep.send(*args, &blk)
-    end
-  end
-end