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

data/lib/bundler/inline.rb

@@ -60,8 +60,8 @@ def gemfile(install = false, options = {}, &gemfile)
 
   Bundler.ui = ui if install
   if install || missing_specs.call
-    Bundler::Installer.install(Bundler.root, definition, :system => true)
-    Bundler::Installer.post_install_messages.each do |name, message|
+    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}"
     end
   end

data/lib/bundler/installer.rb

@@ -7,22 +7,30 @@ require "bundler/installer/standalone"
 require "bundler/installer/gem_installer"
 
 module Bundler
-  class Installer < Environment
+  class Installer
     class << self
-      attr_accessor :post_install_messages, :ambiguous_gems
+      attr_accessor :ambiguous_gems
 
-      Installer.post_install_messages = {}
       Installer.ambiguous_gems = []
     end
 
+    attr_reader :post_install_messages
+
     # Begins the installation process for Bundler.
     # For more information see the #run method on this class.
     def self.install(root, definition, options = {})
       installer = new(root, definition)
+      Plugin.hook("before-install-all", definition.dependencies)
       installer.run(options)
       installer
     end
 
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
+      @post_install_messages = {}
+    end
+
     # Runs the install procedures for a specific Gemfile.
     #
     # Firstly, this method will check to see if Bundler.bundle_path exists
@@ -61,7 +69,7 @@ module Bundler
         @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
       end
 
-      if dependencies.empty?
+      if @definition.dependencies.empty?
         Bundler.ui.warn "The Gemfile specifies no dependencies"
         lock
         return
@@ -108,7 +116,7 @@ module Bundler
           next
         end
 
-        File.open(binstub_path, "w", 0777 & ~File.umask) do |f|
+        File.open(binstub_path, "w", 0o777 & ~File.umask) do |f|
           f.puts ERB.new(template, nil, "-").result(binding)
         end
       end
@@ -138,7 +146,7 @@ module Bundler
       spec.executables.each do |executable|
         next if executable == "bundle"
         executable_path = executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
-        File.open "#{bin_path}/#{executable}", "w", 0755 do |f|
+        File.open "#{bin_path}/#{executable}", "w", 0o755 do |f|
           f.puts ERB.new(template, nil, "-").result(binding)
         end
       end
@@ -160,7 +168,7 @@ module Bundler
     def ensure_specs_are_compatible!
       system_ruby = Bundler::RubyVersion.system
       rubygems_version = Gem::Version.create(Gem::VERSION)
-      specs.each do |spec|
+      @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}, " \
@@ -187,7 +195,10 @@ module Bundler
     end
 
     def install_in_parallel(size, standalone, force = false)
-      ParallelInstaller.call(self, specs, size, standalone, force)
+      spec_installations = ParallelInstaller.call(self, @definition.specs, size, standalone, force)
+      spec_installations.each do |installation|
+        post_install_messages[installation.name] = installation.post_install_message if installation.has_post_install_message?
+      end
     end
 
     def create_bundle_path
@@ -213,5 +224,9 @@ module Bundler
       return if local
       options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
     end
+
+    def lock(opts = {})
+      @definition.lock(Bundler.default_lockfile, opts[:preserve_unknown_sections])
+    end
   end
 end

data/lib/bundler/installer/gem_installer.rb

@@ -15,16 +15,24 @@ module Bundler
       post_install_message = spec_settings ? install_with_settings : install
       Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
       generate_executable_stubs
-      post_install_message
-
+      return true, post_install_message
+    rescue Bundler::InstallHookError, Bundler::SecurityError
+      raise
     rescue Errno::ENOSPC
-      raise Bundler::InstallError, out_of_space_message
+      return false, out_of_space_message
     rescue => e
-      handle_exception(e)
+      return false, specific_failure_message(e)
     end
 
   private
 
+    def specific_failure_message(e)
+      message = "#{e.class}: #{e.message}\n"
+      message += "  " + e.backtrace.join("\n  ") + "\n\n" if Bundler.ui.debug?
+      message = message.lines.first + Bundler.ui.add_color(message.lines.drop(1).join, :clear)
+      message + Bundler.ui.add_color(failure_message, :red)
+    end
+
     def failure_message
       return install_error_message if spec.source.options["git"]
       "#{install_error_message}\n#{gem_install_message}"
@@ -38,16 +46,6 @@ module Bundler
       "Make sure that `gem install #{spec.name} -v '#{spec.version}'` succeeds before bundling."
     end
 
-    def handle_exception(e)
-      # Die if install hook failed or gem signature is bad.
-      raise e if e.is_a?(Bundler::InstallHookError) || e.is_a?(Bundler::SecurityError)
-      # other failure, likely a native extension build failure
-      Bundler.ui.info ""
-      Bundler.ui.warn "#{e.class}: #{e.message}"
-      Bundler.ui.debug e.backtrace.join("\n")
-      raise Bundler::InstallError, failure_message
-    end
-
     def spec_settings
       # Fetch the build settings, if there are any
       Bundler.settings["build.#{spec.name}"]
@@ -63,7 +61,7 @@ module Bundler
     end
 
     def out_of_space_message
-      "Your disk is out of space. Free some space to be able to install your bundle."
+      "#{install_error_message}\nYour disk is out of space. Free some space to be able to install your bundle."
     end
 
     def generate_executable_stubs

data/lib/bundler/installer/parallel_installer.rb

@@ -2,124 +2,146 @@
 require "bundler/worker"
 require "bundler/installer/gem_installer"
 
-class ParallelInstaller
-  class SpecInstallation
-    attr_accessor :spec, :name, :post_install_message, :state
-    def initialize(spec)
-      @spec = spec
-      @name = spec.name
-      @state = :none
-      @post_install_message = ""
-    end
+module Bundler
+  class ParallelInstaller
+    class SpecInstallation
+      attr_accessor :spec, :name, :post_install_message, :state, :error
+      def initialize(spec)
+        @spec = spec
+        @name = spec.name
+        @state = :none
+        @post_install_message = ""
+        @error = nil
+      end
 
-    def installed?
-      state == :installed
-    end
+      def installed?
+        state == :installed
+      end
 
-    def enqueued?
-      state == :enqueued
-    end
+      def enqueued?
+        state == :enqueued
+      end
 
-    # Only true when spec in neither installed nor already enqueued
-    def ready_to_enqueue?
-      !installed? && !enqueued?
-    end
+      def failed?
+        state == :failed
+      end
 
-    def has_post_install_message?
-      !post_install_message.empty?
-    end
+      def installation_attempted?
+        installed? || failed?
+      end
 
-    def ignorable_dependency?(dep)
-      dep.type == :development || dep.name == @name
-    end
+      # Only true when spec in neither installed nor already enqueued
+      def ready_to_enqueue?
+        !enqueued? && !installation_attempted?
+      end
 
-    # Checks installed dependencies against spec's dependencies to make
-    # sure needed dependencies have been installed.
-    def dependencies_installed?(all_specs)
-      installed_specs = all_specs.select(&:installed?).map(&:name)
-      dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
-    end
+      def has_post_install_message?
+        !post_install_message.empty?
+      end
 
-    # Represents only the non-development dependencies, the ones that are
-    # itself and are in the total list.
-    def dependencies(all_spec_names)
-      @dependencies ||= begin
-        deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
-        missing = deps.reject {|dep| all_spec_names.include? dep.name }
-        unless missing.empty?
-          raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
-                              "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
+      def ignorable_dependency?(dep)
+        dep.type == :development || dep.name == @name
+      end
+
+      # Checks installed dependencies against spec's dependencies to make
+      # sure needed dependencies have been installed.
+      def dependencies_installed?(all_specs)
+        installed_specs = all_specs.select(&:installed?).map(&:name)
+        dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
+      end
+
+      # Represents only the non-development dependencies, the ones that are
+      # itself and are in the total list.
+      def dependencies(all_spec_names)
+        @dependencies ||= begin
+          deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
+          missing = deps.reject {|dep| all_spec_names.include? dep.name }
+          unless missing.empty?
+            raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
+                                "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
+          end
+          deps
         end
-        deps
       end
-    end
 
-    # Represents all dependencies
-    def all_dependencies
-      @spec.dependencies
+      # Represents all dependencies
+      def all_dependencies
+        @spec.dependencies
+      end
     end
-  end
 
-  def self.call(*args)
-    new(*args).call
-  end
+    def self.call(*args)
+      new(*args).call
+    end
 
-  # Returns max number of threads machine can handle with a min of 1
-  def self.max_threads
-    [Bundler.settings[:jobs].to_i - 1, 1].max
-  end
+    # Returns max number of threads machine can handle with a min of 1
+    def self.max_threads
+      [Bundler.settings[:jobs].to_i - 1, 1].max
+    end
 
-  def initialize(installer, all_specs, size, standalone, force)
-    @installer = installer
-    @size = size
-    @standalone = standalone
-    @force = force
-    @specs = all_specs.map {|s| SpecInstallation.new(s) }
-  end
+    def initialize(installer, all_specs, size, standalone, force)
+      @installer = installer
+      @size = size
+      @standalone = standalone
+      @force = force
+      @specs = all_specs.map {|s| SpecInstallation.new(s) }
+    end
 
-  def call
-    enqueue_specs
-    process_specs until @specs.all?(&:installed?)
-  ensure
-    worker_pool && worker_pool.stop
-  end
+    def call
+      enqueue_specs
+      process_specs until @specs.all?(&:installed?) || @specs.any?(&:failed?)
+      handle_error if @specs.any?(&:failed?)
+      @specs
+    ensure
+      worker_pool && worker_pool.stop
+    end
 
-  def worker_pool
-    @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
-      message = Bundler::GemInstaller.new(
-        spec_install.spec, @installer, @standalone, worker_num, @force
-      ).install_from_spec
-      spec_install.post_install_message = message unless message.nil?
-      spec_install
-    }
-  end
+    def worker_pool
+      @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
+        gem_installer = Bundler::GemInstaller.new(
+          spec_install.spec, @installer, @standalone, worker_num, @force
+        )
+        success, message = gem_installer.install_from_spec
+        if success && !message.nil?
+          spec_install.post_install_message = message
+        elsif !success
+          spec_install.state = :failed
+          spec_install.error = message
+        end
+        spec_install
+      }
+    end
 
-  # Dequeue a spec and save its post-install message and then enqueue the
-  # remaining specs.
-  # Some specs might've had to wait til this spec was installed to be
-  # processed so the call to `enqueue_specs` is important after every
-  # dequeue.
-  def process_specs
-    spec = worker_pool.deq
-    spec.state = :installed
-    collect_post_install_message spec if spec.has_post_install_message?
-    enqueue_specs
-  end
+    # Dequeue a spec and save its post-install message and then enqueue the
+    # remaining specs.
+    # Some specs might've had to wait til this spec was installed to be
+    # processed so the call to `enqueue_specs` is important after every
+    # dequeue.
+    def process_specs
+      spec = worker_pool.deq
+      spec.state = :installed unless spec.failed?
+      enqueue_specs
+    end
 
-  def collect_post_install_message(spec)
-    Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
-  end
+    def handle_error
+      errors = @specs.select(&:failed?).map(&:error)
+      if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }
+        raise exception
+      end
+      raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")
+    end
 
-  # Keys in the remains hash represent uninstalled gems specs.
-  # We enqueue all gem specs that do not have any dependencies.
-  # Later we call this lambda again to install specs that depended on
-  # previously installed specifications. We continue until all specs
-  # are installed.
-  def enqueue_specs
-    @specs.select(&:ready_to_enqueue?).each do |spec|
-      if spec.dependencies_installed? @specs
-        worker_pool.enq spec
-        spec.state = :enqueued
+    # Keys in the remains hash represent uninstalled gems specs.
+    # We enqueue all gem specs that do not have any dependencies.
+    # Later we call this lambda again to install specs that depended on
+    # previously installed specifications. We continue until all specs
+    # are installed.
+    def enqueue_specs
+      @specs.select(&:ready_to_enqueue?).each do |spec|
+        if spec.dependencies_installed? @specs
+          spec.state = :enqueued
+          worker_pool.enq spec
+        end
       end
     end
   end

data/lib/bundler/lazy_specification.rb

@@ -5,6 +5,8 @@ require "bundler/match_platform"
 
 module Bundler
   class LazySpecification
+    Identifier = Struct.new(:name, :version, :source, :platform, :dependencies)
+
     include MatchPlatform
 
     attr_reader :name, :version, :dependencies, :platform
@@ -61,11 +63,15 @@ module Bundler
     end
 
     def to_s
-      @__to_s ||= "#{name} (#{version})"
+      @__to_s ||= if platform == Gem::Platform::RUBY || platform.nil?
+        "#{name} (#{version})"
+      else
+        "#{name} (#{version}-#{platform})"
+      end
     end
 
     def identifier
-      @__identifier ||= [name, version, source, platform, dependencies].hash
+      @__identifier ||= Identifier.new(name, version, source, platform, dependencies)
     end
 
   private

data/lib/bundler/lockfile_parser.rb

@@ -22,9 +22,10 @@ module Bundler
     GIT          = "GIT".freeze
     GEM          = "GEM".freeze
     PATH         = "PATH".freeze
+    PLUGIN       = "PLUGIN SOURCE".freeze
     SPECS        = "  specs:".freeze
     OPTIONS      = /^  ([a-z]+): (.*)$/i
-    SOURCE       = [GIT, GEM, PATH].freeze
+    SOURCE       = [GIT, GEM, PATH, PLUGIN].freeze
 
     SECTIONS_BY_VERSION_INTRODUCED = {
       # The strings have to be dup'ed for old RG on Ruby 2.3+
@@ -32,6 +33,7 @@ module Bundler
       Gem::Version.create("1.0".dup) => [DEPENDENCIES, PLATFORMS, GIT, GEM, PATH].freeze,
       Gem::Version.create("1.10".dup) => [BUNDLED].freeze,
       Gem::Version.create("1.12".dup) => [RUBY].freeze,
+      Gem::Version.create("1.13".dup) => [PLUGIN].freeze,
     }.freeze
 
     KNOWN_SECTIONS = SECTIONS_BY_VERSION_INTRODUCED.values.flatten.freeze
@@ -107,8 +109,8 @@ module Bundler
         raise LockfileError, "You must use Bundler #{bundler_version.segments.first} or greater with this lockfile."
       when 0
         if current_version < bundler_version
-          Bundler.ui.warn "Warning: the running version of Bundler is older " \
-               "than the version that created the lockfile. We suggest you " \
+          Bundler.ui.warn "Warning: the running version of Bundler (#{current_version}) is older " \
+               "than the version that created the lockfile (#{bundler_version}). We suggest you " \
                "upgrade to the latest version of Bundler by running `gem " \
                "install bundler#{prerelease_text}`.\n"
         end
@@ -118,17 +120,14 @@ module Bundler
   private
 
     TYPES = {
-      GIT  => Bundler::Source::Git,
-      GEM  => Bundler::Source::Rubygems,
-      PATH => Bundler::Source::Path,
+      GIT    => Bundler::Source::Git,
+      GEM    => Bundler::Source::Rubygems,
+      PATH   => Bundler::Source::Path,
+      PLUGIN => Bundler::Plugin,
     }.freeze
 
     def parse_source(line)
       case line
-      when GIT, GEM, PATH
-        @current_source = nil
-        @opts = {}
-        @type = line
       when SPECS
         case @type
         when PATH
@@ -147,6 +146,9 @@ module Bundler
             @rubygems_aggregate.add_remote(url)
           end
           @current_source = @rubygems_aggregate
+        when PLUGIN
+          @current_source = Plugin.source_from_lock(@opts)
+          @sources << @current_source
         end
       when OPTIONS
         value = $2
@@ -161,6 +163,10 @@ module Bundler
         else
           @opts[key] = value
         end
+      when *SOURCE
+        @current_source = nil
+        @opts = {}
+        @type = line
       else
         parse_spec(line)
       end
@@ -201,8 +207,10 @@ module Bundler
     def parse_spec(line)
       if line =~ NAME_VERSION_4
         name = $1
-        version = Gem::Version.new($2)
-        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        version = $2
+        platform = $3
+        version = Gem::Version.new(version)
+        platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
         @current_spec.source = @current_source