bundler 1.11.1 → 2.2.6

data/lib/bundler/installer/parallel_installer.rb

@@ -1,124 +1,228 @@
-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
+# frozen_string_literal: true
+
+require_relative "../worker"
+require_relative "gem_installer"
+
+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 installation_attempted?
+        installed? || failed?
+      end
+
+      # Only true when spec in neither installed nor already enqueued
+      def ready_to_enqueue?
+        !enqueued? && !installation_attempted?
+      end
+
+      def has_post_install_message?
+        !post_install_message.empty?
+      end
+
+      def ignorable_dependency?(dep)
+        dep.type == :development || dep.name == @name
+      end
 
-    def has_post_install_message?
-      !post_install_message.empty?
+      # 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? {|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
+        @dependencies ||= begin
+          all_dependencies.reject {|dep| ignorable_dependency? dep }
+        end
+      end
+
+      def missing_lockfile_dependencies(all_spec_names)
+        deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
+        deps.reject {|dep| all_spec_names.include? dep.name }
+      end
+
+      # Represents all dependencies
+      def all_dependencies
+        @spec.dependencies
+      end
+
+      def to_s
+        "#<#{self.class} #{@spec.full_name} (#{state})>"
+      end
     end
 
-    def ignorable_dependency?(dep)
-      dep.type == :development || dep.name == @name
+    def self.call(*args)
+      new(*args).call
     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 }
+    attr_reader :size
+
+    def initialize(installer, all_specs, size, standalone, force)
+      @installer = installer
+      @size = size
+      @standalone = standalone
+      @force = force
+      @specs = all_specs.map {|s| SpecInstallation.new(s) }
+      @spec_set = all_specs
+      @rake = @specs.find {|s| s.name == "rake" }
     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 }
-        if missing.size > 0
-          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
+    def call
+      check_for_corrupt_lockfile
+
+      if @size > 1
+        install_with_worker
+      else
+        install_serially
       end
+
+      handle_error if failed_specs.any?
+      @specs
+    ensure
+      worker_pool && worker_pool.stop
     end
 
-    # Represents all dependencies
-    def all_dependencies
-      @spec.dependencies
+    def check_for_corrupt_lockfile
+      missing_dependencies = @specs.map do |s|
+        [
+          s,
+          s.missing_lockfile_dependencies(@specs.map(&:name)),
+        ]
+      end.reject {|a| a.last.empty? }
+      return if missing_dependencies.empty?
+
+      warning = []
+      warning << "Your lockfile was created by an old Bundler that left some things out."
+      if @size != 1
+        warning << "Because of the missing DEPENDENCIES, we can only install gems one at a time, instead of installing #{@size} at a time."
+        @size = 1
+      end
+      warning << "You can fix this by adding the missing gems to your Gemfile, running bundle install, and then removing the gems from your Gemfile."
+      warning << "The missing gems are:"
+
+      missing_dependencies.each do |spec, missing|
+        warning << "* #{missing.map(&:name).join(", ")} depended upon by #{spec.name}"
+      end
+
+      Bundler.ui.warn(warning.join("\n"))
     end
-  end
 
-  def self.call(*args)
-    new(*args).call
-  end
+    private
 
-  # 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 failed_specs
+      @specs.select(&:failed?)
+    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 install_with_worker
+      enqueue_specs
+      process_specs until finished_installing?
+    end
 
-  def call
-    enqueue_specs
-    process_specs until @specs.all?(&:installed?)
-  ensure
-    worker_pool && worker_pool.stop
-  end
+    def install_serially
+      until finished_installing?
+        raise "failed to find a spec to enqueue while installing serially" unless spec_install = @specs.find(&:ready_to_enqueue?)
+        spec_install.state = :enqueued
+        do_install(spec_install, 0)
+      end
+    end
+
+    def worker_pool
+      @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda {|spec_install, worker_num|
+        do_install(spec_install, worker_num)
+      }
+    end
 
-  def worker_pool
-    @worker_pool ||= Bundler::Worker.new @size, lambda { |spec_install, worker_num|
-      message = Bundler::GemInstaller.new(
+    def do_install(spec_install, worker_num)
+      Plugin.hook(Plugin::Events::GEM_BEFORE_INSTALL, spec_install)
+      gem_installer = Bundler::GemInstaller.new(
         spec_install.spec, @installer, @standalone, worker_num, @force
-      ).install_from_spec
-      spec_install.post_install_message = message unless message.nil?
+      )
+      success, message = gem_installer.install_from_spec
+      if success
+        spec_install.state = :installed
+        spec_install.post_install_message = message unless message.nil?
+      else
+        spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
+        spec_install.state = :failed
+      end
+      Plugin.hook(Plugin::Events::GEM_AFTER_INSTALL, spec_install)
       spec_install
-    }
-  end
+    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
+      worker_pool.deq
+      enqueue_specs
+    end
 
-  def collect_post_install_message(spec)
-    Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
-  end
+    def finished_installing?
+      @specs.all? do |spec|
+        return true if spec.failed?
+        spec.installed?
+      end
+    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
+    def handle_error
+      errors = failed_specs.map(&:error)
+      if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }
+        raise exception
+      end
+      raise Bundler::InstallError, errors.join("\n\n")
+    end
+
+    def require_tree_for_spec(spec)
+      tree = @spec_set.what_required(spec)
+      t = String.new("In #{File.basename(SharedHelpers.default_gemfile)}:\n")
+      tree.each_with_index do |s, depth|
+        t << "  " * depth.succ << s.name
+        unless tree.last == s
+          t << %( was resolved to #{s.version}, which depends on)
+        end
+        t << %(\n)
+      end
+      t
+    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|
+        next if @rake && !@rake.installed? && spec.name != @rake.name
+
+        if spec.dependencies_installed? @specs
+          spec.state = :enqueued
+          worker_pool.enq spec
+        end
       end
     end
   end

data/lib/bundler/installer/standalone.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class Standalone
     def initialize(groups, definition)
@@ -10,17 +12,16 @@ module Bundler
       end
       File.open File.join(bundler_path, "setup.rb"), "w" do |file|
         file.puts "require 'rbconfig'"
-        file.puts "# ruby 1.8.7 doesn't define RUBY_ENGINE"
-        file.puts "ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'"
+        file.puts "ruby_engine = RUBY_ENGINE"
         file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
         file.puts "path = File.expand_path('..', __FILE__)"
         paths.each do |path|
-          file.puts %($:.unshift "\#{path}/#{path}")
+          file.puts %($:.unshift File.expand_path("\#{path}/#{path}"))
         end
       end
     end
 
-  private
+    private
 
     def paths
       @specs.map do |spec|
@@ -33,16 +34,19 @@ module Bundler
     end
 
     def version_dir
-      "#{Bundler.ruby_version.engine}/#{RbConfig::CONFIG["ruby_version"]}"
+      "#{Bundler::RubyVersion.system.engine}/#{RbConfig::CONFIG["ruby_version"]}"
     end
 
     def bundler_path
-      File.join(Bundler.settings[:path], "bundler")
+      Bundler.root.join(Bundler.settings[:path], "bundler")
     end
 
     def gem_path(path, spec)
       full_path = Pathname.new(path).absolute? ? path : File.join(spec.full_gem_path, path)
       Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path)).to_s
+    rescue TypeError
+      error_message = "#{spec.name} #{spec.version} has an invalid gemspec"
+      raise Gem::InvalidSpecificationException.new(error_message)
     end
   end
 end

data/lib/bundler/lazy_specification.rb

@@ -1,9 +1,25 @@
-require "uri"
-require "rubygems/spec_fetcher"
-require "bundler/match_platform"
+# frozen_string_literal: true
+
+require_relative "match_platform"
 
 module Bundler
   class LazySpecification
+    Identifier = Struct.new(:name, :version, :platform)
+    class Identifier
+      include Comparable
+      def <=>(other)
+        return unless other.is_a?(Identifier)
+        [name, version, platform_string] <=> [other.name, other.version, other.platform_string]
+      end
+
+      protected
+
+      def platform_string
+        platform_string = platform.to_s
+        platform_string == Index::RUBY ? Index::NULL : platform_string
+      end
+    end
+
     include MatchPlatform
 
     attr_reader :name, :version, :dependencies, :platform
@@ -13,7 +29,7 @@ module Bundler
       @name          = name
       @version       = version
       @dependencies  = []
-      @platform      = platform
+      @platform      = platform || Gem::Platform::RUBY
       @source        = source
       @specification = nil
     end
@@ -30,15 +46,25 @@ module Bundler
       identifier == other.identifier
     end
 
+    def eql?(other)
+      identifier.eql?(other.identifier)
+    end
+
+    def hash
+      identifier.hash
+    end
+
     def satisfies?(dependency)
       @name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))
     end
 
     def to_lock
+      out = String.new
+
       if platform == Gem::Platform::RUBY || platform.nil?
-        out = "    #{name} (#{version})\n"
+        out << "    #{name} (#{version})\n"
       else
-        out = "    #{name} (#{version}-#{platform})\n"
+        out << "    #{name} (#{version}-#{platform})\n"
       end
 
       dependencies.sort_by(&:to_s).uniq.each do |dep|
@@ -50,7 +76,23 @@ module Bundler
     end
 
     def __materialize__
-      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+      @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
+        platform_object = Gem::Platform.new(platform)
+        candidates = source.specs.search(search_object)
+        same_platform_candidates = candidates.select do |spec|
+          MatchPlatform.platforms_match?(spec.platform, platform_object)
+        end
+        search = same_platform_candidates.last || candidates.last
+        search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
+        search
+      end
     end
 
     def respond_to?(*args)
@@ -58,14 +100,23 @@ 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, platform)
+    end
+
+    def git_version
+      return unless source.is_a?(Bundler::Source::Git)
+      " #{source.revision[0..6]}"
     end
 
-  private
+    private
 
     def to_ary
       nil
@@ -78,5 +129,18 @@ module Bundler
 
       @specification.send(method, *args, &blk)
     end
+
+    #
+    # For backwards compatibility with existing lockfiles, if the most specific
+    # locked platform is RUBY, we keep the previous behaviour of resolving the
+    # best platform variant at materiliazation time. For previous bundler
+    # versions (before 2.2.0) this was always the case (except when the lockfile
+    # only included non-ruby platforms), but we're also keeping this behaviour
+    # on newer bundlers unless users generate the lockfile from scratch or
+    # explicitly add a more specific platform.
+    #
+    def ruby_platform_materializes_to_ruby_platform?
+      !Bundler.most_specific_locked_platform?(Gem::Platform::RUBY)
+    end
   end
 end