Class: FormulaInstaller — Homebrew Ruby API

#add_build_sandbox_rules(sandbox, formula_path, log_name:) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

sandbox (Sandbox)
formula_path (Pathname)
log_name (String)

# File 'formula_installer.rb', line 1256

def add_build_sandbox_rules(sandbox, formula_path, log_name:)
  sandbox.allow_read_if_exists path: formula_path
  require "trust"
  sandbox.allow_read_if_exists path: Homebrew::Trust.trust_file
  formula.logs.mkpath
  sandbox.record_log(formula.logs/"#{log_name}.sandbox.log")
  sandbox.allow_write_log(formula)
  sandbox.allow_cvs
  sandbox.allow_fossil
end

#api_bottle ⇒ `Bottle`^?

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:

(Bottle, nil)

# File 'formula_installer.rb', line 1652

def api_bottle
  return @api_bottle if @api_bottle_loaded

  @api_bottle_loaded = true
  return unless formula.loaded_from_internal_api?
  return unless formula.core_formula?

  @api_bottle = Homebrew::API::FormulaBottle.bottle(
    name:           formula.name,
    formula_struct: Homebrew::API::Internal.formula_struct(formula.name),
    formula:,
  )
end

#audit_installed ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1767

def audit_installed
  unless formula.keg_only?
    problem_if_output(check_env_path(formula.bin))
    problem_if_output(check_env_path(formula.sbin))
  end
  super
end

#build ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1153

def build
  FileUtils.rm_rf(formula.logs)

  @start_time = Time.now

  # If the formula is still loaded from the API (i.e. the source .rb was never
  # fetched), attempt to download the source now. Without this, specified_path
  # would point at a JSON file (e.g. formula.jws.json) which build.rb cannot
  # load. See: https://github.com/orgs/Homebrew/discussions/6455
  @formula = Homebrew::API::Formula.source_download_formula(formula) if formula.loaded_from_api?

  staging_path = (create_staging_path if formula.fetch_defined?)
  run_fetch(staging_path:) if staging_path

  # 1. formulae can modify ENV, so we must ensure that each
  #    installation has a pristine ENV when it starts, forking now is
  #    the easiest way to do this
  with_env(HOMEBREW_BUILD_STAGING_PATH: staging_path, HOMEBREW_BUILD_FETCH_PHASE: nil) do
    Sandbox.run_or_fork(*build_args(formula_path), step: "building") do |sandbox|
      add_build_sandbox_rules(sandbox, formula_path, log_name: "build")
      if interactive?
        sandbox.allow_write_path(Dir.home)
      else
        sandbox.deny_read_home
      end
      sandbox.allow_write_xcode
      sandbox.allow_write_cellar(formula)
      if staging_path
        # `fetch` has already downloaded everything, so `install` stays
        # offline and off the download cache apart from the package manager
        # caches, which their offline modes still write to.
        sandbox.allow_write_path(HOMEBREW_TEMP)
        sandbox.allow_write_path(staging_path)
        Homebrew::PackageManagerCache.paths.each { |path| sandbox.allow_write_path(path) }
        sandbox.deny_all_network
      else
        sandbox.allow_write_temp_and_cache
        sandbox.deny_all_network unless formula.network_access_allowed?(:build)
      end
      sandbox.deny_write_temp_cellar
    end
  end

  formula.update_head_version

  raise "Empty installation" if !formula.prefix.directory? || Keg.new(formula.prefix).empty_installation?
# Handle all possible exceptions when building.
rescue Exception => e # rubocop:disable Lint/RescueException
  if e.is_a? BuildError
    e.formula = formula
    e.options = display_options(formula)
  end

  Utils::Interrupts.ignore do
    # any exceptions must leave us with nothing installed
    formula.update_head_version
    FileUtils.rm_r(formula.prefix) if formula.prefix.directory?
    rmdir_if_possible(formula.rack)
  end
  raise e
ensure
  # The build child removes the shared staging directory unless it has to
  # be kept, so this only matters when no child got as far as staging.
  FileUtils.rm_rf(staging_path) if staging_path && !keep_tmp? && !debug_symbols? && !interactive? && !debug?
end

#build_args(formula_path) ⇒ `Array<String, Pathname>`

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.

Parameters:

formula_path (Pathname)

Returns:

(Array<String, Pathname>)

# File 'formula_installer.rb', line 1244

def build_args(formula_path)
  [
    "nice",
    *HOMEBREW_RUBY_EXEC_ARGS,
    "--",
    HOMEBREW_LIBRARY_PATH/"build.rb",
    formula_path,
    *build_argv,
  ]
end

#build_argv ⇒ `Array<String>`

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:

(Array<String>)

1150	# File 'formula_installer.rb', line 1150 def build_argv = sanitized_argv_options + options.as_flags

#build_bottle? ⇒ `Boolean`

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:

(Boolean)



251
252
253

# File 'formula_installer.rb', line 251

def build_bottle?
  @build_bottle.present?
end

#build_bottle_postinstall ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 558

def build_bottle_postinstall
  etc_var_postinstall = Find.find(*ETC_VAR_DIRS.select(&:directory?)).to_a
  (etc_var_postinstall - @etc_var_preinstall).each do |file|
    # Keep new `etc`/`var` files in `.bottle` so `Formula#install_etc_var`
    # can restore them later with `InstallRenamed` config handling.
    cp_path_sub(Pathname.new(file), HOMEBREW_PREFIX, formula.bottle_prefix)
  end
end

#build_bottle_preinstall ⇒ `void`

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.

This method returns an undefined value.



553
554
555

# File 'formula_installer.rb', line 553

def build_bottle_preinstall
  @etc_var_preinstall = Find.find(*ETC_VAR_DIRS.select(&:directory?)).to_a
end

#build_from_source? ⇒ `Boolean`

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:

(Boolean)



241
242
243

# File 'formula_installer.rb', line 241

def build_from_source?
  @build_from_source_formulae.include?(formula.full_name)
end

#build_time ⇒ `Float`^?

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:

(Float, nil)



1112
1113
1114

# File 'formula_installer.rb', line 1112

def build_time
  @build_time ||= T.let(Time.now - @start_time, T.nilable(Float)) if @start_time && !interactive?
end

#caveats ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 973

def caveats
  return if only_deps?

  audit_installed if Homebrew::EnvConfig.developer?

  return unless installed_on_request?
  return if quiet?

  caveats = Caveats.new(formula)
  return if caveats.empty?

  Homebrew.messages.record_completions_and_elisp(caveats.completions_and_elisp)
  return if caveats.caveats.empty?

  Homebrew.messages.record_caveats(formula.name, caveats)
end

#check_conflicts ⇒ `void`

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.

This method returns an undefined value.

Raises:

(FormulaConflictError)

# File 'formula_installer.rb', line 671

def check_conflicts
  return if force?
  return if skip_link?
  return unless link_keg

  conflicts = formula.conflicts.select do |c|
    next false if c.name == formula.name || c.name == formula.full_name

    f = Formulary.factory(c.name)
  rescue TapFormulaUnavailableError
    # If the formula name is a fully-qualified name let's silently
    # ignore it as we don't care about things used in taps that aren't
    # currently tapped.
    false
  rescue FormulaUnavailableError => e
    # If the formula name doesn't exist any more then complain but don't
    # stop installation from continuing.
    opoo <<~EOS
      #{formula}: #{e.message}
      'conflicts_with "#{c.name}"' should be removed from #{formula.path.basename}.
    EOS

    raise if Homebrew::EnvConfig.developer?

    $stderr.puts "Please report this issue to the #{formula.tap&.full_name} tap".squeeze(" ")
    $stderr.puts " (not Homebrew/* repositories)!" unless formula.core_formula?
    false
  else
    f.linked_keg.exist? && f.opt_prefix.exist?
  end

  raise FormulaConflictError.new(formula, conflicts) unless conflicts.empty?
end

#check_install_sanity ⇒ `void`

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.

This method returns an undefined value.

Raises:

(CannotInstallFormulaError)

# File 'formula_installer.rb', line 423

def check_install_sanity
  check_installation_already_attempted

  if force_bottle? && !pour_bottle?
    raise CannotInstallFormulaError, "`--force-bottle` passed but #{formula.full_name} has no bottle!"
  end

  if Homebrew.default_prefix? &&
     !build_from_source? && !build_bottle? && !formula.head? && formula.tap&.core_tap? &&
     # Integration tests override homebrew-core locations
     ENV["HOMEBREW_INTEGRATION_TEST"].nil? &&
     !pour_bottle?
    message = if !formula.pour_bottle? && formula.pour_bottle_check_unsatisfied_reason
      formula_message = formula.pour_bottle_check_unsatisfied_reason
      formula_message[0] = formula_message[0].downcase

      <<~EOS
        #{formula}: #{formula_message}
      EOS
    # don't want to complain about no bottle available if doing an
    # upgrade/reinstall/dependency install (but do in the case the bottle
    # check fails)
    elsif fresh_install?(formula)
      <<~EOS
        #{formula}: no bottle available!
      EOS
    end

    if message
      message += <<~EOS
        If you're feeling brave, you can try to install from source with:
          brew install --build-from-source #{formula}

        This is a Tier 3 configuration:
          #{Formatter.url("https://docs.brew.sh/Support-Tiers#tier-3")}
        #{Formatter.bold("Do not report any issues to Homebrew/* repositories!")}
        Read the above document instead before opening any issues or PRs.
      EOS
      raise CannotInstallFormulaError, message
    end
  end

  return if ignore_deps?

  if Homebrew::EnvConfig.developer?
    # `recursive_dependencies` trims cyclic dependencies, so we do one level and take the recursive deps of that.
    # Mapping direct dependencies to deeper dependencies in a hash is also useful for the cyclic output below.
    recursive_dep_map = formula.deps.to_h { |dep| [dep, dep.to_formula.recursive_dependencies] }

    cyclic_dependencies = []
    recursive_dep_map.each do |dep, recursive_deps|
      if [formula.name, formula.full_name].include?(dep.name)
        cyclic_dependencies << "#{formula.full_name} depends on itself directly"
      elsif recursive_deps.any? { |rdep| [formula.name, formula.full_name].include?(rdep.name) }
        cyclic_dependencies << "#{formula.full_name} depends on itself via #{dep.name}"
      end
    end

    if cyclic_dependencies.present?
      raise CannotInstallFormulaError, <<~EOS
        #{formula.full_name} contains a recursive dependency on itself:
          #{cyclic_dependencies.join("\n  ")}
      EOS
    end
  end

  recursive_deps = if pour_bottle?
    # Include implicit dependencies (except duplicates) in formulae to check
    (formula.runtime_dependencies + formula.deps.select(&:implicit?)).uniq(&:name)
  else
    formula.recursive_dependencies
  end

  invalid_arch_dependencies = []
  pinned_unsatisfied_deps = []
  recursive_deps.each do |dep|
    tab = Tab.for_formula(dep.to_formula)
    if tab.arch.present? && tab.arch.to_s != Hardware::CPU.arch.to_s
      invalid_arch_dependencies << "#{dep} was built for #{tab.arch}"
    end

    next unless dep.to_formula.pinned?
    next if dep.satisfied?

    pinned_unsatisfied_deps << dep
  end

  if invalid_arch_dependencies.present?
    raise CannotInstallFormulaError, <<~EOS
      #{formula.full_name} dependencies not built for the #{Hardware::CPU.arch} CPU architecture:
        #{invalid_arch_dependencies.join("\n  ")}
    EOS
  end

  return if pinned_unsatisfied_deps.empty?

  raise CannotInstallFormulaError,
        "You must `brew unpin #{pinned_unsatisfied_deps * " "}` as installing " \
        "#{formula.full_name} requires the latest version of pinned dependencies."
end

#check_installation_already_attempted ⇒ `void`

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.

This method returns an undefined value.

Raises:

(FormulaInstallationAlreadyAttemptedError)



418
419
420

# File 'formula_installer.rb', line 418

def check_installation_already_attempted
  raise FormulaInstallationAlreadyAttemptedError, formula if self.class.attempted.include?(formula)
end

#check_requirements(req_map) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

req_map (Hash{Formula => Array<Requirement>})

Raises:

(UnsatisfiedRequirements)

# File 'formula_installer.rb', line 729

def check_requirements(req_map)
  @requirement_messages = []
  fatals = []

  req_map.each_pair do |dependent, reqs|
    reqs.each do |req|
      next if dependent.latest_version_installed? && req.is_a?(MacOSRequirement) && req.comparator == "<="

      @requirement_messages << "#{dependent}: #{req.message}"
      fatals << req if req.fatal?
    end
  end

  return if fatals.empty?

  puts_requirement_messages
  raise UnsatisfiedRequirements, fatals
end

#clean ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1415

def clean
  ohai "Cleaning" if verbose?
  Cleaner.new(formula).clean
# Handle all possible exceptions when cleaning does not complete.
rescue Exception => e # rubocop:disable Lint/RescueException
  opoo "The cleaning step did not complete successfully"
  puts "Still, the installation was successful, so we will link it into your prefix."

  require "utils/backtrace"
  odebug e, Utils::Backtrace.clean(e)

  Homebrew.failed = true
  @show_summary_heading = true
end

#compute_dependencies(use_cache: true) ⇒ `Array<Dependency>`

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.

Compute and collect the dependencies needed by the formula currently being installed.

Parameters:

use_cache (Boolean) (defaults to: true)

Returns:

(Array<Dependency>)

# File 'formula_installer.rb', line 708

def compute_dependencies(use_cache: true)
  @compute_dependencies = T.let(nil, T.nilable(T::Array[Dependency])) unless use_cache
  @compute_dependencies ||= begin
    # Needs to be done before expand_dependencies
    fetch_bottle_tab if pour_bottle?

    check_requirements(expand_requirements)
    expand_dependencies
  end
end

#create_staging_path ⇒ `Pathname`

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.

The fetch and build phases run in separate sandboxes, so unpack the source once into a directory that outlives both.

Returns:

(Pathname)

# File 'formula_installer.rb', line 1270

def create_staging_path
  staging = Mktemp.new(formula.name, retain: true, retain_in_cache: debug_symbols?)
  staging.quiet!
  staging_path = staging.run(chdir: false, &:tmpdir)
  raise "Failed to create a staging directory for #{formula.name}" if staging_path.nil?

  staging_path
end

#debug? ⇒ `Boolean`

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:

(Boolean)

173	# File 'formula_installer.rb', line 173 def debug? = @debug

#debug_symbols? ⇒ `Boolean`

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:

(Boolean)

176	# File 'formula_installer.rb', line 176 def debug_symbols? = @debug_symbols

#determine_bottle_tab_attributes ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 387

def determine_bottle_tab_attributes
  Tab.clear_cache

  # Setup bottle_tab_runtime_dependencies for compute_dependencies and
  # bottle_built_os_version for dependency resolution.
  begin
    bottle = selected_bottle
    bottle_tab_attributes = bottle&.tab_attributes || {}
    raw_deps = bottle_tab_attributes.fetch("runtime_dependencies", []).then { |deps| deps || [] }
    @bottle_tab_runtime_dependencies = raw_deps.to_h { |dep| [dep["full_name"], dep] }.freeze

    if bottle && bottle.tag.system != :all
      # Extract the OS version the bottle was built on.
      # This ensures that when installing older bottles (e.g. Sonoma bottle on Sequoia),
      # we resolve dependencies according to the bottle's built OS, not the current OS.
      @bottle_built_os_version = bottle_tab_attributes.dig("built_on", "os_version")
    end
  rescue Resource::BottleManifest::Error
    # If we can't get the bottle manifest, assume a full dependencies install.
  end
end

#display_options(formula) ⇒ `Array<String>`

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.

Parameters:

formula (Formula)

Returns:

(Array<String>)

# File 'formula_installer.rb', line 844

def display_options(formula)
  options = if formula.head?
    ["--HEAD"]
  else
    []
  end
  options += effective_build_options_for(formula).used_options.to_a.map(&:to_s)
  options
end

#downloadable ⇒ `Downloadable`

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:

(Downloadable)

# File 'formula_installer.rb', line 1630

def downloadable
  if (bottle_path = formula.local_bottle_path)
    Resource::Local.new(bottle_path.to_s)
  elsif pour_bottle?
    bottle = selected_bottle
    odie "Bottle for #{formula.full_name} is unavailable." if bottle.nil?

    bottle
  else
    resource = formula.resource
    odie "Resource for #{formula.full_name} is unavailable." if resource.nil?

    resource
  end
end

#effective_build_options_for(dependent) ⇒ `BuildOptions`

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.

Parameters:

dependent (Formula)

Returns:

(BuildOptions)

# File 'formula_installer.rb', line 835

def effective_build_options_for(dependent)
  args  = dependent.build.used_options
  args |= options if dependent == formula
  args |= Tab.for_formula(dependent).used_options
  args &= dependent.options
  BuildOptions.new(args, dependent.options)
end

#enqueue_bottle_download(stage:) ⇒ `Downloadable`^?

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.

Start the formula's own bottle download without waiting for its bottle manifest or dependency resolution; both call sites have already checked pour_bottle?.

Parameters:

stage (Boolean)

Returns:

(Downloadable, nil)

# File 'formula_installer.rb', line 1612

def enqueue_bottle_download(stage:)
  return if only_deps? || formula.local_bottle_path

  bottle_download = downloadable
  check_attestation = verify_bottle_attestation? && !bottle_download.cached_download.exist?
  download_queue.enqueue(bottle_download, check_attestation:, stage:)
  bottle_download
end

#enqueue_fetch ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1562

def enqueue_fetch
  return if previously_fetched_formula

  downloadable_object = T.let(nil, T.nilable(Downloadable))
  check_attestation = T.let(false, T::Boolean)
  local_bottle_path = formula.local_bottle_path
  bottle_install = !only_deps? && local_bottle_path.nil? && pour_bottle?(output_warning: true)
  # We skip bottle installs from local bottle paths, as these are done in CI
  # as part of the build lifecycle before attestations are produced.
  verify_attestation = bottle_install && verify_bottle_attestation?
  bottle_download = @enqueued_bottle_download
  bottle_download = enqueue_bottle_download(stage: false) if bottle_download.nil? && bottle_install && @ran_prelude

  fetch_dependencies

  return if only_deps?
  return if local_bottle_path

  downloadable_object = bottle_download || downloadable
  if bottle_install
    if bottle_download.nil?
      fetch_bottle_tab(enqueue: true)
      check_attestation = verify_attestation && !downloadable_object.cached_download.exist?
    end
  else
    @formula = Homebrew::API::Formula.source_download_formula(formula) if formula.loaded_from_api?

    formula.enqueue_resources_and_patches(download_queue:)

    downloadable_object = downloadable
  end

  # Check attestation after download completes. Skip downloads already
  # enqueued (with staging) by `prelude_fetch` so a completed early fetch is
  # not requeued and reported a second time.
  download_queue.enqueue(downloadable_object, check_attestation:) if @enqueued_bottle_download.nil?

  self.class.fetched << formula
rescue CannotInstallFormulaError
  if (cached_download = downloadable_object&.cached_download)&.exist?
    cached_download.unlink
  end

  raise
end

#expand_dependencies ⇒ `Array<Dependency>`

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:

(Array<Dependency>)

832	# File 'formula_installer.rb', line 832 def expand_dependencies = expand_dependencies_for_formula(formula)

#expand_dependencies_for_formula(formula) ⇒ `Array<Dependency>`

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.

Parameters:

formula (Formula)

Returns:

(Array<Dependency>)

# File 'formula_installer.rb', line 793

def expand_dependencies_for_formula(formula)
  # Cache for this expansion only. FormulaInstaller has a lot of inputs which can alter expansion.
  cache_key = "FormulaInstaller-#{formula.full_name}-#{Time.now.to_f}"
  formula_cache = T.let({}, T::Hash[Dependency, Formula])
  satisfied_cache = T.let(
    {},
    T::Hash[T::Array[T.nilable(T.any(Dependency, String, Integer))], T::Boolean],
  )
  Dependency.expand(formula, cache_key:, formula_cache:) do |dependent, dep|
    dependent = T.cast(dependent, Formula)
    build = effective_build_options_for(dependent)

    keep_build_test = false
    keep_build_test ||= dep.test? && include_test? && @include_test_formulae.include?(dependent.full_name)
    keep_build_test ||= dep.build? && !install_bottle_for?(dependent, build) &&
                        (formula.head? || !dependent.latest_version_installed?)

    minimum_version = @bottle_tab_runtime_dependencies.dig(dep.name, "version").presence
    minimum_version = Version.new(minimum_version) if minimum_version
    minimum_revision = @bottle_tab_runtime_dependencies.dig(dep.name, "revision")&.to_i
    bottle_os_version = @bottle_built_os_version

    next Dependable::PRUNE if dep.prune_from_option?(build) || ((dep.build? || dep.test?) && !keep_build_test)

    satisfied_cache_key = T.let([
      dep,
      minimum_version&.to_s,
      minimum_revision,
      bottle_os_version,
    ], T::Array[T.nilable(T.any(Dependency, String, Integer))])
    satisfied = satisfied_cache.fetch(satisfied_cache_key) do
      satisfied_cache[satisfied_cache_key] = dep.satisfied?(minimum_version:, minimum_revision:, bottle_os_version:)
    end

    next Dependable::SKIP if satisfied
  end
end

#expand_requirements ⇒ `Hash{Formula => Array<Requirement>}`

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:

(Hash{Formula => Array<Requirement>})

# File 'formula_installer.rb', line 758

def expand_requirements
  unsatisfied_reqs = Hash.new { |h, k| h[k] = [] }
  formulae = [formula]
  formula_deps_map = formula.recursive_dependencies
                            .to_h { |dep| [dep.name, dep] }

  while (f = formulae.pop)
    runtime_requirements = runtime_requirements(f)
    f.recursive_requirements do |dependent, req|
      dependent = T.cast(dependent, Formula)
      build = effective_build_options_for(dependent)
      install_bottle_for_dependent = install_bottle_for?(dependent, build)

      keep_build_test = false
      keep_build_test ||= runtime_requirements.include?(req)
      keep_build_test ||= req.test? && include_test? && dependent == f
      keep_build_test ||= req.build? && !install_bottle_for_dependent && !dependent.latest_version_installed?

      if req.prune_from_option?(build) ||
         req.satisfied?(env: @env, cc: @cc, build_bottle: @build_bottle, bottle_arch: @bottle_arch) ||
         ((req.build? || req.test?) && !keep_build_test) ||
         formula_deps_map[dependent.name]&.build? ||
         (only_deps? && f == dependent)
        next Dependable::PRUNE
      else
        unsatisfied_reqs[dependent] << req
        nil # Return nil to satisfy T.nilable(Symbol) block sig (Array from << would violate it).
      end
    end
  end

  unsatisfied_reqs
end

#fetch ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1556

def fetch
  enqueue_fetch
  download_queue.fetch(heading: "Fetching downloads for: #{Formatter.identifier(formula.full_name)}")
end

#fetch_bottle_tab(quiet: false, enqueue: false, bottle: nil) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

quiet (Boolean) (defaults to: false)
enqueue (Boolean) (defaults to: false)
bottle (Bottle, nil) (defaults to: nil)

# File 'formula_installer.rb', line 1529

def fetch_bottle_tab(quiet: false, enqueue: false, bottle: nil)
  return if @fetch_bottle_tab
  return if formula.local_bottle_path

  bottle ||= selected_bottle
  if bottle && (manifest_resource = bottle.github_packages_manifest_resource)
    if enqueue
      download_queue.enqueue(manifest_resource) unless manifest_resource.downloaded_and_valid?
    else
      begin
        bottle.fetch_tab(quiet:)
      rescue DownloadError, Resource::BottleManifest::Error
        # do nothing
      end
    end
  else
    begin
      formula.fetch_bottle_tab(quiet: quiet)
    rescue DownloadError, Resource::BottleManifest::Error
      # do nothing
    end
  end

  @fetch_bottle_tab = T.let(true, T.nilable(TrueClass))
end

#fetch_dependencies ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1503

def fetch_dependencies
  return if ignore_deps?

  # Don't output dependencies if we're explicitly installing them.
  deps = compute_dependencies.reject do |dep|
    self.class.fetched.include?(dep.to_formula)
  end

  return if deps.empty?

  deps.each { fetch_dependency(it) }
end

#fetch_dependency(dep) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

dep (Dependency)

# File 'formula_installer.rb', line 877

def fetch_dependency(dep)
  df = dep.to_formula
  fi = FormulaInstaller.new(
    df,
    force_bottle:               false,
    # When fetching we don't need to recurse the dependency tree as it's already
    # been done for us in `compute_dependencies` and there's no requirement to
    # fetch in a particular order.
    # Note, this tree can vary when pouring bottles so we need to check it then.
    ignore_deps:                !pour_bottle?,
    include_test_formulae:      @include_test_formulae,
    build_from_source_formulae: @build_from_source_formulae,
    keep_tmp:                   keep_tmp?,
    debug_symbols:              debug_symbols?,
    force:                      force?,
    debug:                      debug?,
    quiet:                      quiet?,
    verbose:                    verbose?,
  )
  fi.download_queue = download_queue
  fi.prelude
  fi.enqueue_fetch
end

#fetch_fetch_deps ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 528

def fetch_fetch_deps
  return if @compute_dependencies.blank?

  compute_dependencies(use_cache: false) if @compute_dependencies.any? do |dep|
    next false unless dep.implicit?

    fetch_dependencies
    true
  end
end

#finish ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1009

def finish
  return if only_deps?

  ohai "Finishing up" if verbose?

  keg = Keg.new(formula.prefix)
  link(keg)
  warning = link_manual_command_warning
  opoo warning if !quiet? && warning.present?

  install_service

  fix_dynamic_linkage(keg) if !@poured_bottle || !formula.bottle_specification.skip_relocation?(tab: keg.tab)

  require "install"
  Homebrew::Install.global_post_install

  if build_bottle? || skip_post_install?
    unless quiet?
      if build_bottle?
        ohai "Not running 'post_install' as we're building a bottle"
      elsif skip_post_install?
        ohai "Skipping 'post_install' on request"
      end
      puts "You can run it manually using:"
      puts "  brew postinstall #{formula.full_name}"
    end
  else
    formula.install_etc_var
    post_install if formula.post_install_steps_defined? || formula.post_install_defined?
  end

  keg.prepare_debug_symbols if debug_symbols?

  # Updates the cache for a particular formula after doing an install
  CacheStoreDatabase.use(:linkage) do |db|
    break unless db.created?

    typed_db = T.cast(db, CacheStoreDatabase[String, T::Hash[T.any(String, Symbol), T.anything]])
    LinkageChecker.new(keg, formula, cache_db: typed_db, rebuild_cache: true)
  end

  # Update tab with actual runtime dependencies
  tab = keg.tab
  Tab.clear_cache
  f_runtime_deps = formula.runtime_dependencies(read_from_tab: false)
  tab.runtime_dependencies = Tab.runtime_deps_hash(formula, f_runtime_deps)
  tab.write

  # Update packaged SBOM metadata or write a source-install SBOM.
  if @poured_bottle
    if (install_time = tab.time)
      require "sbom"
      SBOM.update_pour_metadata(
        SBOM.spdxfile(formula),
        homebrew_version: HOMEBREW_VERSION,
        time:             install_time,
        supplement:       selected_bottle&.sbom_supplement,
      )
    end
  elsif Homebrew::EnvConfig.sbom? && !build_bottle?
    require "sbom"
    sbom = SBOM.create(formula, tab)
    sbom.write(validate: Homebrew::EnvConfig.developer?)
  end

  # let's reset Utils::Git.available? if we just installed git
  Utils::Git.clear_available_cache if formula.name == "git"

  # use installed ca-certificates when it's needed and available
  if formula.name == "ca-certificates" &&
     Homebrew::EnvConfig.force_brewed_ca_certificates?
    ENV["SSL_CERT_FILE"] = ENV["GIT_SSL_CAINFO"] = (formula.pkgetc/"cert.pem").to_s
    ENV["GIT_SSL_CAPATH"] = formula.pkgetc.to_s
  end

  # use installed curl when it's needed and available
  if formula.name == "curl" &&
     !DevelopmentTools.curl_handles_most_https_certificates?
    ENV["HOMEBREW_CURL"] = (formula.opt_bin/"curl").to_s
    Utils::Curl.clear_path_cache
  end

  caveats

  ohai "Summary" if verbose? || show_summary_heading?
  puts summary

  self.class.installed << formula
ensure
  unlock
end

#fix_dynamic_linkage(keg) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

keg (Keg)

# File 'formula_installer.rb', line 1399

def fix_dynamic_linkage(keg)
  keg.fix_dynamic_linkage
# Rescue all possible exceptions when fixing linkage.
rescue Exception => e # rubocop:disable Lint/RescueException
  ofail "Failed to fix install linkage"
  puts e
  puts "The formula built, but you may encounter issues using it or linking other"
  puts "formulae against it."

  require "utils/backtrace"
  odebug "Backtrace", Utils::Backtrace.clean(e)

  @show_summary_heading = true
end

#forbidden_formula_check(formula_only: false) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

formula_only (Boolean) (defaults to: false)

# File 'formula_installer.rb', line 1889

def forbidden_formula_check(formula_only: false)
  forbidden_formulae = Set.new(Homebrew::EnvConfig.forbidden_formulae.to_s.split)
  return if forbidden_formulae.blank?

  owner = Homebrew::EnvConfig.forbidden_owner
  owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
    "\n#{contact}"
  end

  unless only_deps?
    formula_name = if forbidden_formulae.include?(formula.name)
      formula.name
    elsif forbidden_formulae.include?(formula.full_name)
      formula.full_name
    end

    if formula_name
      raise CannotInstallFormulaError, <<~EOS
        The installation of #{formula_name} was forbidden by #{owner}
        in `$HOMEBREW_FORBIDDEN_FORMULAE`.#{owner_contact}
      EOS
    end
  end

  return if formula_only
  return if ignore_deps?

  compute_dependencies.each do |dep|
    dep_name = if forbidden_formulae.include?(dep.name)
      dep.name
    elsif dep.tap.present? &&
          (dep_full_name = "#{dep.tap}/#{dep.name}") &&
          forbidden_formulae.include?(dep_full_name)
      dep_full_name
    else
      next
    end

    raise CannotInstallFormulaError, <<~EOS
      The installation of #{formula.name} has a dependency #{dep_name}
      but the #{dep_name} formula was forbidden by #{owner} in `$HOMEBREW_FORBIDDEN_FORMULAE`.#{owner_contact}
    EOS
  end
end

#forbidden_license_check ⇒ `void`

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.

This method returns an undefined value.

Raises:

(CannotInstallFormulaError)

# File 'formula_installer.rb', line 1781

def forbidden_license_check
  forbidden_licenses = Homebrew::EnvConfig.forbidden_licenses.to_s.dup
  SPDX::ALLOWED_LICENSE_SYMBOLS.each do |s|
    pattern = /#{s.to_s.tr("_", " ")}/i
    forbidden_licenses.sub!(pattern, s.to_s)
  end

  invalid_licenses = []
  forbidden_licenses = forbidden_licenses.split.each_with_object({}) do |license, hash|
    license_sym = license.to_sym
    license = license_sym if SPDX::ALLOWED_LICENSE_SYMBOLS.include?(license_sym)

    unless SPDX.valid_license?(license)
      invalid_licenses << license
      next
    end

    hash[license] = SPDX.license_version_info(license)
  end

  if invalid_licenses.present?
    opoo <<~EOS
      `$HOMEBREW_FORBIDDEN_LICENSES` contains invalid license identifiers: #{Utils::Text.to_sentence(invalid_licenses)}
      These licenses will not be forbidden. See the valid SPDX license identifiers at:
        #{Formatter.url("https://spdx.org/licenses/")}
      And the licenses for a formula with:
        brew info <formula>
    EOS
  end

  return if forbidden_licenses.blank?

  owner = Homebrew::EnvConfig.forbidden_owner
  owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
    "\n#{contact}"
  end

  unless ignore_deps?
    compute_dependencies.each do |dep|
      dep_f = dep.to_formula
      next unless SPDX.licenses_forbid_installation? dep_f.license, forbidden_licenses

      raise CannotInstallFormulaError, <<~EOS
        The installation of #{formula.name} has a dependency on #{dep.name} where all
        its licenses were forbidden by #{owner} in `$HOMEBREW_FORBIDDEN_LICENSES`:
          #{SPDX.license_expression_to_string dep_f.license}#{owner_contact}
      EOS
    end
  end

  return if only_deps?

  return unless SPDX.licenses_forbid_installation? formula.license, forbidden_licenses

  raise CannotInstallFormulaError, <<~EOS
    #{formula.name}'s licenses are all forbidden by #{owner} in `$HOMEBREW_FORBIDDEN_LICENSES`:
      #{SPDX.license_expression_to_string formula.license}#{owner_contact}
  EOS
end

#forbidden_tap_check(formula_only: false) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

formula_only (Boolean) (defaults to: false)

# File 'formula_installer.rb', line 1842

def forbidden_tap_check(formula_only: false)
  return if Tap.allowed_taps.blank? && Tap.forbidden_taps.blank?

  owner = Homebrew::EnvConfig.forbidden_owner
  owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
    "\n#{contact}"
  end

  # Check the formula itself before its dependencies, since dependency
  # resolution can trigger downloads via `compute_dependencies`.
  unless only_deps?
    formula_tap = formula.tap
    if formula_tap.present? && (!formula_tap.allowed_by_env? || formula_tap.forbidden_by_env?)
      formula_error_message = "The installation of #{formula.full_name} has the tap #{formula_tap}\n" \
                              "but #{owner} "
      unless formula_tap.allowed_by_env?
        formula_error_message << "has not allowed this tap in `$HOMEBREW_ALLOWED_TAPS`"
      end
      formula_error_message << " and\n" if !formula_tap.allowed_by_env? && formula_tap.forbidden_by_env?
      if formula_tap.forbidden_by_env?
        formula_error_message << "has forbidden this tap in `$HOMEBREW_FORBIDDEN_TAPS`"
      end
      formula_error_message << ".#{owner_contact}"

      raise CannotInstallFormulaError, formula_error_message
    end
  end

  return if formula_only
  return if ignore_deps?

  compute_dependencies.each do |dep|
    dep_tap = dep.tap
    next if dep_tap.blank? || (dep_tap.allowed_by_env? && !dep_tap.forbidden_by_env?)

    error_message = "The installation of #{formula.name} has a dependency #{dep.name}\n" \
                    "from the #{dep_tap} tap but #{owner} "
    error_message << "has not allowed this tap in `$HOMEBREW_ALLOWED_TAPS`" unless dep_tap.allowed_by_env?
    error_message << " and\n" if !dep_tap.allowed_by_env? && dep_tap.forbidden_by_env?
    error_message << "has forbidden this tap in `$HOMEBREW_FORBIDDEN_TAPS`" if dep_tap.forbidden_by_env?
    error_message << ".#{owner_contact}"

    raise CannotInstallFormulaError, error_message
  end
end

#force? ⇒ `Boolean`

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:

(Boolean)

179	# File 'formula_installer.rb', line 179 def force? = @force

#force_bottle? ⇒ `Boolean`

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:

(Boolean)

182	# File 'formula_installer.rb', line 182 def force_bottle? = @force_bottle

#formula_path ⇒ `Pathname`

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:

(Pathname)

Raises:

(ArgumentError)

# File 'formula_installer.rb', line 1236

def formula_path
  formula_path = formula.specified_path
  raise ArgumentError, "#{formula.full_name} has no formula path" if formula_path.nil?

  formula_path
end

#fresh_install?(formula) ⇒ `Boolean`

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.

Parameters:

formula (Formula)
_formula (Formula)

Returns:

(Boolean)

# File 'extend/os/linux/formula_installer.rb', line 6

def fresh_install?(formula)
  !Homebrew::EnvConfig.developer? &&
    (installed_on_request? || !formula.any_version_installed?)
end

#git? ⇒ `Boolean`

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:

(Boolean)

185	# File 'formula_installer.rb', line 185 def git? = @git

#ignore_deps? ⇒ `Boolean`

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:

(Boolean)

188	# File 'formula_installer.rb', line 188 def ignore_deps? = @ignore_deps

#include_test? ⇒ `Boolean`

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:

(Boolean)



246
247
248

# File 'formula_installer.rb', line 246

def include_test?
  @include_test_formulae.include?(formula.full_name)
end

#install ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 568

def install
  lock

  start_time = Time.now
  unless pour_bottle?
    require "install"
    Homebrew::Install.perform_build_from_source_checks
  end

  # Warn if a more recent version of this formula is available in the tap.
  begin
    if !quiet? &&
       formula.pkg_version < (v = Formulary.factory(formula.full_name, force_bottle: force_bottle?).pkg_version)
      opoo "#{formula.full_name} #{v} is available and more recent than version #{formula.pkg_version}."
    end
  rescue FormulaUnavailableError
    nil
  end

  check_conflicts

  raise UnbottledError, [formula] if !pour_bottle? && !DevelopmentTools.installed?

  unless ignore_deps?
    deps = compute_dependencies(use_cache: false)
    if ((pour_bottle? && !DevelopmentTools.installed?) || build_bottle?) &&
       (unbottled = unbottled_dependencies(deps)).presence
      # Check that each dependency in deps has a bottle available, terminating
      # abnormally with a UnbottledError if one or more don't.
      raise UnbottledError, unbottled
    end

    install_dependencies(deps)
  end

  return if only_deps?

  formula.deprecated_flags.each do |deprecated_option|
    old_flag = deprecated_option.old_flag
    new_flag = deprecated_option.current_flag
    opoo "#{formula.full_name}: #{old_flag} was deprecated; using #{new_flag} instead!"
  end

  options = display_options(formula).join(" ")
  oh1 "Installing #{Formatter.identifier(formula.full_name)} #{options}".strip if show_header?

  if (tap = formula.tap) && tap.should_report_analytics?
    require "utils/analytics"
    Utils::Analytics.report_package_event(:formula_install, package_name: formula.name, tap_name: tap.name,
on_request: installed_on_request?, options:)
  end

  self.class.attempted << formula

  if pour_bottle?
    begin
      pour
    # Catch any other types of exceptions as they leave us with nothing installed.
    rescue Exception # rubocop:disable Lint/RescueException
      Keg.new(formula.prefix).ignore_interrupts_and_uninstall! if formula.prefix.exist?
      raise
    else
      @poured_bottle = true
    end
  end

  puts_requirement_messages

  build_bottle_preinstall if build_bottle?

  unless @poured_bottle
    build
    clean

    # Store the formula used to build the keg in the keg.
    formula_contents = if (local_bottle_path = formula.local_bottle_path)
      Utils::Bottles.formula_contents local_bottle_path, name: formula.name
    else
      formula.path.read
    end
    s = formula_contents.gsub(/  bottle do.+?end\n\n?/m, "")
    brew_prefix = formula.prefix/".brew"
    brew_prefix.mkpath
    Pathname(brew_prefix/"#{formula.name}.rb").atomic_write(s)

    keg = Keg.new(formula.prefix)
    tab = keg.tab
    tab.installed_on_request = installed_on_request?
    tab.write
  end

  build_bottle_postinstall if build_bottle?

  opoo "Nothing was installed to #{formula.prefix}" unless formula.latest_version_installed?
  end_time = Time.now
  Homebrew.messages.package_installed(formula.name, end_time - start_time)
# Always release locks for interrupts and exits too.
rescue Exception # rubocop:disable Lint/RescueException
  unlock
  raise
end

#install_bottle_for?(dep, build) ⇒ `Boolean`

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.

Parameters:

dep (Formula)
build (BuildOptions)

Returns:

(Boolean)

# File 'formula_installer.rb', line 312

def install_bottle_for?(dep, build)
  return pour_bottle? if dep == formula

  (
    @build_from_source_formulae.exclude?(dep.full_name) &&
      dep.bottle.present? &&
      dep.pour_bottle? &&
      build.used_options.empty? &&
      dep.bottle&.compatible_locations?
  ) || false
end

#install_dependencies(deps) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

deps (Array<Dependency>)

# File 'formula_installer.rb', line 855

def install_dependencies(deps)
  if deps.empty? && only_deps?
    puts "All dependencies for #{formula.full_name} are satisfied."
  elsif !deps.empty?
    deps_with_formulae = deps.map { |dep| [dep, dep.to_formula] }
    if deps.length > 1
      names = deps_with_formulae.map do |dep, dep_formula|
        installed = dep_formula.any_version_installed?
        pretty_install_status(Formatter.identifier(dep), installed:,
                              outdated: installed && dep_formula.outdated?, mark_uninstalled: false,
                              bold: false)
      end
      oh1 "Installing dependencies for #{formula.full_name}:#{Tty.reset} #{Utils::Text.to_sentence(names)}",
          truncate: false
    end
    deps_with_formulae.each { |dep, dep_formula| install_dependency(dep, dep_formula) }
  end

  @show_header = true unless deps.empty?
end

#install_dependency(dep, dep_formula = dep.to_formula) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

dep (Dependency)
dep_formula (Formula) (defaults to: dep.to_formula)

# File 'formula_installer.rb', line 902

def install_dependency(dep, dep_formula = dep.to_formula)
  if dep_formula.linked_keg.directory?
    linked_keg = Keg.new(resolved_path(dep_formula.linked_keg))
    tab = linked_keg.tab
    keg_had_linked_keg = true
    keg_was_linked = linked_keg.linked?
    linked_keg.unlink
  else
    keg_had_linked_keg = false
  end

  if dep_formula.latest_version_installed?
    installed_keg = Keg.new(dep_formula.prefix)
    tab ||= installed_keg.tab
    tmp_keg = Pathname.new("#{installed_keg}.tmp")
    installed_keg.rename(tmp_keg) unless tmp_keg.directory?
  end

  if dep_formula.tap.present? && tab.present? && (tab_tap = tab.source["tap"].presence) &&
     dep_formula.tap.to_s != tab_tap.to_s
    odie <<~EOS
      #{dep_formula} is already installed from #{tab_tap}!
      Please `brew uninstall #{dep_formula}` first."
    EOS
  end

  options = Options.new
  options |= tab.used_options if tab.present?
  options |= Tab.remap_deprecated_options(dep_formula.deprecated_options, dep.options)
  options &= dep_formula.options

  installed_on_request = dep_formula.any_version_installed? && tab.present? && tab.installed_on_request
  installed_on_request ||= false

  fi = FormulaInstaller.new(
    dep_formula,
    options:,
    link_keg:                   keg_had_linked_keg && keg_was_linked,
    installed_on_request:,
    force_bottle:               false,
    include_test_formulae:      @include_test_formulae,
    build_from_source_formulae: @build_from_source_formulae,
    keep_tmp:                   keep_tmp?,
    debug_symbols:              debug_symbols?,
    force:                      force?,
    debug:                      debug?,
    quiet:                      quiet?,
    verbose:                    verbose?,
  )
  action = dep_formula.outdated? ? "Upgrading" : "Installing"
  oh1 "#{action} #{formula.full_name} dependency: #{Formatter.identifier(dep.name)}"
  # prelude only needed to populate bottle_tab_runtime_dependencies, fetching has already been done.
  fi.prelude
  fi.install
  fi.finish
# Handle all possible exceptions installing deps.
rescue Exception => e # rubocop:disable Lint/RescueException
  Utils::Interrupts.ignore do
    tmp_keg.rename(installed_keg.to_path) if tmp_keg && !installed_keg.directory?
    linked_keg.link(verbose: verbose?) if keg_was_linked
  end
  raise unless e.is_a? FormulaInstallationAlreadyAttemptedError

  # We already attempted to install f as part of another formula's
  # dependency tree. In that case, don't generate an error, just move on.
  nil
else
  Utils::Interrupts.ignore { FileUtils.rm_r(tmp_keg) if tmp_keg&.directory? }
end

#install_fetch_deps ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 540

def install_fetch_deps
  return if @compute_dependencies.blank?

  compute_dependencies(use_cache: false) if @compute_dependencies.any? do |dep|
    next false unless dep.implicit?

    fetch_dependencies
    install_dependency(dep)
    true
  end
end

#install_service ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1368

def install_service
  service = if formula.service? && formula.service.command?
    service_path = formula.systemd_service_path
    service_path.atomic_write(formula.service.to_systemd_unit)
    service_path.chmod 0644

    if formula.service.timed?
      timer_path = formula.systemd_timer_path
      timer_path.atomic_write(formula.service.to_systemd_timer)
      timer_path.chmod 0644
    end

    formula.service.to_plist
  end
  return unless service

  launchd_service_path = formula.launchd_service_path
  launchd_service_path.atomic_write(service)
  launchd_service_path.chmod 0644
  log = formula.var/"log"
  log.mkpath if service.include? log.to_s
# Handle all possible exceptions when installing service files.
rescue Exception => e # rubocop:disable Lint/RescueException
  puts e
  ofail "Failed to install service files"

  require "utils/backtrace"
  odebug e, Utils::Backtrace.clean(e)
end

#installed_on_request? ⇒ `Boolean`

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:

(Boolean)

191	# File 'formula_installer.rb', line 191 def installed_on_request? = @installed_on_request

#interactive? ⇒ `Boolean`

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:

(Boolean)

194	# File 'formula_installer.rb', line 194 def interactive? = @interactive

#keep_tmp? ⇒ `Boolean`

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:

(Boolean)

197	# File 'formula_installer.rb', line 197 def keep_tmp? = @keep_tmp

#link(keg) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

keg (Keg)

# File 'formula_installer.rb', line 1280

def link(keg)
  Formula.clear_cache

  if skip_link? && !quiet?
    ohai "Skipping 'link' on request"
    puts "You can run it manually using:"
    puts "  brew link #{formula.full_name}"
  end

  if !link_keg || skip_link?
    begin
      keg.optlink(verbose: verbose?, overwrite: overwrite?)
    rescue Keg::LinkError => e
      ofail "Failed to create #{formula.opt_prefix}"
      puts "Things that depend on #{formula.full_name} will probably not build."
      puts e
    end
    return
  end

  if keg.linked?
    opoo "This keg was marked linked already, continuing anyway"
    keg.remove_linked_keg_record
  end

  Homebrew::Unlink.unlink_link_overwrite_formulae(formula, verbose: verbose?)

  link_overwrite_backup = {} # Hash: conflict file -> backup file
  backup_dir = HOMEBREW_CACHE/"Backup"

  begin
    keg.link(verbose: verbose?, overwrite: overwrite?)
  rescue Keg::ConflictError => e
    conflict_file = e.dst
    if formula.link_overwrite?(conflict_file) && !link_overwrite_backup.key?(conflict_file)
      backup_file = backup_dir/conflict_file.relative_path_from(HOMEBREW_PREFIX).to_s
      backup_file.parent.mkpath
      FileUtils.mv conflict_file, backup_file
      link_overwrite_backup[conflict_file] = backup_file
      retry
    end
    ofail "The `brew link` step did not complete successfully"
    puts "The formula built, but is not symlinked into #{HOMEBREW_PREFIX}"
    puts e
    puts
    puts "Possible conflicting files are:"
    keg.link(dry_run: true, overwrite: true, verbose: verbose?)
    @show_summary_heading = true
  rescue Keg::LinkError => e
    ofail "The `brew link` step did not complete successfully"
    puts "The formula built, but is not symlinked into #{HOMEBREW_PREFIX}"
    puts e
    puts
    puts "You can try again using:"
    puts "  brew link #{formula.name}"
    @show_summary_heading = true
  # Handle all other possible exceptions when linking.
  rescue Exception => e # rubocop:disable Lint/RescueException
    ofail "An unexpected error occurred during the `brew link` step"
    puts "The formula built, but is not symlinked into #{HOMEBREW_PREFIX}"
    puts e

    if debug?
      require "utils/backtrace"
      puts Utils::Backtrace.clean(e)
    end

    @show_summary_heading = true
    Utils::Interrupts.ignore do
      keg.unlink
      link_overwrite_backup.each do |origin, backup|
        origin.parent.mkpath
        FileUtils.mv backup, origin
      end
    end
    raise
  end

  return if link_overwrite_backup.empty?

  opoo "These files were overwritten during the `brew link` step:"
  puts link_overwrite_backup.keys
  puts
  puts "They have been backed up to: #{backup_dir}"
  @show_summary_heading = true
end

#link_manual_command_warning ⇒ `String`^?

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:

(String, nil)

# File 'formula_installer.rb', line 991

def link_manual_command_warning
  return unless installed_on_request?
  return unless formula.keg_only?
  return unless formula.keg_only_reason.versioned_formula?
  return if link_keg
  return if formula.linked?

  reason = formula.link_overwrite_reason
  return if reason.blank?

  <<~EOS
    #{formula.full_name} was installed but not linked because #{reason}.
    To link this version, run:
      brew link #{formula.full_name}
  EOS
end

#only_deps? ⇒ `Boolean`

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:

(Boolean)

200	# File 'formula_installer.rb', line 200 def only_deps? = @only_deps

#overwrite? ⇒ `Boolean`

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:

(Boolean)

203	# File 'formula_installer.rb', line 203 def overwrite? = @overwrite

#post_install ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1462

def post_install
  args = [
    "nice",
    *HOMEBREW_RUBY_EXEC_ARGS,
    "-I", $LOAD_PATH.join(File::PATH_SEPARATOR),
    "--",
    HOMEBREW_LIBRARY_PATH/"postinstall.rb"
  ]

  args << post_install_formula_path

  Sandbox.with_preserved_brew_file do
    Sandbox.run_or_fork(*args, step: "running post-install") do |sandbox|
      formula.logs.mkpath
      sandbox.record_log(formula.logs/"postinstall.sandbox.log")
      sandbox.allow_write_log(formula)
      sandbox.allow_write_xcode
      sandbox.allow_write_cellar(formula)
      sandbox.add_install_hook_rules(
        network_access_allowed: formula.network_access_allowed?(:postinstall),
      )
      Keg.keg_link_directories.each do |dir|
        sandbox.allow_write_path "#{HOMEBREW_PREFIX}/#{dir}"
      end
      sandbox.deny_write_temp_cellar
    end
  end
# Handle all possible exceptions when postinstall does not complete.
rescue Exception => e # rubocop:disable Lint/RescueException
  opoo "The post-install step did not complete successfully"
  puts "You can try again using:"
  puts "  brew postinstall #{formula.full_name}"

  require "utils/backtrace"
  odebug e, Utils::Backtrace.clean(e), always_display: Homebrew::EnvConfig.developer?

  Homebrew.failed = true
  @show_summary_heading = true
end

#post_install_formula_path ⇒ `String`, `Pathname`

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:

(String, Pathname)

# File 'formula_installer.rb', line 1431

def post_install_formula_path
  # Use the formula from the keg when any of the following is true:
  # * We're installing from the JSON API and it has a Ruby post-install hook
  # * We're installing a local bottle file
  # * We're building from source
  # * The formula doesn't exist in the tap (or the tap isn't installed)
  # * The installed keg has a different version from the selected formula.
  #
  # Otherwise use the selected tap formula, without evaluating the keg's
  # recipe while choosing the path.
  tap_formula_path = formula_path
  installed_prefix = formula.any_installed_prefix
  return tap_formula_path if installed_prefix.nil?

  keg_formula_path = installed_prefix/".brew/#{formula.name}.rb"
  if formula.loaded_from_api?
    return formula.full_name unless formula.post_install_defined?

    return keg_formula_path
  end
  return keg_formula_path if formula.local_bottle_path
  return keg_formula_path if build_from_source?

  return keg_formula_path unless tap_formula_path.exist?

  return keg_formula_path if Keg.new(installed_prefix).version != formula.pkg_version

  tap_formula_path
end

#pour ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 1667

def pour
  HOMEBREW_CELLAR.cd do
    downloadable_object = downloadable
    ohai "Pouring #{downloadable_object.downloader.basename}"

    formula.rack.mkpath

    # Download queue may have already extracted the bottle to a temporary directory.
    # We cannot rely on `download_queue` here as dependencies may be poured by another installer.
    if downloadable_object.is_a?(Bottle) && downloadable_object.staged_from_download_queue?
      bottle_tmp_keg = downloadable_object.staged_path_from_download_queue
      FileUtils.rm(downloadable_object.staged_path_from_download_queue_marker)
      FileUtils.mv(bottle_tmp_keg, formula.prefix)
      rmdir_if_possible(bottle_tmp_keg.parent)
    elsif downloadable_object.is_a?(Bottle)
      # Discard anything unexpected under the temporary Cellar path, then
      # verify and extract afresh, refetching if the cached bottle is corrupt.
      downloadable_object.purge_staged_from_download_queue
      downloadable_object.stage
    else
      downloadable_object.downloader.stage
    end
  end

  Tab.clear_cache

  tab = Utils::Bottles.load_tab(formula)

  # fill in missing/outdated parts of the tab
  # keep in sync with Tab#to_bottle_hash
  tab.used_options = []
  tab.unused_options = []
  tab.built_as_bottle = true
  tab.poured_from_bottle = true
  tab.loaded_from_api = formula.loaded_from_api?
  tab.loaded_from_internal_api = formula.loaded_from_internal_api?
  tab.installed_on_request = installed_on_request?
  tab.time = Time.now.to_i
  tab.aliases = formula.aliases
  tab.arch = Hardware::CPU.arch
  tab.source["versions"]["stable"] = formula.stable&.version&.to_s
  tab.source["versions"]["version_scheme"] = formula.version_scheme
  tab.source["path"] = formula.specified_path.to_s
  tab.source["tap_git_head"] = formula.tap&.installed? ? formula.tap&.git_head : nil
  tab.tap = formula.tap
  tab.write

  keg = Keg.new(formula.prefix)
  skip_linkage = formula.bottle_specification.skip_relocation?(tab:)
  if Homebrew::EnvConfig.bottle_domain_custom? && tab.changed_files.nil?
    if self.class.show_missing_bottle_metadata_warning?
      opoo <<~EOS
        No bottle relocation metadata was found for this `HOMEBREW_BOTTLE_DOMAIN`.
        Homebrew will perform full relocation. Ask the mirror operator to provide
        an OCI registry proxy of `ghcr.io` that includes manifests and their
        `sh.brew.tab` annotations, then use `HOMEBREW_ARTIFACT_DOMAIN` instead.
      EOS
    end
    skip_linkage = false
  end
  keg.replace_placeholders_with_locations(tab.changed_files, skip_linkage:, linkage_files: tab.linkage_files)

  # Older bottles may still contain absolute symlinks into their build prefix.
  build_cellar = if tab.built_prefix
    "#{tab.built_prefix}/Cellar"
  else
    Utils::Bottles.tag.default_cellar
  end
  build_prefix = Pathname(build_cellar).parent.to_s
  if build_prefix != HOMEBREW_PREFIX.to_s
    keg.relativize_prefix_symlinks!(prefix: build_prefix,
                                    cellar: build_cellar)
  end

  bottle_specification = formula.bottle_specification
  tag = Utils::Bottles.tag
  cellar = bottle_specification.tag_to_cellar(tag)
  return if BottleSpecification::RELOCATABLE_CELLARS.include?(cellar)

  prefix = tab.built_prefix || Pathname(cellar.to_s).parent.to_s
  build_cellar = tab.built_prefix ? "#{prefix}/Cellar" : cellar.to_s
  return if build_cellar == HOMEBREW_CELLAR.to_s && prefix == HOMEBREW_PREFIX.to_s

  return if Homebrew::EnvConfig.no_relocate_build_prefix?

  tab.relocated_build_prefix = prefix
  tab.relocated_files = keg.relocate_build_prefix(keg, prefix, HOMEBREW_PREFIX,
                                                  files: tab.binary_relocation_files)
  tab.write
end

#pour_bottle?(output_warning: false) ⇒ `Boolean`

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.

Parameters:

output_warning (Boolean) (defaults to: false)

Returns:

(Boolean)

# File 'formula_installer.rb', line 266

def pour_bottle?(output_warning: false)
  return false if !formula.bottle_tag? && !formula.local_bottle_path
  return true  if force_bottle?
  return false if build_from_source? || build_bottle? || interactive?
  return false if @cc
  return false unless options.empty?

  unless formula.pour_bottle?
    if output_warning && formula.pour_bottle_check_unsatisfied_reason
      opoo <<~EOS
        Building #{formula.full_name} from source:
          #{formula.pour_bottle_check_unsatisfied_reason}
      EOS
    end
    return false
  end

  return true if formula.local_bottle_path

  bottle = selected_bottle
  return false if bottle.nil?

  unless bottle.compatible_locations?
    if output_warning
      cellar = bottle.built_cellar.to_s
      prefix = Pathname(cellar).parent
      cause = if Homebrew::EnvConfig.no_relocate_build_prefix?
        "`HOMEBREW_NO_RELOCATE_BUILD_PREFIX` disables bottle build-prefix relocation."
      else
        "Your prefix `#{HOMEBREW_PREFIX}` is #{HOMEBREW_PREFIX.to_s.length} characters long, but this bottle " \
          "can only be relocated to a prefix with a maximum length of #{prefix.to_s.length} characters."
      end
      opoo <<~EOS
        Building #{formula.full_name} from source as the bottle needs:
        - `HOMEBREW_CELLAR=#{cellar}` (yours is #{HOMEBREW_CELLAR})
        - `HOMEBREW_PREFIX=#{prefix}` (yours is #{HOMEBREW_PREFIX})
        #{cause}
      EOS
    end
    return false
  end

  true
end

#prelude ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 369

def prelude
  prelude_fetch unless @ran_prelude_fetch

  determine_bottle_tab_attributes

  verify_deps_exist unless ignore_deps?

  forbidden_license_check
  forbidden_tap_check
  forbidden_formula_check

  check_install_sanity

  install_fetch_deps if !ignore_deps? && Homebrew::EnvConfig.download_concurrency <= 1
  @ran_prelude = true
end

#prelude_fetch(metadata_only: false) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

metadata_only (Boolean) (defaults to: false)

# File 'formula_installer.rb', line 325

def prelude_fetch(metadata_only: false)
  unless @ran_prelude_fetch_metadata
    deprecate_disable_type = DeprecateDisable.type(formula)
    if deprecate_disable_type.present?
      message = "#{formula.full_name} has been #{DeprecateDisable.message(formula)}"

      case deprecate_disable_type
      when :deprecated
        opoo message
      when :disabled
        if force?
          opoo message
        else
          GitHub::Actions.puts_annotation_if_env_set!(:error, message)
          raise CannotInstallFormulaError, message
        end
      end
    end

    # Run the formula-self forbidden checks before any source or bottle
    # download is enqueued so a forbidden formula never triggers a fetch.
    forbidden_tap_check(formula_only: true)
    forbidden_formula_check(formula_only: true)

    # Needs to be done before expand_dependencies for compute_dependencies
    fetch_bottle_tab(enqueue: true) if pour_bottle?

    fetch_fetch_deps unless ignore_deps?

    @ran_prelude_fetch_metadata = true
  end

  return if metadata_only || @ran_prelude_fetch

  if pour_bottle?
    @enqueued_bottle_download = enqueue_bottle_download(stage: true)
  elsif formula.loaded_from_api?
    Homebrew::API::Formula.source_download(formula, download_queue:, enqueue: true)
  end

  @ran_prelude_fetch = true
end

#previously_fetched_formula ⇒ `Formula`^?

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:

(Formula, nil)

# File 'formula_installer.rb', line 1517

def previously_fetched_formula
  # We intentionally don't compare classes here:
  # from-API-JSON and from-source formula classes are not equal but we
  # want to equate them to be the same thing here given mixing bottle and
  # from-source installs of the same formula within the same operation
  # doesn't make sense.
  self.class.fetched.find do |fetched_formula|
    fetched_formula.full_name == formula.full_name && fetched_formula.active_spec_sym == formula.active_spec_sym
  end
end

#problem_if_output(output) ⇒ `void`

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.

This method returns an undefined value.

Parameters:

output (String, nil)

# File 'formula_installer.rb', line 1759

def problem_if_output(output)
  return unless output

  opoo output
  @show_summary_heading = true
end

#quiet? ⇒ `Boolean`

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:

(Boolean)

206	# File 'formula_installer.rb', line 206 def quiet? = @quiet

#run_fetch(staging_path: nil) ⇒ `void`

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.

This method returns an undefined value.

Runs the formula's fetch method with network access before install builds from source; brew fetch --build-from-source also runs it.

Parameters:

staging_path (Pathname, nil) (defaults to: nil)

# File 'formula_installer.rb', line 1222

def run_fetch(staging_path: nil)
  @formula = Homebrew::API::Formula.source_download_formula(formula) if formula.loaded_from_api?

  with_env(HOMEBREW_BUILD_FETCH_PHASE: "1", HOMEBREW_BUILD_STAGING_PATH: staging_path) do
    Sandbox.run_or_fork(*build_args(formula_path), step: "fetching") do |sandbox|
      add_build_sandbox_rules(sandbox, formula_path, log_name: "fetch")
      sandbox.deny_read_home
      sandbox.allow_write_temp_and_cache
      sandbox.allow_write_path(staging_path) if staging_path
    end
  end
end

#runtime_requirements(formula) ⇒ `Array<Requirement>`

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.

Parameters:

formula (Formula)

Returns:

(Array<Requirement>)

# File 'formula_installer.rb', line 749

def runtime_requirements(formula)
  runtime_deps = formula.runtime_formula_dependencies(undeclared: false)
  recursive_requirements = formula.recursive_requirements do |dependent, _|
    next Dependable::PRUNE unless runtime_deps.include?(dependent)
  end
  (recursive_requirements.to_a + formula.requirements.to_a).reject(&:build?).uniq
end

#sanitized_argv_options ⇒ `Array<String>`

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:

(Array<String>)

# File 'formula_installer.rb', line 1117

def sanitized_argv_options
  args = []
  args << "--ignore-dependencies" if ignore_deps?

  if build_bottle?
    args << "--build-bottle"
    args << "--bottle-arch=#{@bottle_arch}" if @bottle_arch
  end

  args << "--git" if git?
  args << "--interactive" if interactive?
  args << "--verbose" if verbose?
  args << "--debug" if debug?
  args << "--cc=#{@cc}" if @cc
  args << "--keep-tmp" if keep_tmp?

  if debug_symbols?
    args << "--debug-symbols"
    args << "--build-from-source"
  end

  if @env.present?
    args << "--env=#{@env}"
  elsif formula.env.std? || formula.deps.select(&:build?).any? { |d| d.name == "scons" }
    args << "--env=std"
  end

  args << "--HEAD" if formula.head?

  args
end

#selected_bottle ⇒ `Bottle`^?

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:

(Bottle, nil)



1647
1648
1649

# File 'formula_installer.rb', line 1647

def selected_bottle
  @selected_bottle ||= api_bottle || formula.bottle || formula.bottle_for_tag(Utils::Bottles.tag)
end

#show_header? ⇒ `Boolean`

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:

(Boolean)

209	# File 'formula_installer.rb', line 209 def show_header? = @show_header

#show_summary_heading? ⇒ `Boolean`

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:

(Boolean)

212	# File 'formula_installer.rb', line 212 def show_summary_heading? = @show_summary_heading

#skip_link? ⇒ `Boolean`

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:

(Boolean)



261
262
263

# File 'formula_installer.rb', line 261

def skip_link?
  @skip_link.present?
end

#skip_post_install? ⇒ `Boolean`

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:

(Boolean)



256
257
258

# File 'formula_installer.rb', line 256

def skip_post_install?
  @skip_post_install.present?
end

#summary ⇒ `String`

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:

(String)

# File 'formula_installer.rb', line 1103

def summary
  s = +""
  s << "#{Homebrew::EnvConfig.install_badge}  " unless Homebrew::EnvConfig.no_emoji?
  s << "#{resolved_path(formula.prefix)}: #{formula.prefix.abv}"
  s << ", built in #{pretty_duration build_time}" if build_time
  s.freeze
end

#unbottled_dependencies(deps) ⇒ `Array<Formula>`

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.

Parameters:

deps (Array<Dependency>)

Returns:

(Array<Formula>)

# File 'formula_installer.rb', line 720

def unbottled_dependencies(deps)
  deps.map(&:to_formula).reject do |dep_f|
    next false unless dep_f.pour_bottle?

    dep_f.bottled?
  end
end

#verbose? ⇒ `Boolean`

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:

(Boolean)

215	# File 'formula_installer.rb', line 215 def verbose? = @verbose

#verify_bottle_attestation? ⇒ `Boolean`

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:

(Boolean)

# File 'formula_installer.rb', line 1622

def verify_bottle_attestation?
  # We skip `gh` to avoid a bootstrapping cycle, in the off-chance a user attempts
  # to explicitly `brew install gh` without already having a version for bootstrapping.
  Homebrew::EnvConfig.verify_attestations? &&
    formula.tap.present? && formula.name != "gh"
end

#verify_deps_exist ⇒ `void`

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.

This method returns an undefined value.

# File 'formula_installer.rb', line 410

def verify_deps_exist
  compute_dependencies
rescue FormulaUnavailableError => e
  e.dependent = formula.full_name
  raise
end

Class: FormulaInstaller Private

Overview

Constant Summary collapse

Constants included from FormulaCellarChecks

Constants included from OS::Mac::FormulaCellarChecks

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Utils::Path

Methods included from Utils::Path::Helpers

Methods included from Utils::Path::FormulaHelpers

Methods included from Utils::Output::Mixin

Methods included from FormulaCellarChecks

Methods included from OS::Linux::FormulaCellarChecks

Methods included from OS::Mac::FormulaCellarChecks

Constructor Details

Instance Attribute Details

#bottle_tab_runtime_dependencies ⇒ Hash{String => Hash{String => String}} (readonly)

#download_queue ⇒ Homebrew::DownloadQueue

#formula ⇒ Formula (readonly)

#link_keg ⇒ Boolean

#options ⇒ Options

#ran_prelude=(value) ⇒ void (writeonly)

Class Method Details

.attempted ⇒ Set<Formula>

.fetched ⇒ Set<Formula>

.installed ⇒ Set<Formula>

.locked ⇒ Array<Formula>

.show_missing_bottle_metadata_warning? ⇒ Boolean

Instance Method Details

#add_build_sandbox_rules(sandbox, formula_path, log_name:) ⇒ void

#api_bottle ⇒ Bottle?

#audit_installed ⇒ void

#build ⇒ void

#build_args(formula_path) ⇒ Array<String, Pathname>

#build_argv ⇒ Array<String>

#build_bottle? ⇒ Boolean

#build_bottle_postinstall ⇒ void

#build_bottle_preinstall ⇒ void

#build_from_source? ⇒ Boolean

#build_time ⇒ Float?

#caveats ⇒ void

#check_conflicts ⇒ void

#check_install_sanity ⇒ void

#check_installation_already_attempted ⇒ void

#check_requirements(req_map) ⇒ void

#clean ⇒ void

#compute_dependencies(use_cache: true) ⇒ Array<Dependency>

#create_staging_path ⇒ Pathname

#debug? ⇒ Boolean

#debug_symbols? ⇒ Boolean

#determine_bottle_tab_attributes ⇒ void

#display_options(formula) ⇒ Array<String>

#downloadable ⇒ Downloadable

#effective_build_options_for(dependent) ⇒ BuildOptions

#enqueue_bottle_download(stage:) ⇒ Downloadable?

#enqueue_fetch ⇒ void

#expand_dependencies ⇒ Array<Dependency>

#expand_dependencies_for_formula(formula) ⇒ Array<Dependency>

#expand_requirements ⇒ Hash{Formula => Array<Requirement>}

#fetch ⇒ void

#fetch_bottle_tab(quiet: false, enqueue: false, bottle: nil) ⇒ void

#fetch_dependencies ⇒ void

#fetch_dependency(dep) ⇒ void

#fetch_fetch_deps ⇒ void

#finish ⇒ void

#fix_dynamic_linkage(keg) ⇒ void

#forbidden_formula_check(formula_only: false) ⇒ void

#forbidden_license_check ⇒ void

#forbidden_tap_check(formula_only: false) ⇒ void

#force? ⇒ Boolean

#force_bottle? ⇒ Boolean

#formula_path ⇒ Pathname

#fresh_install?(formula) ⇒ Boolean

#git? ⇒ Boolean

#ignore_deps? ⇒ Boolean

#include_test? ⇒ Boolean

#install ⇒ void

#install_bottle_for?(dep, build) ⇒ Boolean

#install_dependencies(deps) ⇒ void

#bottle_tab_runtime_dependencies ⇒ `Hash{String => Hash{String => String}}` (readonly)

#download_queue ⇒ `Homebrew::DownloadQueue`

#formula ⇒ `Formula` (readonly)

#link_keg ⇒ `Boolean`

#options ⇒ `Options`

#ran_prelude=(value) ⇒ `void` (writeonly)

.attempted ⇒ `Set<Formula>`

.fetched ⇒ `Set<Formula>`

.installed ⇒ `Set<Formula>`

.locked ⇒ `Array<Formula>`

.show_missing_bottle_metadata_warning? ⇒ `Boolean`

#add_build_sandbox_rules(sandbox, formula_path, log_name:) ⇒ `void`

#api_bottle ⇒ `Bottle`^?

#audit_installed ⇒ `void`

#build ⇒ `void`

#build_args(formula_path) ⇒ `Array<String, Pathname>`

#build_argv ⇒ `Array<String>`

#build_bottle? ⇒ `Boolean`

#build_bottle_postinstall ⇒ `void`

#build_bottle_preinstall ⇒ `void`

#build_from_source? ⇒ `Boolean`

#build_time ⇒ `Float`^?

#caveats ⇒ `void`

#check_conflicts ⇒ `void`

#check_install_sanity ⇒ `void`

#check_installation_already_attempted ⇒ `void`

#check_requirements(req_map) ⇒ `void`

#clean ⇒ `void`

#compute_dependencies(use_cache: true) ⇒ `Array<Dependency>`

#create_staging_path ⇒ `Pathname`

#debug? ⇒ `Boolean`

#debug_symbols? ⇒ `Boolean`

#determine_bottle_tab_attributes ⇒ `void`

#display_options(formula) ⇒ `Array<String>`

#downloadable ⇒ `Downloadable`

#effective_build_options_for(dependent) ⇒ `BuildOptions`

#enqueue_bottle_download(stage:) ⇒ `Downloadable`^?

#enqueue_fetch ⇒ `void`

#expand_dependencies ⇒ `Array<Dependency>`

#expand_dependencies_for_formula(formula) ⇒ `Array<Dependency>`

#expand_requirements ⇒ `Hash{Formula => Array<Requirement>}`

#fetch ⇒ `void`

#fetch_bottle_tab(quiet: false, enqueue: false, bottle: nil) ⇒ `void`

#fetch_dependencies ⇒ `void`

#fetch_dependency(dep) ⇒ `void`

#fetch_fetch_deps ⇒ `void`

#finish ⇒ `void`

#fix_dynamic_linkage(keg) ⇒ `void`

#forbidden_formula_check(formula_only: false) ⇒ `void`

#forbidden_license_check ⇒ `void`

#forbidden_tap_check(formula_only: false) ⇒ `void`

#force? ⇒ `Boolean`

#force_bottle? ⇒ `Boolean`

#formula_path ⇒ `Pathname`

#fresh_install?(formula) ⇒ `Boolean`

#git? ⇒ `Boolean`

#ignore_deps? ⇒ `Boolean`

#include_test? ⇒ `Boolean`

#install ⇒ `void`

#install_bottle_for?(dep, build) ⇒ `Boolean`

#install_dependencies(deps) ⇒ `void`

#install_dependency(dep, dep_formula = dep.to_formula) ⇒ `void`

#install_fetch_deps ⇒ `void`

#install_service ⇒ `void`

#installed_on_request? ⇒ `Boolean`

#interactive? ⇒ `Boolean`

#keep_tmp? ⇒ `Boolean`

#link(keg) ⇒ `void`

#link_manual_command_warning ⇒ `String`^?

#only_deps? ⇒ `Boolean`

#overwrite? ⇒ `Boolean`

#post_install ⇒ `void`

#post_install_formula_path ⇒ `String`, `Pathname`

#pour ⇒ `void`

#pour_bottle?(output_warning: false) ⇒ `Boolean`

#prelude ⇒ `void`

#prelude_fetch(metadata_only: false) ⇒ `void`

#previously_fetched_formula ⇒ `Formula`^?

#problem_if_output(output) ⇒ `void`

#quiet? ⇒ `Boolean`