Class: Homebrew::Cmd::InstallCmd Private

Inherits:

AbstractCommand

Object
AbstractCommand
Homebrew::Cmd::InstallCmd

show all

Defined in:: cmd/install.rb,
sorbet/rbi/dsl/homebrew/cmd/install_cmd.rbi

This class is part of a private API. This class may only be used in the Homebrew/brew repository. Third parties should avoid using this class if possible, as it may be removed or changed without warning.

Defined Under Namespace

Classes: Args

Instance Method Summary collapse

#args ⇒ Homebrew::Cmd::InstallCmd::Args private
#run ⇒ void private

Methods inherited from AbstractCommand

command, command_name, dev_cmd?, #initialize, parser, ruby_cmd?

Methods included from Utils::Output::Mixin

#issue_reporting_message, #odebug, #odeprecated, #odie, #odisabled, #ofail, #oh1, #oh1_title, #ohai, #ohai_title, #onoe, #opoo, #opoo_outside_github_actions, #opoo_without_github_actions_annotation, #pretty_deprecated, #pretty_disabled, #pretty_duration, #pretty_install_status, #pretty_installed, #pretty_uninstalled, #pretty_unmarked, #pretty_upgradable, #pretty_warning

Constructor Details

This class inherits a constructor from Homebrew::AbstractCommand

Instance Method Details

#args ⇒ `Homebrew::Cmd::InstallCmd::Args`

This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Returns:

(Homebrew::Cmd::InstallCmd::Args)

10	# File 'sorbet/rbi/dsl/homebrew/cmd/install_cmd.rbi', line 10 def args; end

#run ⇒ `void`

This method returns an undefined value.

# File 'cmd/install.rb', line 179

def run
  if args.env.present?
    # Can't use `replacement: false` because `install_args` are used by
    # `build.rb`. Instead, `hide_from_man_page` and don't do anything with
    # this argument here.
    # This odisabled should stick around indefinitely.
    odisabled "`brew install --env`", "`env :std` in specific formula files"
  end

  args.named.each do |name|
    if (tap_with_name = Tap.with_formula_name(name))
      tap, = tap_with_name
    elsif (tap_with_token = Tap.with_cask_token(name))
      tap, = tap_with_token
    end

    tap&.ensure_installed!
  end
  Homebrew::Trust.trust_fully_qualified_items!(args.named, type: args.only_formula_or_cask)

  if args.ignore_dependencies?
    opoo <<~EOS
      #{Tty.bold}`--ignore-dependencies` is an unsupported Homebrew developer option!#{Tty.reset}
      Adjust your PATH to put any preferred versions of applications earlier in the
      PATH rather than using this unsupported option!

    EOS
  end

  formulae, casks = T.cast(
    args.named.to_formulae_and_casks(warn: false).partition { it.is_a?(Formula) },
    [T::Array[Formula], T::Array[Cask::Cask]],
  )
  ask = !args.no_ask?

  installed_casks = T.let([], T::Array[Cask::Cask])
  new_casks = T.let([], T::Array[Cask::Cask])
  upgrade_casks = T.let([], T::Array[Cask::Cask])
  fetch_casks = T.let([], T::Array[Cask::Cask])
  if casks.any?
    require "cask/installer"
    require "cask/upgrade"
    require "install"

    prefetched_cask_installers = T.let([], T::Array[Cask::Installer])

    if args.dry_run?
      Install.print_dry_run_casks(casks, skip_cask_deps: args.skip_cask_deps?, include_installed: false)
      return
    end

    installed_casks, new_casks = casks.partition(&:installed?)

    fetch_casks = if Homebrew::EnvConfig.no_install_upgrade?
      new_casks
    else
      upgrade_casks = Cask::Upgrade.outdated_casks(casks, args:, force: true, quiet: true)
      new_casks | upgrade_casks
    end
    Install.ask_casks fetch_casks, skip_cask_deps: args.skip_cask_deps? if ask
  end

  if Homebrew::EnvConfig.verify_attestations?
    require "attestation"
    formulae = Homebrew::Attestation.sort_formulae_for_install(formulae)
  end

  # if the user's flags will prevent bottle only-installations when no
  # developer tools are available, we need to stop them early on
  build_flags = []
  unless DevelopmentTools.installed?
    build_flags << "--HEAD" if args.HEAD?
    build_flags << "--build-bottle" if args.build_bottle?
    build_flags << "--build-from-source" if args.build_from_source?

    raise BuildFlagsError.new(build_flags, bottled: formulae.all?(&:bottled?)) if build_flags.present?
  end

  if build_flags.present? && !Homebrew::EnvConfig.developer?
    opoo "building from source is not supported!"
    puts "You're on your own. Failures are expected so don't create any issues, please!"
  end

  installed_formulae = formulae.select do |f|
    Install.install_formula?(
      f,
      head:              args.HEAD?,
      fetch_head:        args.fetch_HEAD?,
      only_dependencies: args.only_dependencies?,
      force:             args.force?,
      quiet:             args.quiet?,
      skip_link:         args.skip_link?,
      overwrite:         args.overwrite?,
    )
  end

  return if formulae.any? && installed_formulae.empty? && casks.empty?

  require "install"

  formulae_installer = Install.formula_installers(
    installed_formulae,
    installed_on_request:       !args.as_dependency?,
    build_bottle:               args.build_bottle?,
    force_bottle:               args.force_bottle?,
    bottle_arch:                args.bottle_arch,
    ignore_deps:                args.ignore_dependencies?,
    only_deps:                  args.only_dependencies?,
    include_test_formulae:      args.include_test_formulae,
    build_from_source_formulae: args.build_from_source_formulae,
    cc:                         args.cc,
    git:                        args.git?,
    interactive:                args.interactive?,
    keep_tmp:                   args.keep_tmp?,
    debug_symbols:              args.debug_symbols?,
    force:                      args.force?,
    overwrite:                  args.overwrite?,
    debug:                      args.debug?,
    quiet:                      args.quiet?,
    verbose:                    args.verbose?,
    dry_run:                    args.dry_run?,
    skip_post_install:          args.skip_post_install?,
    skip_link:                  args.skip_link?,
  )

  shared_download_queue = T.let(nil, T.nilable(Homebrew::DownloadQueue))
  if !args.dry_run? && formulae_installer.any?
    shared_download_queue = Homebrew::DownloadQueue.new(pour: true)
    # Start bottle manifest (and, once downloads are confirmed, bottle)
    # transfers before the local-only work below.
    formulae_installer = Install.prelude_fetch_formulae(formulae_installer,
                                                        download_queue: shared_download_queue,
                                                        metadata_only:  ask)
  end

  begin
    Install.perform_preinstall_checks_once
    Install.check_cc_argv(args.cc)

    dependants = Upgrade.dependants(
      installed_formulae,
      flags:                      args.flags_only,
      ask:                        ask,
      installed_on_request:       !args.as_dependency?,
      force_bottle:               args.force_bottle?,
      build_from_source_formulae: args.build_from_source_formulae,
      interactive:                args.interactive?,
      keep_tmp:                   args.keep_tmp?,
      debug_symbols:              args.debug_symbols?,
      force:                      args.force?,
      debug:                      args.debug?,
      quiet:                      args.quiet?,
      verbose:                    args.verbose?,
      dry_run:                    args.dry_run?,
    )

    # Main block: if asking the user is enabled, show dry-run information.
    if ask
      shared_download_queue&.fetch(only: Resource::BottleManifest,
                                   heading: "Downloading bottle manifests", allow_failures: true)
      Install.ask_formulae(
        formulae_installer,
        dependants,
        flags:                      args.flags_only,
        force_bottle:               args.force_bottle?,
        build_from_source_formulae: args.build_from_source_formulae,
        interactive:                args.interactive?,
        keep_tmp:                   args.keep_tmp?,
        debug_symbols:              args.debug_symbols?,
        force:                      args.force?,
        debug:                      args.debug?,
        quiet:                      args.quiet?,
        verbose:                    args.verbose?,
      )
    end
  # Ensure the early download queue is shut down on interrupts and declined prompts.
  rescue Exception # rubocop:disable Lint/RescueException
    shared_download_queue&.shutdown
    raise
  end

  dependent_formulae_installer = if args.dry_run?
    []
  else
    Upgrade.dependent_formula_installers(
      dependants,
      installed_formulae,
      flags:                      args.flags_only,
      force_bottle:               args.force_bottle?,
      build_from_source_formulae: args.build_from_source_formulae,
      interactive:                args.interactive?,
      keep_tmp:                   args.keep_tmp?,
      debug_symbols:              args.debug_symbols?,
      force:                      args.force?,
      debug:                      args.debug?,
      quiet:                      args.quiet?,
      verbose:                    args.verbose?,
    )
  end

  if !args.dry_run? && (formulae_installer.any? || dependent_formulae_installer.any? || fetch_casks.any?)
    download_queue = T.let(shared_download_queue || Homebrew::DownloadQueue.new(pour: true),
                           Homebrew::DownloadQueue)
    shared_download_queue = nil
    begin
      if !ask && upgrade_casks.any?
        Cask::Upgrade.show_upgrade_summary(
          upgrade_casks.map { |cask| "#{cask.full_name} #{cask.installed_version} -> #{cask.version}" },
        )
      end

      all_formulae_installer = Install.enqueue_formulae(
        (formulae_installer + dependent_formulae_installer).uniq { |fi| fi.formula.full_name },
        download_queue:,
      )
      formulae_installer &= all_formulae_installer
      dependent_formulae_installer &= all_formulae_installer

      if fetch_casks.any?
        prefetched_cask_installers = fetch_casks.map do |cask|
          Cask::Installer.new(
            cask,
            adopt:          args.adopt?,
            binaries:       args.binaries?,
            verbose:        args.verbose?,
            force:          args.force?,
            quiet:          args.quiet?,
            skip_cask_deps: args.skip_cask_deps?,
            require_sha:    args.require_sha?,
            upgrade:        upgrade_casks.include?(cask),
            download_queue:,
            defer_fetch:    true,
          )
        end

        Install.enqueue_cask_installers(prefetched_cask_installers, download_queue:)
      end

      download_queue.fetch(heading: Install.combined_fetch_downloads_heading(
        formula_names: all_formulae_installer.map { |fi| fi.formula.name },
      ) || "Fetching dependency downloads")
      # Install everything that did download, rather than aborting the
      # whole run; the failures above still exit nonzero at the end.
      all_formulae_installer = Install.reject_failed_downloads(all_formulae_installer, download_queue:)
      formulae_installer &= all_formulae_installer
      dependent_formulae_installer &= all_formulae_installer
    ensure
      download_queue.shutdown
    end
  end
  shared_download_queue&.shutdown

  installed_or_upgraded_formulae = Install.install_formulae(
    formulae_installer,
    dry_run: args.dry_run?,
    verbose: args.verbose?,
    cleanup: false,
  )

  installed_or_upgraded_formulae |= Upgrade.upgrade_dependents(
    dependants, installed_formulae,
    flags:                         args.flags_only,
    dry_run:                       args.dry_run?,
    force_bottle:                  args.force_bottle?,
    build_from_source_formulae:    args.build_from_source_formulae,
    interactive:                   args.interactive?,
    keep_tmp:                      args.keep_tmp?,
    debug_symbols:                 args.debug_symbols?,
    force:                         args.force?,
    debug:                         args.debug?,
    quiet:                         args.quiet?,
    verbose:                       args.verbose?,
    cleanup:                       false,
    prefetched_formula_installers: dependent_formulae_installer
  )

  installed_or_upgraded_casks = T.let([], T::Array[Cask::Cask])
  if prefetched_cask_installers
    new_casks.each do |cask|
      installer = prefetched_cask_installers.find { |candidate| candidate.cask.equal?(cask) }
      installer ||= Cask::Installer.new(
        cask,
        adopt:          args.adopt?,
        binaries:       args.binaries?,
        force:          args.force?,
        quiet:          args.quiet?,
        require_sha:    args.require_sha?,
        skip_cask_deps: args.skip_cask_deps?,
        verbose:        args.verbose?,
      )
      installer.install
      installed_or_upgraded_casks << cask
    rescue => e
      ofail "#{cask.full_name}: #{e}"
    end

    if !Homebrew::EnvConfig.no_install_upgrade? && installed_casks.any?
      begin
        Cask::Upgrade.upgrade_casks!(
          *installed_casks,
          force:                      args.force?,
          dry_run:                    args.dry_run?,
          binaries:                   args.binaries?,
          require_sha:                args.require_sha?,
          skip_cask_deps:             args.skip_cask_deps?,
          verbose:                    args.verbose?,
          quiet:                      args.quiet?,
          skip_prefetch:              true,
          show_upgrade_summary:       false,
          upgraded_casks:             installed_or_upgraded_casks,
          prefetched_cask_installers:,
          args:,
        )
      rescue => e
        ofail e
      end
    end
  end

  Install.finish_installation(
    formulae:      installed_or_upgraded_formulae,
    casks:         installed_or_upgraded_casks,
    dry_run:       args.dry_run?,
    display_times: args.display_times?,
  )
rescue FormulaUnreadableError, FormulaClassUnavailableError,
       TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
  require "utils/backtrace"

  # Need to rescue before `FormulaUnavailableError` (superclass of this)
  # is handled, as searching for a formula doesn't make sense here (the
  # formula was found, but there's a problem with its implementation).
  $stderr.puts Utils::Backtrace.clean(e) if Homebrew::EnvConfig.developer?
  ofail e.message
rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError => e
  Homebrew.failed = true

  # formula name or cask token
  name = case e
  when FormulaOrCaskUnavailableError then e.name
  when Cask::CaskUnavailableError then e.token
  else T.absurd(e)
  end

  if name == "updog"
    ofail "What's updog?"
    return
  end

  opoo e

  require "missing_formula"
  reason = MissingFormula.reason(name, silent: true)
  if !args.cask? && reason
    $stderr.puts reason
    return
  end

  # We don't seem to get good search results when the tap is specified
  # so we might as well return early.
  return if name.include?("/")

  require "search"

  package_types = []
  package_types << "formulae" unless args.cask?
  package_types << "casks" unless args.formula?

  ohai "Searching for similarly named #{package_types.join(" and ")}..."

  # Don't treat formula/cask name as a regex
  string_or_regex = name
  all_formulae, all_casks = Search.search_names(string_or_regex, args)

  if all_formulae.any?
    ohai "Formulae", Formatter.columns(all_formulae)
    first_formula = all_formulae.first.to_s
    puts <<~EOS

      To install #{first_formula}, run:
        brew install #{first_formula}
    EOS
  end
  puts if all_formulae.any? && all_casks.any?
  if all_casks.any?
    ohai "Casks", Formatter.columns(all_casks)
    first_cask = all_casks.first.to_s
    puts <<~EOS

      To install #{first_cask}, run:
        brew install --cask #{first_cask}
    EOS
  end
  return if all_formulae.any? || all_casks.any?

  odie "No #{package_types.join(" or ")} found for #{name}."
end