class Bundler::Installer

def self.install(root, definition, options = {})
  installer = new(root, definition)
  installer.run(options)
  installer
end

def can_install_in_parallel?
  if Bundler.rubygems.provides?(">= 2.1.0")
    true
  else
    Bundler.ui.warn "Rubygems #{Gem::VERSION} is not threadsafe, so your "\
      "gems will be installed one at a time. Upgrade to Rubygems 2.1.0 " \
      "or higher to enable parallel gem installation."
    false
  end
end

def create_bundle_path
  SharedHelpers.filesystem_access(Bundler.bundle_path.to_s) do |p|
    Bundler.mkdir_p(p)
  end unless Bundler.bundle_path.exist?
rescue Errno::EEXIST
  raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " \
    "because of an invalid symlink. Remove the symlink so the directory can be created."
end

def generate_bundler_executable_stubs(spec, options = {})
  if options[:binstubs_cmd] && spec.executables.empty?
    options = {}
    spec.runtime_dependencies.each do |dep|
      bins = @definition.specs[dep].first.executables
      options[dep.name] = bins unless bins.empty?
    end
    if options.any?
      Bundler.ui.warn "#{spec.name} has no executables, but you may want " \
        "one from a gem it depends on."
      options.each {|name, bins| Bundler.ui.warn "  #{name} has: #{bins.join(", ")}" }
    else
      Bundler.ui.warn "There are no executables for the gem #{spec.name}."
    end
    return
  end
  # double-assignment to avoid warnings about variables that will be used by ERB
  bin_path = bin_path = Bundler.bin_path
  template = template = File.read(File.expand_path("../templates/Executable", __FILE__))
  relative_gemfile_path = relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)
  ruby_command = ruby_command = Thor::Util.ruby_command
  exists = []
  spec.executables.each do |executable|
    next if executable == "bundle"
    binstub_path = "#{bin_path}/#{executable}"
    if File.exist?(binstub_path) && !options[:force]
      exists << executable
      next
    end
    File.open(binstub_path, "w", 0777 & ~File.umask) do |f|
      f.puts ERB.new(template, nil, "-").result(binding)
    end
  end
  if options[:binstubs_cmd] && exists.any?
    case exists.size
    when 1
      Bundler.ui.warn "Skipped #{exists[0]} since it already exists."
    when 2
      Bundler.ui.warn "Skipped #{exists.join(" and ")} since they already exist."
    else
      items = exists[0...-1].empty? ? nil : exists[0...-1].join(", ")
      skipped = [items, exists[-1]].compact.join(" and ")
      Bundler.ui.warn "Skipped #{skipped} since they already exist."
    end
    Bundler.ui.warn "If you want to overwrite skipped stubs, use --force."
  end
end

def generate_standalone_bundler_executable_stubs(spec)
  # double-assignment to avoid warnings about variables that will be used by ERB
  bin_path = Bundler.bin_path
  template = File.read(File.expand_path("../templates/Executable.standalone", __FILE__))
  ruby_command = ruby_command = Thor::Util.ruby_command
  spec.executables.each do |executable|
    next if executable == "bundle"
    standalone_path = standalone_path = Pathname(Bundler.settings[:path]).expand_path.relative_path_from(bin_path)
    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|
      f.puts ERB.new(template, nil, "-").result(binding)
    end
  end
end

def install(options)
  force = options["force"]
  jobs = 1
  jobs = [Bundler.settings[:jobs].to_i - 1, 1].max if can_install_in_parallel?
  install_in_parallel jobs, options[:standalone], force
end

def install_in_parallel(size, standalone, force = false)
  ParallelInstaller.call(self, specs, size, standalone, force)
end

def resolve_if_need(options)
  if Bundler.default_lockfile.exist? && !options["update"]
    local = Bundler.ui.silence do
      begin
        tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
        true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
      rescue BundlerError
      end
    end
  end
  unless local
    options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
  end
end

def run(options)
  create_bundle_path
  if Bundler.settings[:frozen]
    @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
  end
  if dependencies.empty?
    Bundler.ui.warn "The Gemfile specifies no dependencies"
    lock
    return
  end
  resolve_if_need(options)
  install(options)
  lock unless Bundler.settings[:frozen]
  Standalone.new(options[:standalone], @definition).generate if options[:standalone]
end