bundler 1.17.3 → 2.4.19

data/lib/bundler/gem_helpers.rb

@@ -2,7 +2,7 @@
 
 module Bundler
   module GemHelpers
-    GENERIC_CACHE = {} # rubocop:disable MutableConstant
+    GENERIC_CACHE = { Gem::Platform::RUBY => Gem::Platform::RUBY } # rubocop:disable Style/MutableConstant
     GENERICS = [
       [Gem::Platform.new("java"), Gem::Platform.new("java")],
       [Gem::Platform.new("mswin32"), Gem::Platform.new("mswin32")],
@@ -10,12 +10,11 @@ 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("mingw32"), Gem::Platform.new("x86-mingw32")]
+      [Gem::Platform.new("x64-mingw-ucrt"), Gem::Platform.new("x64-mingw-ucrt")],
+      [Gem::Platform.new("mingw32"), Gem::Platform.new("x86-mingw32")],
     ].freeze
 
     def generic(p)
-      return p if p == Gem::Platform::RUBY
-
       GENERIC_CACHE[p] ||= begin
         _, found = GENERICS.find do |match, _generic|
           p.os == match.os && (!match.cpu || p.cpu == match.cpu)
@@ -26,46 +25,49 @@ module Bundler
     module_function :generic
 
     def generic_local_platform
-      generic(Bundler.local_platform)
+      generic(local_platform)
     end
     module_function :generic_local_platform
 
+    def local_platform
+      Bundler.local_platform
+    end
+    module_function :local_platform
+
     def platform_specificity_match(spec_platform, user_platform)
       spec_platform = Gem::Platform.new(spec_platform)
-      return PlatformMatch::EXACT_MATCH if spec_platform == user_platform
-      return PlatformMatch::WORST_MATCH if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
-
-      PlatformMatch.new(
-        PlatformMatch.os_match(spec_platform, user_platform),
-        PlatformMatch.cpu_match(spec_platform, user_platform),
-        PlatformMatch.platform_version_match(spec_platform, user_platform)
-      )
+
+      PlatformMatch.specificity_score(spec_platform, user_platform)
     end
     module_function :platform_specificity_match
 
     def select_best_platform_match(specs, platform)
-      specs.select {|spec| spec.match_platform(platform) }.
-        min_by {|spec| platform_specificity_match(spec.platform, platform) }
+      matching = specs.select {|spec| spec.match_platform(platform) }
+
+      sort_best_platform_match(matching, platform)
     end
     module_function :select_best_platform_match
 
-    PlatformMatch = Struct.new(:os_match, :cpu_match, :platform_version_match)
-    class PlatformMatch
-      def <=>(other)
-        return nil unless other.is_a?(PlatformMatch)
+    def sort_best_platform_match(matching, platform)
+      exact = matching.select {|spec| spec.platform == platform }
+      return exact if exact.any?
 
-        m = os_match <=> other.os_match
-        return m unless m.zero?
+      sorted_matching = matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
+      exemplary_spec = sorted_matching.first
 
-        m = cpu_match <=> other.cpu_match
-        return m unless m.zero?
+      sorted_matching.take_while {|spec| same_specificity(platform, spec, exemplary_spec) && same_deps(spec, exemplary_spec) }
+    end
+    module_function :sort_best_platform_match
 
-        m = platform_version_match <=> other.platform_version_match
-        m
-      end
+    class PlatformMatch
+      def self.specificity_score(spec_platform, user_platform)
+        return -1 if spec_platform == user_platform
+        return 1_000_000 if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
 
-      EXACT_MATCH = new(-1, -1, -1).freeze
-      WORST_MATCH = new(1_000_000, 1_000_000, 1_000_000).freeze
+        os_match(spec_platform, user_platform) +
+          cpu_match(spec_platform, user_platform) * 10 +
+          platform_version_match(spec_platform, user_platform) * 100
+      end
 
       def self.os_match(spec_platform, user_platform)
         if spec_platform.os == user_platform.os
@@ -97,5 +99,19 @@ module Bundler
         end
       end
     end
+
+    def same_specificity(platform, spec, exemplary_spec)
+      platform_specificity_match(spec.platform, platform) == platform_specificity_match(exemplary_spec.platform, platform)
+    end
+    module_function :same_specificity
+
+    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
+    module_function :same_deps
   end
 end

data/lib/bundler/gem_tasks.rb

@@ -3,5 +3,5 @@
 require "rake/clean"
 CLOBBER.include "pkg"
 
-require "bundler/gem_helper"
+require_relative "gem_helper"
 Bundler::GemHelper.install_tasks

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["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,19 @@ 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
+    # Given a Resolver::Package and an Array of Specifications of available
+    # versions for a gem, this method will return the Array of Specifications
+    # 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 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 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
+    def sort_versions(package, specs)
+      specs = filter_dep_specs(specs, package) if strict
 
-        # 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)
-        else
-          sort_dep_specs(spec_groups, locked_spec)
-        end.tap do |specs|
-          if DEBUG
-            STDERR.puts before_result
-            STDERR.puts " after sort_versions: #{debug_format_result(dep, specs).inspect}"
-          end
-        end
-      end
+      sort_dep_specs(specs, package)
     end
 
     # @return [bool] Convenience method for testing value of level variable.
@@ -98,80 +68,72 @@ module Bundler
       level == :minor
     end
 
-  private
+    # @return [bool] Convenience method for testing value of pre variable.
+    def pre?
+      pre == true
+    end
 
-    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
+    private
 
-          must_match = minor? ? [0] : [0, 1]
+    def filter_dep_specs(specs, package)
+      locked_version = package.locked_version
+      return specs if locked_version.nil? || major?
 
-          matches = must_match.map {|idx| gsv.segments[idx] == lsv.segments[idx] }
-          (matches.uniq == [true]) ? (gsv >= lsv) : false
-        else
-          true
-        end
-      end
+      specs.select do |spec|
+        gsv = spec.version
 
-      sort_dep_specs(res, locked_spec)
-    end
+        must_match = minor? ? [0] : [0, 1]
 
-    def sort_dep_specs(spec_groups, locked_spec)
-      return spec_groups unless locked_spec
-      @gem_name = locked_spec.name
-      @locked_version = locked_spec.version
+        all_match = must_match.all? {|idx| gsv.segments[idx] == locked_version.segments[idx] }
+        all_match && gsv >= locked_version
+      end
+    end
 
-      result = spec_groups.sort do |a, b|
-        @a_ver = a.version
-        @b_ver = b.version
+    def sort_dep_specs(specs, package)
+      locked_version = package.locked_version
 
-        unless @prerelease_specified[@gem_name]
-          a_pre = @a_ver.prerelease?
-          b_pre = @b_ver.prerelease?
+      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?
-          @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
+          a <=> b
+        elsif either_version_older_than_locked?(a, b, locked_version)
+          a <=> b
+        elsif segments_do_not_match?(a, b, :major)
+          b <=> a
+        elsif !minor? && segments_do_not_match?(a, b, :minor)
+          b <=> a
         else
-          @a_ver <=> @b_ver
+          a <=> b
         end
       end
-      post_sort(result)
+      post_sort(result, package.unlock?, locked_version)
     end
 
-    def either_version_older_than_locked
-      @a_ver < @locked_version || @b_ver < @locked_version
+    def either_version_older_than_locked?(a, b, locked_version)
+      locked_version && (a.version < locked_version || b.version < locked_version)
     end
 
-    def segments_do_not_match(level)
+    def segments_do_not_match?(a, b, level)
       index = [:major, :minor].index(level)
-      @a_ver.segments[index] != @b_ver.segments[index]
-    end
-
-    def unlocking_gem?
-      unlock_gems.empty? || unlock_gems.include?(@gem_name)
+      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_end(result, locked_version)
       end
     end
 
@@ -179,12 +141,5 @@ module Bundler
       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]
-    end
   end
 end

data/lib/bundler/graph.rb

@@ -27,7 +27,7 @@ module Bundler
       GraphVizClient.new(self).run
     end
 
-  private
+    private
 
     def _populate_relations
       parent_dependencies = _groups.values.to_set.flatten
@@ -114,10 +114,10 @@ module Bundler
         @groups.each do |group|
           g.add_nodes(
             group, {
-              :style     => "filled",
+              :style => "filled",
               :fillcolor => "#B9B9D5",
-              :shape     => "box3d",
-              :fontsize  => 16
+              :shape => "box3d",
+              :fontsize => 16,
             }.merge(@node_options[group])
           )
         end
@@ -142,7 +142,7 @@ module Bundler
             g.output @output_format.to_sym => "#{@output_file}.#{@output_format}"
             Bundler.ui.info "#{@output_file}.#{@output_format}"
           rescue ArgumentError => e
-            $stderr.puts "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
+            warn "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
             raise e
           end
         end

data/lib/bundler/index.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module Bundler
   class Index
     include Enumerable
@@ -15,8 +13,8 @@ module Bundler
     attr_reader :specs, :all_specs, :sources
     protected :specs, :all_specs
 
-    RUBY = "ruby".freeze
-    NULL = "\0".freeze
+    RUBY = "ruby"
+    NULL = "\0"
 
     def initialize
       @sources = []
@@ -58,42 +56,21 @@ module Bundler
 
     # Search this index's specs, and any source indexes that this index knows
     # about, returning all of the results.
-    def search(query, base = nil)
-      sort_specs(unsorted_search(query, base))
-    end
-
-    def unsorted_search(query, base)
-      results = local_search(query, base)
-
-      seen = results.map(&:full_name).to_set unless @sources.empty?
+    def search(query)
+      results = local_search(query)
+      return results unless @sources.any?
 
       @sources.each do |source|
-        source.unsorted_search(query, base).each do |spec|
-          results << spec if seen.add?(spec.full_name)
-        end
-      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]
+        results.concat(source.search(query))
       end
+      results.uniq(&:full_name)
     end
 
-    def sort_specs(specs)
-      self.class.sort_specs(specs)
-    end
-
-    def local_search(query, base = nil)
+    def local_search(query)
       case query
       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, base)
-      when DepProxy then search_by_dependency(query.dep, base)
+      when Array then specs_by_name_and_version(*query)
       else
         raise "You can't search for a #{query.inspect}."
       end
@@ -121,10 +98,9 @@ module Bundler
       names
     end
 
-    # returns a list of the dependencies
     def unmet_dependency_names
       dependency_names.select do |name|
-        name != "bundler" && search(name).empty?
+        search(name).empty?
       end
     end
 
@@ -170,7 +146,7 @@ module Bundler
     def dependencies_eql?(spec, other_spec)
       deps       = spec.dependencies.select {|d| d.type != :development }
       other_deps = other_spec.dependencies.select {|d| d.type != :development }
-      Set.new(deps) == Set.new(other_deps)
+      deps.sort == other_deps.sort
     end
 
     def add_source(index)
@@ -179,28 +155,14 @@ module Bundler
       @sources.uniq! # need to use uniq! here instead of checking for the item before adding
     end
 
-  private
+    private
 
-    def specs_by_name(name)
-      @specs[name].values
+    def specs_by_name_and_version(name, version)
+      specs_by_name(name).select {|spec| spec.version == version }
     end
 
-    def search_by_dependency(dependency, base = nil)
-      @cache[base || false] ||= {}
-      @cache[base || false][dependency] ||= begin
-        specs = specs_by_name(dependency.name)
-        specs += base if base
-        found = specs.select do |spec|
-          next true if spec.source.is_a?(Source::Gemspec)
-          if base # allow all platforms when searching from a lockfile
-            dependency.matches_spec?(spec)
-          else
-            dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform)
-          end
-        end
-
-        found
-      end
+    def specs_by_name(name)
+      @specs[name].values
     end
 
     EMPTY_SEARCH = [].freeze

data/lib/bundler/injector.rb

@@ -2,7 +2,7 @@
 
 module Bundler
   class Injector
-    INJECTED_GEMS = "injected gems".freeze
+    INJECTED_GEMS = "injected gems"
 
     def self.inject(new_deps, options = {})
       injector = new(new_deps, options)
@@ -70,11 +70,15 @@ 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.
+      # This prevents e.g. `bundle remove ...` from using outdated information.
+      Bundler.reset_paths!
     end
 
-  private
+    private
 
     def conservative_version(spec)
       version = spec.version
@@ -111,8 +115,14 @@ module Bundler
         end
 
         source = ", :source => \"#{d.source}\"" unless d.source.nil?
-
-        %(gem #{name}#{requirement}#{group}#{source})
+        path = ", :path => \"#{d.path}\"" unless d.path.nil?
+        git = ", :git => \"#{d.git}\"" unless d.git.nil?
+        github = ", :github => \"#{d.github}\"" unless d.github.nil?
+        branch = ", :branch => \"#{d.branch}\"" unless d.branch.nil?
+        ref = ", :ref => \"#{d.ref}\"" unless d.ref.nil?
+        require_path = ", :require => #{convert_autorequire(d.autorequire)}" unless d.autorequire.nil?
+
+        %(gem #{name}#{requirement}#{group}#{source}#{path}#{git}#{github}#{branch}#{ref}#{require_path})
       end.join("\n")
     end
 
@@ -123,10 +133,10 @@ module Bundler
       end
     end
 
-    # evalutes a gemfile to remove the specified gem
+    # evaluates a gemfile to remove the specified gem
     # from it.
     def remove_deps(gemfile_path)
-      initial_gemfile = IO.readlines(gemfile_path)
+      initial_gemfile = File.readlines(gemfile_path)
 
       Bundler.ui.info "Removing gems from #{gemfile_path}"
 
@@ -136,8 +146,8 @@ module Bundler
 
       removed_deps = remove_gems_from_dependencies(builder, @deps, gemfile_path)
 
-      # abort the opertion if no gems were removed
-      # no need to operate on gemfile furthur
+      # abort the operation if no gems were removed
+      # no need to operate on gemfile further
       return [] if removed_deps.empty?
 
       cleaned_gemfile = remove_gems_from_gemfile(@deps, gemfile_path)
@@ -153,8 +163,8 @@ module Bundler
 
     # @param [Dsl]      builder Dsl object of current Gemfile.
     # @param [Array]    gems Array of names of gems to be removed.
-    # @param [Pathname] path of the Gemfile
-    # @return [Array]   removed_deps Array of removed dependencies.
+    # @param [Pathname] gemfile_path Path of the Gemfile.
+    # @return [Array]   Array of removed dependencies.
     def remove_gems_from_dependencies(builder, gems, gemfile_path)
       removed_deps = []
 
@@ -177,11 +187,22 @@ module Bundler
     # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
     def remove_gems_from_gemfile(gems, gemfile_path)
       patterns = /gem\s+(['"])#{Regexp.union(gems)}\1|gem\s*\((['"])#{Regexp.union(gems)}\2\)/
+      new_gemfile = []
+      multiline_removal = false
+      File.readlines(gemfile_path).each do |line|
+        match_data = line.match(patterns)
+        if match_data && is_not_within_comment?(line, match_data)
+          multiline_removal = line.rstrip.end_with?(",")
+          # skip lines which match the regex
+          next
+        end
 
-      # remove lines which match the regex
-      new_gemfile = IO.readlines(gemfile_path).reject {|line| line.match(patterns) }
+        # skip followup lines until line does not end with ','
+        new_gemfile << line unless multiline_removal
+        multiline_removal = line.rstrip.end_with?(",") if multiline_removal
+      end
 
-      # remove lone \n and append them with other strings
+      # remove line \n and append them with other strings
       new_gemfile.each_with_index do |_line, index|
         if new_gemfile[index + 1] == "\n"
           new_gemfile[index] += new_gemfile[index + 1]
@@ -194,6 +215,13 @@ module Bundler
       new_gemfile.join.chomp
     end
 
+    # @param [String] line          Individual line of gemfile content.
+    # @param [MatchData] match_data Data about Regex match.
+    def is_not_within_comment?(line, match_data)
+      match_start_index = match_data.offset(0).first
+      !line[0..match_start_index].include?("#")
+    end
+
     # @param [Array] gemfile       Array of gemfile contents.
     # @param [String] block_name   Name of block name to look for.
     def remove_nested_blocks(gemfile, block_name)
@@ -206,8 +234,8 @@ module Bundler
         nested_blocks -= 1
 
         gemfile.each_with_index do |line, index|
-          next unless !line.nil? && line.include?(block_name)
-          if gemfile[index + 1] =~ /^\s*end\s*$/
+          next unless !line.nil? && line.strip.start_with?(block_name)
+          if /^\s*end\s*$/.match?(gemfile[index + 1])
             gemfile[index] = nil
             gemfile[index + 1] = nil
           end
@@ -222,7 +250,7 @@ module Bundler
     # @param [Array] removed_deps      Array of removed dependencies.
     # @param [Array] initial_gemfile   Contents of original Gemfile before any operation.
     def cross_check_for_errors(gemfile_path, original_deps, removed_deps, initial_gemfile)
-      # evalute the new gemfile to look for any failure cases
+      # evaluate the new gemfile to look for any failure cases
       builder = Dsl.new
       builder.eval_gemfile(gemfile_path)
 
@@ -249,5 +277,11 @@ module Bundler
     def show_warning(message)
       Bundler.ui.info Bundler.ui.add_color(message, :yellow)
     end
+
+    def convert_autorequire(autorequire)
+      autorequire = autorequire.first
+      return autorequire if autorequire == "false"
+      autorequire.inspect
+    end
   end
 end