bundler 2.2.7 → 2.2.17

data/lib/bundler/plugin/api/source.rb

@@ -140,6 +140,13 @@ module Bundler
           end
         end
 
+        # Set internal representation to fetch the gems/specs locally.
+        #
+        # When this is called, the source should try to fetch the specs and
+        # install from the local system.
+        def local!
+        end
+
         # Set internal representation to fetch the gems/specs from remote.
         #
         # When this is called, the source should try to fetch the specs and

data/lib/bundler/plugin/installer.rb

@@ -16,15 +16,13 @@ module Bundler
 
         version = options[:version] || [">= 0"]
 
-        Bundler.settings.temporary(:disable_multisource => false) do
-          if options[:git]
-            install_git(names, version, options)
-          elsif options[:local_git]
-            install_local_git(names, version, options)
-          else
-            sources = options[:source] || Bundler.rubygems.sources
-            install_rubygems(names, version, sources)
-          end
+        if options[:git]
+          install_git(names, version, options)
+        elsif options[:local_git]
+          install_local_git(names, version, options)
+        else
+          sources = options[:source] || Bundler.rubygems.sources
+          install_rubygems(names, version, sources)
         end
       end
 
@@ -79,7 +77,7 @@ module Bundler
         source_list = SourceList.new
 
         source_list.add_git_source(git_source_options) if git_source_options
-        source_list.add_rubygems_source("remotes" => rubygems_source) if rubygems_source
+        source_list.global_rubygems_source = rubygems_source if rubygems_source
 
         deps = names.map {|name| Dependency.new name, version }
 

data/lib/bundler/plugin/source_list.rb

@@ -17,6 +17,10 @@ module Bundler
         path_sources + git_sources + rubygems_sources + [metadata_source]
       end
 
+      def default_source
+        git_sources.first || global_rubygems_source
+      end
+
       private
 
       def rubygems_aggregate_class

data/lib/bundler/resolver.rb

@@ -5,6 +5,8 @@ module Bundler
     require_relative "vendored_molinillo"
     require_relative "resolver/spec_group"
 
+    include GemHelpers
+
     # Figures out the best possible configuration of gems that satisfies
     # the list of passed dependencies and any child dependencies without
     # causing any gem activation errors.
@@ -15,17 +17,21 @@ module Bundler
     # ==== Returns
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
-    def self.resolve(requirements, index, source_requirements = {}, base = [], gem_version_promoter = GemVersionPromoter.new, additional_base_requirements = [], platforms = nil)
-      platforms = Set.new(platforms) if platforms
+    def self.resolve(requirements, source_requirements = {}, base = [], gem_version_promoter = GemVersionPromoter.new, additional_base_requirements = [], platforms = nil)
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
-      resolver = new(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
+      resolver = new(source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
       result = resolver.start(requirements)
       SpecSet.new(result)
     end
 
-    def initialize(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
-      @index = index
+    def initialize(source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)
       @source_requirements = source_requirements
+
+      @index_requirements = source_requirements.each_with_object({}) do |source_requirement, index_requirements|
+        name, source = source_requirement
+        index_requirements[name] = name == :global ? source : source.specs
+      end
+
       @base = base
       @resolver = Molinillo::Resolver.new(self, self)
       @search_for = {}
@@ -35,10 +41,14 @@ module Bundler
         @base_dg.add_vertex(ls.name, DepProxy.get_proxy(dep, ls.platform), true)
       end
       additional_base_requirements.each {|d| @base_dg.add_vertex(d.name, d) }
-      @platforms = platforms
+      @platforms = platforms.reject {|p| p != Gem::Platform::RUBY && (platforms - [p]).any? {|pl| generic(pl) == p } }
+      @resolving_only_for_ruby = platforms == [Gem::Platform::RUBY]
       @gem_version_promoter = gem_version_promoter
       @use_gvp = Bundler.feature_flag.use_gem_version_promoter_for_major_updates? || !@gem_version_promoter.major?
-      @lockfile_uses_separate_rubygems_sources = Bundler.feature_flag.disable_multisource?
+      @no_aggregate_global_source = @source_requirements[:global].nil?
+
+      @variant_specific_names = []
+      @generic_names = ["Ruby\0", "RubyGems\0"]
     end
 
     def start(requirements)
@@ -102,16 +112,25 @@ module Bundler
     include Molinillo::SpecificationProvider
 
     def dependencies_for(specification)
-      specification.dependencies_for_activated_platforms
+      all_dependencies = specification.dependencies_for_activated_platforms
+
+      if @variant_specific_names.include?(specification.name)
+        @variant_specific_names |= all_dependencies.map(&:name) - @generic_names
+      else
+        generic_names, variant_specific_names = specification.partitioned_dependency_names_for_activated_platforms
+        @variant_specific_names |= variant_specific_names - @generic_names
+        @generic_names |= generic_names
+      end
+
+      all_dependencies
     end
 
     def search_for(dependency_proxy)
       platform = dependency_proxy.__platform
       dependency = dependency_proxy.dep
-      @search_for[dependency_proxy] ||= begin
-        name = dependency.name
-        index = index_for(dependency)
-        results = index.search(dependency, @base[name])
+      name = dependency.name
+      search_result = @search_for[dependency_proxy] ||= begin
+        results = results_for(dependency, @base[name])
 
         if vertex = @base_dg.vertex_named(name)
           locked_requirement = vertex.payload.requirement
@@ -136,56 +155,67 @@ module Bundler
           end
           nested.reduce([]) do |groups, (version, specs)|
             next groups if locked_requirement && !locked_requirement.satisfied_by?(version)
-            spec_group = SpecGroup.new(specs)
-            groups << spec_group
+
+            specs_by_platform = Hash.new do |current_specs, current_platform|
+              current_specs[current_platform] = select_best_platform_match(specs, current_platform)
+            end
+
+            spec_group_ruby = SpecGroup.create_for(specs_by_platform, [Gem::Platform::RUBY], Gem::Platform::RUBY)
+            groups << spec_group_ruby if spec_group_ruby
+
+            next groups if @resolving_only_for_ruby
+
+            spec_group = SpecGroup.create_for(specs_by_platform, @platforms, platform)
+            groups << spec_group if spec_group
+
+            groups
           end
         else
           []
         end
         # GVP handles major itself, but it's still a bit risky to trust it with it
         # until we get it settled with new behavior. For 2.x it can take over all cases.
-        search = if !@use_gvp
+        if !@use_gvp
           spec_groups
         else
           @gem_version_promoter.sort_versions(dependency, spec_groups)
         end
-        selected_sgs = []
-        search.each do |sg|
-          next unless sg.for?(platform)
-          sg_all_platforms = sg.copy_for(self.class.sort_platforms(@platforms).reverse)
-          next unless sg_all_platforms
-
-          selected_sgs << sg_all_platforms
+      end
 
-          next if sg_all_platforms.activated_platforms == [Gem::Platform::RUBY]
-          # Add a spec group for "non platform specific spec" as the fallback
-          # spec group.
-          sg_ruby = sg.copy_for([Gem::Platform::RUBY])
-          next unless sg_ruby
+      unless search_result.empty?
+        specific_dependency = @variant_specific_names.include?(name)
+        return search_result unless specific_dependency
 
-          selected_sgs.insert(-2, sg_ruby)
+        search_result.each do |sg|
+          if @generic_names.include?(name)
+            @variant_specific_names -= [name]
+            sg.activate_all_platforms!
+          else
+            sg.activate_platform!(platform)
+          end
         end
-        selected_sgs
       end
+
+      search_result
     end
 
     def index_for(dependency)
-      source = @source_requirements[dependency.name]
+      source = @index_requirements[dependency.name]
       if source
-        source.specs
-      elsif @lockfile_uses_separate_rubygems_sources
+        source
+      elsif @no_aggregate_global_source
         Index.build do |idx|
-          if dependency.all_sources
-            dependency.all_sources.each {|s| idx.add_source(s.specs) if s }
-          else
-            idx.add_source @source_requirements[:default].specs
-          end
+          dependency.all_sources.each {|s| idx.add_source(s.specs) }
         end
       else
-        @index
+        @index_requirements[:global]
       end
     end
 
+    def results_for(dependency, base)
+      index_for(dependency).search(dependency, base)
+    end
+
     def name_for(dependency)
       dependency.name
     end
@@ -213,18 +243,20 @@ module Bundler
     def relevant_sources_for_vertex(vertex)
       if vertex.root?
         [@source_requirements[vertex.name]]
-      elsif @lockfile_uses_separate_rubygems_sources
+      elsif @no_aggregate_global_source
         vertex.recursive_predecessors.map do |v|
           @source_requirements[v.name]
-        end << @source_requirements[:default]
+        end.compact << @source_requirements[:default]
+      else
+        []
       end
     end
 
     def sort_dependencies(dependencies, activated, conflicts)
       dependencies.sort_by do |dependency|
-        dependency.all_sources = relevant_sources_for_vertex(activated.vertex_named(dependency.name))
         name = name_for(dependency)
         vertex = activated.vertex_named(name)
+        dependency.all_sources = relevant_sources_for_vertex(vertex)
         [
           @base_dg.vertex_named(name) ? 0 : 1,
           vertex.payload ? 0 : 1,
@@ -237,13 +269,6 @@ module Bundler
       end
     end
 
-    # Sort platforms from most general to most specific
-    def self.sort_platforms(platforms)
-      platforms.sort_by do |platform|
-        platform_sort_key(platform)
-      end
-    end
-
     def self.platform_sort_key(platform)
       # Prefer specific platform to not specific platform
       return ["99-LAST", "", "", ""] if Gem::Platform::RUBY == platform
@@ -298,7 +323,7 @@ module Bundler
             "If you are updating multiple gems in your Gemfile at once,\n" \
             "try passing them all to `bundle update`"
         elsif source = @source_requirements[name]
-          specs = source.specs[name]
+          specs = source.specs.search(name)
           versions_with_platforms = specs.map {|s| [s.version, s.platform] }
           message = String.new("Could not find gem '#{SharedHelpers.pretty_dependency(requirement)}' in #{source}#{cache_message}.\n")
           message << if versions_with_platforms.any?
@@ -307,7 +332,7 @@ module Bundler
             "The source does not contain any versions of '#{name}'"
           end
         else
-          message = "Could not find gem '#{requirement}' in any of the gem sources " \
+          message = "Could not find gem '#{SharedHelpers.pretty_dependency(requirement)}' in any of the gem sources " \
             "listed in your Gemfile#{cache_message}."
         end
         raise GemNotFound, message
@@ -373,7 +398,7 @@ module Bundler
             if other_bundler_required
               o << "\n\n"
 
-              candidate_specs = @source_requirements[:default_bundler].specs.search(conflict_dependency)
+              candidate_specs = @index_requirements[:default_bundler].search(conflict_dependency)
               if candidate_specs.any?
                 target_version = candidate_specs.last.version
                 new_command = [File.basename($PROGRAM_NAME), "_#{target_version}_", *ARGV].join(" ")
@@ -392,14 +417,8 @@ module Bundler
 
             relevant_sources = if conflict.requirement.source
               [conflict.requirement.source]
-            elsif conflict.requirement.all_sources
-              conflict.requirement.all_sources
-            elsif @lockfile_uses_separate_rubygems_sources
-              # every conflict should have an explicit group of sources when we
-              # enforce strict pinning
-              raise "no source set for #{conflict}"
             else
-              []
+              conflict.requirement.all_sources
             end.compact.map(&:to_s).uniq.sort
 
             metadata_requirement = name.end_with?("\0")
@@ -436,23 +455,21 @@ module Bundler
     def validate_resolved_specs!(resolved_specs)
       resolved_specs.each do |v|
         name = v.name
-        next unless sources = relevant_sources_for_vertex(v)
-        sources.compact!
+        sources = relevant_sources_for_vertex(v)
+        next unless sources.any?
         if default_index = sources.index(@source_requirements[:default])
           sources.delete_at(default_index)
         end
-        sources.reject! {|s| s.specs[name].empty? }
+        sources.reject! {|s| s.specs.search(name).empty? }
         sources.uniq!
         next if sources.size <= 1
 
-        multisource_disabled = Bundler.feature_flag.disable_multisource?
-
         msg = ["The gem '#{name}' was found in multiple relevant sources."]
         msg.concat sources.map {|s| "  * #{s}" }.sort
-        msg << "You #{multisource_disabled ? :must : :should} add this gem to the source block for the source you wish it to be installed from."
+        msg << "You #{@no_aggregate_global_source ? :must : :should} add this gem to the source block for the source you wish it to be installed from."
         msg = msg.join("\n")
 
-        raise SecurityError, msg if multisource_disabled
+        raise SecurityError, msg if @no_aggregate_global_source
         Bundler.ui.warn "Warning: #{msg}"
       end
     end

data/lib/bundler/resolver/spec_group.rb

@@ -3,27 +3,37 @@
 module Bundler
   class Resolver
     class SpecGroup
-      include GemHelpers
-
       attr_accessor :name, :version, :source
       attr_accessor :activated_platforms
 
-      def initialize(all_specs)
-        @all_specs = all_specs
-        raise ArgumentError, "cannot initialize with an empty value" unless exemplary_spec = all_specs.first
+      def self.create_for(specs, all_platforms, specific_platform)
+        specific_platform_specs = specs[specific_platform]
+        return unless specific_platform_specs.any?
+
+        platforms = all_platforms.select {|p| specs[p].any? }
+
+        new(specific_platform_specs.first, specs, platforms)
+      end
+
+      def initialize(exemplary_spec, specs, relevant_platforms)
+        @exemplary_spec = exemplary_spec
         @name = exemplary_spec.name
         @version = exemplary_spec.version
         @source = exemplary_spec.source
 
-        @activated_platforms = []
-        @dependencies = nil
-        @specs        = Hash.new do |specs, platform|
-          specs[platform] = select_best_platform_match(all_specs, platform)
+        @all_platforms = relevant_platforms
+        @activated_platforms = relevant_platforms
+        @dependencies = Hash.new do |dependencies, platforms|
+          dependencies[platforms] = dependencies_for(platforms)
         end
+        @partitioned_dependency_names = Hash.new do |partitioned_dependency_names, platforms|
+          partitioned_dependency_names[platforms] = partitioned_dependency_names_for(platforms)
+        end
+        @specs = specs
       end
 
       def to_specs
-        @activated_platforms.map do |p|
+        activated_platforms.map do |p|
           specs = @specs[p]
           next unless specs.any?
 
@@ -35,17 +45,12 @@ module Bundler
         end.flatten.compact.uniq
       end
 
-      def copy_for(platforms)
-        platforms.select! {|p| for?(p) }
-        return unless platforms.any?
-
-        copied_sg = self.class.new(@all_specs)
-        copied_sg.activated_platforms = platforms
-        copied_sg
+      def activate_platform!(platform)
+        self.activated_platforms = [platform]
       end
 
-      def for?(platform)
-        @specs[platform].any?
+      def activate_all_platforms!
+        self.activated_platforms = @all_platforms
       end
 
       def to_s
@@ -54,11 +59,11 @@ module Bundler
       end
 
       def dependencies_for_activated_platforms
-        dependencies = @activated_platforms.map {|p| __dependencies[p] }
-        metadata_dependencies = @activated_platforms.map do |platform|
-          metadata_dependencies(@specs[platform].first, platform)
-        end
-        dependencies.concat(metadata_dependencies).flatten
+        @dependencies[activated_platforms]
+      end
+
+      def partitioned_dependency_names_for_activated_platforms
+        @partitioned_dependency_names[activated_platforms]
       end
 
       def ==(other)
@@ -84,27 +89,37 @@ module Bundler
       protected
 
       def sorted_activated_platforms
-        @activated_platforms.sort_by(&:to_s)
+        activated_platforms.sort_by(&:to_s)
       end
 
       private
 
-      def __dependencies
-        @dependencies = Hash.new do |dependencies, platform|
-          dependencies[platform] = []
-          specs = @specs[platform]
-          if spec = specs.first
-            spec.dependencies.each do |dep|
-              next if dep.type == :development
-              dependencies[platform] << DepProxy.get_proxy(dep, platform)
-            end
-          end
-          dependencies[platform]
+      def dependencies_for(platforms)
+        platforms.map do |platform|
+          __dependencies(platform) + metadata_dependencies(platform)
+        end.flatten
+      end
+
+      def partitioned_dependency_names_for(platforms)
+        return @dependencies[platforms].map(&:name), [] if platforms.size == 1
+
+        @dependencies[platforms].partition do |dep_proxy|
+          @dependencies[platforms].count {|dp| dp.dep == dep_proxy.dep } == platforms.size
+        end.map {|deps| deps.map(&:name) }
+      end
+
+      def __dependencies(platform)
+        dependencies = []
+        @specs[platform].first.dependencies.each do |dep|
+          next if dep.type == :development
+          dependencies << DepProxy.get_proxy(dep, platform)
         end
+        dependencies
       end
 
-      def metadata_dependencies(spec, platform)
-        return [] unless spec && spec.is_a?(Gem::Specification)
+      def metadata_dependencies(platform)
+        spec = @specs[platform].first
+        return [] unless spec.is_a?(Gem::Specification)
         dependencies = []
         if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
           dependencies << DepProxy.get_proxy(Gem::Dependency.new("Ruby\0", spec.required_ruby_version), platform)