bundler 2.4.3 → 2.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4598d8531bbdd46221e7238ee2aa828683a3e1854e47bf901857f791a01eb969
-  data.tar.gz: ead0de0789d8d5682c8d58e60da80a245d5710f8358669e544bb915546f3b82c
+  metadata.gz: f0ed8153bf4161ce7da774eaa1abd23954e3ca61eb7ba730efcb934a6c13b2fe
+  data.tar.gz: 81f598764da83308327451e2ab17276401b9f89f6cd170f82c540b74e3038b41
 SHA512:
-  metadata.gz: 8078880e8f03117e011bedb3150aba2dfc91c271dfd289ed99f0850e5cb8c62c50af5d7c834c2fc224e17ff925f59e237b33141c1b7d9dec3efdaf35b9f353c1
-  data.tar.gz: 278df46d98c43489e941b788aca7b3cc46358a3ea099987f83c8cdb3b618ed3b0373d7bea590a80620332316d0b12a0bf98f0d02349c55d769174960f5169a45
+  metadata.gz: 668e10c171354b03ee63547510c0e3cb57caa1146749b9f357ee36d74d9c3bfaa84283dc39d908b91a0e7870ecd673b392f7ea062e7987f9f833b492700f5533
+  data.tar.gz: b498147f45cdd036ba4cb3c8ed03eb6353397a5acbbe76fb0b2729c58a4fc99beb86247b6d410e3e55612b7f950d53bea05f705a8d387ed24ab00c47388e7a4a

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+# 2.4.5 (January 21, 2023)
+
+## Bug fixes:
+
+  - Fix `bundler/inline` not resolving properly if gems not preinstalled [#6282](https://github.com/rubygems/rubygems/pull/6282)
+  - Fix packages for external platforms being introduced in lockfile when Bundler retries resolution [#6285](https://github.com/rubygems/rubygems/pull/6285)
+
+## Documentation:
+
+  - Update bundle-exec man page to not use deprecated `Bundler.with_clean_env` [#6284](https://github.com/rubygems/rubygems/pull/6284)
+
+# 2.4.4 (January 16, 2023)
+
+## Bug fixes:
+
+  - Fix platform specific gems removed from the lockfile [#6266](https://github.com/rubygems/rubygems/pull/6266)
+  - Properly handle incompatibilities on platform specific gems [#6270](https://github.com/rubygems/rubygems/pull/6270)
+  - Optimistically exclude prereleases from initial resolution [#6246](https://github.com/rubygems/rubygems/pull/6246)
+  - Fix another case of not properly falling back to ruby variant when materializing [#6261](https://github.com/rubygems/rubygems/pull/6261)
+  - Skip setting `BUNDLER_SETUP` on Ruby 2.6 [#6252](https://github.com/rubygems/rubygems/pull/6252)
+  - Let resolver deal with legacy gems with equivalent version and different dependencies [#6219](https://github.com/rubygems/rubygems/pull/6219)
+
 # 2.4.3 (January 6, 2023)
 
 ## 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 = "2023-01-06".freeze
-    @git_commit_sha = "ed1f27f75c".freeze
+    @built_at = "2023-01-21".freeze
+    @git_commit_sha = "d8ff3b6e4a".freeze
     @release = true
     # end ivars
 

data/lib/bundler/definition.rb

@@ -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
@@ -473,31 +483,19 @@ 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))
-      end
+      @resolver ||= Resolver.new(resolution_packages, gem_version_promoter)
     end
 
     def expanded_dependencies
-      @expanded_dependencies ||= dependencies + metadata_dependencies
+      dependencies + metadata_dependencies
     end
 
     def resolution_packages
       @resolution_packages ||= begin
-        packages = Hash.new do |h, k|
-          h[k] = Resolver::Package.new(k, @platforms, @originally_locked_specs, @unlock[:gems])
-        end
-
-        expanded_dependencies.each do |dep|
-          name = dep.name
-          platforms = dep.gem_platforms(@platforms)
-
-          packages[name] = Resolver::Package.new(name, platforms, @originally_locked_specs, @unlock[:gems], :dependency => dep)
-        end
-
-        packages
+        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
 
@@ -531,13 +529,15 @@ module Bundler
         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 = start_resolution(: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[incomplete_specs.first.name]
+          package = resolution_packages.get_package(incomplete_specs.first.name)
           resolver.raise_not_found! package
         end
 
@@ -550,14 +550,14 @@ module Bundler
       specs
     end
 
-    def start_resolution(exclude_specs: [])
-      result = resolver.start(expanded_dependencies, resolution_packages, :exclude_specs => exclude_specs)
+    def start_resolution
+      result = resolver.start
 
       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?
+      sources.non_global_rubygems_sources.all?(&:dependency_api_available?) && !sources.aggregate_global_source?
     end
 
     def pin_locally_available_names(source_requirements)
@@ -885,11 +885,12 @@ module Bundler
       current == proposed
     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
+    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
+      resolution_packages
     end
 
     def remove_ruby_from_platforms_if_necessary!(dependencies)

data/lib/bundler/installer.rb

@@ -249,17 +249,13 @@ module Bundler
 
     # returns whether or not a re-resolve was needed
     def resolve_if_needed(options)
+      @definition.resolution_mode = options
+
       if !@definition.unlocking? && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file?
         return false if @definition.nothing_changed? && !@definition.missing_specs?
       end
 
-      if options["local"]
-        @definition.resolve_with_cache!
-      elsif options["prefer-local"]
-        @definition.resolve_prefering_local!
-      else
-        @definition.resolve_remotely!
-      end
+      @definition.setup_sources_for_resolve
 
       true
     end

data/lib/bundler/lazy_specification.rb

@@ -89,7 +89,7 @@ module Bundler
 
         installable_candidates = GemHelpers.select_best_platform_match(matching_specs, target_platform)
 
-        specification = __materialize__(installable_candidates)
+        specification = __materialize__(installable_candidates, :fallback_to_non_installable => false)
         return specification unless specification.nil?
 
         if target_platform != platform
@@ -102,13 +102,18 @@ module Bundler
       __materialize__(candidates)
     end
 
-    def __materialize__(candidates)
+    # If in frozen mode, we fallback to a non-installable candidate because by
+    # doing this we avoid re-resolving and potentially end up changing the
+    # lock file, which is not allowed. In that case, we will give a proper error
+    # about the mismatch higher up the stack, right before trying to install the
+    # bad gem.
+    def __materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)
       search = candidates.reverse.find do |spec|
         spec.is_a?(StubSpecification) ||
           (spec.matches_current_ruby? &&
             spec.matches_current_rubygems?)
       end
-      if search.nil? && Bundler.frozen_bundle?
+      if search.nil? && fallback_to_non_installable
         search = candidates.last
       else
         search.dependencies = dependencies if search && search.full_name == full_name && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))

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

@@ -74,13 +74,13 @@ Finally, \fBbundle exec\fR also implicitly modifies \fBGemfile\.lock\fR if the l
 By default, when attempting to \fBbundle exec\fR to a file with a ruby shebang, Bundler will \fBKernel\.load\fR that file instead of using \fBKernel\.exec\fR\. For the vast majority of cases, this is a performance improvement\. In a rare few cases, this could cause some subtle side\-effects (such as dependence on the exact contents of \fB$0\fR or \fB__FILE__\fR) and the optimization can be disabled by enabling the \fBdisable_exec_load\fR setting\.
 .
 .SS "Shelling out"
-Any Ruby code that opens a subshell (like \fBsystem\fR, backticks, or \fB%x{}\fR) will automatically use the current Bundler environment\. If you need to shell out to a Ruby command that is not part of your current bundle, use the \fBwith_clean_env\fR method with a block\. Any subshells created inside the block will be given the environment present before Bundler was activated\. For example, Homebrew commands run Ruby, but don\'t work inside a bundle:
+Any Ruby code that opens a subshell (like \fBsystem\fR, backticks, or \fB%x{}\fR) will automatically use the current Bundler environment\. If you need to shell out to a Ruby command that is not part of your current bundle, use the \fBwith_unbundled_env\fR method with a block\. Any subshells created inside the block will be given the environment present before Bundler was activated\. For example, Homebrew commands run Ruby, but don\'t work inside a bundle:
 .
 .IP "" 4
 .
 .nf
 
-Bundler\.with_clean_env do
+Bundler\.with_unbundled_env do
   `brew install wget`
 end
 .
@@ -89,13 +89,13 @@ end
 .IP "" 0
 .
 .P
-Using \fBwith_clean_env\fR is also necessary if you are shelling out to a different bundle\. Any Bundler commands run in a subshell will inherit the current Gemfile, so commands that need to run in the context of a different bundle also need to use \fBwith_clean_env\fR\.
+Using \fBwith_unbundled_env\fR is also necessary if you are shelling out to a different bundle\. Any Bundler commands run in a subshell will inherit the current Gemfile, so commands that need to run in the context of a different bundle also need to use \fBwith_unbundled_env\fR\.
 .
 .IP "" 4
 .
 .nf
 
-Bundler\.with_clean_env do
+Bundler\.with_unbundled_env do
   Dir\.chdir "/other/bundler/project" do
     `bundle exec \./script`
   end

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

@@ -84,20 +84,20 @@ the `disable_exec_load` setting.
 Any Ruby code that opens a subshell (like `system`, backticks, or `%x{}`) will
 automatically use the current Bundler environment. If you need to shell out to
 a Ruby command that is not part of your current bundle, use the
-`with_clean_env` method with a block. Any subshells created inside the block
+`with_unbundled_env` method with a block. Any subshells created inside the block
 will be given the environment present before Bundler was activated. For
 example, Homebrew commands run Ruby, but don't work inside a bundle:
 
-    Bundler.with_clean_env do
+    Bundler.with_unbundled_env do
       `brew install wget`
     end
 
-Using `with_clean_env` is also necessary if you are shelling out to a different
+Using `with_unbundled_env` is also necessary if you are shelling out to a different
 bundle. Any Bundler commands run in a subshell will inherit the current
 Gemfile, so commands that need to run in the context of a different bundle also
-need to use `with_clean_env`.
+need to use `with_unbundled_env`.
 
-    Bundler.with_clean_env do
+    Bundler.with_unbundled_env do
       Dir.chdir "/other/bundler/project" do
         `bundle exec ./script`
       end

data/lib/bundler/resolver/base.rb

@@ -1,19 +1,47 @@
 # frozen_string_literal: true
 
+require_relative "package"
+
 module Bundler
   class Resolver
     class Base
-      def initialize(base, additional_base_requirements)
+      attr_reader :packages, :requirements, :source_requirements
+
+      def initialize(source_requirements, dependencies, base, platforms, options)
+        @source_requirements = source_requirements
+
         @base = base
-        @additional_base_requirements = additional_base_requirements
+
+        @packages = Hash.new do |hash, name|
+          hash[name] = Package.new(name, platforms, **options)
+        end
+
+        @requirements = dependencies.map do |dep|
+          dep_platforms = dep.gem_platforms(platforms)
+
+          # Dependencies scoped to external platforms are ignored
+          next if dep_platforms.empty?
+
+          name = dep.name
+
+          @packages[name] = Package.new(name, dep_platforms, **options.merge(:dependency => dep))
+
+          dep
+        end.compact
       end
 
       def [](name)
         @base[name]
       end
 
-      def delete(spec)
-        @base.delete(spec)
+      def delete(specs)
+        specs.each do |spec|
+          @base.delete(spec)
+        end
+      end
+
+      def get_package(name)
+        @packages[name]
       end
 
       def base_requirements
@@ -24,10 +52,14 @@ module Bundler
         names.each do |name|
           @base.delete_by_name(name)
 
-          @additional_base_requirements.reject! {|dep| dep.name == name }
+          @base_requirements.delete(name)
         end
+      end
 
-        @base_requirements = nil
+      def include_prereleases(names)
+        names.each do |name|
+          get_package(name).consider_prereleases!
+        end
       end
 
       private
@@ -38,7 +70,6 @@ module Bundler
           req = Gem::Requirement.new(ls.version)
           base_requirements[ls.name] = req
         end
-        @additional_base_requirements.each {|d| base_requirements[d.name] = d.requirement }
         base_requirements
       end
     end

data/lib/bundler/resolver/candidate.rb

@@ -26,9 +26,8 @@ module Bundler
 
       def initialize(version, specs: [])
         @spec_group = Resolver::SpecGroup.new(specs)
-        @platforms = specs.map(&:platform).sort_by(&:to_s).uniq
         @version = Gem::Version.new(version)
-        @ruby_only = @platforms == [Gem::Platform::RUBY]
+        @ruby_only = specs.map(&:platform).uniq == [Gem::Platform::RUBY]
       end
 
       def dependencies
@@ -88,9 +87,7 @@ module Bundler
       end
 
       def to_s
-        return @version.to_s if @platforms.empty? || @ruby_only
-
-        "#{@version} (#{@platforms.join(", ")})"
+        @version.to_s
       end
     end
   end

data/lib/bundler/resolver/package.rb

@@ -15,12 +15,13 @@ module Bundler
     class Package
       attr_reader :name, :platforms, :dependency, :locked_version
 
-      def initialize(name, platforms, locked_specs, unlock, dependency: nil)
+      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, dependency: nil)
         @name = name
         @platforms = platforms
         @locked_version = locked_specs[name].first&.version
         @unlock = unlock
         @dependency = dependency || Dependency.new(name, @locked_version)
+        @prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore
       end
 
       def to_s
@@ -47,8 +48,16 @@ module Bundler
         @unlock.empty? || @unlock.include?(name)
       end
 
+      def ignores_prereleases?
+        @prerelease == :ignore
+      end
+
       def prerelease_specified?
-        @dependency.prerelease?
+        @prerelease == :consider_first
+      end
+
+      def consider_prereleases!
+        @prerelease = :consider_last
       end
 
       def force_ruby_platform?

data/lib/bundler/resolver.rb

@@ -9,26 +9,21 @@ module Bundler
   class Resolver
     require_relative "vendored_pub_grub"
     require_relative "resolver/base"
-    require_relative "resolver/package"
     require_relative "resolver/candidate"
     require_relative "resolver/incompatibility"
     require_relative "resolver/root"
 
     include GemHelpers
 
-    def initialize(source_requirements, base, gem_version_promoter, additional_base_requirements)
-      @source_requirements = source_requirements
-      @base = Resolver::Base.new(base, additional_base_requirements)
+    def initialize(base, gem_version_promoter)
+      @source_requirements = base.source_requirements
+      @base = base
       @gem_version_promoter = gem_version_promoter
     end
 
-    def start(requirements, packages, exclude_specs: [])
-      exclude_specs.each do |spec|
-        remove_from_candidates(spec)
-      end
-
-      @requirements = requirements
-      @packages = packages
+    def start
+      @requirements = @base.requirements
+      @packages = @base.packages
 
       root, logger = setup_solver
 
@@ -78,33 +73,26 @@ module Bundler
     rescue PubGrub::SolveFailure => e
       incompatibility = e.incompatibility
 
-      names_to_unlock = []
-      extended_explanation = nil
+      names_to_unlock, names_to_allow_prereleases_for, extended_explanation = find_names_to_relax(incompatibility)
 
-      while incompatibility.conflict?
-        cause = incompatibility.cause
-        incompatibility = cause.incompatibility
-
-        incompatibility.terms.each do |term|
-          name = term.package.name
-          names_to_unlock << name if base_requirements[name]
+      names_to_relax = names_to_unlock + names_to_allow_prereleases_for
 
-          no_versions_incompat = [cause.incompatibility, cause.satisfier].find {|incompat| incompat.cause.is_a?(PubGrub::Incompatibility::NoVersions) }
-          next unless no_versions_incompat
+      if names_to_relax.any?
+        if names_to_unlock.any?
+          Bundler.ui.debug "Found conflicts with locked dependencies. Will retry with #{names_to_unlock.join(", ")} unlocked...", true
 
-          extended_explanation = no_versions_incompat.extended_explanation
+          @base.unlock_names(names_to_unlock)
         end
-      end
-
-      names_to_unlock.uniq!
 
-      if names_to_unlock.any?
-        Bundler.ui.debug "Found conflicts with locked dependencies. Retrying with #{names_to_unlock.join(", ")} unlocked...", true
+        if names_to_allow_prereleases_for.any?
+          Bundler.ui.debug "Found conflicts with dependencies with prereleases. Will retrying considering prereleases for #{names_to_allow_prereleases_for.join(", ")}...", true
 
-        @base.unlock_names(names_to_unlock)
+          @base.include_prereleases(names_to_allow_prereleases_for)
+        end
 
         root, logger = setup_solver
 
+        Bundler.ui.debug "Retrying resolution...", true
         retry
       end
 
@@ -118,6 +106,35 @@ module Bundler
       raise SolveFailure.new(explanation)
     end
 
+    def find_names_to_relax(incompatibility)
+      names_to_unlock = []
+      names_to_allow_prereleases_for = []
+      extended_explanation = nil
+
+      while incompatibility.conflict?
+        cause = incompatibility.cause
+        incompatibility = cause.incompatibility
+
+        incompatibility.terms.each do |term|
+          package = term.package
+          name = package.name
+
+          if base_requirements[name]
+            names_to_unlock << name
+          elsif package.ignores_prereleases?
+            names_to_allow_prereleases_for << name
+          end
+
+          no_versions_incompat = [cause.incompatibility, cause.satisfier].find {|incompat| incompat.cause.is_a?(PubGrub::Incompatibility::NoVersions) }
+          next unless no_versions_incompat
+
+          extended_explanation = no_versions_incompat.extended_explanation
+        end
+      end
+
+      [names_to_unlock.uniq, names_to_allow_prereleases_for.uniq, extended_explanation]
+    end
+
     def parse_dependency(package, dependency)
       range = if repository_for(package).is_a?(Source::Gemspec)
         PubGrub::VersionRange.any
@@ -215,7 +232,7 @@ module Bundler
 
     def all_versions_for(package)
       name = package.name
-      results = (@base[name] + @all_specs[name]).uniq(&:full_name)
+      results = (@base[name] + filter_prereleases(@all_specs[name], package)).uniq {|spec| [spec.version.hash, spec.platform] }
       locked_requirement = base_requirements[name]
       results = filter_matching_specs(results, locked_requirement) if locked_requirement
 
@@ -284,6 +301,12 @@ module Bundler
       end
     end
 
+    def filter_prereleases(specs, package)
+      return specs unless package.ignores_prereleases?
+
+      specs.reject {|s| s.version.prerelease? }
+    end
+
     def requirement_satisfied_by?(requirement, spec)
       requirement.satisfied_by?(spec.version) || spec.source.is_a?(Source::Gemspec)
     end
@@ -304,25 +327,20 @@ module Bundler
       @base.base_requirements
     end
 
-    def remove_from_candidates(spec)
-      @base.delete(spec)
-    end
-
     def prepare_dependencies(requirements, packages)
       to_dependency_hash(requirements, packages).map do |dep_package, dep_constraint|
         name = dep_package.name
 
-        # If a dependency is scoped to a platform different from the current
-        # one, we ignore it. However, it may reappear during resolution as a
-        # transitive dependency of another package, so we need to reset the
-        # package so the proper versions are considered if reintroduced later.
-        if dep_package.platforms.empty?
-          @packages.delete(name)
-          next
+        next [dep_package, dep_constraint] if name == "bundler"
+
+        versions = versions_for(dep_package, dep_constraint.range)
+        if versions.empty? && dep_package.ignores_prereleases?
+          @sorted_versions.delete(dep_package)
+          dep_package.consider_prereleases!
+          versions = versions_for(dep_package, dep_constraint.range)
         end
+        next [dep_package, dep_constraint] unless versions.empty?
 
-        next [dep_package, dep_constraint] if name == "bundler"
-        next [dep_package, dep_constraint] unless versions_for(dep_package, dep_constraint.range).empty?
         next unless dep_package.current_platform?
 
         raise_not_found!(dep_package)

data/lib/bundler/shared_helpers.rb

@@ -284,7 +284,7 @@ module Bundler
       Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", find_gemfile.to_s
       Bundler::SharedHelpers.set_env "BUNDLER_VERSION", Bundler::VERSION
-      Bundler::SharedHelpers.set_env "BUNDLER_SETUP", File.expand_path("setup", __dir__)
+      Bundler::SharedHelpers.set_env "BUNDLER_SETUP", File.expand_path("setup", __dir__) unless RUBY_VERSION < "2.7"
     end
 
     def set_path

data/lib/bundler/source/rubygems.rb

@@ -292,7 +292,7 @@ module Bundler
       end
 
       def dependency_api_available?
-        api_fetchers.any?
+        @allow_remote && api_fetchers.any?
       end
 
       protected

data/lib/bundler/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundler
 version: !ruby/object:Gem::Version
-  version: 2.4.3
+  version: 2.4.5
 platform: ruby
 authors:
 - André Arko
@@ -22,7 +22,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-06 00:00:00.000000000 Z
+date: 2023-01-21 00:00:00.000000000 Z
 dependencies: []
 description: Bundler manages an application's dependencies through its entire life,
   across many machines, systematically and repeatably
@@ -380,7 +380,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.0.1
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.5
 signing_key:
 specification_version: 4
 summary: The best way to manage your application's dependencies