Use the resolver to resolve for ruby / rubygems versions

3 files changed, 46 insertions, 19 deletions

diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb
index e1826746ff..121ef9c2c4 100644
--- a/lib/bundler/definition.rb
+++ b/lib/bundler/definition.rb
@@ -264,6 +264,8 @@ module Bundler
           dependency_names -= pinned_spec_names(source.specs)
           dependency_names.concat(source.unmet_deps).uniq!
         end
+        idx << Gem::Specification.new("ruby\0", RUBY_VERSION)
+        idx << Gem::Specification.new("rubygems\0", Gem::VERSION)
       end
     end
 
@@ -728,8 +730,19 @@ module Bundler
       @locked_specs.any? {|s| s.satisfies?(dep) && (!dep.source || s.source.include?(dep.source)) }
     end
 
+    # This list of dependencies is only used in #resolve, so it's OK to add
+    # the metadata dependencies here
     def expanded_dependencies
-      @expanded_dependencies ||= expand_dependencies(dependencies, @remote)
+      @expanded_dependencies ||= begin
+        ruby_versions = [RUBY_VERSION]
+        ruby_versions.concat(@ruby_version.versions) if @ruby_version
+        ruby_versions << @locked_ruby_version if @locked_ruby_version && !@unlock[:ruby]
+        metadata_dependencies = [
+          Dependency.new("ruby\0", ruby_versions),
+          Dependency.new("rubygems\0", Gem::VERSION),
+        ]
+        expand_dependencies(dependencies + metadata_dependencies, @remote)
+      end
     end
 
     def expand_dependencies(dependencies, remote = false)
diff --git a/lib/bundler/resolver.rb b/lib/bundler/resolver.rb
index e1d993831f..ca24b23b7e 100644
--- a/lib/bundler/resolver.rb
+++ b/lib/bundler/resolver.rb
@@ -124,15 +124,7 @@ module Bundler
 
       def for?(platform, ruby_version)
         spec = @specs[platform]
-        return false unless spec
-
-        return true if ruby_version.nil?
-        # Only allow endpoint specifications since they won't hit the network to
-        # fetch the full gemspec when calling required_ruby_version
-        return true if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)
-        return true if spec.required_ruby_version.nil?
-
-        spec.required_ruby_version.satisfied_by?(ruby_version.to_gem_version_with_patchlevel)
+        !spec.nil?
       end
 
       def to_s
@@ -140,7 +132,9 @@ module Bundler
       end
 
       def dependencies_for_activated_platforms
-        @activated.map {|p| __dependencies[p] }.flatten
+        dependencies = @activated.map {|p| __dependencies[p] }
+        metadata_dependencies = @activated.map {|platform| metadata_dependencies(@specs[platform], platform) }
+        dependencies.concat(metadata_dependencies).flatten
       end
 
       def platforms_for_dependency_named(dependency)
@@ -163,6 +157,21 @@ module Bundler
           dependencies
         end
       end
+
+      def metadata_dependencies(spec, platform)
+        return [] unless spec
+        # Only allow endpoint specifications since they won't hit the network to
+        # fetch the full gemspec when calling required_ruby_version
+        return [] if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)
+        dependencies = []
+        if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
+          dependencies << DepProxy.new(Gem::Dependency.new("ruby\0", spec.required_ruby_version), platform)
+        end
+        if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
+          dependencies << DepProxy.new(Gem::Dependency.new("rubygems\0", spec.required_rubygems_version), platform)
+        end
+        dependencies
+      end
     end
 
     # Figures out the best possible configuration of gems that satisfies
@@ -201,7 +210,9 @@ module Bundler
     def start(requirements)
       verify_gemfile_dependencies_are_found!(requirements)
       dg = @resolver.resolve(requirements, @base_dg)
-      dg.map(&:payload).map(&:to_specs).flatten
+      dg.map(&:payload).
+        reject {|sg| sg.name.end_with?("\0") }.
+        map(&:to_specs).flatten
     rescue Molinillo::VersionConflict => e
       raise VersionConflict.new(e.conflicts.keys.uniq, e.message)
     rescue Molinillo::CircularDependencyError => e
diff --git a/spec/install/gems/resolving_spec.rb b/spec/install/gems/resolving_spec.rb
index 90c07adf10..5939a2f875 100644
--- a/spec/install/gems/resolving_spec.rb
+++ b/spec/install/gems/resolving_spec.rb
@@ -126,23 +126,26 @@ describe "bundle install with install-time dependencies" do
           end
         end
 
-        install_gemfile <<-G
-          source "file://#{gem_repo2}"
+        install_gemfile <<-G, :artifice => "compact_index", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo2 }
+          source "http://localgemserver.test/"
           ruby "#{RUBY_VERSION}"
           gem 'require_ruby'
         G
 
         expect(out).to_not include("Gem::InstallError: require_ruby requires Ruby version > 9000")
 
-        nice_error = <<-E.strip.gsub(/^ {8}/, "")
-          Fetching source index from file:#{gem_repo1}/
+        nice_error = strip_whitespace(<<-E).strip
+          Fetching gem metadata from http://localgemserver.test/.
+          Fetching version metadata from http://localgemserver.test/
           Resolving dependencies...
-          Bundler could not find compatible versions for gem "require_ruby":
+          Bundler could not find compatible versions for gem "ruby\0":
             In Gemfile:
-              ruby (= #{RUBY_VERSION})
+              ruby\0 (= 2.3.1)
 
               require_ruby was resolved to 1.0, which depends on
-                ruby (> 9000)
+                ruby\0 (> 9000)
+
+          Could not find gem 'ruby\0 (> 9000)', which is required by gem 'require_ruby', in any of the sources.
         E
         expect(out).to eq(nice_error)
       end