class Bundler::ParallelInstaller

# File bundler/installer/parallel_installer.rb, line 70
def self.call(*args)
  new(*args).call
end

# File bundler/installer/parallel_installer.rb, line 76
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

# File bundler/installer/parallel_installer.rb, line 86
def call
  check_for_corrupt_lockfile

  if @rake
    do_install(@rake, 0)
    Gem::Specification.reset
  end

  if @size > 1
    install_with_worker
  else
    install_serially
  end

  check_for_unmet_dependencies

  handle_error if failed_specs.any?
  @specs
ensure
  worker_pool && worker_pool.stop
end

# File bundler/installer/parallel_installer.rb, line 131
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

# File bundler/installer/parallel_installer.rb, line 108
def check_for_unmet_dependencies
  unmet_dependencies = @specs.map do |s|
    [
      s,
      s.dependencies.reject {|dep| @specs.any? {|spec| dep.matches_spec?(spec.spec) } },
    ]
  end.reject {|a| a.last.empty? }
  return if unmet_dependencies.empty?

  warning = []
  warning << "Your lockfile doesn't include a valid resolution."
  warning << "You can fix this by regenerating your lockfile or trying to manually editing the bad locked gems to a version that satisfies all dependencies."
  warning << "The unmet dependencies are:"

  unmet_dependencies.each do |spec, unmet_spec_dependencies|
    unmet_spec_dependencies.each do |unmet_spec_dependency|
      warning << "* #{unmet_spec_dependency}, depended upon #{spec.full_name}, unsatisfied by #{@specs.find {|s| s.name == unmet_spec_dependency.name && !unmet_spec_dependency.matches_spec?(s.spec) }.full_name}"
    end
  end

  Bundler.ui.warn(warning.join("\n"))
end

# File bundler/installer/parallel_installer.rb, line 181
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
  )
  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

# File bundler/installer/parallel_installer.rb, line 241
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

# File bundler/installer/parallel_installer.rb, line 158
def failed_specs
  @specs.select(&:failed?)
end

# File bundler/installer/parallel_installer.rb, line 208
def finished_installing?
  @specs.all? do |spec|
    return true if spec.failed?
    spec.installed?
  end
end

# File bundler/installer/parallel_installer.rb, line 215
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

# File bundler/installer/parallel_installer.rb, line 167
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

# File bundler/installer/parallel_installer.rb, line 162
def install_with_worker
  enqueue_specs
  process_specs until finished_installing?
end

# File bundler/installer/parallel_installer.rb, line 203
def process_specs
  worker_pool.deq
  enqueue_specs
end

# File bundler/installer/parallel_installer.rb, line 223
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

# File bundler/installer/parallel_installer.rb, line 175
def worker_pool
  @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda {|spec_install, worker_num|
    do_install(spec_install, worker_num)
  }
end