rubygems-update 3.3.19 → 3.3.22

data/bundler/lib/bundler/definition.rb

@@ -70,6 +70,7 @@ module Bundler
       @unlock          = unlock
       @optional_groups = optional_groups
       @remote          = false
+      @prefer_local    = false
       @specs           = nil
       @ruby_version    = ruby_version
       @gemfiles        = gemfiles
@@ -144,8 +145,6 @@ module Bundler
       @dependency_changes = converge_dependencies
       @local_changes = converge_locals
 
-      @reresolve = nil
-
       @requires = compute_requires
     end
 
@@ -170,6 +169,13 @@ module Bundler
       resolve
     end
 
+    def resolve_prefering_local!
+      @prefer_local = true
+      @remote = true
+      sources.remote!
+      resolve
+    end
+
     def resolve_with_cache!
       sources.cached!
       resolve
@@ -210,6 +216,7 @@ module Bundler
       true
     rescue BundlerError => e
       @resolve = nil
+      @resolver = nil
       @specs = nil
       @gem_version_promoter = nil
 
@@ -280,7 +287,7 @@ module Bundler
         end
       else
         Bundler.ui.debug("Found changes from the lockfile, re-resolving dependencies because #{change_reason}")
-        @reresolve = reresolve
+        resolver.start(expanded_dependencies)
       end
     end
 
@@ -474,10 +481,16 @@ module Bundler
 
     private
 
-    def reresolve
-      last_resolve = converge_locked_specs
-      expanded_dependencies = expand_dependencies(dependencies + metadata_dependencies, true)
-      Resolver.resolve(expanded_dependencies, source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve, platforms)
+    def resolver
+      @resolver ||= begin
+        last_resolve = converge_locked_specs
+        remove_ruby_from_platforms_if_necessary!(dependencies)
+        Resolver.new(source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve(last_resolve), platforms)
+      end
+    end
+
+    def expanded_dependencies
+      @expanded_dependencies ||= expand_dependencies(dependencies + metadata_dependencies, true)
     end
 
     def filter_specs(specs, deps)
@@ -505,21 +518,17 @@ module Bundler
         raise GemNotFound, "Could not find #{missing_specs_list.join(" nor ")}"
       end
 
-      if @reresolve.nil?
+      loop do
         incomplete_specs = specs.incomplete_specs
+        break if incomplete_specs.empty?
 
-        if incomplete_specs.any?
-          Bundler.ui.debug("The lockfile does not have all gems needed for the current platform though, Bundler will still re-resolve dependencies")
-          @unlock[:gems].concat(incomplete_specs.map(&:name))
-          @resolve = reresolve
-          specs = resolve.materialize(dependencies)
-        end
+        Bundler.ui.debug("The lockfile does not have all gems needed for the current platform though, Bundler will still re-resolve dependencies")
+        @resolve = resolver.start(expanded_dependencies, :exclude_specs => incomplete_specs)
+        specs = resolve.materialize(dependencies)
       end
 
-      unless specs["bundler"].any?
-        bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last
-        specs["bundler"] = bundler
-      end
+      bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last
+      specs["bundler"] = bundler
 
       specs
     end
@@ -528,6 +537,19 @@ module Bundler
       @remote && sources.non_global_rubygems_sources.all?(&:dependency_api_available?) && !sources.aggregate_global_source?
     end
 
+    def pin_locally_available_names(source_requirements)
+      source_requirements.each_with_object({}) do |(name, original_source), new_source_requirements|
+        local_source = original_source.dup
+        local_source.local_only!
+
+        new_source_requirements[name] = if local_source.specs.search(name).any?
+          local_source
+        else
+          original_source
+        end
+      end
+    end
+
     def current_ruby_platform_locked?
       return false unless generic_local_platform == Gem::Platform::RUBY
       return false if Bundler.settings[:force_ruby_platform] && !@platforms.include?(Gem::Platform::RUBY)
@@ -695,7 +717,9 @@ module Bundler
     # commonly happen if the Gemfile has changed since the lockfile was last
     # generated
     def converge_locked_specs
-      resolve = converge_specs(@locked_specs)
+      converged = converge_specs(@locked_specs)
+
+      resolve = SpecSet.new(converged.reject {|s| @unlock[:gems].include?(s.name) })
 
       diff = nil
 
@@ -719,16 +743,24 @@ module Bundler
         specs[dep].any? {|s| s.satisfies?(dep) && (!dep.source || s.source.include?(dep.source)) }
       end
 
+      @specs_that_changed_sources = []
+
       specs.each do |s|
-        # Replace the locked dependency's source with the equivalent source from the Gemfile
         dep = @dependencies.find {|d| s.satisfies?(d) }
 
-        s.source = (dep && dep.source) || sources.get(s.source) || sources.default_source
+        # Replace the locked dependency's source with the equivalent source from the Gemfile
+        s.source = if dep && dep.source
+          gemfile_source = dep.source
+          lockfile_source = s.source
 
-        next if @unlock[:sources].include?(s.source.name)
+          @specs_that_changed_sources << s if gemfile_source != lockfile_source
 
-        # If the spec is from a path source and it doesn't exist anymore
-        # then we unlock it.
+          gemfile_source
+        else
+          sources.get_with_fallback(s.source)
+        end
+
+        next if @unlock[:sources].include?(s.source.name)
 
         # Path sources have special logic
         if s.source.instance_of?(Source::Path) || s.source.instance_of?(Source::Gemspec)
@@ -760,12 +792,12 @@ module Bundler
         end
       end
 
-      SpecSet.new(filter_specs(converged, deps).reject {|s| @unlock[:gems].include?(s.name) })
+      filter_specs(converged, deps)
     end
 
     def metadata_dependencies
       @metadata_dependencies ||= [
-        Dependency.new("Ruby\0", RubyVersion.system.gem_version),
+        Dependency.new("Ruby\0", Gem.ruby_version),
         Dependency.new("RubyGems\0", Gem::VERSION),
       ]
     end
@@ -792,7 +824,9 @@ module Bundler
       # specs will be available later when the resolver knows where to
       # look for that gemspec (or its dependencies)
       source_requirements = if precompute_source_requirements_for_indirect_dependencies?
-        { :default => sources.default_source }.merge(source_map.all_requirements)
+        all_requirements = source_map.all_requirements
+        all_requirements = pin_locally_available_names(all_requirements) if @prefer_local
+        { :default => sources.default_source }.merge(all_requirements)
       else
         { :default => Source::RubygemsAggregate.new(sources, source_map) }.merge(source_map.direct_requirements)
       end
@@ -802,9 +836,18 @@ module Bundler
       end
       source_requirements[:default_bundler] = source_requirements["bundler"] || sources.default_source
       source_requirements["bundler"] = sources.metadata_source # needs to come last to override
+      verify_changed_sources!
       source_requirements
     end
 
+    def verify_changed_sources!
+      @specs_that_changed_sources.each do |s|
+        if s.source.specs.search(s.name).empty?
+          raise GemNotFound, "Could not find gem '#{s.name}' in #{s.source}"
+        end
+      end
+    end
+
     def requested_groups
       values = groups - Bundler.settings[:without] - @optional_groups + Bundler.settings[:with]
       values &= Bundler.settings[:only] unless Bundler.settings[:only].empty?
@@ -835,13 +878,22 @@ module Bundler
       end
     end
 
-    def additional_base_requirements_for_resolve
+    def additional_base_requirements_for_resolve(last_resolve)
       return [] unless @locked_gems && unlocking? && !sources.expired_sources?(@locked_gems.sources)
-      converge_specs(@originally_locked_specs).map do |locked_spec|
-        name = locked_spec.name
-        dep = Dependency.new(name, ">= #{locked_spec.version}")
-        DepProxy.get_proxy(dep, locked_spec.platform)
-      end
+      converge_specs(@originally_locked_specs - last_resolve).map do |locked_spec|
+        Dependency.new(locked_spec.name, ">= #{locked_spec.version}")
+      end.uniq
+    end
+
+    def remove_ruby_from_platforms_if_necessary!(dependencies)
+      return if Bundler.frozen_bundle? ||
+                Bundler.local_platform == Gem::Platform::RUBY ||
+                !platforms.include?(Gem::Platform::RUBY) ||
+                (@new_platform && platforms.last == Gem::Platform::RUBY) ||
+                !@originally_locked_specs.incomplete_ruby_specs?(expand_dependencies(dependencies))
+
+      remove_platform(Gem::Platform::RUBY)
+      add_current_platform
     end
 
     def source_map

data/bundler/lib/bundler/dependency.rb

@@ -7,92 +7,24 @@ require_relative "rubygems_ext"
 module Bundler
   class Dependency < Gem::Dependency
     attr_reader :autorequire
-    attr_reader :groups, :platforms, :gemfile, :git, :github, :branch, :ref, :force_ruby_platform
+    attr_reader :groups, :platforms, :gemfile, :path, :git, :github, :branch, :ref, :force_ruby_platform
 
-    # rubocop:disable Naming/VariableNumber
+    ALL_RUBY_VERSIONS = ((18..27).to_a + (30..31).to_a).freeze
     PLATFORM_MAP = {
-      :ruby     => Gem::Platform::RUBY,
-      :ruby_18  => Gem::Platform::RUBY,
-      :ruby_19  => Gem::Platform::RUBY,
-      :ruby_20  => Gem::Platform::RUBY,
-      :ruby_21  => Gem::Platform::RUBY,
-      :ruby_22  => Gem::Platform::RUBY,
-      :ruby_23  => Gem::Platform::RUBY,
-      :ruby_24  => Gem::Platform::RUBY,
-      :ruby_25  => Gem::Platform::RUBY,
-      :ruby_26  => Gem::Platform::RUBY,
-      :ruby_27  => Gem::Platform::RUBY,
-      :ruby_30  => Gem::Platform::RUBY,
-      :ruby_31  => Gem::Platform::RUBY,
-      :mri      => Gem::Platform::RUBY,
-      :mri_18   => Gem::Platform::RUBY,
-      :mri_19   => Gem::Platform::RUBY,
-      :mri_20   => Gem::Platform::RUBY,
-      :mri_21   => Gem::Platform::RUBY,
-      :mri_22   => Gem::Platform::RUBY,
-      :mri_23   => Gem::Platform::RUBY,
-      :mri_24   => Gem::Platform::RUBY,
-      :mri_25   => Gem::Platform::RUBY,
-      :mri_26   => Gem::Platform::RUBY,
-      :mri_27   => Gem::Platform::RUBY,
-      :mri_30   => Gem::Platform::RUBY,
-      :mri_31   => Gem::Platform::RUBY,
-      :rbx      => Gem::Platform::RUBY,
-      :truffleruby => Gem::Platform::RUBY,
-      :jruby    => Gem::Platform::JAVA,
-      :jruby_18 => Gem::Platform::JAVA,
-      :jruby_19 => Gem::Platform::JAVA,
-      :mswin    => Gem::Platform::MSWIN,
-      :mswin_18 => Gem::Platform::MSWIN,
-      :mswin_19 => Gem::Platform::MSWIN,
-      :mswin_20 => Gem::Platform::MSWIN,
-      :mswin_21 => Gem::Platform::MSWIN,
-      :mswin_22 => Gem::Platform::MSWIN,
-      :mswin_23 => Gem::Platform::MSWIN,
-      :mswin_24 => Gem::Platform::MSWIN,
-      :mswin_25 => Gem::Platform::MSWIN,
-      :mswin_26 => Gem::Platform::MSWIN,
-      :mswin_27 => Gem::Platform::MSWIN,
-      :mswin_30 => Gem::Platform::MSWIN,
-      :mswin_31 => Gem::Platform::MSWIN,
-      :mswin64    => Gem::Platform::MSWIN64,
-      :mswin64_19 => Gem::Platform::MSWIN64,
-      :mswin64_20 => Gem::Platform::MSWIN64,
-      :mswin64_21 => Gem::Platform::MSWIN64,
-      :mswin64_22 => Gem::Platform::MSWIN64,
-      :mswin64_23 => Gem::Platform::MSWIN64,
-      :mswin64_24 => Gem::Platform::MSWIN64,
-      :mswin64_25 => Gem::Platform::MSWIN64,
-      :mswin64_26 => Gem::Platform::MSWIN64,
-      :mswin64_27 => Gem::Platform::MSWIN64,
-      :mswin64_30 => Gem::Platform::MSWIN64,
-      :mswin64_31 => Gem::Platform::MSWIN64,
-      :mingw    => Gem::Platform::MINGW,
-      :mingw_18 => Gem::Platform::MINGW,
-      :mingw_19 => Gem::Platform::MINGW,
-      :mingw_20 => Gem::Platform::MINGW,
-      :mingw_21 => Gem::Platform::MINGW,
-      :mingw_22 => Gem::Platform::MINGW,
-      :mingw_23 => Gem::Platform::MINGW,
-      :mingw_24 => Gem::Platform::MINGW,
-      :mingw_25 => Gem::Platform::MINGW,
-      :mingw_26 => Gem::Platform::MINGW,
-      :mingw_27 => Gem::Platform::MINGW,
-      :mingw_30 => Gem::Platform::MINGW,
-      :mingw_31 => Gem::Platform::MINGW,
-      :x64_mingw    => Gem::Platform::X64_MINGW,
-      :x64_mingw_20 => Gem::Platform::X64_MINGW,
-      :x64_mingw_21 => Gem::Platform::X64_MINGW,
-      :x64_mingw_22 => Gem::Platform::X64_MINGW,
-      :x64_mingw_23 => Gem::Platform::X64_MINGW,
-      :x64_mingw_24 => Gem::Platform::X64_MINGW,
-      :x64_mingw_25 => Gem::Platform::X64_MINGW,
-      :x64_mingw_26 => Gem::Platform::X64_MINGW,
-      :x64_mingw_27 => Gem::Platform::X64_MINGW,
-      :x64_mingw_30 => Gem::Platform::X64_MINGW,
-      :x64_mingw_31 => Gem::Platform::X64_MINGW,
-    }.freeze
-    # rubocop:enable Naming/VariableNumber
+      :ruby        => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
+      :mri         => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
+      :rbx         => [Gem::Platform::RUBY],
+      :truffleruby => [Gem::Platform::RUBY],
+      :jruby       => [Gem::Platform::JAVA, [18, 19]],
+      :windows     => [Gem::Platform::WINDOWS, ALL_RUBY_VERSIONS],
+      :mswin       => [Gem::Platform::MSWIN,     ALL_RUBY_VERSIONS],
+      :mswin64     => [Gem::Platform::MSWIN64,   ALL_RUBY_VERSIONS - [18]],
+      :mingw       => [Gem::Platform::MINGW,     ALL_RUBY_VERSIONS],
+      :x64_mingw   => [Gem::Platform::X64_MINGW, ALL_RUBY_VERSIONS - [18, 19]],
+    }.each_with_object({}) do |(platform, spec), hash|
+      hash[platform] = spec[0]
+      spec[1]&.each {|version| hash[:"#{platform}_#{version}"] = spec[0] }
+    end.freeze
 
     def initialize(name, version, options = {}, &blk)
       type = options["type"] || :runtime
@@ -101,6 +33,7 @@ module Bundler
       @autorequire    = nil
       @groups         = Array(options["group"] || :default).map(&:to_sym)
       @source         = options["source"]
+      @path           = options["path"]
       @git            = options["git"]
       @github         = options["github"]
       @branch         = options["branch"]
@@ -151,7 +84,7 @@ module Bundler
     def to_lock
       out = super
       out << "!" if source
-      out << "\n"
+      out
     end
 
     def specific?

data/bundler/lib/bundler/endpoint_specification.rb

@@ -3,7 +3,7 @@
 module Bundler
   # used for Creating Specifications from the Gemcutter Endpoint
   class EndpointSpecification < Gem::Specification
-    include MatchPlatform
+    include MatchRemoteMetadata
 
     attr_reader :name, :version, :platform, :checksum
     attr_accessor :source, :remote, :dependencies
@@ -12,7 +12,7 @@ module Bundler
       super()
       @name         = name
       @version      = Gem::Version.create version
-      @platform     = platform
+      @platform     = Gem::Platform.new(platform)
       @spec_fetcher = spec_fetcher
       @dependencies = dependencies.map {|dep, reqs| build_dependency(dep, reqs) }
 
@@ -22,17 +22,6 @@ module Bundler
       parse_metadata(metadata)
     end
 
-    def required_ruby_version
-      @required_ruby_version ||= _remote_specification.required_ruby_version
-    end
-
-    # A fallback is included because the original version of the specification
-    # API didn't include that field, so some marshalled specs in the index have it
-    # set to +nil+.
-    def required_rubygems_version
-      @required_rubygems_version ||= _remote_specification.required_rubygems_version || Gem::Requirement.default
-    end
-
     def fetch_platform
       @platform
     end

data/bundler/lib/bundler/feature_flag.rb

@@ -39,7 +39,6 @@ module Bundler
     settings_flag(:setup_makes_kernel_gem_public) { !bundler_3_mode? }
     settings_flag(:suppress_install_using_messages) { bundler_3_mode? }
     settings_flag(:update_requires_all_flag) { bundler_4_mode? }
-    settings_flag(:use_gem_version_promoter_for_major_updates) { bundler_3_mode? }
 
     settings_option(:default_cli_command) { bundler_3_mode? ? :cli_help : :install }
 

data/bundler/lib/bundler/fetcher.rb

@@ -240,8 +240,8 @@ module Bundler
     def connection
       @connection ||= begin
         needs_ssl = remote_uri.scheme == "https" ||
-          Bundler.settings[:ssl_verify_mode] ||
-          Bundler.settings[:ssl_client_cert]
+                    Bundler.settings[:ssl_verify_mode] ||
+                    Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
         con = PersistentHTTP.new :name => "bundler", :proxy => :ENV
@@ -256,8 +256,8 @@ module Bundler
         end
 
         ssl_client_cert = Bundler.settings[:ssl_client_cert] ||
-          (Gem.configuration.ssl_client_cert if
-            Gem.configuration.respond_to?(:ssl_client_cert))
+                          (Gem.configuration.ssl_client_cert if
+                            Gem.configuration.respond_to?(:ssl_client_cert))
         if ssl_client_cert
           pem = File.read(ssl_client_cert)
           con.cert = OpenSSL::X509::Certificate.new(pem)
@@ -288,8 +288,8 @@ module Bundler
     def bundler_cert_store
       store = OpenSSL::X509::Store.new
       ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
-        (Gem.configuration.ssl_ca_cert if
-          Gem.configuration.respond_to?(:ssl_ca_cert))
+                    (Gem.configuration.ssl_ca_cert if
+                      Gem.configuration.respond_to?(:ssl_ca_cert))
       if ssl_ca_cert
         if File.directory? ssl_ca_cert
           store.add_path ssl_ca_cert

data/bundler/lib/bundler/gem_helpers.rb

@@ -44,6 +44,12 @@ module Bundler
 
     def select_best_platform_match(specs, platform)
       matching = specs.select {|spec| spec.match_platform(platform) }
+
+      sort_best_platform_match(matching, platform)
+    end
+    module_function :select_best_platform_match
+
+    def sort_best_platform_match(matching, platform)
       exact = matching.select {|spec| spec.platform == platform }
       return exact if exact.any?
 
@@ -52,7 +58,7 @@ module Bundler
 
       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_best_platform_match
 
     class PlatformMatch
       def self.specificity_score(spec_platform, user_platform)

data/bundler/lib/bundler/gem_version_promoter.rb

@@ -55,19 +55,17 @@ 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
+    # Given a Dependency 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 dep [Dependency] The Dependency of the gem.
-    # @param spec_groups [SpecGroup] An array of SpecGroups for the same gem
+    # @param spec_groups [Specification] An array of Specifications for the same gem
     #    named in the @dep param.
-    # @return [SpecGroup] A new instance of the SpecGroup Array sorted and
+    # @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
 
@@ -79,15 +77,14 @@ module Bundler
           filter_dep_specs(spec_groups, locked_spec)
         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
         end
       end
     end
 
+    def reset
+      @sort_versions = {}
+    end
+
     # @return [bool] Convenience method for testing value of level variable.
     def major?
       level == :major
@@ -179,12 +176,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/bundler/lib/bundler/injector.rb

@@ -115,13 +115,14 @@ module Bundler
         end
 
         source = ", :source => \"#{d.source}\"" unless d.source.nil?
+        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}#{git}#{github}#{branch}#{ref}#{require_path})
+        %(gem #{name}#{requirement}#{group}#{source}#{path}#{git}#{github}#{branch}#{ref}#{require_path})
       end.join("\n")
     end
 

data/bundler/lib/bundler/inline.rb

@@ -54,7 +54,7 @@ def gemfile(install = false, options = {}, &gemfile)
 
       Bundler.ui = install ? ui : Bundler::UI::Silent.new
       if install || definition.missing_specs?
-        Bundler.settings.temporary(:inline => true) do
+        Bundler.settings.temporary(:inline => true, :no_install => false) do
           installer = Bundler::Installer.install(Bundler.root, definition, :system => true)
           installer.post_install_messages.each do |name, message|
             Bundler.ui.info "Post-install message from #{name}:\n#{message}"

data/bundler/lib/bundler/installer/standalone.rb

@@ -47,7 +47,7 @@ module Bundler
     end
 
     def bundler_path
-      Bundler.root.join(Bundler.settings[:path], "bundler")
+      Bundler.root.join(Bundler.settings[:path].to_s, "bundler")
     end
 
     def gem_path(path, spec)

data/bundler/lib/bundler/installer.rb

@@ -238,19 +238,14 @@ module Bundler
     end
 
     def ensure_specs_are_compatible!
-      system_ruby = Bundler::RubyVersion.system
-      rubygems_version = Bundler.rubygems.version
       @definition.specs.each do |spec|
-        if required_ruby_version = spec.required_ruby_version
-          unless required_ruby_version.satisfied_by?(system_ruby.gem_version)
-            raise InstallError, "#{spec.full_name} requires ruby version #{required_ruby_version}, " \
-              "which is incompatible with the current version, #{system_ruby}"
-          end
+        unless spec.matches_current_ruby?
+          raise InstallError, "#{spec.full_name} requires ruby version #{spec.required_ruby_version}, " \
+            "which is incompatible with the current version, #{Gem.ruby_version}"
         end
-        next unless required_rubygems_version = spec.required_rubygems_version
-        unless required_rubygems_version.satisfied_by?(rubygems_version)
-          raise InstallError, "#{spec.full_name} requires rubygems version #{required_rubygems_version}, " \
-            "which is incompatible with the current version, #{rubygems_version}"
+        unless spec.matches_current_rubygems?
+          raise InstallError, "#{spec.full_name} requires rubygems version #{spec.required_rubygems_version}, " \
+            "which is incompatible with the current version, #{Gem.rubygems_version}"
         end
       end
     end
@@ -268,7 +263,14 @@ module Bundler
         return false if @definition.nothing_changed? && !@definition.missing_specs?
       end
 
-      options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
+      if options["local"]
+        @definition.resolve_with_cache!
+      elsif options["prefer-local"]
+        @definition.resolve_prefering_local!
+      else
+        @definition.resolve_remotely!
+      end
+
       true
     end
 

data/bundler/lib/bundler/lazy_specification.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "match_platform"
-
 module Bundler
   class LazySpecification
     include MatchPlatform
@@ -76,35 +74,35 @@ module Bundler
     end
 
     def materialize_for_installation
-      __materialize__(ruby_platform_materializes_to_ruby_platform? ? platform : Bundler.local_platform)
-    end
+      source.local!
+
+      candidates = if source.is_a?(Source::Path) || !ruby_platform_materializes_to_ruby_platform?
+        target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : Bundler.local_platform
+
+        source.specs.search(Dependency.new(name, version)).select do |spec|
+          MatchPlatform.platforms_match?(spec.platform, target_platform)
+        end
+      else
+        source.specs.search(self)
+      end
 
-    def materialize_for_resolution
-      return self unless Gem::Platform.match_spec?(self)
+      return self if candidates.empty?
 
-      __materialize__(platform)
+      __materialize__(candidates)
     end
 
-    def __materialize__(platform)
-      @specification = if source.is_a?(Source::Gemspec) && source.gemspec.name == name
-        source.gemspec.tap {|s| s.source = source }
-      else
-        search_object = if source.is_a?(Source::Path)
-          Dependency.new(name, version)
-        else
-          ruby_platform_materializes_to_ruby_platform? ? self : Dependency.new(name, version)
-        end
-        candidates = source.specs.search(search_object)
-        same_platform_candidates = candidates.select do |spec|
-          MatchPlatform.platforms_match?(spec.platform, platform)
-        end
-        installable_candidates = same_platform_candidates.select do |spec|
+    def __materialize__(candidates)
+      @specification = begin
+        search = candidates.reverse.find do |spec|
           spec.is_a?(StubSpecification) ||
-            (spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
-              spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version))
+            (spec.matches_current_ruby? &&
+              spec.matches_current_rubygems?)
+        end
+        if search.nil? && Bundler.frozen_bundle?
+          search = candidates.last
+        else
+          search.dependencies = dependencies if search && search.full_name == full_name && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
         end
-        search = installable_candidates.last || same_platform_candidates.last
-        search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
         search
       end
     end

data/bundler/lib/bundler/lockfile_generator.rb

@@ -60,7 +60,7 @@ module Bundler
       handled = []
       definition.dependencies.sort_by(&:to_s).each do |dep|
         next if handled.include?(dep.name)
-        out << dep.to_lock
+        out << dep.to_lock << "\n"
         handled << dep.name
       end
     end