bundler 2.2.27 → 2.6.1

data/lib/bundler/gem_helper.rb

@@ -21,7 +21,7 @@ module Bundler
 
       def gemspec(&block)
         gemspec = instance.gemspec
-        block.call(gemspec) if block
+        block&.call(gemspec)
         gemspec
       end
     end
@@ -47,7 +47,7 @@ module Bundler
         built_gem_path = build_gem
       end
 
-      desc "Generate SHA512 checksum if #{name}-#{version}.gem into the checksums directory."
+      desc "Generate SHA512 checksum of #{name}-#{version}.gem into the checksums directory."
       task "build:checksum" => "build" do
         build_checksum(built_gem_path)
       end
@@ -76,7 +76,7 @@ module Bundler
         tag_version { git_push(args[:remote]) } unless already_tagged?
       end
 
-      task "release:rubygem_push" do
+      task "release:rubygem_push" => "build" do
         rubygem_push(built_gem_path) if gem_push?
       end
 
@@ -98,10 +98,7 @@ module Bundler
       built_gem_path ||= build_gem
       cmd = [*gem_command, "install", built_gem_path.to_s]
       cmd << "--local" if local
-      _, status = sh_with_status(cmd)
-      unless status.success?
-        raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output"
-      end
+      sh(cmd)
       Bundler.ui.confirm "#{name} (#{version}) installed."
     end
 
@@ -110,9 +107,9 @@ module Bundler
       SharedHelpers.filesystem_access(File.join(base, "checksums")) {|p| FileUtils.mkdir_p(p) }
       file_name = "#{File.basename(built_gem_path)}.sha512"
       require "digest/sha2"
-      checksum = Digest::SHA512.new.hexdigest(built_gem_path.to_s)
+      checksum = ::Digest::SHA512.file(built_gem_path).hexdigest
       target = File.join(base, "checksums", file_name)
-      File.write(target, checksum)
+      File.write(target, checksum + "\n")
       Bundler.ui.confirm "#{name} #{version} checksum written to checksums/#{file_name}."
     end
 
@@ -132,8 +129,8 @@ module Bundler
 
     def git_push(remote = nil)
       remote ||= default_remote
-      perform_git_push "#{remote} refs/heads/#{current_branch}"
-      perform_git_push "#{remote} refs/tags/#{version_tag}"
+      sh("git push #{remote} refs/heads/#{current_branch}".shellsplit)
+      sh("git push #{remote} refs/tags/#{version_tag}".shellsplit)
       Bundler.ui.confirm "Pushed git commits and release tag."
     end
 
@@ -155,19 +152,11 @@ module Bundler
 
     def gem_push_host
       env_rubygems_host = ENV["RUBYGEMS_HOST"]
-      env_rubygems_host = nil if
-        env_rubygems_host && env_rubygems_host.empty?
+      env_rubygems_host = nil if env_rubygems_host&.empty?
 
       allowed_push_host || env_rubygems_host || "rubygems.org"
     end
 
-    def perform_git_push(options = "")
-      cmd = "git push #{options}"
-      out, status = sh_with_status(cmd.shellsplit)
-      return if status.success?
-      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n"
-    end
-
     def already_tagged?
       return false unless sh(%w[git tag]).split(/\n/).include?(version_tag)
       Bundler.ui.confirm "Tag #{version_tag} has already been created."
@@ -218,8 +207,7 @@ module Bundler
     def sh(cmd, &block)
       out, status = sh_with_status(cmd, &block)
       unless status.success?
-        cmd = cmd.shelljoin if cmd.respond_to?(:shelljoin)
-        raise(out.empty? ? "Running `#{cmd}` failed. Run this command directly for more detailed output." : out)
+        raise("Running `#{cmd.shelljoin}` failed with the following output:\n\n#{out}\n")
       end
       out
     end
@@ -227,9 +215,9 @@ module Bundler
     def sh_with_status(cmd, &block)
       Bundler.ui.debug(cmd)
       SharedHelpers.chdir(base) do
-        outbuf = IO.popen(cmd, :err => [:child, :out], &:read)
+        outbuf = IO.popen(cmd, err: [:child, :out], &:read)
         status = $?
-        block.call(outbuf) if status.success? && block
+        block&.call(outbuf) if status.success?
         [outbuf, status]
       end
     end

data/lib/bundler/gem_helpers.rb

@@ -10,6 +10,7 @@ module Bundler
       [Gem::Platform.new("universal-mingw32"), Gem::Platform.new("universal-mingw32")],
       [Gem::Platform.new("x64-mingw32"), Gem::Platform.new("x64-mingw32")],
       [Gem::Platform.new("x86_64-mingw32"), Gem::Platform.new("x64-mingw32")],
+      [Gem::Platform.new("x64-mingw-ucrt"), Gem::Platform.new("x64-mingw-ucrt")],
       [Gem::Platform.new("mingw32"), Gem::Platform.new("x86-mingw32")],
     ].freeze
 
@@ -33,6 +34,11 @@ module Bundler
     end
     module_function :local_platform
 
+    def generic_local_platform_is_ruby?
+      generic_local_platform == Gem::Platform::RUBY
+    end
+    module_function :generic_local_platform_is_ruby?
+
     def platform_specificity_match(spec_platform, user_platform)
       spec_platform = Gem::Platform.new(spec_platform)
 
@@ -40,17 +46,53 @@ module Bundler
     end
     module_function :platform_specificity_match
 
-    def select_best_platform_match(specs, platform)
-      matching = specs.select {|spec| spec.match_platform(platform) }
+    def select_all_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
+      matching = if force_ruby
+        specs.select {|spec| spec.match_platform(Gem::Platform::RUBY) && spec.force_ruby_platform! }
+      else
+        specs.select {|spec| spec.match_platform(platform) }
+      end
+
+      if prefer_locked
+        locked_originally = matching.select {|spec| spec.is_a?(LazySpecification) }
+        return locked_originally if locked_originally.any?
+      end
+
+      matching
+    end
+    module_function :select_all_platform_match
+
+    def 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)
+
+      sort_and_filter_best_platform_match(matching, platform)
+    end
+    module_function :select_best_platform_match
+
+    def select_best_local_platform_match(specs, force_ruby: false)
+      matching = select_all_platform_match(specs, local_platform, force_ruby: force_ruby).filter_map(&:materialized_for_installation)
+
+      sort_best_platform_match(matching, local_platform)
+    end
+    module_function :select_best_local_platform_match
+
+    def sort_and_filter_best_platform_match(matching, platform)
+      return matching if matching.one?
+
       exact = matching.select {|spec| spec.platform == platform }
       return exact if exact.any?
 
-      sorted_matching = matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
+      sorted_matching = sort_best_platform_match(matching, platform)
       exemplary_spec = sorted_matching.first
 
-      sorted_matching.take_while{|spec| same_specificity(platform, spec, exemplary_spec) && same_deps(spec, exemplary_spec) }
+      sorted_matching.take_while {|spec| same_specificity(platform, spec, exemplary_spec) && same_deps(spec, exemplary_spec) }
     end
-    module_function :select_best_platform_match
+    module_function :sort_and_filter_best_platform_match
+
+    def sort_best_platform_match(matching, platform)
+      matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
+    end
+    module_function :sort_best_platform_match
 
     class PlatformMatch
       def self.specificity_score(spec_platform, user_platform)
@@ -100,8 +142,6 @@ module Bundler
 
     def same_deps(spec, exemplary_spec)
       same_runtime_deps = spec.dependencies.sort == exemplary_spec.dependencies.sort
-      return same_runtime_deps unless spec.is_a?(Gem::Specification) && exemplary_spec.is_a?(Gem::Specification)
-
       same_metadata_deps = spec.required_ruby_version == exemplary_spec.required_ruby_version && spec.required_rubygems_version == exemplary_spec.required_rubygems_version
       same_runtime_deps && same_metadata_deps
     end

data/lib/bundler/gem_version_promoter.rb

@@ -7,14 +7,13 @@ module Bundler
   # available dependency versions as found in its index, before returning it to
   # to the resolution engine to select the best version.
   class GemVersionPromoter
-    DEBUG = ENV["BUNDLER_DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER"]
-
-    attr_reader :level, :locked_specs, :unlock_gems
+    attr_reader :level
+    attr_accessor :pre
 
     # By default, strict is false, meaning every available version of a gem
     # is returned from sort_versions. The order gives preference to the
     # requested level (:patch, :minor, :major) but in complicated requirement
-    # cases some gems will by necessity by promoted past the requested level,
+    # cases some gems will by necessity be promoted past the requested level,
     # or even reverted to older versions.
     #
     # If strict is set to true, the results from sort_versions will be
@@ -24,24 +23,13 @@ module Bundler
     # existing in the referenced source.
     attr_accessor :strict
 
-    attr_accessor :prerelease_specified
-
-    # Given a list of locked_specs and a list of gems to unlock creates a
-    # GemVersionPromoter instance.
+    # Creates a GemVersionPromoter instance.
     #
-    # @param locked_specs [SpecSet] All current locked specs. Unlike Definition
-    #   where this list is empty if all gems are being updated, this should
-    #   always be populated for all gems so this class can properly function.
-    # @param unlock_gems [String] List of gem names being unlocked. If empty,
-    #   all gems will be considered unlocked.
     # @return [GemVersionPromoter]
-    def initialize(locked_specs = SpecSet.new([]), unlock_gems = [])
+    def initialize
       @level = :major
       @strict = false
-      @locked_specs = locked_specs
-      @unlock_gems = unlock_gems
-      @sort_versions = {}
-      @prerelease_specified = {}
+      @pre = false
     end
 
     # @param value [Symbol] One of three Symbols: :major, :minor or :patch.
@@ -55,37 +43,39 @@ module Bundler
       @level = v
     end
 
-    # Given a Dependency and an Array of SpecGroups of available versions for a
-    # gem, this method will return the Array of SpecGroups sorted (and possibly
-    # truncated if strict is true) in an order to give preference to the current
-    # level (:major, :minor or :patch) when resolution is deciding what versions
-    # best resolve all dependencies in the bundle.
-    # @param dep [Dependency] The Dependency of the gem.
-    # @param spec_groups [SpecGroup] An array of SpecGroups for the same gem
-    #    named in the @dep param.
-    # @return [SpecGroup] A new instance of the SpecGroup Array sorted and
-    #    possibly filtered.
-    def sort_versions(dep, spec_groups)
-      before_result = "before sort_versions: #{debug_format_result(dep, spec_groups).inspect}" if DEBUG
-
-      @sort_versions[dep] ||= begin
-        gem_name = dep.name
-
-        # An Array per version returned, different entries for different platforms.
-        # We only need the version here so it's ok to hard code this to the first instance.
-        locked_spec = locked_specs[gem_name].first
-
-        if strict
-          filter_dep_specs(spec_groups, locked_spec)
+    # Given a Resolver::Package and an Array of Specifications of available
+    # versions for a gem, this method will return the Array of Specifications
+    # sorted in an order to give preference to the current level (:major, :minor
+    # or :patch) when resolution is deciding what versions best resolve all
+    # dependencies in the bundle.
+    # @param package [Resolver::Package] The package being resolved.
+    # @param specs [Specification] An array of Specifications for the package.
+    # @return [Specification] A new instance of the Specification Array sorted.
+    def sort_versions(package, specs)
+      locked_version = package.locked_version
+
+      result = specs.sort do |a, b|
+        unless package.prerelease_specified? || pre?
+          a_pre = a.prerelease?
+          b_pre = b.prerelease?
+
+          next 1 if a_pre && !b_pre
+          next -1 if b_pre && !a_pre
+        end
+
+        if major? || locked_version.nil?
+          b <=> a
+        elsif either_version_older_than_locked?(a, b, locked_version)
+          b <=> a
+        elsif segments_do_not_match?(a, b, :major)
+          a <=> b
+        elsif !minor? && segments_do_not_match?(a, b, :minor)
+          a <=> b
         else
-          sort_dep_specs(spec_groups, locked_spec)
-        end.tap do |specs|
-          if DEBUG
-            puts before_result
-            puts " after sort_versions: #{debug_format_result(dep, specs).inspect}"
-          end
+          b <=> a
         end
       end
+      post_sort(result, package.unlock?, locked_version)
     end
 
     # @return [bool] Convenience method for testing value of level variable.
@@ -98,93 +88,62 @@ module Bundler
       level == :minor
     end
 
-    private
-
-    def filter_dep_specs(spec_groups, locked_spec)
-      res = spec_groups.select do |spec_group|
-        if locked_spec && !major?
-          gsv = spec_group.version
-          lsv = locked_spec.version
-
-          must_match = minor? ? [0] : [0, 1]
-
-          matches = must_match.map {|idx| gsv.segments[idx] == lsv.segments[idx] }
-          matches.uniq == [true] ? (gsv >= lsv) : false
-        else
-          true
-        end
-      end
-
-      sort_dep_specs(res, locked_spec)
+    # @return [bool] Convenience method for testing value of pre variable.
+    def pre?
+      pre == true
     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
+    # Given a Resolver::Package and an Array of Specifications of available
+    # versions for a gem, this method will truncate the Array if strict
+    # is true. That means filtering out downgrades from the version currently
+    # locked, and filtering out upgrades that go past the selected level (major,
+    # minor, or patch).
+    # @param package [Resolver::Package] The package being resolved.
+    # @param specs [Specification] An array of Specifications for the package.
+    # @return [Specification] A new instance of the Specification Array
+    #   truncated.
+    def filter_versions(package, specs)
+      return specs unless strict
 
-      result = spec_groups.sort do |a, b|
-        @a_ver = a.version
-        @b_ver = b.version
+      locked_version = package.locked_version
+      return specs if locked_version.nil? || major?
 
-        unless @prerelease_specified[@gem_name]
-          a_pre = @a_ver.prerelease?
-          b_pre = @b_ver.prerelease?
+      specs.select do |spec|
+        gsv = spec.version
 
-          next -1 if a_pre && !b_pre
-          next  1 if b_pre && !a_pre
-        end
+        must_match = minor? ? [0] : [0, 1]
 
-        if major?
-          @a_ver <=> @b_ver
-        elsif either_version_older_than_locked
-          @a_ver <=> @b_ver
-        elsif segments_do_not_match(:major)
-          @b_ver <=> @a_ver
-        elsif !minor? && segments_do_not_match(:minor)
-          @b_ver <=> @a_ver
-        else
-          @a_ver <=> @b_ver
-        end
+        all_match = must_match.all? {|idx| gsv.segments[idx] == locked_version.segments[idx] }
+        all_match && gsv >= locked_version
       end
-      post_sort(result)
     end
 
-    def either_version_older_than_locked
-      @a_ver < @locked_version || @b_ver < @locked_version
-    end
+    private
 
-    def segments_do_not_match(level)
-      index = [:major, :minor].index(level)
-      @a_ver.segments[index] != @b_ver.segments[index]
+    def either_version_older_than_locked?(a, b, locked_version)
+      a.version < locked_version || b.version < locked_version
     end
 
-    def unlocking_gem?
-      unlock_gems.empty? || unlock_gems.include?(@gem_name)
+    def segments_do_not_match?(a, b, level)
+      index = [:major, :minor].index(level)
+      a.segments[index] != b.segments[index]
     end
 
     # Specific version moves can't always reliably be done during sorting
     # as not all elements are compared against each other.
-    def post_sort(result)
+    def post_sort(result, unlock, locked_version)
       # default :major behavior in Bundler does not do this
       return result if major?
-      if unlocking_gem?
+      if unlock || locked_version.nil?
         result
       else
-        move_version_to_end(result, @locked_version)
+        move_version_to_beginning(result, locked_version)
       end
     end
 
-    def move_version_to_end(result, version)
+    def move_version_to_beginning(result, version)
       move, keep = result.partition {|s| s.version.to_s == version.to_s }
-      keep.concat(move)
-    end
-
-    def debug_format_result(dep, spec_groups)
-      a = [dep.to_s,
-           spec_groups.map {|sg| [sg.version, sg.dependencies_for_activated_platforms.map {|dp| [dp.name, dp.requirement.to_s] }] }]
-      last_map = a.last.map {|sg_data| [sg_data.first.version, sg_data.last.map {|aa| aa.join(" ") }] }
-      [a.first, last_map, level, strict ? :strict : :not_strict]
+      move.concat(keep)
     end
   end
 end

data/lib/bundler/graph.rb

@@ -84,7 +84,7 @@ module Bundler
       else
         raise ArgumentError, "2nd argument is invalid"
       end
-      label.nil? ? {} : { :label => label }
+      label.nil? ? {} : { label: label }
     end
 
     def spec_for_dependency(dependency)
@@ -103,7 +103,7 @@ module Bundler
       end
 
       def g
-        @g ||= ::GraphViz.digraph(@graph_name, :concentrate => true, :normalize => true, :nodesep => 0.55) do |g|
+        @g ||= ::GraphViz.digraph(@graph_name, concentrate: true, normalize: true, nodesep: 0.55) do |g|
           g.edge[:weight]   = 2
           g.edge[:fontname] = g.node[:fontname] = "Arial, Helvetica, SansSerif"
           g.edge[:fontsize] = 12
@@ -114,10 +114,10 @@ module Bundler
         @groups.each do |group|
           g.add_nodes(
             group, {
-              :style     => "filled",
-              :fillcolor => "#B9B9D5",
-              :shape     => "box3d",
-              :fontsize  => 16,
+              style: "filled",
+              fillcolor: "#B9B9D5",
+              shape: "box3d",
+              fontsize: 16,
             }.merge(@node_options[group])
           )
         end
@@ -125,8 +125,8 @@ module Bundler
         @relations.each do |parent, children|
           children.each do |child|
             if @groups.include?(parent)
-              g.add_nodes(child, { :style => "filled", :fillcolor => "#B9B9D5" }.merge(@node_options[child]))
-              g.add_edges(parent, child, { :constraint => false }.merge(@edge_options["#{parent}_#{child}"]))
+              g.add_nodes(child, { style: "filled", fillcolor: "#B9B9D5" }.merge(@node_options[child]))
+              g.add_edges(parent, child, { constraint: false }.merge(@edge_options["#{parent}_#{child}"]))
             else
               g.add_nodes(child, @node_options[child])
               g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
@@ -135,7 +135,7 @@ module Bundler
         end
 
         if @output_format.to_s == "debug"
-          $stdout.puts g.output :none => String
+          $stdout.puts g.output none: String
           Bundler.ui.info "debugging bundle viz..."
         else
           begin