Class: Homebrew::Diagnostic::Checks

#__check_linked_brew!(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)

Returns:

(Boolean)

# File 'diagnostic.rb', line 1152

def __check_linked_brew!(formula)
  formula.installed_prefixes.each do |prefix|
    prefix.find do |src|
      next if src == prefix

      dst = HOMEBREW_PREFIX + src.relative_path_from(prefix)
      return true if dst.symlink? && src == Utils::Path.resolved_path(dst)
    end
  end

  false
end

#__check_stray_files(dir, pattern, allow_list, message) ⇒ `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:

dir (String)
pattern (String)
allow_list (Array<String>)
message (String)

Returns:

(String, nil)

# File 'diagnostic.rb', line 343

def __check_stray_files(dir, pattern, allow_list, message)
  return unless File.directory?(dir)

  files = Dir.chdir(dir) do
    (Dir.glob(pattern) - Dir.glob(allow_list))
      .select { |f| File.file?(f) && !File.symlink?(f) }
      .map do |f|
        f.sub!(%r{/.*}, "/*") unless @verbose
        File.join(dir, f)
      end
      .sort.uniq
  end
  return if files.empty?

  append_indented_list files, message
end

#__tap_git_status(tap, path) ⇒ `Finding`^?

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:

tap (String)
path (Pathname)

Returns:

(Finding, nil)

# File 'diagnostic.rb', line 1302

def __tap_git_status(tap, path)
  return unless path.exist?

  status = path.cd do
    Utils.popen_read_text(Utils::Git.git, "status", "--untracked-files=all", "--porcelain", err: File::NULL)
  end
  return if status.blank?

  message = <<~EOS
    You have uncommitted modifications to #{tap}.
  EOS
  commands = ["git -C \"#{path}\" stash -u && git -C \"#{path}\" clean -d -f"]
  remediation = Finding::Remediation.new(
    text:     append_indented_list(commands, <<~EOS),
      If this is a surprise to you, then you should stash these modifications.
      Stashing returns Homebrew to a pristine state but can be undone
      should you later need to do so for some reason.

    EOS
    commands:,
  )

  modified = status.split("\n").map(&:strip)
  message += append_indented_list modified, <<~EOS
    Uncommitted files:

  EOS
  Finding.new(message, affects: modified, remediation:) if message.present?
end

#add_info(*args) ⇒ `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:

args (T.anything)



109
110
111

# File 'diagnostic.rb', line 109

def add_info(*args)
  ohai(*args) if @verbose
end

#all ⇒ `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>)



1877
1878
1879

# File 'diagnostic.rb', line 1877

def all
  methods.map(&:to_s).grep(/^check_/).sort
end

#append_indented_list(list, string) ⇒ `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:

list (Array<Formula, Pathname, Cask::Cask, String>)
string (String)

Returns:

(String)

# File 'diagnostic.rb', line 88

def append_indented_list(list, string)
  list.reduce(string.dup) { |acc, elem| acc << "  #{elem}\n" }
      .freeze
end

#broken_tap(tap) ⇒ `Finding`^?

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:

tap (Tap)

Returns:

(Finding, nil)

# File 'diagnostic.rb', line 305

def broken_tap(tap)
  return unless Utils::Git.available?

  repo = GitRepository.new(HOMEBREW_REPOSITORY)
  return unless repo.git_repository?

  commands = ["rm -rf \"#{tap.path}\"",
              "brew tap #{tap.name}"]
  finding = Finding.new(
    "#{tap.full_name} was not tapped properly!",
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You can solve this by tapping again:
      EOS
      commands:,
    ),
  )

  return finding if tap.remote.blank?

  tap_head = tap.git_head
  return finding if tap_head.blank?
  return if tap_head != repo.head_ref

  finding
end

#build_error_checks ⇒ `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>)



219
220
221

# File 'diagnostic.rb', line 219

def build_error_checks
  supported_configuration_checks + build_from_source_checks
end

#build_from_source_checks ⇒ `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>)



207
208
209

# File 'diagnostic.rb', line 207

def build_from_source_checks
  [].freeze
end

#cask_checks ⇒ `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>)



1882
1883
1884

# File 'diagnostic.rb', line 1882

def cask_checks
  all.grep(/^check_cask_/)
end

#certificate_trust_check(cert_file, root_names:, advisory_url:, script:) ⇒ `Finding`^?

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.

Reports trusted roots and a script to remove them from a certificate bundle.

Parameters:

cert_file (String)
root_names (Array<String>)
advisory_url (String)
script (String)

Returns:

(Finding, nil)

# File 'diagnostic.rb', line 139

def certificate_trust_check(cert_file, root_names:, advisory_url:, script:)
  require "openssl"

  roots = OpenSSL::X509::Certificate.load(File.read(cert_file)).flat_map do |certificate|
    certificate.subject.to_a.filter_map { |name, value, _type| value if name == "CN" }
  end & root_names
  return if roots.empty?

  Finding.new(
    append_indented_list(roots, <<~EOS),
    links:       [advisory_url],
    remediation: <<~EOS,
      Run this script to create a backup and remove these roots:
        sudo #{RUBY_PATH.to_s.shellescape} --disable=gems,rubyopt #{script}

      The script validates the bundle before replacing it. Removing the roots
      can break HTTPS connections to some websites.

      Run `brew doctor` afterwards and after system updates, which can restore
      the roots.
      For details and software update plans, see:
        #{advisory_url}
    EOS
  )
rescue Errno::ENOENT
  nil
rescue SystemCallError, OpenSSL::OpenSSLError
  Finding.new(
    "Could not check #{cert_file} for roots that trust compromised CAs.",
    remediation: <<~EOS,
      Ensure the file is readable and contains valid PEM certificates,
      then rerun `brew doctor`.
    EOS
  )
end

#check_access_directories ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 564

def check_access_directories
  not_writable_dirs =
    Keg.must_be_writable_directories.select(&:exist?)
       .reject(&:writable?)
  return if not_writable_dirs.empty?

  commands = ["sudo chown -R #{current_user} #{not_writable_dirs.join(" ")}",
              "chmod u+w #{not_writable_dirs.join(" ")}"]
  Finding.new(
    append_indented_list(not_writable_dirs, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You should change the ownership of these directories to your user,
        and make sure that you have write permission.
      EOS
      commands:,
    ),
  )
end

#check_brew_git_origin ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 939

def check_brew_git_origin
  repo = GitRepository.new(HOMEBREW_REPOSITORY)
  examine_git_origin(repo, Homebrew::EnvConfig.brew_git_remote)
end

#check_brew_path ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 607

def check_brew_path
  brew = which("brew", paths)
  return if brew.nil? || File.identical?(brew, HOMEBREW_BREW_FILE)

  Finding.new(
    <<~EOS,
      Another `brew` shadows this Homebrew installation in your PATH:
        #{brew}

      This may be a helper, wrapper or another Homebrew installation.
    EOS
    remediation: path_remediation,
  )
end

#check_cask_corrupt_dirs ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1672

def check_cask_corrupt_dirs
  corrupt = Cask::Caskroom.corrupt_cask_dirs
  return if corrupt.empty?

  commands = corrupt.map { |token| "brew reinstall --cask --force #{token}" }
  Finding.new(
    append_indented_list(corrupt.map { |token| "#{Cask::Caskroom.path}/#{token}" }, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        To fix this, run:
      EOS
      commands:,
    ),
  )
end

#check_cask_deprecated_disabled ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1266

def check_cask_deprecated_disabled
  casks = Cask::Caskroom.casks
  deprecated_or_disabled = casks.select(&:deprecated?)
  deprecated_or_disabled += casks.select(&:disabled?)
  return if deprecated_or_disabled.empty?

  Finding.new(
    "Some installed casks are deprecated or disabled.",
    affects:     deprecated_or_disabled.map(&:token),
    remediation: append_indented_list(deprecated_or_disabled.sort_by(&:token).uniq, <<~EOS),
      You should find replacements for the following casks:

    EOS
  )
end

#check_cask_environment_variables ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1726

def check_cask_environment_variables
  environment_variables = %w[
    RUBYLIB
    RUBYOPT
    RUBYPATH
    RBENV_VERSION
    CHRUBY_VERSION
    GEM_HOME
    GEM_PATH
    BUNDLE_PATH
    PATH
    SHELL
    HOMEBREW_CASK_OPTS
  ]

  locale_variables = ENV.keys.grep(/^(?:LC_\S+|LANG|LANGUAGE)\Z/).sort

  cask_environment_variables = (locale_variables + environment_variables).sort.filter_map do |var|
    next unless ENV.key?(var)

    %Q(#{var}="#{Utils::Shell.sh_quote(ENV.fetch(var))}")
  end
  add_info "Cask Environment Variables:", cask_environment_variables

  nil
end

#check_cask_install_location ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1629

def check_cask_install_location
  locations = Dir.glob(HOMEBREW_CELLAR.join("brew-cask", "*")).reverse
  return if locations.empty?

  Finding.new(
    append_indented_list(locations, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     <<~EOS,
        Run `brew uninstall --force brew-cask`.
      EOS
      commands: ["brew uninstall --force brew-cask"],
    ),
  )
end

#check_cask_load_path ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1717

def check_cask_load_path
  paths = $LOAD_PATH.map { user_tilde(it) }

  add_info "$LOAD_PATHS", paths.presence || none_string

  Finding.new("$LOAD_PATH is empty") if paths.blank?
end

#check_cask_software_versions ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1622

def check_cask_software_versions
  add_info "Homebrew Version", HOMEBREW_VERSION

  nil
end

#check_cask_staging_location ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1647

def check_cask_staging_location
  # Skip this check when running CI since the staging path is not writable for security reasons
  return if GitHub::Actions.env_set?

  path = Cask::Caskroom.path

  add_info "Cask Staging Location", user_tilde(path.to_s)

  return if !path.exist? || path.writable?

  commands = ["sudo chown -R #{current_user} #{user_tilde(path.to_s)}"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        To fix this, run:
      EOS
      commands:,
    ),
  )
end

#check_cask_taps ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1692

def check_cask_taps
  error_tap_paths = []

  taps = (Tap.to_a + [CoreCaskTap.instance]).uniq

  taps_info = taps.filter_map do |tap|
    cask_count = begin
      tap.cask_files.count
    rescue
      error_tap_paths << tap.path
      0
    end
    next if cask_count.zero?

    "#{tap.path} (#{Utils.pluralize("cask", cask_count, include_count: true)})"
  end
  add_info "Cask Taps:", taps_info

  taps_string = Utils.pluralize("tap", error_tap_paths.count)
  return unless error_tap_paths.present?

  Finding.new("Unable to read from cask #{taps_string}: #{Utils::Text.to_sentence(error_tap_paths)}")
end

#check_cask_xattr ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1754

def check_cask_xattr
  # If quarantine is not available, a warning is already shown by check_cask_quarantine_support so just return
  return unless Cask::Quarantine.available?
  return Finding.new("Unable to find `xattr`.") unless File.exist?("/usr/bin/xattr")

  result = system_command "/usr/bin/xattr", args: ["-h"]

  return if result.status.success?

  if result.stderr.include? "ImportError: No module named pkg_resources"
    result = Utils.popen_read "/usr/bin/python", "--version", err: :out

    if result.include? "Python 2.7"
      commands = ["sudo /usr/bin/python -m pip install -I setuptools"]
      Finding.new(
        <<~EOS,
        remediation: Finding::Remediation.new(
          text:     append_indented_list(commands, <<~EOS),
            To this fix, reinstall macOS or run:
          EOS
          commands:,
        ),
      )
    else
      commands = ["defaults write com.apple.versioner.python Version 2.7"]
      Finding.new(
        <<~EOS,
        remediation: Finding::Remediation.new(
          text:     append_indented_list(commands, <<~EOS),
            To fix this, run:
          EOS
          commands:,
        ),
      )
    end
  elsif result.stderr.include? "pkg_resources.DistributionNotFound"
    Finding.new("Your Python installation is unable to find `xattr`.")
  else
    Finding.new("unknown xattr error: #{result.stderr.split("\n").last}")
  end
end

#check_casktap_integrity ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 970

def check_casktap_integrity
  core_cask_tap = CoreCaskTap.instance
  return unless core_cask_tap.installed?

  broken_tap(core_cask_tap) ||
    examine_git_origin(core_cask_tap.git_repository, core_cask_tap.remote || core_cask_tap.default_remote)
end

#check_coretap_integrity ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 958

def check_coretap_integrity
  core_tap = CoreTap.instance
  unless core_tap.installed?
    return unless EnvConfig.no_install_from_api?

    core_tap.ensure_installed!
  end

  broken_tap(core_tap) || examine_git_origin(core_tap.git_repository, Homebrew::EnvConfig.core_git_remote)
end

#check_deleted_formula ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1491

def check_deleted_formula
  newest_kegs_first = Keg.all.select(&:deleted_formula?).sort_by(&:scheme_and_version).reverse
  kegs_with_a_tap, kegs_without_a_tap = newest_kegs_first.partition { |keg| keg.tab.tap }
  deleted_kegs = (kegs_with_a_tap + kegs_without_a_tap).uniq(&:name)

  return if deleted_kegs.blank?

  kegs_by_tap = deleted_kegs.group_by { |keg| keg.tab.tap }
  official_taps, other_taps = kegs_by_tap.keys.sort_by(&:to_s).partition { |tap| tap&.official? }
  potential_dependency_kegs = deleted_kegs.select { |keg| installed_as_dependency?(keg.tab) }
  installed_formulae = Formula.installed if potential_dependency_kegs.present?
  installed_dependency_names = installed_formula_dependency_names(installed_formulae || [])
  dependency_keg_names = potential_dependency_kegs.map(&:name) & installed_dependency_names.to_a
  dependency_kegs, direct_kegs = deleted_kegs.partition { |keg| dependency_keg_names.include?(keg.name) }
  direct_groups_by_type = { deleted: [], untapped: [], no_tap: [] }
  dependency_groups_by_type = { deleted: [], untapped: [], no_tap: [] }
  (official_taps + other_taps).each do |tap|
    type, header = if tap.nil?
      [:no_tap, "No tap recorded (possibly installed manually):\n"]
    elsif tap.core_tap? || tap.installed? ||
          (tap.official? && DEPRECATED_OFFICIAL_TAPS.include?(tap.repository))
      [:deleted, "Deleted from #{tap}:\n"]
    else
      [:untapped, "From untapped #{tap}:\n"]
    end

    direct, dependencies = kegs_by_tap.fetch(tap).partition do |keg|
      direct_kegs.include?(keg)
    end
    if direct.present?
      direct_groups_by_type.fetch(type) << append_indented_list(direct.map(&:name).sort,
                                                                header)
    end
    if dependencies.present?
      dependency_groups_by_type.fetch(type) << append_indented_list(dependencies.map(&:name).sort,
                                                                    header)
    end
  end

  text = +"Some installed kegs have no formulae!\n"
  remediation = []
  if direct_kegs.present?
    text << "You should find replacements for the following formulae.\n"
    remediation << direct_groups_by_type.values.flatten.join("\n").strip
  end
  if dependency_kegs.present?
    dependency_names = dependency_kegs.to_h { |keg| [keg.name, keg.name] }
    remediation << [
      "The following formulae are installed as dependencies:",
      dependency_groups_by_type.values.flatten.join("\n").strip,
      formula_dependency_upgrade_guidance(
        dependency_names,
        installed_formulae: installed_formulae || [],
      ),
    ].compact_blank.join("\n\n")
  end

  Finding.new(
    text,
    affects:     deleted_kegs.map(&:name).sort,
    remediation: remediation.compact_blank.join("\n\n"),
  )
end

#check_deprecated_cask_taps ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1602

def check_deprecated_cask_taps
  tapped_caskroom_taps = ::Tap.select { |t| t.user == "caskroom" || t.name == "phinze/cask" }
                              .map(&:name)
  return if tapped_caskroom_taps.empty?

  commands = ["brew untap #{tapped_caskroom_taps.join(" ")}"]
  Finding.new(
    append_indented_list(tapped_caskroom_taps, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Please remove it by running:
      EOS
      commands:,
    ),
  )
end

#check_deprecated_disabled ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1223

def check_deprecated_disabled
  return unless HOMEBREW_CELLAR.exist?

  installed_formulae = Formula.installed
  deprecated_or_disabled = installed_formulae.select do |f|
    (f.deprecated? || f.disabled?) &&
      f.installed_kegs.none? { |keg| keg.name == f.name && keg.deleted_formula? }
  end
  return if deprecated_or_disabled.empty?

  installed_dependency_names = installed_formula_dependency_names(installed_formulae)
  dependency_formulae, replacement_formulae = deprecated_or_disabled.partition do |formula|
    tab = formula.any_installed_keg&.tab
    tab && installed_as_dependency?(tab) &&
      installed_dependency_names.intersect?(formula.possible_names)
  end

  remediation = []
  if replacement_formulae.present?
    remediation << append_indented_list(replacement_formulae.sort_by(&:full_name).uniq, <<~EOS)
      You should find replacements for the following formulae:

    EOS
  end
  if dependency_formulae.present?
    dependency_names = dependency_formulae.each_with_object({}) do |formula, names|
      formula.possible_names.each { |name| names[name] = formula.full_name }
    end
    remediation << append_indented_list(dependency_formulae.map(&:full_name).sort.uniq, <<~EOS)
      The following formulae are installed as dependencies:

    EOS
    remediation << formula_dependency_upgrade_guidance(dependency_names, installed_formulae:)
  end

  Finding.new(
    "Some installed formulae are deprecated or disabled.",
    affects:     deprecated_or_disabled.map(&:full_name),
    remediation: remediation.join("\n"),
  )
end

#check_deprecated_official_taps ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1027

def check_deprecated_official_taps
  tapped_deprecated_taps =
    Tap.select(&:official?).map(&:repository) & DEPRECATED_OFFICIAL_TAPS

  # TODO: remove this once it's no longer in the default GitHub Actions image
  tapped_deprecated_taps -= ["bundle"] if GitHub::Actions.env_set?

  return if tapped_deprecated_taps.empty?

  Finding.new(
    append_indented_list(tapped_deprecated_taps.map { |name| "Homebrew/homebrew-#{name}" }, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     <<~EOS,
        Untap them with `brew untap`.
      EOS
      commands: ["brew untap"],
    ),
  )
end

#check_exist_directories ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 542

def check_exist_directories
  return if HOMEBREW_PREFIX.writable?

  not_exist_dirs = Keg.must_exist_directories.reject(&:exist?)
  return if not_exist_dirs.empty?

  commands = ["sudo mkdir -p #{not_exist_dirs.join(" ")}",
              "sudo chown -R #{current_user} #{not_exist_dirs.join(" ")}"]
  Finding.new(
    append_indented_list(not_exist_dirs, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You should create these directories and change their ownership to your user.
      EOS
      commands:,
    ),
  )
end

#check_for_broken_symlinks ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 497

def check_for_broken_symlinks
  broken_symlinks = []

  Keg.must_exist_subdirectories.each do |d|
    next unless d.directory?

    d.find do |path|
      broken_symlinks << path if path.symlink? && !Utils::Path.resolved_path_exists?(path)
    end
  end
  return if broken_symlinks.empty?

  Finding.new(
    append_indented_list(broken_symlinks, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     <<~EOS,
        Remove them with `brew cleanup`
      EOS
      commands: ["brew cleanup"],
    ),
  )
end

#check_for_duplicate_casks ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1841

def check_for_duplicate_casks
  return if ENV["HOMEBREW_TEST_BOT"].present?

  core_cask_names = CoreCaskTap.instance.cask_tokens
  shadowed_cask_full_names = non_core_taps.flat_map do |tap|
    tap_cask_names = tap.cask_tokens.map { |s| s.delete_prefix("#{tap.name}/") }
    (core_cask_names & tap_cask_names).map { |f| "#{tap.name}/#{f}" }
  end.compact.sort
  return if shadowed_cask_full_names.empty?

  installed_cask_tap_names = Cask::Caskroom.casks.filter_map(&:tap).uniq.reject(&:official?).map(&:name)
  shadowed_cask_tap_names = shadowed_cask_full_names.filter_map { |s| Utils.tap_from_full_name(s) }.uniq
  unused_shadowed_cask_tap_names = (shadowed_cask_tap_names - installed_cask_tap_names).sort

  remediation = if unused_shadowed_cask_tap_names.empty?
    "Their taps are in use, so you must use these full names throughout Homebrew.\n"
  else
    commands = ["brew untap #{unused_shadowed_cask_tap_names.join(" ")}"]
    Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Some of these can be resolved with:
      EOS
      commands:,
    )
  end

  Finding.new(
    append_indented_list(shadowed_cask_full_names, <<~EOS),
      The following casks have the same name as core casks:
    EOS
    affects:     shadowed_cask_full_names,
    remediation:,
  )
end

#check_for_duplicate_formulae ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1806

def check_for_duplicate_formulae
  return if ENV["HOMEBREW_TEST_BOT"].present?

  core_formula_names = CoreTap.instance.formula_names
  shadowed_formula_full_names = non_core_taps.flat_map do |tap|
    tap_formula_names = tap.formula_names.map { |s| s.delete_prefix("#{tap.name}/") }
    (core_formula_names & tap_formula_names).map { |f| "#{tap.name}/#{f}" }
  end.compact.sort
  return if shadowed_formula_full_names.empty?

  installed_formula_tap_names = Formula.installed.filter_map(&:tap).uniq.reject(&:official?).map(&:name)
  shadowed_formula_tap_names = shadowed_formula_full_names.filter_map { |s| Utils.tap_from_full_name(s) }.uniq
  unused_shadowed_formula_tap_names = (shadowed_formula_tap_names - installed_formula_tap_names).sort

  remediation = if unused_shadowed_formula_tap_names.empty?
    "Their taps are in use, so you must use these full names throughout Homebrew."
  else
    commands = ["brew untap #{unused_shadowed_formula_tap_names.join(" ")}"]
    Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Some of these can be resolved with:
      EOS
      commands:,
    )
  end

  Finding.new(
    append_indented_list(shadowed_formula_full_names, <<~EOS),
      The following formulae have the same name as core formulae:
    EOS
    remediation:,
  )
end

#check_for_external_cmd_name_conflict ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1420

def check_for_external_cmd_name_conflict
  cmds = Commands.tap_cmd_directories.flat_map { |p| Dir["#{p}/brew-*"] }.uniq
  cmds = cmds.select { |cmd| File.file?(cmd) && File.executable?(cmd) }
  cmd_map = {}
  cmds.each do |cmd|
    cmd_name = File.basename(cmd, ".rb")
    cmd_map[cmd_name] ||= []
    cmd_map[cmd_name] << cmd
  end
  cmd_map.reject! { |_cmd_name, cmd_paths| cmd_paths.size == 1 }
  return if cmd_map.empty?

  if ENV["CI"].present? && cmd_map.keys.length == 1 &&
     cmd_map.keys.first == "brew-test-bot"
    return
  end

  message = "You have external commands with conflicting names.\n"
  cmd_map.each do |cmd_name, cmd_paths|
    message += append_indented_list cmd_paths, <<~EOS
      Found command `#{cmd_name}` in the following places:
    EOS
  end

  Finding.new(message)
end

#check_for_git ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 807

def check_for_git
  return if Utils::Git.available?

  commands = ["brew install git"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You may want to install Git:
      EOS
      commands:,
    ),
  )
end

#check_for_installed_developer_tools ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 333

def check_for_installed_developer_tools
  return if DevelopmentTools.installed?

  Finding.new(
    "No developer tools installed.\n",
    remediation: DevelopmentTools.installation_instructions,
  )
end

#check_for_nix_homebrew ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 945

def check_for_nix_homebrew
  return unless OS.nix_managed_homebrew?

  Finding.new(
    <<~EOS,
      Your Homebrew installation is managed by Nix.
      Homebrew does not support Nix-managed installations.
    EOS
    tier: 3,
  )
end

#check_for_non_prefixed_coreutils ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1333

def check_for_non_prefixed_coreutils
  coreutils = Formula["coreutils"]
  return unless coreutils.any_version_installed?

  gnubin = %W[#{coreutils.opt_libexec}/gnubin #{coreutils.libexec}/gnubin]
  return unless paths.intersect?(gnubin)

  Finding.new(
    <<~EOS,
      Putting non-prefixed coreutils in your path can cause GMP builds to fail.
    EOS
  )
rescue FormulaUnavailableError
  nil
end

#check_for_other_frameworks ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1166

def check_for_other_frameworks
  # Other frameworks that are known to cause problems when present
  frameworks_to_check = %w[
    expat.framework
    libexpat.framework
    libcurl.framework
  ]
  frameworks_found = frameworks_to_check
                     .map { |framework| "/Library/Frameworks/#{framework}" }
                     .select { |framework| File.exist? framework }
  return if frameworks_found.empty?

  Finding.new(
    <<~EOS,
    remediation: append_indented_list(frameworks_found, <<~EOS),
      To compile CMake, you may wish to move these out of the way:
    EOS
  )
end

#check_for_pydistutils_cfg_in_home ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1350

def check_for_pydistutils_cfg_in_home
  return unless File.exist? "#{Dir.home}/.pydistutils.cfg"

  Finding.new(
    <<~EOS,
      A '.pydistutils.cfg' file was found in $HOME, which may cause Python
      builds to fail. See:
        #{Formatter.url("https://bugs.python.org/issue6138")}
        #{Formatter.url("https://bugs.python.org/issue4655")}
    EOS
    links: [
      "https://bugs.python.org/issue6138",
      "https://bugs.python.org/issue4655",
    ],
  )
end

#check_for_stray_dylibs ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 361

def check_for_stray_dylibs
  # Dylibs which are generally OK should be added to this list,
  # with a short description of the software they come with.
  allow_list = [
    "libfuse.2.dylib", # MacFuse
    "libfuse3.*.dylib", # MacFuse
    "libfuse_ino64.2.dylib", # MacFuse
    "libfuse-t*.dylib", # FUSE-T
    "libmacfuse_i32.2.dylib", # OSXFuse MacFuse compatibility layer
    "libmacfuse_i64.2.dylib", # OSXFuse MacFuse compatibility layer
    "libosxfuse_i32.2.dylib", # OSXFuse
    "libosxfuse_i64.2.dylib", # OSXFuse
    "libosxfuse.2.dylib", # OSXFuse
    "libTrAPI.dylib", # TrAPI/Endpoint Security VPN
    "libntfs-3g.*.dylib", # NTFS-3G
    "libntfs.*.dylib", # NTFS-3G
    "libublio.*.dylib", # NTFS-3G
    "libUFSDNTFS.dylib", # Paragon NTFS
    "libUFSDExtFS.dylib", # Paragon ExtFS
    "libecomlodr.dylib", # Symantec Endpoint Protection
    "libsymsea*.dylib", # Symantec Endpoint Protection
    "sentinel.dylib", # SentinelOne
    "sentinel-*.dylib", # SentinelOne
    "libASAF.dylib", # Apple Immersive Audio SDK
    "JPKI*.dylib", # JPKI (Japanese My Number Card) client
  ]

  msg = __check_stray_files "/usr/local/lib", "*.dylib", allow_list, <<~EOS
    Unbrewed dylibs were found in /usr/local/lib.
    If you didn't put them there on purpose they could cause problems when
    building Homebrew formulae and may need to be deleted.

    Unexpected dylibs:
  EOS
  Finding.new(msg) if msg.present?
end

#check_for_stray_headers ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 475

def check_for_stray_headers
  allow_list = [
    "fuse.h", # MacFuse
    "fuse/**/*.h", # MacFuse
    "fuse3/**/*.h", # MacFuse
    "macfuse/**/*.h", # OSXFuse MacFuse compatibility layer
    "osxfuse/**/*.h", # OSXFuse
    "ntfs/**/*.h", # NTFS-3G
    "ntfs-3g/**/*.h", # NTFS-3G
  ]

  msg = __check_stray_files "/usr/local/include", "**/*.h", allow_list, <<~EOS
    Unbrewed header files were found in /usr/local/include.
    If you didn't put them there on purpose they could cause problems when
    building Homebrew formulae and may need to be deleted.

    Unexpected header files:
  EOS
  Finding.new(msg) if msg.present?
end

#check_for_stray_las ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 452

def check_for_stray_las
  allow_list = [
    "libfuse.la", # MacFuse
    "libfuse_ino64.la", # MacFuse
    "libosxfuse_i32.la", # OSXFuse
    "libosxfuse_i64.la", # OSXFuse
    "libosxfuse.la", # OSXFuse
    "libntfs-3g.la", # NTFS-3G
    "libntfs.la", # NTFS-3G
    "libublio.la", # NTFS-3G
  ]

  msg = __check_stray_files "/usr/local/lib", "*.la", allow_list, <<~EOS
    Unbrewed '.la' files were found in /usr/local/lib.
    If you didn't put them there on purpose they could cause problems when
    building Homebrew formulae and may need to be deleted.

    Unexpected '.la' files:
  EOS
  Finding.new(msg) if msg.present?
end

#check_for_stray_pcs ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 428

def check_for_stray_pcs
  # Package-config files which are generally OK should be added to this list,
  # with a short description of the software they come with.
  allow_list = [
    "fuse.pc", # OSXFuse/MacFuse
    "fuse3.pc", # OSXFuse/MacFuse
    "fuse-t.pc", # FUSE-T
    "macfuse.pc", # OSXFuse MacFuse compatibility layer
    "osxfuse.pc", # OSXFuse
    "libntfs-3g.pc", # NTFS-3G
    "libublio.pc", # NTFS-3G
  ]

  msg = __check_stray_files "/usr/local/lib/pkgconfig", "*.pc", allow_list, <<~EOS
    Unbrewed '.pc' files were found in /usr/local/lib/pkgconfig.
    If you didn't put them there on purpose they could cause problems when
    building Homebrew formulae and may need to be deleted.

    Unexpected '.pc' files:
  EOS
  Finding.new(msg) if msg.present?
end

#check_for_stray_static_libs ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 399

def check_for_stray_static_libs
  # Static libs which are generally OK should be added to this list,
  # with a short description of the software they come with.
  allow_list = [
    "libfuse-t*.a", # FUSE-T
    "libfuse3.a", # FUSE-T
    "libntfs-3g.a", # NTFS-3G
    "libntfs.a", # NTFS-3G
    "libublio.a", # NTFS-3G
    "libappfirewall.a", # Symantec Endpoint Protection
    "libautoblock.a", # Symantec Endpoint Protection
    "libautosetup.a", # Symantec Endpoint Protection
    "libconnectionsclient.a", # Symantec Endpoint Protection
    "liblocationawareness.a", # Symantec Endpoint Protection
    "libpersonalfirewall.a", # Symantec Endpoint Protection
    "libtrustedcomponents.a", # Symantec Endpoint Protection
  ]

  msg = __check_stray_files "/usr/local/lib", "*.a", allow_list, <<~EOS
    Unbrewed static libraries were found in /usr/local/lib.
    If you didn't put them there on purpose they could cause problems when
    building Homebrew formulae and may need to be deleted.

    Unexpected static libraries:
  EOS
  Finding.new(msg) if msg.present?
end

#check_for_symlinked_cellar ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 694

def check_for_symlinked_cellar
  return unless HOMEBREW_CELLAR.exist?
  return unless HOMEBREW_CELLAR.symlink?

  Finding.new(
    <<~EOS,
      Symlinked Cellars can cause problems.
      Your Homebrew Cellar is a symlink: #{HOMEBREW_CELLAR}
                      which resolves to: #{HOMEBREW_CELLAR.realpath}

      The recommended Homebrew installations are either:
      (A) Have Cellar be a real directory inside of your `$HOMEBREW_PREFIX`
      (B) Symlink "bin/brew" into your prefix, but don't symlink "Cellar".

      Older installations of Homebrew may have created a symlinked Cellar, but this can
      cause problems when two formulae install to locations that are mapped on top of each
      other during the linking step.
    EOS
  )
end

#check_for_tap_ruby_files_locations ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1448

def check_for_tap_ruby_files_locations
  bad_tap_files = {}
  Tap.installed.each do |tap|
    unused_formula_dirs = tap.potential_formula_dirs - [tap.formula_dir]
    unused_formula_dirs.each do |dir|
      next unless dir.exist?

      dir.children.each do |path|
        next if path.extname != ".rb"

        bad_tap_files[tap] ||= []
        bad_tap_files[tap] << path
      end
    end
  end
  return if bad_tap_files.empty?

  Finding.new(bad_tap_files.keys.map do |tap|
    append_indented_list bad_tap_files[tap], <<~EOS
      Found Ruby file outside #{tap} tap formula directory.
      (#{tap.formula_dir}):
    EOS
  end.join("\n"))
end

#check_for_unlinked_but_not_keg_only ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1389

def check_for_unlinked_but_not_keg_only
  unlinked = Formula.racks.reject do |rack|
    next true if (HOMEBREW_LINKED_KEGS/rack.basename).directory?

    begin
      Keg.from_rack(rack)&.deleted_formula? || Formulary.from_rack(rack).keg_only?
    rescue Homebrew::UntrustedTapError
      true
    rescue FormulaUnavailableError, TapFormulaAmbiguityError
      false
    end
  end.map(&:basename)
  return if unlinked.empty?

  Finding.new(
    <<~EOS,
    affects:     unlinked.map(&:to_s),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(unlinked, <<~EOS),
        Run `brew link` on these:
      EOS
      commands: unlinked.map { |unlink| "brew link #{unlink}" },
    ),
  )
end

#check_for_unnecessary_cask_tap ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1578

def check_for_unnecessary_cask_tap
  return if Homebrew::EnvConfig.developer?
  return if Homebrew::EnvConfig.no_install_from_api?
  return if Homebrew::EnvConfig.devcmdrun?

  cask_tap = CoreCaskTap.instance
  return unless cask_tap.installed?

  commands = ["brew untap #{cask_tap.name}"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Please remove it by running:
      EOS
      commands:,
    ),
  )
end

#check_for_unnecessary_core_tap ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1556

def check_for_unnecessary_core_tap
  return if Homebrew::EnvConfig.developer?
  return if Homebrew::EnvConfig.no_install_from_api?
  return if Homebrew::EnvConfig.devcmdrun?
  return unless CoreTap.instance.installed?

  commands = ["brew untap #{CoreTap.instance.name}"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Please remove it by running:
      EOS
      commands:,
    ),
  )
end

#check_for_unreadable_installed_formula ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1368

def check_for_unreadable_installed_formula
  formula_unavailable_exceptions = []
  Formula.racks.each do |rack|
    Formulary.from_rack(rack)
  rescue FormulaUnreadableError, FormulaClassUnavailableError,
         TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
    formula_unavailable_exceptions << e
  rescue Homebrew::UntrustedTapError, FormulaUnavailableError, TapFormulaAmbiguityError
    nil
  end
  return if formula_unavailable_exceptions.empty?

  Finding.new(
    append_indented_list(formula_unavailable_exceptions.map { |s| "#{s}\n" }, <<~EOS),
      Some installed formulae are not readable:
    EOS
    affects: formula_unavailable_exceptions,
  )
end

#check_git_config_in_sandbox ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 827

def check_git_config_in_sandbox
  require "download_strategy"

  return unless Utils::Git.available?
  return if Sandbox.nested_sandbox?
  return unless Sandbox.use_for?("checking Git configuration", warn_without_sandbox: false)

  sandbox = Sandbox.for_operation(home_read_exception: :git, network_access: true)
  output = +""
  begin
    config = GitDownloadStrategy.sandboxed_git(
      sandbox, "config", "--null", "--list", "--includes", timeout: 10
    )
    return if config.success?

    output << config.stdout << "\0" << config.stderr
    problem = "Git failed while reading configuration (#{config.status})."
  rescue Timeout::Error
    problem = "The Git configuration check timed out."
  end

  output.scrub!
  paths = sandbox.denied_read_paths.select do |path|
    output.match?(%r{#{Regexp.escape(path)}(?=/|[\s\0'"]|\z)})
  end

  remediation = <<~EOS
    Check your global Git configuration and includes.
    Correct unreadable paths or use files accessible to the sandbox.
    Homebrew will not expand sandbox access for configured paths.
    This check does not run credential helpers or verify authentication.
  EOS
  if paths.present?
    remediation += append_indented_list(paths.map(&:inspect), <<~EOS)

      Sandbox-restricted locations referenced by Git:
    EOS
  end

  Finding.new(
    <<~EOS,
      Git checks failed inside Homebrew's download sandbox.
      Git source downloads may also be affected.
      #{problem}
    EOS
    remediation: Finding::Remediation.new(text: remediation),
  )
rescue SystemCallError, RuntimeError
  Finding.new(<<~EOS)
    The Git configuration check could not run in Homebrew's download sandbox.
    Check Homebrew's sandbox setup and temporary directory permissions.
  EOS
end

#check_git_newline_settings ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 882

def check_git_newline_settings
  return unless Utils::Git.available?

  autocrlf = HOMEBREW_REPOSITORY.cd do
    Utils.popen_read_text(Utils::Git.git, "config", "--get", "core.autocrlf", err: :err).chomp
  end
  return if autocrlf != "true"

  commands = ["git config --global core.autocrlf input"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        If you are not routinely dealing with Windows-based projects,
        consider removing these by running:
      EOS
      commands:,
    ),
  )
end

#check_git_status ⇒ `Array<Finding>`

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<Finding>)

# File 'diagnostic.rb', line 1283

def check_git_status
  return [] unless Utils::Git.available?

  repos = {
    "Homebrew/brew"          => HOMEBREW_REPOSITORY,
    "Homebrew/homebrew-core" => CoreTap.instance.path,
    "Homebrew/homebrew-cask" => CoreCaskTap.instance.path,
  }

  status = []
  repos.each do |name, path|
    finding = __tap_git_status(name, path)
    status << finding if finding.present?
  end

  status
end

#check_git_version ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 784

def check_git_version
  minimum_version = ENV.fetch("HOMEBREW_MINIMUM_GIT_VERSION")
  return unless Utils::Git.available?
  return if Utils::Git.version >= Version.new(minimum_version)

  git = Formula["git"]
  git_upgrade_cmd = git.any_version_installed? ? "upgrade" : "install"
  commands = ["brew #{git_upgrade_cmd} git"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Please upgrade:
      EOS
      commands:,
    ),
  )
end

#check_github_api_tokens ⇒ `Finding`^?

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.

odeprecated "Remove this check when the minimum curl is 7.55 at the next major/minor release."

Returns:

(Finding, nil)

# File 'diagnostic.rb', line 765

def check_github_api_tokens
  return if Homebrew::EnvConfig.github_api_token.blank?

  require "utils/curl"

  minimum_version = HOMEBREW_CURL_HEADER_FILE_MIN_VERSION
  return if Utils::Curl.curl_version >= Version.new(minimum_version)

  Finding.new(
    <<~EOS,
      GitHub API tokens are set, but curl #{Utils::Curl.curl_version} is older than #{minimum_version}.
      Homebrew does not pass these tokens to curl. Requests use unauthenticated
      rate limits and cannot access private repositories or write to GitHub.
    EOS
    remediation: "Upgrade curl to #{minimum_version} or newer to use GitHub API tokens.",
  )
end

#check_homebrew_prefix ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1474

def check_homebrew_prefix
  return if Homebrew.default_prefix?
  return if ENV["HOMEBREW_INTEGRATION_TEST"]
  return if BottleSpecification.compatible_locations?

  Finding.new(
    <<~EOS,
      Your Homebrew's prefix is not #{Homebrew::DEFAULT_PREFIX}.

      Some of Homebrew's bottles (binary packages) cannot be used with this prefix.
    EOS
    tier:        3,
    remediation: "Consider uninstalling Homebrew and reinstalling into the default prefix.",
  )
end

#check_homebrew_repository_git_hooks ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 909

def check_homebrew_repository_git_hooks
  found = T.let([], T::Array[Pathname])

  hooks_dir = HOMEBREW_REPOSITORY/".git/hooks"
  if hooks_dir.directory?
    found += hooks_dir.children.reject { |path| path.basename.to_s.end_with?(".sample") }.sort_by(&:to_s)
  end

  gitconfig = HOMEBREW_REPOSITORY/".gitconfig"
  found << gitconfig if gitconfig.exist?
  return if found.empty?

  commands = ["rm -rf \"#{HOMEBREW_REPOSITORY}/.git/hooks\" \"#{HOMEBREW_REPOSITORY}/.gitconfig\""]
  Finding.new(
    append_indented_list(found, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        Remove them with:
      EOS
      commands:,
    ),
  )
end

#check_missing_deps ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1202

def check_missing_deps
  return if !HOMEBREW_CELLAR.exist? && !Cask::Caskroom.path.exist?

  missing = Homebrew::Missing.deps(Formula.installed, Cask::Caskroom.casks)
  return if missing.empty?

  commands = Homebrew::Missing.install_commands(missing)
  Finding.new(
    append_indented_list(missing.map { |name, deps| Homebrew::Missing.format_deps(name, deps) }, <<~EOS),
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You should `brew install` the missing dependencies:
      EOS
      commands:,
    ),
  )
end

#check_multiple_cellars ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 587

def check_multiple_cellars
  return if HOMEBREW_PREFIX.to_s == HOMEBREW_REPOSITORY.to_s
  return unless (HOMEBREW_REPOSITORY/"Cellar").exist?
  return unless (HOMEBREW_PREFIX/"Cellar").exist?

  commands = ["rm -rf #{HOMEBREW_REPOSITORY}/Cellar"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        You should delete #{HOMEBREW_REPOSITORY}/Cellar:
      EOS
      commands:,
    ),
  )
end

#check_tap_git_branch ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 979

def check_tap_git_branch
  return if ENV["CI"]
  return unless Utils::Git.available?

  deprecated_master = []
  commands = []

  brew_repo = GitRepository.new(HOMEBREW_REPOSITORY)
  deprecated_master << "Homebrew/brew" if brew_repo.branch_name == "master"

  Tap.installed.each do |tap|
    if tap.git_repository.branch_name == "master" && tap.official?
      deprecated_master << tap.name
    elsif !tap.git_repository.default_origin_branch?
      commands << "git -C $(brew --repo #{tap.name}) checkout #{tap.git_repository.origin_branch_name}"
    end
  end

  message = +""

  if deprecated_master.any?
    message += append_indented_list deprecated_master, <<~EOS
      The following repositories are on the deprecated "master" branch.
      The "master" branch sync will stop and this warning will become an error
      when Homebrew 5.2.0 is released (no earlier than 2026-06-10).
      Run `brew update` to migrate to "main":

    EOS
  end

  remediation = nil
  if commands.any?
    message << "\n" if deprecated_master.any?
    message << <<~EOS
      Some taps are not on the default git origin branch and may not receive updates.
    EOS
    remediation = Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        If this is a surprise to you, check out the default branch with:
      EOS
      commands:,
    )
  end

  Finding.new(message, remediation:) if message.present?
end

#check_tmpdir ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1190

def check_tmpdir
  tmpdir = ENV.fetch("TMPDIR", nil)
  return if tmpdir.nil? || File.directory?(tmpdir)

  Finding.new(
    <<~EOS,
      TMPDIR #{tmpdir.inspect} doesn't exist.
    EOS
  )
end

#check_tmpdir_sticky_bit ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 523

def check_tmpdir_sticky_bit
  world_writable = HOMEBREW_TEMP.stat.mode & 0777 == 0777
  return if !world_writable || HOMEBREW_TEMP.sticky?

  commands = ["sudo chmod +t #{HOMEBREW_TEMP}"]
  Finding.new(
    <<~EOS,
    remediation: Finding::Remediation.new(
      text:     append_indented_list(commands, <<~EOS),
        To set it, run the following command:
      EOS
      commands:,
    ),
  )
end

#check_tools ⇒ `Array<Finding>`

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<Finding>)

# File 'diagnostic.rb', line 716

def check_tools
  require "utils/curl"
  require "utils/tool"

  %w[git curl].filter_map do |tool|
    minimum = ENV.fetch("HOMEBREW_MINIMUM_#{tool.upcase}_VERSION")
    if tool == "git"
      Utils::Git.clear_available_cache
    else
      Utils::Curl.clear_path_cache
    end
    # Always probe the executable, then reselect and retry once on failure.
    next if 2.times.any? do
      begin
        result = system_command "/bin/bash", args: ["-c", <<~SH], timeout: 10, print_stderr: false
          source "${HOMEBREW_LIBRARY}/Homebrew/utils.sh"
          source "${HOMEBREW_LIBRARY}/Homebrew/utils/#{tool}.sh"
          setup_#{tool}
          printf '%s\\0' "${HOMEBREW_SELECTED_TOOL}"
          [[ -n "${HOMEBREW_SELECTED_TOOL}" ]] || exit 1
          exec "${HOMEBREW_SELECTED_TOOL}" --version
        SH
        path, output = result.stdout.split("\0", 2)
        version = output&.[](/^#{tool}(?: version)? (\d+(?:\.\d+)+)/, 1)
        if result.success? && path.present? && version && Version.new(version) >= Version.new(minimum)
          ENV["HOMEBREW_#{tool.upcase}"] = path
          if tool == "curl"
            ENV["HOMEBREW_CURL_VERSION"] = version
            ENV["HOMEBREW_CURL_VERSION_PATH"] = path
          end
          next true
        end
      rescue Timeout::Error, SystemCallError
        # A failed launch or hung version probe also invalidates selection.
      end
      Utils::Tool.invalidate_cache(tool.to_sym)
      false
    end

    Finding.new(<<~EOS)
      Homebrew could not find a working #{tool} after refreshing its cached selection.
      Minimum required version: #{minimum}
      Initial executable: #{ENV.fetch("HOMEBREW_#{tool.upcase}", tool)}
    EOS
  end
end

#check_untrusted_taps ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 1050

def check_untrusted_taps
  return if Homebrew::EnvConfig.no_require_tap_trust?

  untrusted_taps = Homebrew::Trust.wholly_untrusted_taps
  return if untrusted_taps.empty?

  untrusted_tap_names = untrusted_taps.map(&:name)
  untrusted_tap_name_set = untrusted_tap_names.to_set
  installed_formulae_by_tap = {}
  installed_casks_by_tap = {}
  Formula.racks.each do |rack|
    next unless (keg = Keg.from_rack(rack))
    next unless (tap = keg.tab.tap)
    next unless untrusted_tap_name_set.include?(tap.name)

    installed_formulae = installed_formulae_by_tap[tap.name] ||= []
    installed_formulae << "#{tap.name}/#{rack.basename}"
  rescue
    nil
  end
  installed_formula_message = installed_formulae_by_tap.sort_by(&:first).filter_map do |_tap_name, formulae|
    next if formulae.empty?

    "brew trust --formula #{formulae.sort.join(" ")}"
  end
  Cask::Caskroom.casks.each do |cask|
    next unless (tap = cask.tab.tap)
    next unless untrusted_tap_name_set.include?(tap.name)

    installed_casks = installed_casks_by_tap[tap.name] ||= []
    installed_casks << "#{tap.name}/#{cask.token}"
  end
  installed_cask_message = installed_casks_by_tap.sort_by(&:first).filter_map do |_tap_name, casks|
    next if casks.empty?

    "brew trust --cask #{casks.sort.join(" ")}"
  end
  installed_items_from_untrusted_taps = installed_formula_message.present? || installed_cask_message.present?
  untap_command = ["brew untap #{untrusted_tap_names.join(" ")}"]
  untap_message = append_indented_list(untap_command, <<~EOS)
    Untap them with:
  EOS
  generic_trust_types = []
  generic_trust_commands = []
  if installed_formula_message.blank?
    generic_trust_types << "formulae"
    generic_trust_commands << "brew trust --formula <user>/<tap>/<formula>"
  end
  if installed_cask_message.blank?
    generic_trust_types << "casks"
    generic_trust_commands << "brew trust --cask <user>/<tap>/<cask>"
  end
  generic_trust_types << "commands"
  generic_trust_commands << "brew trust --command <user>/<tap>/<command>"
  generic_trust_prefix = if installed_items_from_untrusted_taps
    "Trust other specific"
  else
    "Trust specific"
  end
  generic_trust_message = append_indented_list generic_trust_commands, <<~EOS
    #{generic_trust_prefix} #{Utils::Text.to_sentence(generic_trust_types)} with:
  EOS
  trust_messages = if installed_items_from_untrusted_taps
    ["Prefer trusting only the specific formulae, casks or commands you need.\n"]
  else
    [untap_message]
  end
  if installed_formula_message.present?
    trust_messages << append_indented_list(installed_formula_message, <<~EOS)
      Trust installed formulae from these taps with:
    EOS
  end
  if installed_cask_message.present?
    trust_messages << append_indented_list(installed_cask_message, <<~EOS)
      Trust installed casks from these taps with:
    EOS
  end
  trust_messages << generic_trust_message
  trust_messages << <<~EOS
    Whole-tap trust is broader and includes all current and future formulae,
    casks and commands from the listed taps. Trust whole taps with:
      brew trust #{untrusted_tap_names.join(" ")}
  EOS
  trust_messages << untap_message if installed_items_from_untrusted_taps
  trust_messages << <<~EOS
    For more information, see:
      #{Formatter.url("https://docs.brew.sh/Tap-Trust")}
  EOS
  untrusted_message = append_indented_list untrusted_tap_names, <<~EOS
    The following taps are not trusted:
  EOS
  untrusted_message += "\nHomebrew is currently ignoring formulae, casks and commands" \
                       "\nfrom these taps because tap trust is required."

  Finding.new(
    untrusted_message,
    links:       ["https://docs.brew.sh/Tap-Trust"],
    remediation: trust_messages.join,
  )
end

#check_user_path_1 ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 623

def check_user_path_1
  @seen_prefix_bin = false
  @seen_prefix_sbin = false

  message = ""

  paths.each do |p|
    case p
    when "/usr/bin"
      unless @seen_prefix_bin
        # only show the doctor message if there are any conflicts
        # rationale: a default install should not trigger any brew doctor messages
        conflicts = Dir["#{HOMEBREW_PREFIX}/bin/*"]
                    .map { |fn| File.basename fn }
                    .select { |bn| File.exist? "/usr/bin/#{bn}" }

        unless conflicts.empty?
          message = append_indented_list conflicts, <<~EOS
            /usr/bin occurs before #{HOMEBREW_PREFIX}/bin in your PATH.
            This means that system-provided programs will be used instead of those
            provided by Homebrew.

            The following tools exist at both paths:
          EOS
        end
      end
    when "#{HOMEBREW_PREFIX}/bin"
      @seen_prefix_bin = true
    when "#{HOMEBREW_PREFIX}/sbin"
      @seen_prefix_sbin = true
    end
  end

  @user_path_1_done = true
  Finding.new(message, remediation: path_remediation) if message.present?
end

#check_user_path_2 ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 661

def check_user_path_2
  check_user_path_1 unless @user_path_1_done
  return if @seen_prefix_bin

  Finding.new(
    <<~EOS,
      Homebrew's "bin" was not found in your PATH.
    EOS
    remediation: path_remediation,
  )
end

#check_user_path_3 ⇒ `Finding`^?

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:

(Finding, nil)

# File 'diagnostic.rb', line 674

def check_user_path_3
  check_user_path_1 unless @user_path_1_done
  return if @seen_prefix_sbin

  # Don't complain about sbin not being in the path if it doesn't exist
  sbin = HOMEBREW_PREFIX/"sbin"
  return unless sbin.directory?
  return if sbin.children.empty?
  return if sbin.children.one? && sbin.children.first.basename.to_s == ".keepme"

  Finding.new(
    <<~EOS,
      Homebrew's "sbin" was not found in your PATH but you have installed
      formulae that put executables in #{HOMEBREW_PREFIX}/sbin.
    EOS
    remediation: path_remediation(sbin.to_s),
  )
end

#current_user ⇒ `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)



1887
1888
1889

# File 'diagnostic.rb', line 1887

def current_user
  ENV.fetch("USER", "$(whoami)")
end

#desired_git_remote?(url, desired_origin) ⇒ `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.

Compares like Tap.same_remote?, e.g. treating SSH and HTTPS GitHub URLs as the same, but also allows a .git suffix or trailing slash on other hosts, e.g. mirrors.

Parameters:

url (String)
desired_origin (String)

Returns:

(Boolean)



226
227
228

# File 'diagnostic.rb', line 226

def desired_git_remote?(url, desired_origin)
  Tap.same_remote?(url, desired_origin) || url.match?(%r{\A#{Regexp.escape(desired_origin)}(\.git|/)?\z}i)
end

#examine_git_origin(repository_path, desired_origin) ⇒ `Finding`^?

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:

repository_path (GitRepository)
desired_origin (String)

Returns:

(Finding, nil)

# File 'diagnostic.rb', line 231

def examine_git_origin(repository_path, desired_origin)
  return if !Utils::Git.available? || !repository_path.git_repository?

  current_origin = repository_path.origin_url
  return if current_origin && desired_git_remote?(current_origin, desired_origin)

  remotes = Utils.popen_read(Utils::Git.git, "-C", repository_path.pathname, "remote", "-v").lines
  desired_remote, desired_remote_url = remotes.find do |line|
    remote, url, direction = line.split
    remote != "origin" && direction == "(fetch)" && url && desired_git_remote?(url, desired_origin)
  end&.split

  if current_origin.nil?
    Finding.new(
      <<~EOS,
      remediation: Finding::Remediation.new(
        text:     <<~EOS,
          You can solve this by adding the remote:
            git -C "#{repository_path}" remote add origin #{Formatter.url(desired_origin)}
        EOS
        commands: [
          "git -C \"#{repository_path}\" remote add origin #{desired_origin}",
        ],
      ),
    )
  elsif desired_remote
    Finding.new(
      <<~EOS,
      remediation: Finding::Remediation.new(
        text:     <<~EOS,
          You can solve this by renaming the remotes:
            git -C "#{repository_path}" remote rename origin fork
            git -C "#{repository_path}" remote rename #{desired_remote} origin
        EOS
        commands: [
          "git -C \"#{repository_path}\" remote rename origin fork",
          "git -C \"#{repository_path}\" remote rename #{desired_remote} origin",
        ],
      ),
    )
  else
    Finding.new(
      <<~EOS,
      remediation: Finding::Remediation.new(
        text:     <<~EOS,
          You can solve this by setting the origin remote:
            git -C "#{repository_path}" remote set-url origin #{Formatter.url(desired_origin)}
        EOS
        commands: [
          "git -C \"#{repository_path}\" remote set-url origin #{desired_origin}",
        ],
      ),
    )
  end
end

#fatal_build_from_source_checks ⇒ `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 'diagnostic.rb', line 187

def fatal_build_from_source_checks
  %w[
    check_for_installed_developer_tools
  ].freeze
end

#fatal_preinstall_checks ⇒ `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 'diagnostic.rb', line 180

def fatal_preinstall_checks
  %w[
    check_access_directories
  ].freeze
end

#fatal_setup_build_environment_checks ⇒ `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>)



194
195
196

# File 'diagnostic.rb', line 194

def fatal_setup_build_environment_checks
  [].freeze
end

#find_relative_paths(*relative_paths) ⇒ `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.

Finds files in HOMEBREW_PREFIX and /usr/local. Specify paths relative to a prefix, e.g. "include/foo.h". Sets @found for your convenience.

Parameters:

relative_paths (String, Array<String>)

# File 'diagnostic.rb', line 81

def find_relative_paths(*relative_paths)
  @found = [HOMEBREW_PREFIX, "/usr/local"].uniq.reduce([]) do |found, prefix|
    found + relative_paths.map { |f| File.join(prefix, f) }.select { |f| File.exist? f }
  end
end

#macos_bottle_remediation(version, intel:) ⇒ `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:

version (MacOSVersion)
intel (Boolean)

Returns:

(String, nil)

# File 'diagnostic.rb', line 114

def macos_bottle_remediation(version, intel:)
  return if !intel && !version.outdated_release?
  return if version > :tahoe

  remediation = +"Homebrew no longer builds bottles for this configuration.\n"
  # At the time of writing, MacPorts does not provide a full set of binary packages
  # for Intel Tahoe:
  # https://build.macports.org/builders/ports-26_x86_64-builder
  remediation << if intel && version >= :tahoe
    <<~EOS
      Existing bottles may still work, but updated formulae may build from source.
    EOS
  else
    <<~EOS
      Consider MacPorts, which provides binary packages for this macOS version:
        #{Formatter.url("https://www.macports.org")}
    EOS
  end
end

#non_core_taps ⇒ `Array<Tap>`

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<Tap>)



1801
1802
1803

# File 'diagnostic.rb', line 1801

def non_core_taps
  @non_core_taps ||= Tap.installed.reject(&:core_tap?).reject(&:core_cask_tap?)
end

#none_string ⇒ `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)



104
105
106

# File 'diagnostic.rb', line 104

def none_string
  "<NONE>"
end

#preinstall_checks ⇒ `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 'diagnostic.rb', line 212

def preinstall_checks
  %w[
    check_untrusted_taps
  ].freeze
end

#supported_configuration_checks ⇒ `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 'diagnostic.rb', line 199

def supported_configuration_checks
  %w[
    check_homebrew_prefix
    check_for_nix_homebrew
  ].freeze
end

#user_tilde(path) ⇒ `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:

path (String)

Returns:

(String)

# File 'diagnostic.rb', line 94

def user_tilde(path)
  home = Dir.home
  if path == home
    "~"
  else
    path.gsub(%r{^#{home}/}, "~/")
  end
end

Class: Homebrew::Diagnostic::Checks Private

Overview

HELPERS collapse

Instance Method Summary collapse

Methods included from Utils::Output::Mixin

Methods included from SystemCommand::Mixin

Methods included from OS::Linux::Diagnostic::Checks

Methods included from OS::Mac::Diagnostic::Checks

Constructor Details

#initialize(verbose: true) ⇒ void

Instance Method Details

#__check_linked_brew!(formula) ⇒ Boolean

#__check_stray_files(dir, pattern, allow_list, message) ⇒ String?

#__tap_git_status(tap, path) ⇒ Finding?

#add_info(*args) ⇒ void

#all ⇒ Array<String>

#append_indented_list(list, string) ⇒ String

#broken_tap(tap) ⇒ Finding?

#build_error_checks ⇒ Array<String>

#build_from_source_checks ⇒ Array<String>

#cask_checks ⇒ Array<String>

#certificate_trust_check(cert_file, root_names:, advisory_url:, script:) ⇒ Finding?

#check_access_directories ⇒ Finding?

#check_brew_git_origin ⇒ Finding?

#check_brew_path ⇒ Finding?

#check_cask_corrupt_dirs ⇒ Finding?

#check_cask_deprecated_disabled ⇒ Finding?

#check_cask_environment_variables ⇒ Finding?

#check_cask_install_location ⇒ Finding?

#check_cask_load_path ⇒ Finding?

#check_cask_software_versions ⇒ Finding?

#check_cask_staging_location ⇒ Finding?

#check_cask_taps ⇒ Finding?

#check_cask_xattr ⇒ Finding?

#check_casktap_integrity ⇒ Finding?

#check_coretap_integrity ⇒ Finding?

#check_deleted_formula ⇒ Finding?

#check_deprecated_cask_taps ⇒ Finding?

#check_deprecated_disabled ⇒ Finding?

#check_deprecated_official_taps ⇒ Finding?

#check_exist_directories ⇒ Finding?

#check_for_broken_symlinks ⇒ Finding?

#check_for_duplicate_casks ⇒ Finding?

#check_for_duplicate_formulae ⇒ Finding?

#check_for_external_cmd_name_conflict ⇒ Finding?

#check_for_git ⇒ Finding?

#check_for_installed_developer_tools ⇒ Finding?

#check_for_nix_homebrew ⇒ Finding?

#check_for_non_prefixed_coreutils ⇒ Finding?

#check_for_other_frameworks ⇒ Finding?

#check_for_pydistutils_cfg_in_home ⇒ Finding?

#check_for_stray_dylibs ⇒ Finding?

#check_for_stray_headers ⇒ Finding?

#check_for_stray_las ⇒ Finding?

#check_for_stray_pcs ⇒ Finding?

#check_for_stray_static_libs ⇒ Finding?

#check_for_symlinked_cellar ⇒ Finding?

#check_for_tap_ruby_files_locations ⇒ Finding?

#check_for_unlinked_but_not_keg_only ⇒ Finding?

#check_for_unnecessary_cask_tap ⇒ Finding?

#check_for_unnecessary_core_tap ⇒ Finding?

#check_for_unreadable_installed_formula ⇒ Finding?

#check_git_config_in_sandbox ⇒ Finding?

#check_git_newline_settings ⇒ Finding?

#check_git_status ⇒ Array<Finding>

#check_git_version ⇒ Finding?

#check_github_api_tokens ⇒ Finding?

#check_homebrew_prefix ⇒ Finding?

#check_homebrew_repository_git_hooks ⇒ Finding?

#check_missing_deps ⇒ Finding?

#check_multiple_cellars ⇒ Finding?

#check_tap_git_branch ⇒ Finding?

#check_tmpdir ⇒ Finding?

#check_tmpdir_sticky_bit ⇒ Finding?

#check_tools ⇒ Array<Finding>

#check_untrusted_taps ⇒ Finding?

#check_user_path_1 ⇒ Finding?

#check_user_path_2 ⇒ Finding?

#check_user_path_3 ⇒ Finding?

#current_user ⇒ String

#initialize(verbose: true) ⇒ `void`

#__check_linked_brew!(formula) ⇒ `Boolean`

#__check_stray_files(dir, pattern, allow_list, message) ⇒ `String`^?

#__tap_git_status(tap, path) ⇒ `Finding`^?

#add_info(*args) ⇒ `void`

#all ⇒ `Array<String>`

#append_indented_list(list, string) ⇒ `String`

#broken_tap(tap) ⇒ `Finding`^?

#build_error_checks ⇒ `Array<String>`

#build_from_source_checks ⇒ `Array<String>`

#cask_checks ⇒ `Array<String>`

#certificate_trust_check(cert_file, root_names:, advisory_url:, script:) ⇒ `Finding`^?

#check_access_directories ⇒ `Finding`^?

#check_brew_git_origin ⇒ `Finding`^?

#check_brew_path ⇒ `Finding`^?

#check_cask_corrupt_dirs ⇒ `Finding`^?

#check_cask_deprecated_disabled ⇒ `Finding`^?

#check_cask_environment_variables ⇒ `Finding`^?

#check_cask_install_location ⇒ `Finding`^?

#check_cask_load_path ⇒ `Finding`^?

#check_cask_software_versions ⇒ `Finding`^?

#check_cask_staging_location ⇒ `Finding`^?

#check_cask_taps ⇒ `Finding`^?

#check_cask_xattr ⇒ `Finding`^?

#check_casktap_integrity ⇒ `Finding`^?

#check_coretap_integrity ⇒ `Finding`^?

#check_deleted_formula ⇒ `Finding`^?

#check_deprecated_cask_taps ⇒ `Finding`^?

#check_deprecated_disabled ⇒ `Finding`^?

#check_deprecated_official_taps ⇒ `Finding`^?

#check_exist_directories ⇒ `Finding`^?

#check_for_broken_symlinks ⇒ `Finding`^?

#check_for_duplicate_casks ⇒ `Finding`^?

#check_for_duplicate_formulae ⇒ `Finding`^?

#check_for_external_cmd_name_conflict ⇒ `Finding`^?

#check_for_git ⇒ `Finding`^?

#check_for_installed_developer_tools ⇒ `Finding`^?

#check_for_nix_homebrew ⇒ `Finding`^?

#check_for_non_prefixed_coreutils ⇒ `Finding`^?

#check_for_other_frameworks ⇒ `Finding`^?

#check_for_pydistutils_cfg_in_home ⇒ `Finding`^?

#check_for_stray_dylibs ⇒ `Finding`^?

#check_for_stray_headers ⇒ `Finding`^?

#check_for_stray_las ⇒ `Finding`^?

#check_for_stray_pcs ⇒ `Finding`^?

#check_for_stray_static_libs ⇒ `Finding`^?

#check_for_symlinked_cellar ⇒ `Finding`^?

#check_for_tap_ruby_files_locations ⇒ `Finding`^?

#check_for_unlinked_but_not_keg_only ⇒ `Finding`^?

#check_for_unnecessary_cask_tap ⇒ `Finding`^?

#check_for_unnecessary_core_tap ⇒ `Finding`^?

#check_for_unreadable_installed_formula ⇒ `Finding`^?

#check_git_config_in_sandbox ⇒ `Finding`^?

#check_git_newline_settings ⇒ `Finding`^?

#check_git_status ⇒ `Array<Finding>`

#check_git_version ⇒ `Finding`^?

#check_github_api_tokens ⇒ `Finding`^?

#check_homebrew_prefix ⇒ `Finding`^?

#check_homebrew_repository_git_hooks ⇒ `Finding`^?

#check_missing_deps ⇒ `Finding`^?

#check_multiple_cellars ⇒ `Finding`^?

#check_tap_git_branch ⇒ `Finding`^?

#check_tmpdir ⇒ `Finding`^?

#check_tmpdir_sticky_bit ⇒ `Finding`^?

#check_tools ⇒ `Array<Finding>`

#check_untrusted_taps ⇒ `Finding`^?

#check_user_path_1 ⇒ `Finding`^?

#check_user_path_2 ⇒ `Finding`^?

#check_user_path_3 ⇒ `Finding`^?

#current_user ⇒ `String`

#desired_git_remote?(url, desired_origin) ⇒ `Boolean`

#examine_git_origin(repository_path, desired_origin) ⇒ `Finding`^?

#fatal_build_from_source_checks ⇒ `Array<String>`

#fatal_preinstall_checks ⇒ `Array<String>`

#fatal_setup_build_environment_checks ⇒ `Array<String>`

#find_relative_paths(*relative_paths) ⇒ `void`

#macos_bottle_remediation(version, intel:) ⇒ `String`^?

#non_core_taps ⇒ `Array<Tap>`

#none_string ⇒ `String`^?

#preinstall_checks ⇒ `Array<String>`