bundler 1.13.0.rc.1 → 1.13.0.rc.2

data/lib/bundler/plugin/dsl.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Bundler
-  # Dsl to parse the Gemfile looking for plugins to install
   module Plugin
+    # Dsl to parse the Gemfile looking for plugins to install
     class DSL < Bundler::Dsl
       class PluginGemfileError < PluginError; end
       alias_method :_gem, :gem # To use for plugin installation as gem
@@ -12,9 +12,20 @@ module Bundler
       # They will be handled by method_missing
       [:gemspec, :gem, :path, :install_if, :platforms, :env].each {|m| undef_method m }
 
+      # This lists the plugins that was added automatically and not specified by
+      # the user.
+      #
+      # When we encounter :type attribute with a source block, we add a plugin
+      # by name bundler-source-<type> to list of plugins to be installed.
+      #
+      # These plugins are optional and are not installed when there is conflict
+      # with any other plugin.
+      attr_reader :inferred_plugins
+
       def initialize
         super
         @sources = Plugin::SourceList.new
+        @inferred_plugins = [] # The source plugins inferred from :type
       end
 
       def plugin(name, *args)
@@ -24,6 +35,19 @@ module Bundler
       def method_missing(name, *args)
         raise PluginGemfileError, "Undefined local variable or method `#{name}' for Gemfile" unless Bundler::Dsl.method_defined? name
       end
+
+      def source(source, *args, &blk)
+        options = args.last.is_a?(Hash) ? args.pop.dup : {}
+        options = normalize_hash(options)
+        return super unless options.key?("type")
+
+        plugin_name = "bundler-source-#{options["type"]}"
+
+        return if @dependencies.any? {|d| d.name == plugin_name }
+
+        plugin(plugin_name)
+        @inferred_plugins << plugin_name
+      end
     end
   end
 end

data/lib/bundler/plugin/index.rb

@@ -13,38 +13,77 @@ module Bundler
         end
       end
 
+      class SourceConflict < PluginError
+        def initialize(plugin, sources)
+          msg = "Source(s) `#{sources.join("`, `")}` declared by #{plugin} are already registered."
+          super msg
+        end
+      end
+
       def initialize
         @plugin_paths = {}
         @commands = {}
+        @sources = {}
+        @hooks = {}
+        @load_paths = {}
 
-        load_index
+        load_index(global_index_file, true)
+        load_index(local_index_file) if SharedHelpers.in_bundle?
       end
 
-      # This function is to be called when a new plugin is installed. This function shall add
-      # the functions of the plugin to existing maps and also the name to source location.
+      # This function is to be called when a new plugin is installed. This
+      # function shall add the functions of the plugin to existing maps and also
+      # the name to source location.
       #
       # @param [String] name of the plugin to be registered
       # @param [String] path where the plugin is installed
+      # @param [Array<String>] load_paths for the plugin
       # @param [Array<String>] commands that are handled by the plugin
-      def register_plugin(name, path, commands)
-        @plugin_paths[name] = path
+      # @param [Array<String>] sources that are handled by the plugin
+      def register_plugin(name, path, load_paths, commands, sources, hooks)
+        old_commands = @commands.dup
 
         common = commands & @commands.keys
         raise CommandConflict.new(name, common) unless common.empty?
         commands.each {|c| @commands[c] = name }
 
+        common = sources & @sources.keys
+        raise SourceConflict.new(name, common) unless common.empty?
+        sources.each {|k| @sources[k] = name }
+
+        hooks.each {|e| (@hooks[e] ||= []) << name }
+
+        @plugin_paths[name] = path
+        @load_paths[name] = load_paths
         save_index
+      rescue
+        @commands = old_commands
+        raise
       end
 
-      # Path where the index file is stored
+      # Path of default index file
       def index_file
         Plugin.root.join("index")
       end
 
+      # Path where the global index file is stored
+      def global_index_file
+        Plugin.global_root.join("index")
+      end
+
+      # Path where the local index file is stored
+      def local_index_file
+        Plugin.local_root.join("index")
+      end
+
       def plugin_path(name)
         Pathname.new @plugin_paths[name]
       end
 
+      def load_paths(name)
+        @load_paths[name]
+      end
+
       # Fetch the name of plugin handling the command
       def command_plugin(command)
         @commands[command]
@@ -54,27 +93,55 @@ module Bundler
         @plugin_paths[name]
       end
 
+      def source?(source)
+        @sources.key? source
+      end
+
+      def source_plugin(name)
+        @sources[name]
+      end
+
+      # Returns the list of plugin names handling the passed event
+      def hook_plugins(event)
+        @hooks[event] || []
+      end
+
     private
 
-      # Reads the index file from the directory and initializes the instance variables.
-      def load_index
+      # Reads the index file from the directory and initializes the instance
+      # variables.
+      #
+      # It skips the sources if the second param is true
+      # @param [Pathname] index file path
+      # @param [Boolean] is the index file global index
+      def load_index(index_file, global = false)
         SharedHelpers.filesystem_access(index_file, :read) do |index_f|
           valid_file = index_f && index_f.exist? && !index_f.size.zero?
           break unless valid_file
+
           data = index_f.read
+
           require "bundler/yaml_serializer"
           index = YAMLSerializer.load(data)
-          @plugin_paths = index["plugin_paths"] || {}
-          @commands = index["commands"] || {}
+
+          @commands.merge!(index["commands"])
+          @hooks.merge!(index["hooks"])
+          @load_paths.merge!(index["load_paths"])
+          @plugin_paths.merge!(index["plugin_paths"])
+          @sources.merge!(index["sources"]) unless global
         end
       end
 
-      # Should be called when any of the instance variables change. Stores the instance
-      # variables in YAML format. (The instance variables are supposed to be only String key value pairs)
+      # Should be called when any of the instance variables change. Stores the
+      # instance variables in YAML format. (The instance variables are supposed
+      # to be only String key value pairs)
       def save_index
         index = {
+          "commands"     => @commands,
+          "hooks"        => @hooks,
+          "load_paths"   => @load_paths,
           "plugin_paths" => @plugin_paths,
-          "commands" => @commands,
+          "sources"      => @sources,
         }
 
         require "bundler/yaml_serializer"

data/lib/bundler/plugin/installer.rb

@@ -25,18 +25,14 @@ module Bundler
       # Installs the plugin from Definition object created by limited parsing of
       # Gemfile searching for plugins to be installed
       #
-      # @param [Definition] definiton object
-      # @return [Hash] map of plugin names to thier paths
+      # @param [Definition] definition object
+      # @return [Hash] map of names to their specs they are installed with
       def install_definition(definition)
-        plugins = definition.dependencies.map(&:name)
-
         def definition.lock(*); end
         definition.resolve_remotely!
         specs = definition.specs
 
-        paths = install_from_specs specs
-
-        Hash[paths.select {|name, _| plugins.include? name }]
+        install_from_specs specs
       end
 
     private
@@ -66,7 +62,7 @@ module Bundler
       # @param [Array] version of the gem to install
       # @param [String, Array<String>] source(s) to resolve the gem
       #
-      # @return [String] the path where the plugin was installed
+      # @return [Hash] map of names to the specs of plugins installed
       def install_rubygems(names, version, sources)
         deps = names.map {|name| Dependency.new name, version }
 
@@ -82,14 +78,14 @@ module Bundler
       #
       # @param specs to install
       #
-      # @return [Hash] map of names to path where the plugin was installed
+      # @return [Hash] map of names to the specs
       def install_from_specs(specs)
         paths = {}
 
         specs.each do |spec|
           spec.source.install spec
 
-          paths[spec.name] = spec.full_gem_path
+          paths[spec.name] = spec
         end
 
         paths

data/lib/bundler/plugin/source_list.rb

@@ -19,6 +19,10 @@ module Bundler
       def add_rubygems_source(options = {})
         add_source_to_list Plugin::Installer::Rubygems.new(options), @rubygems_sources
       end
+
+      def all_sources
+        path_sources + git_sources + rubygems_sources
+      end
     end
   end
 end

data/lib/bundler/postit_trampoline.rb

@@ -1,51 +1,68 @@
 # frozen_string_literal: true
+if ENV["BUNDLE_ENABLE_TRAMPOLINE"]
 
-module BundlerVendoredPostIt; end
-require "bundler/vendor/postit/lib/postit"
-require "rubygems"
+  module BundlerVendoredPostIt; end
+  require "bundler/vendor/postit/lib/postit"
+  require "rubygems"
 
-environment = BundlerVendoredPostIt::PostIt::Environment.new([])
-version = Gem::Requirement.new(environment.bundler_version)
+  environment = BundlerVendoredPostIt::PostIt::Environment.new([])
+  version = Gem::Requirement.new(environment.bundler_version)
 
-installed_version =
-  if defined?(Bundler::VERSION)
-    Bundler::VERSION
-  else
-    File.read(File.expand_path("../version.rb", __FILE__)) =~ /VERSION = "(.+)"/
-    $1
-  end
-installed_version &&= Gem::Version.new(installed_version)
-
-if !version.satisfied_by?(installed_version)
-  begin
-    installer = BundlerVendoredPostIt::PostIt::Installer.new(version)
-    installer.install!
-  rescue => e
-    abort <<-EOS.strip
+  installed_version =
+    if defined?(Bundler::VERSION)
+      Bundler::VERSION
+    else
+      File.read(File.expand_path("../version.rb", __FILE__)) =~ /VERSION = "(.+)"/
+      $1
+    end
+  installed_version &&= Gem::Version.new(installed_version)
+
+  if !version.satisfied_by?(installed_version)
+    begin
+      installer = BundlerVendoredPostIt::PostIt::Installer.new(version)
+      unless installer.installed?
+        warn "Installing locked Bundler version #{version.to_s.gsub("= ", "")}..."
+        installer.install!
+      end
+    rescue => e
+      abort <<-EOS.strip
 Installing the inferred bundler version (#{version}) failed.
 If you'd like to update to the current bundler version (#{installed_version}) in this project, run `bundle update --bundler`.
 The error was: #{e}
     EOS
-  end
+    end
 
-  Gem.loaded_specs.delete("bundler") unless defined?(Bundler)
-  gem "bundler", version
-  $:.delete(File.expand_path("../..", __FILE__))
-else
-  begin
+    if deleted_spec = Gem.loaded_specs.delete("bundler")
+      deleted_spec.full_require_paths.each {|path| $:.delete(path) }
+    else
+      $:.delete(File.expand_path("../..", __FILE__))
+    end
     gem "bundler", version
-  rescue LoadError
-    $:.unshift(File.expand_path("../..", __FILE__))
+  else
+    begin
+      gem "bundler", version
+    rescue LoadError
+      $:.unshift(File.expand_path("../..", __FILE__))
+    end
   end
-end
-
-running_version = begin
-  require "bundler/version"
-  Bundler::VERSION
-rescue LoadError, NameError
-  nil
-end
-
-if !Gem::Version.correct?(running_version.to_s) || !version.satisfied_by?(Gem::Version.create(running_version))
-  abort "The running bundler (#{running_version}) does not match the required `#{version}`"
-end
+
+  running_version = begin
+    require "bundler/version"
+    Bundler::VERSION
+  rescue LoadError, NameError
+    nil
+  end
+
+  ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"] = installed_version.to_s
+
+  if !Gem::Requirement.new(">= 1.13.pre".dup).satisfied_by?(Gem::Version.new(running_version)) && (ARGV.empty? || ARGV.any? {|a| %w(install i).include? a })
+    puts <<-WARN.strip
+You're running Bundler #{installed_version} but this project uses #{running_version}. To update, run `bundle update --bundler`.
+  WARN
+  end
+
+  if !Gem::Version.correct?(running_version.to_s) || !version.satisfied_by?(Gem::Version.create(running_version))
+    abort "The running bundler (#{running_version}) does not match the required `#{version}`"
+  end
+
+end # unless ENV["BUNDLE_ENABLE_TRAMPOLINE"]

data/lib/bundler/resolver.rb

@@ -122,14 +122,17 @@ module Bundler
         @source ||= first.source
       end
 
-      def for?(platform, required_ruby_version)
-        if spec = @specs[platform]
-          if required_ruby_version && spec.respond_to?(:required_ruby_version) && spec_required_ruby_version = spec.required_ruby_version
-            spec_required_ruby_version.satisfied_by?(required_ruby_version.to_gem_version_with_patchlevel)
-          else
-            true
-          end
-        end
+      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)
       end
 
       def to_s
@@ -172,14 +175,14 @@ 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 = [], ruby_version = nil)
+    def self.resolve(requirements, index, source_requirements = {}, base = [], ruby_version = nil, gem_version_promoter = GemVersionPromoter.new, additional_base_requirements = [])
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
-      resolver = new(index, source_requirements, base, ruby_version)
+      resolver = new(index, source_requirements, base, ruby_version, gem_version_promoter, additional_base_requirements)
       result = resolver.start(requirements)
       SpecSet.new(result)
     end
 
-    def initialize(index, source_requirements, base, ruby_version)
+    def initialize(index, source_requirements, base, ruby_version, gem_version_promoter, additional_base_requirements)
       @index = index
       @source_requirements = source_requirements
       @base = base
@@ -187,7 +190,9 @@ module Bundler
       @search_for = {}
       @base_dg = Molinillo::DependencyGraph.new
       @base.each {|ls| @base_dg.add_vertex(ls.name, Dependency.new(ls.name, ls.version), true) }
+      additional_base_requirements.each {|d| @base_dg.add_vertex(d.name, d) }
       @ruby_version = ruby_version
+      @gem_version_promoter = gem_version_promoter
     end
 
     def start(requirements)
@@ -249,7 +254,7 @@ module Bundler
         if vertex = @base_dg.vertex_named(dependency.name)
           locked_requirement = vertex.payload.requirement
         end
-        if results.any?
+        spec_groups = if results.any?
           nested = []
           results.each do |spec|
             version, specs = nested.last
@@ -266,6 +271,13 @@ module Bundler
         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.
+        if @gem_version_promoter.major?
+          spec_groups
+        else
+          @gem_version_promoter.sort_versions(dependency, spec_groups)
+        end
       end
       search.select {|sg| sg.for?(platform, @ruby_version) }.each {|sg| sg.activate_platform!(platform) }
     end

data/lib/bundler/retry.rb

@@ -45,7 +45,8 @@ module Bundler
       @failed = true
       raise e if last_attempt? || @exceptions.any? {|k| e.is_a?(k) }
       return true unless name
-      Bundler.ui.warn "Retrying#{" #{name}" if name} due to error (#{current_run.next}/#{total_runs}): #{e.class} #{e.message}"
+      Bundler.ui.info "" unless Bundler.ui.debug? # Add new line incase dots preceded this
+      Bundler.ui.warn "Retrying #{name} due to error (#{current_run.next}/#{total_runs}): #{e.class} #{e.message}", Bundler.ui.debug?
     end
 
     def keep_trying?