rubygems-update 3.5.3 → 3.7.1

data/bundler/lib/bundler/source_list.rb

@@ -22,6 +22,7 @@ module Bundler
       @metadata_source        = Source::Metadata.new
 
       @merged_gem_lockfile_sections = false
+      @local_mode = true
     end
 
     def merged_gem_lockfile_sections?
@@ -73,6 +74,10 @@ module Bundler
       global_rubygems_source
     end
 
+    def local_mode?
+      @local_mode
+    end
+
     def default_source
       global_path_source || global_rubygems_source
     end
@@ -86,7 +91,7 @@ module Bundler
     end
 
     def rubygems_remotes
-      rubygems_sources.map(&:remotes).flatten.uniq
+      rubygems_sources.flat_map(&:remotes).uniq
     end
 
     def all_sources
@@ -98,7 +103,7 @@ module Bundler
     end
 
     def get(source)
-      source_list_for(source).find {|s| equivalent_source?(source, s) }
+      source_list_for(source).find {|s| s.include?(source) }
     end
 
     def lock_sources
@@ -136,15 +141,25 @@ module Bundler
       different_sources?(lock_sources, replacement_sources)
     end
 
+    def prefer_local!
+      all_sources.each(&:prefer_local!)
+    end
+
     def local_only!
       all_sources.each(&:local_only!)
     end
 
+    def local!
+      all_sources.each(&:local!)
+    end
+
     def cached!
       all_sources.each(&:cached!)
     end
 
     def remote!
+      @local_mode = false
+
       all_sources.each(&:remote!)
     end
 
@@ -157,27 +172,58 @@ module Bundler
     end
 
     def map_sources(replacement_sources)
-      rubygems, git, plugin = [@rubygems_sources, @git_sources, @plugin_sources].map do |sources|
+      rubygems = @rubygems_sources.map do |source|
+        replace_rubygems_source(replacement_sources, source)
+      end
+
+      git, plugin = [@git_sources, @plugin_sources].map do |sources|
         sources.map do |source|
-          replacement_sources.find {|s| s == source } || source
+          replace_source(replacement_sources, source)
         end
       end
 
       path = @path_sources.map do |source|
-        replacement_sources.find {|s| s == (source.is_a?(Source::Gemspec) ? source.as_path_source : source) } || source
+        replace_path_source(replacement_sources, source)
       end
 
       [rubygems, path, git, plugin]
     end
 
     def global_replacement_source(replacement_sources)
-      replacement_source = replacement_sources.find {|s| s == global_rubygems_source }
-      return global_rubygems_source unless replacement_source
+      replace_rubygems_source(replacement_sources, global_rubygems_source, &:local!)
+    end
+
+    def replace_rubygems_source(replacement_sources, gemfile_source)
+      replace_source(replacement_sources, gemfile_source) do |replacement_source|
+        # locked sources never include credentials so always prefer remotes from the gemfile
+        replacement_source.remotes = gemfile_source.remotes
+
+        yield replacement_source if block_given?
+
+        replacement_source
+      end
+    end
+
+    def replace_source(replacement_sources, gemfile_source)
+      replacement_source = replacement_sources.find {|s| s == gemfile_source }
+      return gemfile_source unless replacement_source
+
+      replacement_source = yield(replacement_source) if block_given?
 
-      replacement_source.local!
       replacement_source
     end
 
+    def replace_path_source(replacement_sources, gemfile_source)
+      replace_source(replacement_sources, gemfile_source) do |replacement_source|
+        if gemfile_source.is_a?(Source::Gemspec)
+          gemfile_source.checksum_store = replacement_source.checksum_store
+          gemfile_source
+        else
+          replacement_source
+        end
+      end
+    end
+
     def different_sources?(lock_sources, replacement_sources)
       !equivalent_sources?(lock_sources, replacement_sources)
     end
@@ -219,9 +265,5 @@ module Bundler
     def equivalent_sources?(lock_sources, replacement_sources)
       lock_sources.sort_by(&:identifier) == replacement_sources.sort_by(&:identifier)
     end
-
-    def equivalent_source?(source, other_source)
-      source == other_source
-    end
   end
 end

data/bundler/lib/bundler/source_map.rb

@@ -23,7 +23,7 @@ module Bundler
           if previous_source.nil?
             requirements[indirect_dependency_name] = source
           else
-            no_ambiguous_sources = Bundler.feature_flag.bundler_3_mode?
+            no_ambiguous_sources = Bundler.feature_flag.bundler_4_mode?
 
             msg = ["The gem '#{indirect_dependency_name}' was found in multiple relevant sources."]
             msg.concat [previous_source, source].map {|s| "  * #{s}" }.sort

data/bundler/lib/bundler/spec_set.rb

@@ -7,89 +7,86 @@ module Bundler
     include Enumerable
     include TSort
 
-    attr_reader :incomplete_specs
-
-    def initialize(specs, incomplete_specs = [])
+    def initialize(specs)
       @specs = specs
-      @incomplete_specs = incomplete_specs
     end
 
-    def for(dependencies, check = false, platforms = [nil])
-      handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
-      deps = dependencies.product(platforms)
-      specs = []
+    def for(dependencies, platforms_or_legacy_check = [nil], legacy_platforms = [nil], skips: [])
+      platforms = if [true, false].include?(platforms_or_legacy_check)
+        Bundler::SharedHelpers.major_deprecation 2,
+          "SpecSet#for received a `check` parameter, but that's no longer used and deprecated. " \
+          "SpecSet#for always implicitly performs validation. Please remove this parameter",
+          print_caller_location: true
 
-      loop do
-        break unless dep = deps.shift
+        legacy_platforms
+      else
+        platforms_or_legacy_check
+      end
 
-        name = dep[0].name
-        platform = dep[1]
-        incomplete = false
+      materialize_dependencies(dependencies, platforms, skips: skips)
 
-        key = [name, platform]
-        next if handled.key?(key)
+      @materializations.flat_map(&:specs).uniq
+    end
 
-        handled[key] = true
+    def normalize_platforms!(deps, platforms)
+      remove_invalid_platforms!(deps, platforms)
+      add_extra_platforms!(platforms)
 
-        specs_for_dep = specs_for_dependency(*dep)
-        if specs_for_dep.any?
-          specs.concat(specs_for_dep)
+      platforms.map! do |platform|
+        next platform if platform == Gem::Platform::RUBY
 
-          specs_for_dep.first.dependencies.each do |d|
-            next if d.type == :development
-            incomplete = true if d.name != "bundler" && lookup[d.name].nil?
-            deps << [d, dep[1]]
-          end
-        else
-          incomplete = true
+        begin
+          Integer(platform.version)
+        rescue ArgumentError, TypeError
+          next platform
         end
 
-        if incomplete && check
-          @incomplete_specs += lookup[name] || [LazySpecification.new(name, nil, nil)]
-        end
+        less_specific_platform = Gem::Platform.new([platform.cpu, platform.os, nil])
+        next platform if incomplete_for_platform?(deps, less_specific_platform)
+
+        less_specific_platform
+      end.uniq!
+    end
+
+    def add_originally_invalid_platforms!(platforms, originally_invalid_platforms)
+      originally_invalid_platforms.each do |originally_invalid_platform|
+        platforms << originally_invalid_platform if complete_platform(originally_invalid_platform)
       end
+    end
 
-      specs.uniq
+    def remove_invalid_platforms!(deps, platforms, skips: [])
+      invalid_platforms = []
+
+      platforms.reject! do |platform|
+        next false if skips.include?(platform)
+
+        invalid = incomplete_for_platform?(deps, platform)
+        invalid_platforms << platform if invalid
+        invalid
+      end
+
+      invalid_platforms
     end
 
-    def complete_platforms!(platforms)
-      return platforms.concat([Gem::Platform::RUBY]).uniq if @specs.empty?
+    def add_extra_platforms!(platforms)
+      if @specs.empty?
+        platforms.concat([Gem::Platform::RUBY]).uniq
+        return
+      end
 
-      new_platforms = @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq.select do |platform|
+      new_platforms = all_platforms.select do |platform|
         next if platforms.include?(platform)
-        next unless GemHelpers.generic(platform) == Gem::Platform::RUBY
-
-        new_specs = []
-
-        valid_platform = lookup.all? do |_, specs|
-          spec = specs.first
-          matching_specs = spec.source.specs.search([spec.name, spec.version])
-          platform_spec = GemHelpers.select_best_platform_match(matching_specs, platform).find do |s|
-            s.matches_current_metadata? && valid_dependencies?(s)
-          end
-
-          if platform_spec
-            new_specs << LazySpecification.from_spec(platform_spec)
-            true
-          else
-            false
-          end
-        end
-        next unless valid_platform
+        next unless Gem::Platform.generic(platform) == Gem::Platform::RUBY
 
-        @specs.concat(new_specs.uniq)
+        complete_platform(platform)
       end
-      return platforms if new_platforms.empty?
+      return if new_platforms.empty?
 
       platforms.concat(new_platforms)
+      return if new_platforms.include?(Bundler.local_platform)
 
-      less_specific_platform = new_platforms.find {|platform| platform != Gem::Platform::RUBY && platform === Bundler.local_platform }
+      less_specific_platform = new_platforms.find {|platform| platform != Gem::Platform::RUBY && Bundler.local_platform === platform && platform === Bundler.local_platform }
       platforms.delete(Bundler.local_platform) if less_specific_platform
-
-      @sorted = nil
-      @lookup = nil
-
-      platforms
     end
 
     def validate_deps(s)
@@ -109,15 +106,13 @@ module Bundler
     end
 
     def []=(key, value)
-      @specs << value
-      @lookup = nil
-      @sorted = nil
+      delete_by_name(key)
+
+      add_spec(value)
     end
 
     def delete(specs)
-      specs.each {|spec| @specs.delete(spec) }
-      @lookup = nil
-      @sorted = nil
+      Array(specs).each {|spec| remove_spec(spec) }
     end
 
     def sort!
@@ -133,50 +128,80 @@ module Bundler
     end
 
     def materialize(deps)
-      materialized = self.for(deps, true)
+      materialize_dependencies(deps)
 
-      SpecSet.new(materialized, incomplete_specs)
+      SpecSet.new(materialized_specs)
     end
 
     # Materialize for all the specs in the spec set, regardless of what platform they're for
-    # This is in contrast to how for does platform filtering (and specifically different from how `materialize` calls `for` only for the current platform)
     # @return [Array<Gem::Specification>]
     def materialized_for_all_platforms
       @specs.map do |s|
         next s unless s.is_a?(LazySpecification)
-        s.source.remote!
-        spec = s.materialize_for_installation
+        spec = s.materialize_for_cache
         raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
         spec
       end
     end
 
     def incomplete_for_platform?(deps, platform)
-      return false if @specs.empty?
+      incomplete_specs_for_platform(deps, platform).any?
+    end
+
+    def incomplete_specs_for_platform(deps, platform)
+      return [] if @specs.empty?
 
-      @incomplete_specs = []
+      validation_set = self.class.new(@specs)
+      validation_set.for(deps, [platform])
+      validation_set.incomplete_specs
+    end
 
-      self.for(deps, true, [platform])
+    def missing_specs_for(deps)
+      materialize_dependencies(deps)
 
-      @incomplete_specs.any?
+      missing_specs
     end
 
     def missing_specs
-      @specs.select {|s| s.is_a?(LazySpecification) }
+      @materializations.flat_map(&:completely_missing_specs)
+    end
+
+    def partially_missing_specs
+      @materializations.flat_map(&:partially_missing_specs)
+    end
+
+    def incomplete_specs
+      @materializations.flat_map(&:incomplete_specs)
+    end
+
+    def insecurely_materialized_specs
+      materialized_specs.select(&:insecurely_materialized?)
     end
 
     def -(other)
+      SharedHelpers.major_deprecation 2, "SpecSet#- has been removed with no replacement"
+
       SpecSet.new(to_a - other.to_a)
     end
 
     def find_by_name_and_platform(name, platform)
-      @specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
+      @specs.detect {|spec| spec.name == name && spec.installable_on_platform?(platform) }
+    end
+
+    def specs_with_additional_variants_from(other)
+      sorted | additional_variants_from(other)
     end
 
     def delete_by_name(name)
       @specs.reject! {|spec| spec.name == name }
-      @lookup = nil
-      @sorted = nil
+      @sorted&.reject! {|spec| spec.name == name }
+      return if @lookup.nil?
+
+      @lookup[name] = nil
+    end
+
+    def version_for(name)
+      exemplary_spec(name)&.version
     end
 
     def what_required(spec)
@@ -187,6 +212,8 @@ module Bundler
     end
 
     def <<(spec)
+      SharedHelpers.major_deprecation 2, "SpecSet#<< has been removed with no replacement"
+
       @specs << spec
     end
 
@@ -210,22 +237,98 @@ module Bundler
       lookup.keys
     end
 
+    def valid?(s)
+      s.matches_current_metadata? && valid_dependencies?(s)
+    end
+
+    def to_s
+      map(&:full_name).to_s
+    end
+
     private
 
+    def materialize_dependencies(dependencies, platforms = [nil], skips: [])
+      handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
+      deps = dependencies.product(platforms)
+      @materializations = []
+
+      loop do
+        break unless dep = deps.shift
+
+        dependency = dep[0]
+        platform = dep[1]
+        name = dependency.name
+
+        key = [name, platform]
+        next if handled.key?(key)
+
+        handled[key] = true
+
+        materialization = Materialization.new(dependency, platform, candidates: lookup[name])
+
+        deps.concat(materialization.dependencies) if materialization.complete?
+
+        @materializations << materialization unless skips.include?(name)
+      end
+
+      @materializations
+    end
+
+    def materialized_specs
+      @materializations.filter_map(&:materialized_spec)
+    end
+
+    def complete_platform(platform)
+      new_specs = []
+
+      valid_platform = lookup.all? do |_, specs|
+        spec = specs.first
+        matching_specs = spec.source.specs.search([spec.name, spec.version])
+        platform_spec = MatchPlatform.select_best_platform_match(matching_specs, platform).find do |s|
+          valid?(s)
+        end
+
+        if platform_spec
+          new_specs << LazySpecification.from_spec(platform_spec) unless specs.include?(platform_spec)
+          true
+        else
+          false
+        end
+      end
+
+      if valid_platform && new_specs.any?
+        new_specs.each {|spec| add_spec(spec) }
+      end
+
+      valid_platform
+    end
+
+    def all_platforms
+      @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq
+    end
+
+    def additional_variants_from(other)
+      other.select do |other_spec|
+        spec = exemplary_spec(other_spec.name)
+        next unless spec
+
+        selected = spec.version == other_spec.version && valid_dependencies?(other_spec)
+        other_spec.source = spec.source if selected
+        selected
+      end
+    end
+
     def valid_dependencies?(s)
       validate_deps(s) == :valid
     end
 
     def sorted
-      rake = @specs.find {|s| s.name == "rake" }
-      begin
-        @sorted ||= ([rake] + tsort).compact.uniq
-      rescue TSort::Cyclic => error
-        cgems = extract_circular_gems(error)
-        raise CyclicDependencyError, "Your bundle requires gems that depend" \
-          " on each other, creating an infinite loop. Please remove either" \
-          " gem '#{cgems[0]}' or gem '#{cgems[1]}' and try again."
-      end
+      @sorted ||= ([@specs.find {|s| s.name == "rake" }] + tsort).compact.uniq
+    rescue TSort::Cyclic => error
+      cgems = extract_circular_gems(error)
+      raise CyclicDependencyError, "Your bundle requires gems that depend" \
+        " on each other, creating an infinite loop. Please remove either" \
+        " gem '#{cgems[0]}' or gem '#{cgems[1]}' and try again."
     end
 
     def extract_circular_gems(error)
@@ -236,8 +339,7 @@ module Bundler
       @lookup ||= begin
         lookup = {}
         @specs.each do |s|
-          lookup[s.name] ||= []
-          lookup[s.name] << s
+          index_spec(lookup, s.name, s)
         end
         lookup
       end
@@ -248,19 +350,6 @@ module Bundler
       @specs.sort_by(&:name).each {|s| yield s }
     end
 
-    def specs_for_dependency(dep, platform)
-      specs_for_name = lookup[dep.name]
-      return [] unless specs_for_name
-
-      matching_specs = if dep.force_ruby_platform
-        GemHelpers.force_ruby_platform(specs_for_name)
-      else
-        GemHelpers.select_best_platform_match(specs_for_name, platform || Bundler.local_platform)
-      end
-      matching_specs.map!(&:materialize_for_installation).compact! if platform.nil?
-      matching_specs
-    end
-
     def tsort_each_child(s)
       s.dependencies.sort_by(&:name).each do |d|
         next if d.type == :development
@@ -271,5 +360,40 @@ module Bundler
         specs_for_name.each {|s2| yield s2 }
       end
     end
+
+    def add_spec(spec)
+      @specs << spec
+
+      name = spec.name
+
+      @sorted&.insert(@sorted.bsearch_index {|s| s.name >= name } || @sorted.size, spec)
+      return if @lookup.nil?
+
+      index_spec(@lookup, name, spec)
+    end
+
+    def remove_spec(spec)
+      @specs.delete(spec)
+      @sorted&.delete(spec)
+      return if @lookup.nil?
+
+      indexed_specs = @lookup[spec.name]
+      return unless indexed_specs
+
+      if indexed_specs.size > 1
+        @lookup[spec.name].delete(spec)
+      else
+        @lookup[spec.name] = nil
+      end
+    end
+
+    def index_spec(hash, key, value)
+      hash[key] ||= []
+      hash[key] << value
+    end
+
+    def exemplary_spec(name)
+      self[name].first
+    end
   end
 end

data/bundler/lib/bundler/stub_specification.rb

@@ -9,6 +9,10 @@ module Bundler
       spec
     end
 
+    def insecurely_materialized?
+      false
+    end
+
     attr_reader :checksum
     attr_accessor :stub, :ignored
 
@@ -28,6 +32,17 @@ module Bundler
 
     # @!group Stub Delegates
 
+    def ignored?
+      return @ignored unless @ignored.nil?
+
+      @ignored = missing_extensions?
+      return false unless @ignored
+
+      warn "Source #{source} is ignoring #{self} because it is missing extensions"
+
+      true
+    end
+
     def manually_installed?
       # This is for manually installed gems which are gems that were fixed in place after a
       # failed installation. Once the issue was resolved, the user then manually created
@@ -45,8 +60,8 @@ module Bundler
       true
     end
 
-    def activated
-      stub.activated
+    def activated?
+      stub.activated?
     end
 
     def activated=(activated)
@@ -77,6 +92,14 @@ module Bundler
       stub.full_require_paths
     end
 
+    def require_paths
+      stub.require_paths
+    end
+
+    def base_dir=(path)
+      stub.base_dir = path
+    end
+
     def load_paths
       full_require_paths
     end
@@ -93,6 +116,10 @@ module Bundler
       stub.raw_require_paths
     end
 
+    def inspect
+      "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
+    end
+
     private
 
     def _remote_specification

data/bundler/lib/bundler/templates/Executable

@@ -10,17 +10,6 @@
 
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("<%= relative_gemfile_path %>", __dir__)
 
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
 require "rubygems"
 require "bundler/setup"