bundler 2.6.5 → 2.7.1

data/lib/bundler/man/bundle-update.1.ronn

@@ -9,13 +9,13 @@ bundle-update(1) -- Update your gems to the latest available versions
                         [--local]
                         [--ruby]
                         [--bundler[=VERSION]]
+                        [--force]
                         [--full-index]
                         [--gemfile=GEMFILE]
                         [--jobs=NUMBER]
                         [--quiet]
                         [--patch|--minor|--major]
                         [--pre]
-                        [--redownload]
                         [--strict]
                         [--conservative]
 
@@ -54,6 +54,9 @@ gem.
 * `--bundler[=BUNDLER]`:
   Update the locked version of bundler to the invoked bundler version.
 
+* `--force`, `--redownload`:
+  Force reinstalling every gem, even if already installed.
+
 * `--full-index`:
   Fall back to using the single-file index of all gems.
 
@@ -70,9 +73,6 @@ gem.
 * `--quiet`:
   Only output warnings and errors.
 
-* `--redownload`, `--force`:
-  Force downloading every gem.
-
 * `--patch`:
   Prefer updating only to next patch version.
 

data/lib/bundler/man/bundle-version.1

@@ -1,6 +1,6 @@
 .\" generated with Ronn-NG/v0.10.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.10.1
-.TH "BUNDLE\-VERSION" "1" "January 2025" ""
+.TH "BUNDLE\-VERSION" "1" "July 2025" ""
 .SH "NAME"
 \fBbundle\-version\fR \- Prints Bundler version information
 .SH "SYNOPSIS"

data/lib/bundler/man/bundle-viz.1

@@ -1,6 +1,6 @@
 .\" generated with Ronn-NG/v0.10.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.10.1
-.TH "BUNDLE\-VIZ" "1" "January 2025" ""
+.TH "BUNDLE\-VIZ" "1" "July 2025" ""
 .SH "NAME"
 \fBbundle\-viz\fR \- Generates a visual dependency graph for your Gemfile
 .SH "SYNOPSIS"

data/lib/bundler/man/bundle.1

@@ -1,6 +1,6 @@
 .\" generated with Ronn-NG/v0.10.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.10.1
-.TH "BUNDLE" "1" "January 2025" ""
+.TH "BUNDLE" "1" "July 2025" ""
 .SH "NAME"
 \fBbundle\fR \- Ruby Dependency Management
 .SH "SYNOPSIS"

data/lib/bundler/man/gemfile.5

@@ -1,6 +1,6 @@
 .\" generated with Ronn-NG/v0.10.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.10.1
-.TH "GEMFILE" "5" "January 2025" ""
+.TH "GEMFILE" "5" "July 2025" ""
 .SH "NAME"
 \fBGemfile\fR \- A format for describing gem dependencies for Ruby programs
 .SH "SYNOPSIS"

data/lib/bundler/match_platform.rb

@@ -1,23 +1,42 @@
 # frozen_string_literal: true
 
-require_relative "gem_helpers"
-
 module Bundler
   module MatchPlatform
-    include GemHelpers
+    def installable_on_platform?(target_platform) # :nodoc:
+      return true if [Gem::Platform::RUBY, nil, target_platform].include?(platform)
+      return true if Gem::Platform.new(platform) === target_platform
 
-    def match_platform(p)
-      MatchPlatform.platforms_match?(platform, p)
+      false
     end
 
-    def self.platforms_match?(gemspec_platform, local_platform)
-      return true if gemspec_platform.nil?
-      return true if gemspec_platform == Gem::Platform::RUBY
-      return true if local_platform == gemspec_platform
-      gemspec_platform = Gem::Platform.new(gemspec_platform)
-      return true if gemspec_platform === local_platform
+    def self.select_best_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
+      matching = select_all_platform_match(specs, platform, force_ruby: force_ruby, prefer_locked: prefer_locked)
 
-      false
+      Gem::Platform.sort_and_filter_best_platform_match(matching, platform)
+    end
+
+    def self.select_best_local_platform_match(specs, force_ruby: false)
+      local = Bundler.local_platform
+      matching = select_all_platform_match(specs, local, force_ruby: force_ruby).filter_map(&:materialized_for_installation)
+
+      Gem::Platform.sort_best_platform_match(matching, local)
+    end
+
+    def self.select_all_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
+      matching = specs.select {|spec| spec.installable_on_platform?(force_ruby ? Gem::Platform::RUBY : platform) }
+
+      specs.each(&:force_ruby_platform!) if force_ruby
+
+      if prefer_locked
+        locked_originally = matching.select {|spec| spec.is_a?(::Bundler::LazySpecification) }
+        return locked_originally if locked_originally.any?
+      end
+
+      matching
+    end
+
+    def self.generic_local_platform_is_ruby?
+      Bundler.generic_local_platform == Gem::Platform::RUBY
     end
   end
 end

data/lib/bundler/materialization.rb

@@ -22,9 +22,9 @@ module Bundler
       @specs ||= if @candidates.nil?
         []
       elsif platform
-        GemHelpers.select_best_platform_match(@candidates, platform, force_ruby: dep.force_ruby_platform)
+        MatchPlatform.select_best_platform_match(@candidates, platform, force_ruby: dep.force_ruby_platform)
       else
-        GemHelpers.select_best_local_platform_match(@candidates, force_ruby: dep.force_ruby_platform || dep.default_force_ruby_platform)
+        MatchPlatform.select_best_local_platform_match(@candidates, force_ruby: dep.force_ruby_platform || dep.default_force_ruby_platform)
       end
     end
 

data/lib/bundler/plugin/api/source.rb

@@ -67,7 +67,7 @@ module Bundler
         # to check out same version of gem later.
         #
         # There options are passed when the source plugin is created from the
-        # lock file.
+        # lockfile.
         #
         # @return [Hash]
         def options_to_lock

data/lib/bundler/plugin/index.rb

@@ -31,7 +31,7 @@ module Bundler
 
         begin
           load_index(global_index_file, true)
-        rescue GenericSystemCallError
+        rescue PermissionError
           # no need to fail when on a read-only FS, for example
           nil
         rescue ArgumentError => e

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

@@ -8,6 +8,14 @@ module Bundler
           SharedHelpers.in_bundle? ? Bundler.root : Plugin.root
         end
 
+        def eql?(other)
+          return unless other.class == self.class
+          expanded_original_path == other.expanded_original_path &&
+            version == other.version
+        end
+
+        alias_method :==, :eql?
+
         def generate_bin(spec, disable_extensions = false)
           # Need to find a way without code duplication
           # For now, we can ignore this

data/lib/bundler/plugin.rb

@@ -195,7 +195,7 @@ module Bundler
       @sources[name]
     end
 
-    # @param [Hash] The options that are present in the lock file
+    # @param [Hash] The options that are present in the lockfile
     # @return [API::Source] the instance of the class that handles the source
     #                       type passed in locked_opts
     def from_lock(locked_opts)

data/lib/bundler/resolver/candidate.rb

@@ -17,7 +17,7 @@ module Bundler
     # Some candidates may also keep some information explicitly about the
     # package they refer to. These candidates are referred to as "canonical" and
     # are used when materializing resolution results back into RubyGems
-    # specifications that can be installed, written to lock files, and so on.
+    # specifications that can be installed, written to lockfiles, and so on.
     #
     class Candidate
       include Comparable
@@ -48,35 +48,38 @@ module Bundler
         @version.segments
       end
 
-      def sort_obj
-        [@version, @priority]
-      end
-
       def <=>(other)
         return unless other.is_a?(self.class)
 
-        sort_obj <=> other.sort_obj
+        version_comparison = version <=> other.version
+        return version_comparison unless version_comparison.zero?
+
+        priority <=> other.priority
       end
 
       def ==(other)
         return unless other.is_a?(self.class)
 
-        sort_obj == other.sort_obj
+        version == other.version && priority == other.priority
       end
 
       def eql?(other)
         return unless other.is_a?(self.class)
 
-        sort_obj.eql?(other.sort_obj)
+        version.eql?(other.version) && priority.eql?(other.priority)
       end
 
       def hash
-        sort_obj.hash
+        [@version, @priority].hash
       end
 
       def to_s
         @version.to_s
       end
+
+      protected
+
+      attr_reader :priority
     end
   end
 end

data/lib/bundler/resolver/package.rb

@@ -30,7 +30,7 @@ module Bundler
       def platform_specs(specs)
         platforms.map do |platform|
           prefer_locked = @new_platforms.include?(platform) ? false : !unlock?
-          GemHelpers.select_best_platform_match(specs, platform, prefer_locked: prefer_locked)
+          MatchPlatform.select_best_platform_match(specs, platform, prefer_locked: prefer_locked)
         end
       end
 

data/lib/bundler/resolver/strategy.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Resolver
+    class Strategy
+      def initialize(source)
+        @source = source
+      end
+
+      def next_package_and_version(unsatisfied)
+        package, range = next_term_to_try_from(unsatisfied)
+
+        [package, most_preferred_version_of(package, range).first]
+      end
+
+      private
+
+      def next_term_to_try_from(unsatisfied)
+        unsatisfied.min_by do |package, range|
+          matching_versions = @source.versions_for(package, range)
+          higher_versions = @source.versions_for(package, range.upper_invert)
+
+          [matching_versions.count <= 1 ? 0 : 1, higher_versions.count]
+        end
+      end
+
+      def most_preferred_version_of(package, range)
+        versions = @source.versions_for(package, range)
+
+        # Conditional avoids (among other things) calling
+        # sort_versions_by_preferred with the root package
+        if versions.size > 1
+          @source.sort_versions_by_preferred(package, versions)
+        else
+          versions
+        end
+      end
+    end
+  end
+end

data/lib/bundler/resolver.rb

@@ -12,8 +12,7 @@ module Bundler
     require_relative "resolver/candidate"
     require_relative "resolver/incompatibility"
     require_relative "resolver/root"
-
-    include GemHelpers
+    require_relative "resolver/strategy"
 
     def initialize(base, gem_version_promoter, most_specific_locked_platform = nil)
       @source_requirements = base.source_requirements
@@ -78,7 +77,7 @@ module Bundler
     end
 
     def solve_versions(root:, logger:)
-      solver = PubGrub::VersionSolver.new(source: self, root: root, logger: logger)
+      solver = PubGrub::VersionSolver.new(source: self, root: root, strategy: Strategy.new(self), logger: logger)
       result = solver.solve
       resolved_specs = result.flat_map {|package, version| version.to_specs(package, @most_specific_locked_platform) }
       SpecSet.new(resolved_specs).specs_with_additional_variants_from(@base.locked_specs)
@@ -167,15 +166,7 @@ module Bundler
     end
 
     def versions_for(package, range=VersionRange.any)
-      versions = select_sorted_versions(package, range)
-
-      # Conditional avoids (among other things) calling
-      # sort_versions_by_preferred with the root package
-      if versions.size > 1
-        sort_versions_by_preferred(package, versions)
-      else
-        versions
-      end
+      range.select_versions(@sorted_versions[package])
     end
 
     def no_versions_incompatibility_for(package, unsatisfied_term)
@@ -280,12 +271,12 @@ module Bundler
           next groups if platform_specs.all?(&:empty?)
         end
 
-        ruby_specs = select_best_platform_match(specs, Gem::Platform::RUBY)
+        ruby_specs = MatchPlatform.select_best_platform_match(specs, Gem::Platform::RUBY)
         ruby_group = Resolver::SpecGroup.new(ruby_specs)
 
         unless ruby_group.empty?
-          platform_specs.each do |specs|
-            ruby_group.merge(Resolver::SpecGroup.new(specs))
+          platform_specs.each do |s|
+            ruby_group.merge(Resolver::SpecGroup.new(s))
           end
 
           groups << Resolver::Candidate.new(version, group: ruby_group, priority: -1)
@@ -319,6 +310,16 @@ module Bundler
       "Gemfile"
     end
 
+    def raise_incomplete!(incomplete_specs)
+      raise_not_found!(@base.get_package(incomplete_specs.first.name))
+    end
+
+    def sort_versions_by_preferred(package, versions)
+      @gem_version_promoter.sort_versions(package, versions)
+    end
+
+    private
+
     def raise_not_found!(package)
       name = package.name
       source = source_for(name)
@@ -355,8 +356,6 @@ module Bundler
       raise GemNotFound, message
     end
 
-    private
-
     def filtered_versions_for(package)
       @gem_version_promoter.filter_versions(package, @all_versions[package])
     end
@@ -414,10 +413,6 @@ module Bundler
       requirement.satisfied_by?(spec.version) || spec.source.is_a?(Source::Gemspec)
     end
 
-    def sort_versions_by_preferred(package, versions)
-      @gem_version_promoter.sort_versions(package, versions)
-    end
-
     def repository_for(package)
       source_for(package.name)
     end
@@ -433,7 +428,7 @@ module Bundler
         next [dep_package, dep_constraint] if name == "bundler"
 
         dep_range = dep_constraint.range
-        versions = select_sorted_versions(dep_package, dep_range)
+        versions = versions_for(dep_package, dep_range)
         if versions.empty?
           if dep_package.ignores_prereleases? || dep_package.prefer_local?
             @all_versions.delete(dep_package)
@@ -441,7 +436,7 @@ module Bundler
           end
           dep_package.consider_prereleases! if dep_package.ignores_prereleases?
           dep_package.consider_remote_versions! if dep_package.prefer_local?
-          versions = select_sorted_versions(dep_package, dep_range)
+          versions = versions_for(dep_package, dep_range)
         end
 
         if versions.empty? && select_all_versions(dep_package, dep_range).any?
@@ -456,10 +451,6 @@ module Bundler
       end.to_h
     end
 
-    def select_sorted_versions(package, range)
-      range.select_versions(@sorted_versions[package])
-    end
-
     def select_all_versions(package, range)
       range.select_versions(@all_versions[package])
     end