Class: Formula Abstract Private

Inherits:
Object show all
Extended by:
APIHashable, BuildEnvironment::DSL, Cachable, Forwardable, OnSystem::MacOSAndLinux, T::Helpers, Utils::Output::Mixin
Includes:
Context, FileUtils, Homebrew::Livecheck::Constants, OS::Linux::Formula, OS::Mac::Formula, OnSystem::MacOSAndLinux, Utils::Output::Mixin, Utils::Shebang, Utils::Shell
Defined in:
formula.rb,
sorbet/rbi/dsl/formula.rbi

Overview

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

This class is abstract.

A formula provides instructions and metadata for Homebrew to install a piece of software. Every Homebrew formula is a Formula. All subclasses of Formula (and all Ruby classes) have to be named UpperCase and not-use-dashes. A formula specified in this-formula.rb should have a class named ThisFormula. Homebrew does enforce that the name of the file and the class correspond. Make sure you check with brew search that the name is free!

Example

class Wget < Formula homepage "https://www.gnu.org/software/wget/" url "https://ftp.gnu.org/gnu/wget/wget-1.15.tar.gz" sha256 "52126be8cf1bddd7536886e74c053ad7d0ed2aa89b4b630f76785bac21695fcd" def install system "./configure", "--prefix=#{prefix}" system "make", "install" end end

See Also:

Defined Under Namespace

Classes: FormulaConflict

Constant Summary

Constants included from Homebrew::Livecheck::Constants

Homebrew::Livecheck::Constants::LATEST_VERSION

Constants included from Utils::Shell

Utils::Shell::SHELL_PROFILE_MAP, Utils::Shell::UNSAFE_SHELL_CHAR

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from OnSystem::MacOSAndLinux

included, on_arch_conditional, on_macos, on_system_conditional

Methods included from BuildEnvironment::DSL

inherited

Methods included from Cachable

cache

Methods included from APIHashable

generated_hash!, generating_hash!, generating_hash?

Methods included from Utils::Output::Mixin

odebug, odeprecated, odie, odisabled, ofail, oh1, oh1_title, ohai, ohai_title, onoe, opoo, opoo_outside_github_actions, pretty_duration, pretty_installed, pretty_outdated, pretty_uninstalled

Methods included from Context

current, current=, #debug?, #quiet?, #verbose?, #with_context

Methods included from Utils::Shell

csh_quote, export_value, from_path, parent, preferred, preferred_path, prepend_path_in_profile, profile, set_variable_in_profile, sh_quote, shell_with_prompt

Methods included from Utils::Shebang

rewrite_shebang

Constructor Details

#initialize(name, path, spec, alias_path: nil, tap: nil, force_bottle: 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.

Parameters:

  • name (String)
  • path (Pathname)
  • spec (Symbol)
  • alias_path (Pathname, nil) (defaults to: nil)
  • tap (Tap, nil) (defaults to: nil)
  • force_bottle (Boolean) (defaults to: false) 
 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
 
# File 'formula.rb', line 238 def initialize(name, path, spec, alias_path: nil, tap: nil, force_bottle: false) # Only allow instances of subclasses. The base class does not hold any spec information (URLs etc).  raise "Do not call `Formula.new' directly without a subclass." unless self.class < Formula # Stop any subsequent modification of a formula's definition.  # Changes do not propagate to existing instances of formulae.  # Now that we have an instance, it's too late to make any changes to the class-level definition.  self.class.freeze @name = T.let(name, String) @unresolved_path = T.let(path, Pathname) @path = T.let(path.resolved_path, Pathname) @alias_path = T.let(alias_path, T.nilable(Pathname)) @alias_name = T.let((File.basename(alias_path) if alias_path), T.nilable(String)) @revision = T.let(self.class.revision || 0, Integer) @version_scheme = T.let(self.class.version_scheme || 0, Integer) @compatibility_version = T.let(self.class.compatibility_version, T.nilable(Integer)) @head = T.let(nil, T.nilable(SoftwareSpec)) @stable = T.let(nil, T.nilable(SoftwareSpec)) @autobump = T.let(true, T::Boolean) @no_autobump_message = T.let(nil, T.nilable(T.any(String, Symbol))) @force_bottle = T.let(force_bottle, T::Boolean) @tap = T.let(tap, T.nilable(Tap)) @tap ||= if path == Formulary.core_path(name) CoreTap.instance else Tap.from_path(path) end @full_name = T.let(T.must(full_name_with_optional_tap(name)), String) @full_alias_name = T.let(full_name_with_optional_tap(@alias_name), T.nilable(String)) self.class.spec_syms.each do |sym| spec_eval sym end @active_spec = T.let(determine_active_spec(spec), SoftwareSpec) @active_spec_sym = T.let(head? ? :head : :stable, Symbol) validate_attributes! @build = T.let(active_spec.build, T.any(BuildOptions, Tab)) @pin = T.let(FormulaPin.new(self), FormulaPin) @follow_installed_alias = T.let(true, T::Boolean) @prefix_returns_versioned_prefix = T.let(false, T.nilable(T::Boolean)) @oldname_locks = T.let([], T::Array[FormulaLock]) @on_system_blocks_exist = T.let(false, T::Boolean) @fully_loaded_formula = T.let(nil, T.nilable(Formula)) end

Class Attribute Details

.api_source ⇒ Hash{String => T.untyped}? (readonly)

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.

Whether this formula was loaded using the formulae.brew.sh API.

Returns:

 3456 3457 3458
 
# File 'formula.rb', line 3456 def api_source @api_source end

.conflicts ⇒ Array<FormulaConflict>? (readonly)

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:

 3664 3665 3666
 
# File 'formula.rb', line 3664 def conflicts @conflicts end

.deprecation_date ⇒ Date? (readonly)

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 date of deprecation of a Formula.

Returns:

  • (Date, nil) —

    if no date is specified.

See Also:

 4547 4548 4549
 
# File 'formula.rb', line 4547 def deprecation_date @deprecation_date end

.deprecation_reason ⇒ String, ... (readonly)

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 reason for deprecation of a Formula.

Returns:

  • (String, Symbol, nil) —

    if no reason was provided or the formula is not deprecated.

See Also:

 4554 4555 4556
 
# File 'formula.rb', line 4554 def deprecation_reason @deprecation_reason end

.deprecation_replacement_cask ⇒ String? (readonly)

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 replacement cask for a deprecated Formula.

Returns:

  • (String, nil) —

    if no replacement was provided or the formula is not deprecated.

See Also:

 4568 4569 4570
 
# File 'formula.rb', line 4568 def deprecation_replacement_cask @deprecation_replacement_cask end

.deprecation_replacement_formula ⇒ String? (readonly)

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 replacement formula for a deprecated Formula.

Returns:

  • (String, nil) —

    if no replacement was provided or the formula is not deprecated.

See Also:

 4561 4562 4563
 
# File 'formula.rb', line 4561 def deprecation_replacement_formula @deprecation_replacement_formula end

.disable_date ⇒ Date? (readonly)

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 date that this Formula was or becomes disabled. Returns nil if no date is specified.

Returns:

  • (Date, nil)

See Also:

 4646 4647 4648
 
# File 'formula.rb', line 4646 def disable_date @disable_date end

.disable_reason ⇒ String, ... (readonly)

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 reason this Formula is disabled. Returns nil if no reason was provided or the formula is not disabled.

Returns:

See Also:

 4653 4654 4655
 
# File 'formula.rb', line 4653 def disable_reason @disable_reason end

.disable_replacement_cask ⇒ String? (readonly)

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 replacement cask for a disabled Formula. Returns nil if no reason was provided or the formula is not disabled.

Returns:

See Also:

 4667 4668 4669
 
# File 'formula.rb', line 4667 def disable_replacement_cask @disable_replacement_cask end

.disable_replacement_formula ⇒ String? (readonly)

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 replacement formula for a disabled Formula. Returns nil if no reason was provided or the formula is not disabled.

Returns:

See Also:

 4660 4661 4662
 
# File 'formula.rb', line 4660 def disable_replacement_formula @disable_replacement_formula end

.keg_only_reason ⇒ KegOnlyReason? (readonly)

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 reason for why this software is not linked (by default) to HOMEBREW_PREFIX.

Returns:

 3465 3466 3467
 
# File 'formula.rb', line 3465 def keg_only_reason @keg_only_reason end

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:

 3670 3671 3672
 
# File 'formula.rb', line 3670 def link_overwrite_paths @link_overwrite_paths end

.no_autobump_message ⇒ String, ... (readonly)

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.

Message that explains why the formula was excluded from the autobump list. Returns nil if no message is specified.

Returns:

See Also:

 4386 4387 4388
 
# File 'formula.rb', line 4386 def no_autobump_message @no_autobump_message end

.pour_bottle_check_unsatisfied_reason ⇒ 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.

If pour_bottle? returns false: the user-visible reason to display for why they cannot use the bottle.

Returns:

 3678 3679 3680
 
# File 'formula.rb', line 3678 def pour_bottle_check_unsatisfied_reason @pour_bottle_check_unsatisfied_reason end

.pour_bottle_only_if ⇒ Symbol? (readonly)

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:

 3673 3674 3675
 
# File 'formula.rb', line 3673 def pour_bottle_only_if @pour_bottle_only_if end

.skip_clean_paths ⇒ Set<String, Symbol>? (readonly)

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:

 3667 3668 3669
 
# File 'formula.rb', line 3667 def skip_clean_paths @skip_clean_paths end

Instance Attribute Details

#active_log_type ⇒ String? (readonly)

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.

When performing a build, test, or other loggable action, indicates which log file location to use.

Returns:

 213 214 215
 
# File 'formula.rb', line 213 def active_log_type @active_log_type end

#active_spec=(spec_sym) ⇒ 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:

Raises:

 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
 
# File 'formula.rb', line 290 def active_spec=(spec_sym) spec = send(spec_sym) raise FormulaSpecificationError, "#{spec_sym} spec is not available for #{full_name}" unless spec old_spec_sym = @active_spec_sym @active_spec = spec @active_spec_sym = spec_sym validate_attributes! @build = active_spec.build return if spec_sym == old_spec_sym Dependency.clear_cache Requirement.clear_cache end

#active_spec_sym ⇒ Symbol (readonly)

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.

A symbol to indicate currently active SoftwareSpec. It's either :stable or :head.

Returns:

See Also:

  • #active_spec
 173 174 175
 
# File 'formula.rb', line 173 def active_spec_sym @active_spec_sym end

#alias_name ⇒ String? (readonly)

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 name of the alias that was used to identify this Formula. e.g. another-name-for-this-formula

Returns:

 114 115 116
 
# File 'formula.rb', line 114 def alias_name @alias_name end

#alias_path ⇒ Pathname? (readonly)

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 path to the alias that was used to identify this Formula. e.g. /usr/local/Library/Taps/homebrew/homebrew-core/Aliases/another-name-for-this-formula

Returns:

 109 110 111
 
# File 'formula.rb', line 109 def alias_path @alias_path end

#build ⇒ BuildOptions, Tab

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 BuildOptions or Tab for this Formula. Lists the arguments passed and any options in the Formula. Note that these may differ at different times during the installation of a Formula. This is annoying but is the result of state that we're trying to eliminate.

Returns:

 220 221 222
 
# File 'formula.rb', line 220 def build @build end

#buildpath ⇒ Pathname? (readonly)

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 current working directory during builds. Will only be non-nil inside #install.

Returns:

 198 199 200
 
# File 'formula.rb', line 198 def buildpath @buildpath end

#compatibility_version ⇒ Integer? (readonly)

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.

Used to indicate API/ABI compatibility for dependencies.

Returns:

  • (Integer, nil)

See Also:

  • compatibility_version=
 193 194 195
 
# File 'formula.rb', line 193 def compatibility_version @compatibility_version end

#follow_installed_alias ⇒ Boolean Also known as: follow_installed_alias?

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.

Whether this formula should be considered outdated if the target of the alias it was installed with has since changed. Defaults to true.

Returns:

  • (Boolean) 
 226 227 228
 
# File 'formula.rb', line 226 def follow_installed_alias @follow_installed_alias end

#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.

Whether or not to force the use of a bottle.

Returns:

  • (Boolean) 
 232 233 234
 
# File 'formula.rb', line 232 def force_bottle @force_bottle end

#full_alias_name ⇒ String? (readonly)

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 fully-qualified alias referring to this Formula. For core formulae it's the same as #alias_name. e.g. homebrew/tap-name/another-name-for-this-formula

Returns:

 128 129 130
 
# File 'formula.rb', line 128 def full_alias_name @full_alias_name end

#full_name ⇒ String (readonly)

The fully-qualified name of this Formula. For core formulae it's the same as #name. e.g. homebrew/tap-name/this-formula

Returns:

 122 123 124
 
# File 'formula.rb', line 122 def full_name @full_name end

#head ⇒ SoftwareSpec? (readonly)

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 HEAD SoftwareSpec for this Formula. Installed when using brew install --HEAD. This is always installed with the version HEAD and taken from the latest commit in the version control system. nil if there is no HEAD version.

Returns:

See Also:

 160 161 162
 
# File 'formula.rb', line 160 def head @head end

#local_bottle_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.

When installing a bottle (binary package) from a local path this will be set to the full path to the bottle tarball. If not, it will be nil.

Returns:

 208 209 210
 
# File 'formula.rb', line 208 def local_bottle_path @local_bottle_path end

#name ⇒ String (readonly)

The name of this Formula. e.g. this-formula

Returns:

 104 105 106
 
# File 'formula.rb', line 104 def name @name end

#path ⇒ Pathname (readonly)

The full path to this Formula. e.g. /usr/local/Library/Taps/homebrew/homebrew-core/Formula/t/this-formula.rb

Returns:

 135 136 137
 
# File 'formula.rb', line 135 def path @path end

#pinned? ⇒ Boolean (readonly)

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 1809
 
# File 'formula.rb', line 1809 delegate pinned?: :@pin

#revision ⇒ Integer (readonly)

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.

Used for creating new Homebrew versions of software without new upstream versions.

Returns:

  • (Integer)

See Also:

  • revision=
 183 184 185
 
# File 'formula.rb', line 183 def revision @revision end

#source_modified_time ⇒ Time? (readonly)

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 most recent modified time for source files.

Returns:

 177 178 179
 
# File 'formula.rb', line 177 def source_modified_time @source_modified_time end

#stable ⇒ SoftwareSpec? (readonly)

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

The stable (and default) SoftwareSpec for this Formula. This contains all the attributes (e.g. URL, checksum) that apply to the stable version of this formula.

Returns:

 150 151 152
 
# File 'formula.rb', line 150 def stable @stable end

#tap ⇒ Tap? (readonly)

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

The Tap instance associated with this Formula. If it's nil, then this formula is loaded from a path or URL.

Returns:

 142 143 144
 
# File 'formula.rb', line 142 def tap @tap end

#testpath ⇒ Pathname? (readonly)

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 current working directory during tests. Will only be non-nil inside test.

Returns:

 203 204 205
 
# File 'formula.rb', line 203 def testpath @testpath end

#version_scheme ⇒ Integer (readonly)

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.

Used to change version schemes for packages.

Returns:

  • (Integer)

See Also:

  • version_scheme=
 188 189 190
 
# File 'formula.rb', line 188 def version_scheme @version_scheme end

Class Method Details

.[](name) ⇒ 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:

Returns:

 2391 2392 2393
 
# File 'formula.rb', line 2391 def self.[](name) Formulary.factory(name) end

.alias_full_names ⇒ 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.

An array of all aliases as fully-qualified names.

Returns:

 2378 2379 2380
 
# File 'formula.rb', line 2378 def self.alias_full_names @alias_full_names ||= T.let(core_aliases + tap_aliases, T.nilable(T::Array[String])) end

.aliases ⇒ 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.

An array of all aliases.

Returns:

 2370 2371 2372 2373 2374
 
# File 'formula.rb', line 2370 def self.aliases @aliases ||= T.let((core_aliases + tap_aliases.map do |name| name.split("/").fetch(-1) end).uniq.sort, T.nilable(T::Array[String])) end

.all(eval_all: false) ⇒ 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.

An array of each known Formula. Can only be used when users specify --eval-all with a command or set HOMEBREW_EVAL_ALL=1.

Parameters:

  • eval_all (Boolean) (defaults to: false)

Returns:

 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
 
# File 'formula.rb', line 2299 def self.all(eval_all: false) if !eval_all && !Homebrew::EnvConfig.eval_all? raise ArgumentError, "Formula#all cannot be used without `--eval-all` or `HOMEBREW_EVAL_ALL=1`" end (core_names + tap_files).filter_map do |name_or_file| Formulary.factory(name_or_file) rescue FormulaUnavailableError, FormulaUnreadableError => e # Don't let one broken formula break commands. But do complain.  onoe "Failed to import: #{name_or_file}" $stderr.puts e nil end end

.allow_network_access!(phases = []) ⇒ 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.

The phases for which network access is allowed. By default, network access is allowed for all phases. Valid phases are :build, :test, and :postinstall. When no argument is passed, network access will be allowed for all phases.

Examples

allow_network_access! 
allow_network_access! :build 
allow_network_access! [:build, :test]

Parameters:

 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
 
# File 'formula.rb', line 3563 def allow_network_access!(phases = []) phases_array = Array(phases) if phases_array.empty? network_access_allowed.each_key { |phase| network_access_allowed[phase] = true } else phases_array.each do |phase| raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase) network_access_allowed[phase] = true end end end

.autobump? ⇒ 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.

Is the formula in the autobump list?

Returns:

  • (Boolean) 
 4373 4374 4375
 
# File 'formula.rb', line 4373 def autobump? @autobump != false # @autobump may be `nil` end

.bottle(&block) ⇒ void

This method returns an undefined value.

Adds a bottle SoftwareSpec. This provides a pre-built binary package built by the Homebrew maintainers for you. It will be installed automatically if there is a binary package for your platform and you haven't passed or previously used any options on this formula.

If you maintain your own repository, you can add your own bottle links. You can ignore this block entirely if submitting to Homebrew/homebrew-core. It'll be handled for you by the Brew Test Bot.

bottle do root_url "https://example.com" # Optional root to calculate bottle URLs.  rebuild 1 # Marks the old bottle as outdated without bumping the version/revision of the formula.  # Optionally specify the HOMEBREW_CELLAR in which the bottles were built.  sha256 cellar: "/brew/Cellar", catalina: "ef65c759c5097a36323fa9c77756468649e8d1980a3a4e05695c05e39568967c" sha256 cellar: :any, mojave: "28f4090610946a4eb207df102d841de23ced0d06ba31cb79e040d883906dcd4f" sha256 high_sierra: "91dd0caca9bd3f38c439d5a7b6f68440c4274945615fae035ff0a369264b8a2f" end

Homebrew maintainers aim to bottle all formulae.

Parameters:

See Also:

 3846
 
# File 'formula.rb', line 3846 def bottle(&block) = stable.bottle(&block)

.build ⇒ 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.

Returns:

 3849
 
# File 'formula.rb', line 3849 def build = stable.build

.build_flags ⇒ 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.

Get the BUILD_FLAGS from the formula's namespace set in Formulary::load_formula.

Returns:

 3853 3854 3855 3856 3857 3858 3859
 
# File 'formula.rb', line 3853 def build_flags namespace = T.must(to_s.split("::")[0..-2]).join("::") return [] if namespace.empty? mod = const_get(namespace) mod.const_get(:BUILD_FLAGS) end

.compatibility_version(val = T.unsafe(nil)) ⇒ Integer?

Used to indicate API/ABI compatibility for dependencies. If a formula has a compatibility_version of 1, then it need not be upgraded when installing or upgrading dependencies as long as dependencies are known to work with versions of the formula that have compatibility_version 1. nil if unset.

Example

compatibility_version 1

Parameters:

  • val (Integer) (defaults to: T.unsafe(nil))

Returns:

  • (Integer, nil) 
 3732 3733 3734
 
# File 'formula.rb', line 3732 def compatibility_version(val = T.unsafe(nil)) val.nil? ? @compatibility_version : @compatibility_version = T.let(val, T.nilable(Integer)) end

.conflicts_with(*names) ⇒ void

This method returns an undefined value.

One or more formulae that conflict with this one and why.

Example

conflicts_with "imagemagick", because: "both install `convert` binaries"

Parameters:

  • names (T.untyped) 
 4141 4142 4143 4144
 
# File 'formula.rb', line 4141 def conflicts_with(*names) opts = T.let(names.last.is_a?(Hash) ? names.pop : {}, T::Hash[Symbol, T.untyped]) names.each { |name| T.must(conflicts) << FormulaConflict.new(name, opts[:because]) } end

.core_alias_files ⇒ Array<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.

An array of all alias files of core Formulae.

Returns:

 2352 2353 2354
 
# File 'formula.rb', line 2352 def self.core_alias_files CoreTap.instance.alias_files end

.core_aliases ⇒ 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.

An array of all core aliases.

Returns:

 2358 2359 2360
 
# File 'formula.rb', line 2358 def self.core_aliases CoreTap.instance.aliases end

.core_names ⇒ 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.

An array of all core Formula names.

Returns:

 2266 2267 2268
 
# File 'formula.rb', line 2266 def self.core_names CoreTap.instance.formula_names end

.cxxstdlib_check(check_type) ⇒ void

This method returns an undefined value.

Pass :skip to this method to disable post-install stdlib checking.

Parameters:

 4233 4234 4235 4236
 
# File 'formula.rb', line 4233 def cxxstdlib_check(check_type) # odeprecated "`cxxstdlib_check :skip`"  define_method(:skip_cxxstdlib_check?) { true } if check_type == :skip end

.deny_network_access!(phases = []) ⇒ 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.

The phases for which network access is denied. By default, network access is allowed for all phases. Valid phases are :build, :test, and :postinstall. When no argument is passed, network access will be denied for all phases.

Examples

deny_network_access! 
deny_network_access! :build 
deny_network_access! [:build, :test]

Parameters:

 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606
 
# File 'formula.rb', line 3595 def deny_network_access!(phases = []) phases_array = Array(phases) if phases_array.empty? network_access_allowed.each_key { |phase| network_access_allowed[phase] = false } else phases_array.each do |phase| raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase) network_access_allowed[phase] = false end end end

.depends_on(dep) ⇒ void

This method returns an undefined value.

The dependencies for this formula. Use strings for the names of other formulae. Homebrew provides some :special Requirements for stuff that needs extra handling (often changing some ENV vars or deciding whether to use the system provided version).

Examples

:build means this dependency is only needed during build.

depends_on "cmake" => :build

:test means this dependency is only needed during testing.

depends_on "node" => :test

:recommended dependencies are built by default. But a --without-... option is generated to opt-out.

depends_on "readline" => :recommended

:optional dependencies are NOT built by default unless the auto-generated --with-... option is passed.

depends_on "glib" => :optional

If you need to specify that another formula has to be built with/out certain options (note, no -- needed before the option):

depends_on "zeromq" => "with-pgm" depends_on "qt" => ["with-qtdbus", "developer"] # Multiple options.

Optional and enforce that "boost" is built using --with-c++11.

depends_on "boost" => [:optional, "with-c++11"]

If a dependency is only needed in certain cases:

depends_on "sqlite" if MacOS.version >= :catalina depends_on xcode: :build # If the formula really needs full Xcode to compile. depends_on macos: :mojave # Needs at least macOS Mojave (10.14) to run.

It is possible to only depend on something if build.with? or build.without? "another_formula":

depends_on "postgresql" if build.without? "sqlite"

Parameters:

 4007 4008 4009
 
# File 'formula.rb', line 4007 def depends_on(dep) specs.each { |spec| spec.depends_on(dep) } end

.deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) ⇒ void

TODO:

replace legacy replacement with replacement_formula or replacement_cask

This method returns an undefined value.

Deprecates a Formula (on the given date) so a warning is shown on each installation. If the date has not yet passed the formula will not be deprecated.

Examples

deprecate! date: "2020-08-27", because: :unmaintained 
deprecate! date: "2020-08-27", because: "has been replaced by foo" 
deprecate! date: "2020-08-27", because: "has been replaced by foo", replacement_formula: "foo" 
deprecate! date: "2020-08-27", because: "has been replaced by foo", replacement_cask: "foo"

Parameters:

  • date (String)
  • because (String, Symbol, nil)
  • replacement (String, nil) (defaults to: nil)
  • replacement_formula (String, nil) (defaults to: nil)
  • replacement_cask (String, nil) (defaults to: nil)

See Also:

 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531
 
# File 'formula.rb', line 4512 def deprecate!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1 raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!" end if replacement odeprecated( "deprecate!(:replacement)", "deprecate!(:replacement_formula) or deprecate!(:replacement_cask)", ) end @deprecation_date = T.let(Date.parse(date), T.nilable(Date)) return if T.must(@deprecation_date) > Date.today @deprecation_reason = T.let(because, T.nilable(T.any(String, Symbol))) @deprecation_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String)) @deprecation_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String)) T.must(@deprecated = T.let(true, T.nilable(T::Boolean))) end

.deprecated? ⇒ 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.

Whether this Formula is deprecated (i.e. warns on installation). Defaults to false.

Returns:

  • (Boolean)

See Also:

 4538 4539 4540
 
# File 'formula.rb', line 4538 def deprecated? @deprecated == true end

.deprecated_option(hash) ⇒ void

This method returns an undefined value.

Deprecated options are used to rename options and migrate users who used them to newer ones. They are mostly used for migrating non-with options (e.g. enable-debug) to with options (e.g. with-debug).

Example

deprecated_option "enable-debug" => "with-debug"

Parameters:

 4070 4071 4072
 
# File 'formula.rb', line 4070 def deprecated_option(hash) specs.each { |spec| spec.deprecated_option(hash) } end

.desc(val = T.unsafe(nil)) ⇒ String?

A one-line description of the software. Used by users to get an overview of the software and Homebrew maintainers. Shows when running brew info.

Example

desc "Example formula"

Parameters:

  • val (String) (defaults to: T.unsafe(nil))

Returns:

 3479 3480 3481
 
# File 'formula.rb', line 3479 def desc(val = T.unsafe(nil)) val.nil? ? @desc : @desc = T.let(val, T.nilable(String)) end

.disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) ⇒ void

TODO:

replace legacy replacement with replacement_formula or replacement_cask

This method returns an undefined value.

Disables a Formula (on the given date) so it cannot be installed. If the date has not yet passed the formula will be deprecated instead of disabled.

Examples

disable! date: "2020-08-27", because: :does_not_build 
disable! date: "2020-08-27", because: "has been replaced by foo" 
disable! date: "2020-08-27", because: "has been replaced by foo", replacement_formula: "foo" 
disable! date: "2020-08-27", because: "has been replaced by foo", replacement_cask: "foo"

Parameters:

  • date (String)
  • because (String, Symbol, nil)
  • replacement (String, nil) (defaults to: nil)
  • replacement_formula (String, nil) (defaults to: nil)
  • replacement_cask (String, nil) (defaults to: nil)

See Also:

 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630
 
# File 'formula.rb', line 4604 def disable!(date:, because:, replacement: nil, replacement_formula: nil, replacement_cask: nil) if [replacement, replacement_formula, replacement_cask].filter_map(&:presence).length > 1 raise ArgumentError, "more than one of replacement, replacement_formula and/or replacement_cask specified!" end if replacement odeprecated( "disable!(:replacement)", "disable!(:replacement_formula) or deprecate!(:replacement_cask)", ) end @disable_date = T.let(Date.parse(date), T.nilable(Date)) if T.must(@disable_date) > Date.today @deprecation_reason = T.let(because, T.nilable(T.any(String, Symbol))) @deprecation_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String)) @deprecation_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String)) @deprecated = T.let(true, T.nilable(T::Boolean)) return end @disable_reason = T.let(because, T.nilable(T.any(String, Symbol))) @disable_replacement_formula = T.let(replacement_formula.presence || replacement, T.nilable(String)) @disable_replacement_cask = T.let(replacement_cask.presence || replacement, T.nilable(String)) @disabled = T.let(true, T.nilable(T::Boolean)) end

.disabled? ⇒ 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.

Whether this Formula is disabled (i.e. cannot be installed). Defaults to false.

Returns:

  • (Boolean)

See Also:

 4637 4638 4639
 
# File 'formula.rb', line 4637 def disabled? @disabled == true end

.fails_with(compiler, &block) ⇒ void

This method returns an undefined value.

Marks the Formula as failing with a particular compiler so it will fall back to others.

Examples

For Apple compilers, this should be in the format:

fails_with :clang do build 600 cause "multiple configure and compile errors" end

The block may be omitted and if present, the build may be omitted; if so, then the compiler will not be allowed for all versions.

major_version should be the major release number only, for instance '7' for the GCC 7 series (7.0, 7.1, etc.). If version or the block is omitted, then the compiler will not be allowed for all compilers in that series.

For example, if a bug is only triggered on GCC 7.1 but is not encountered on 7.2:

fails_with :gcc => '7' do version '7.1' end

Parameters:

 4270 4271 4272
 
# File 'formula.rb', line 4270 def fails_with(compiler, &block) specs.each { |spec| spec.fails_with(compiler, &block) } end

.freeze ⇒ T.self_type

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:

  • (T.self_type) 
 3433 3434 3435 3436 3437 3438 3439 3440 3441
 
# File 'formula.rb', line 3433 def freeze specs.each(&:freeze) @livecheck.freeze @conflicts.freeze @skip_clean_paths.freeze @link_overwrite_paths.freeze @preserve_rpath&.freeze super end

.full_names ⇒ 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.

An array of all Formula names, which the tap formulae have as the fully-qualified name.

Returns:

 2292 2293 2294
 
# File 'formula.rb', line 2292 def self.full_names @full_names ||= T.let(core_names + tap_names, T.nilable(T::Array[String])) end

.fuzzy_search(name) ⇒ 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 a list of approximately matching formula names, but not the complete match.

Parameters:

Returns:

 2384 2385 2386 2387 2388
 
# File 'formula.rb', line 2384 def self.fuzzy_search(name) @spell_checker ||= T.let(DidYouMean::SpellChecker.new(dictionary: Set.new(names + full_names).to_a), T.nilable(DidYouMean::SpellChecker)) T.cast(@spell_checker.correct(name), T::Array[String]) end

.head(val = nil, specs = {}, &block) ⇒ T.untyped

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.

Adds a head SoftwareSpec. This can be installed by passing the --HEAD option to allow installing software directly from a branch of a version-control repository. If called as a method this provides just the url for the SoftwareSpec. If a block is provided you can also add depends_on and Patches just to the head SoftwareSpec. The download strategies (e.g. :using =>) are the same as for url. Git repositories must always specify branch:.

Example

head "https://we.prefer.https.over.git.example.com/.git", branch: "main" 
head "https://example.com/.git", branch: "name_of_branch"

or (if autodetect fails):

head "https://hg.is.awesome.but.git.has.won.example.com/", using: :hg

Parameters:

  • val (String, nil) (defaults to: nil)
  • specs (Hash{Symbol => T.untyped}) (defaults to: {})
  • block (T.proc.void, nil)

Returns:

  • (T.untyped) 
 3912 3913 3914 3915 3916 3917 3918 3919 3920
 
# File 'formula.rb', line 3912 def head(val = nil, specs = {}, &block) if block T.must(@head).instance_eval(&block) elsif val T.must(@head).url(val, specs) else @head end end

.homepage(val = T.unsafe(nil)) ⇒ String?

The homepage for the software. Used by users to get more information about the software and Homebrew maintainers as a point of contact for e.g. submitting patches. Can be opened with running brew home.

Example

homepage "https://www.example.com"

Parameters:

  • val (String) (defaults to: T.unsafe(nil))

Returns:

 3630 3631 3632
 
# File 'formula.rb', line 3630 def homepage(val = T.unsafe(nil)) val.nil? ? @homepage : @homepage = T.let(val, T.nilable(String)) end

.inherited(child) ⇒ 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.

Initialise instance variables for each subclass. These need to be initialised before the class is frozen, and some DSL may never be called so it can't be done lazily.

Parameters:

 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
 
# File 'formula.rb', line 3411 def inherited(child) super child.instance_eval do # Ensure this is synced with `freeze`  @stable = T.let(SoftwareSpec.new(flags: build_flags), T.nilable(SoftwareSpec)) @head = T.let(HeadSoftwareSpec.new(flags: build_flags), T.nilable(HeadSoftwareSpec)) @livecheck = T.let(Livecheck.new(self), T.nilable(Livecheck)) @conflicts = T.let([], T.nilable(T::Array[FormulaConflict])) @skip_clean_paths = T.let(Set.new, T.nilable(T::Set[T.any(String, Symbol)])) @link_overwrite_paths = T.let(Set.new, T.nilable(T::Set[String])) @loaded_from_api = T.let(false, T.nilable(T::Boolean)) @loaded_from_stub = T.let(false, T.nilable(T::Boolean)) @api_source = T.let(nil, T.nilable(T::Hash[String, T.untyped])) @on_system_blocks_exist = T.let(false, T.nilable(T::Boolean)) @network_access_allowed = T.let(SUPPORTED_NETWORK_ACCESS_PHASES.to_h do |phase| [phase, DEFAULT_NETWORK_ACCESS_ALLOWED] end, T.nilable(T::Hash[Symbol, T::Boolean])) @preserve_rpath = T.let(false, T.nilable(T::Boolean)) end end

.installed ⇒ 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.

An array of all installed Formulae.

Returns:

 2335 2336 2337 2338 2339 2340 2341
 
# File 'formula.rb', line 2335 def self.installed Formula.cache[:installed] ||= racks.flat_map do |rack| Formulary.from_rack(rack) rescue [] end.uniq(&:name) end

.installed_formula_names ⇒ 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.

An array of all currently installed formula names.

Returns:

 2329 2330 2331
 
# File 'formula.rb', line 2329 def self.installed_formula_names racks.map { |rack| rack.basename.to_s } end

.installed_with_alias_path(alias_path) ⇒ 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:

Returns:

 2344 2345 2346 2347 2348
 
# File 'formula.rb', line 2344 def self.installed_with_alias_path(alias_path) return [] if alias_path.nil? installed.select { |f| f.installed_alias_path == alias_path } end

.keg_only(reason, explanation = "") ⇒ void

This method returns an undefined value.

Software that will not be symlinked into the brew --prefix and will only live in its Cellar. Other formulae can depend on it and Homebrew will add the necessary includes, libraries and other paths while building that other formula.

Keg-only formulae are not in your PATH and are not seen by compilers if you build your own software outside of Homebrew. This way, we don't shadow software provided by macOS.

Examples

keg_only :provided_by_macos 
keg_only :versioned_formulae 
keg_only "because I want it so"

Parameters:

 4225 4226 4227
 
# File 'formula.rb', line 4225 def keg_only(reason, explanation = "") @keg_only_reason = T.let(KegOnlyReason.new(reason, explanation), T.nilable(KegOnlyReason)) end

.license(args = nil) ⇒ String, ...

The SPDX ID of the open-source license that the formula uses. Shows when running brew info.

Use :any_of, :all_of or :with to describe complex license expressions. :any_of should be used when the user can choose which license to use. :all_of should be used when the user must use all licenses. :with should be used to specify a valid SPDX exception.

Add + to an identifier to indicate that the formula can be licensed under later versions of the same license.

Examples

license "BSD-2-Clause" 
license "EPL-1.0+" 
license any_of: ["MIT", "GPL-2.0-only"] 
license all_of: ["MIT", "GPL-2.0-only"] 
license "GPL-2.0-only" => { with: "LLVM-exception" } 
license :public_domain 
license any_of: [ "MIT", :public_domain, all_of: ["0BSD", "Zlib", "Artistic-1.0+"], "Apache-2.0" => { with: "LLVM-exception" }, ]

Parameters:

Returns:

See Also:

 3536 3537 3538 3539 3540 3541 3542
 
# File 'formula.rb', line 3536 def license(args = nil) if args.nil? @licenses else @licenses = T.let(args, T.nilable(T.any(String, Symbol, T::Hash[T.any(String, Symbol), T.anything]))) end end

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.

Permit overwriting certain files while linking.

Examples

Sometimes we accidentally install files outside the prefix. Once we fix that, users will get a link conflict error. Overwrite those files with:

link_overwrite "bin/foo", "lib/bar" 
link_overwrite "share/man/man1/baz-*"

Parameters:

Returns:

 4684 4685 4686 4687
 
# File 'formula.rb', line 4684 def link_overwrite(*paths) paths.flatten! T.must(link_overwrite_paths).merge(paths) end

.livecheck(&block) ⇒ T.untyped

Livecheck can be used to check for newer versions of the software. This method evaluates the DSL specified in the livecheck block of the Formula (if it exists) and sets the instance variables of a Livecheck object accordingly. This is used by brew livecheck to check for newer versions of the software.

Example

livecheck do skip "Not maintained" url "https://example.com/foo/releases" regex /foo-(\d+(?:\.\d+)+)\.tar/ end

Parameters:

  • block (T.proc.bind(Livecheck).returns(T.untyped), nil)

Returns:

  • (T.untyped) 
 4347 4348 4349 4350 4351 4352
 
# File 'formula.rb', line 4347 def livecheck(&block) return @livecheck unless block @livecheck_defined = T.let(true, T.nilable(T::Boolean)) @livecheck.instance_eval(&block) end

.livecheck_defined? ⇒ 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.

Checks whether a livecheck specification is defined or not.

It returns true when a livecheck block is present in the Formula and false otherwise.

Returns:

  • (Boolean) 
 3639 3640 3641
 
# File 'formula.rb', line 3639 def livecheck_defined? @livecheck_defined == true end

.livecheckable? ⇒ 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.

Deprecated.

Use livecheck_defined? instead.

Checks whether a livecheck specification is defined or not. This is a legacy alias for #livecheck_defined?.

It returns true when a livecheck block is present in the Formula and false otherwise.

Returns:

  • (Boolean) 
 3649 3650 3651 3652
 
# File 'formula.rb', line 3649 def livecheckable? odisabled "`livecheckable?`", "`livecheck_defined?`" @livecheck_defined == true end

.loaded_from_api? ⇒ 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.

Whether this formula was loaded using the formulae.brew.sh API.

Returns:

  • (Boolean) 
 3448
 
# File 'formula.rb', line 3448 def loaded_from_api? = !!@loaded_from_api

.loaded_from_stub? ⇒ 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.

Whether this formula was loaded using the internal formulae.brew.sh API.

Returns:

  • (Boolean) 
 3452
 
# File 'formula.rb', line 3452 def loaded_from_stub? = !!@loaded_from_stub

.mirror(val) ⇒ void

This method returns an undefined value.

Additional URLs for the stable version of the formula. These are only used if the url fails to download. It's optional and there can be more than one. Generally we add them when the main url is unreliable. If url is really unreliable then we may swap the mirror and url.

Example

mirror "https://in.case.the.host.is.down.example.com" mirror "https://in.case.the.mirror.is.down.example.com

Parameters:

 3803
 
# File 'formula.rb', line 3803 def mirror(val) = stable.mirror(val)

.names ⇒ 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.

An array of all Formula names.

Returns:

 2284 2285 2286 2287 2288
 
# File 'formula.rb', line 2284 def self.names @names ||= T.let((core_names + tap_names.map do |name| name.split("/").fetch(-1) end).uniq.sort, T.nilable(T::Array[String])) end

.needs(*standards) ⇒ void

This method returns an undefined value.

Marks the Formula as needing a certain standard, so Homebrew will fall back to other compilers if the default compiler does not implement that standard.

We generally prefer to depends_on a desired compiler and to explicitly use that compiler in a formula's #install block, rather than implicitly finding a suitable compiler with needs.

Parameters:

See Also:

 4286 4287 4288
 
# File 'formula.rb', line 4286 def needs(*standards) specs.each { |spec| spec.needs(*standards) } end

.network_access_allowed ⇒ Hash{Symbol => 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:

 3444
 
# File 'formula.rb', line 3444 def network_access_allowed = T.must(@network_access_allowed)

.network_access_allowed?(phase) ⇒ 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.

Whether the specified phase should be forced offline.

Parameters:

Returns:

  • (Boolean)

Raises:

  • (ArgumentError) 
 3610 3611 3612 3613 3614 3615
 
# File 'formula.rb', line 3610 def network_access_allowed?(phase) raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase) env_var = Homebrew::EnvConfig.send(:"formula_#{phase}_network") env_var.nil? ? network_access_allowed[phase] : env_var == "allow" end

.no_autobump!(because:) ⇒ void

TODO:

limit this method to the official taps only (e.g. raise an error if !tap.official?)

This method returns an undefined value.

Exclude the formula from the autobump list.

Parameters:

 4361 4362 4363 4364 4365 4366 4367 4368 4369
 
# File 'formula.rb', line 4361 def no_autobump!(because:) if because.is_a?(Symbol) && !NO_AUTOBUMP_REASONS_LIST.key?(because) raise ArgumentError, "'because' argument should use valid symbol or a string!" end @no_autobump_defined = T.let(true, T.nilable(T::Boolean)) @no_autobump_message = T.let(because, T.nilable(T.any(String, Symbol))) @autobump = T.let(false, T.nilable(T::Boolean)) end

.no_autobump_defined? ⇒ 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.

Is a no_autobump! method defined?

Returns:

  • (Boolean) 
 4379
 
# File 'formula.rb', line 4379 def no_autobump_defined? = @no_autobump_defined == true

.on_system_blocks_exist? ⇒ 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.

Whether this formula contains OS/arch-specific blocks (e.g. on_macos, on_arm, on_monterey :or_older, on_system :linux, macos: :big_sur_or_newer).

Returns:

  • (Boolean) 
 3461
 
# File 'formula.rb', line 3461 def on_system_blocks_exist? = !!@on_system_blocks_exist

.option(name, description = "") ⇒ void

This method returns an undefined value.

Options can be used as arguments to brew install. To switch features on/off: "with-something" or "with-otherthing". To use other software: "with-other-software" or "without-foo". Note that for depends_on that are :optional or :recommended, options are generated automatically.

There are also some special options:

  • :universal: build a universal binary/library (e.g. on newer Intel Macs this means a combined x86_64/x86 binary/library).

Examples

option "with-spam", "The description goes here without a dot at the end" 
option "with-qt", "Text here overwrites what's autogenerated by 'depends_on "qt" => :optional'" 
option :universal

Parameters:

 4054 4055 4056
 
# File 'formula.rb', line 4054 def option(name, description = "") specs.each { |spec| spec.option(name, description) } end

.patch(strip = :p1, src = nil, &block) ⇒ void

This method returns an undefined value.

External patches can be declared using resource-style blocks.

Examples

patch do url "https://example.com/example_patch.diff" sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2" end

A strip level of -p1 is assumed. It can be overridden using a symbol argument:

patch :p0 do url "https://example.com/example_patch.diff" sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2" end

Patches can be declared in stable and head blocks. This form is preferred over using conditionals.

stable do patch do url "https://example.com/example_patch.diff" sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2" end end

Embedded (__END__) patches are declared like so:

patch :DATA patch :p0, :DATA

Patches can also be embedded by passing a string. This makes it possible to provide multiple embedded patches while making only some of them conditional.

patch :p0, "..."

Parameters:

See Also:

 4127 4128 4129
 
# File 'formula.rb', line 4127 def patch(strip = :p1, src = nil, &block) specs.each { |spec| spec.patch(strip, src, &block) } end

.pour_bottle?(only_if: nil, &block) ⇒ void

This method returns an undefined value.

Defines whether the Formula's bottle can be used on the given Homebrew installation.

Examples

If the bottle requires the Xcode CLT to be installed a Formula would declare:

pour_bottle? do reason "The bottle needs the Xcode CLT to be installed." satisfy { MacOS::CLT.installed? } end

If satisfy returns false then a bottle will not be used and instead the Formula will be built from source and reason will be printed.

Alternatively, a preset reason can be passed as a symbol:

pour_bottle? only_if: :clt_installed

Parameters:

  • only_if (Symbol, nil) (defaults to: nil)
  • block (T.proc.params(arg0: T.untyped).returns(T.any(T::Boolean, Symbol)), nil) 
 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
 
# File 'formula.rb', line 4440 def pour_bottle?(only_if: nil, &block) @pour_bottle_check = T.let(PourBottleCheck.new(self), T.nilable(PourBottleCheck)) @pour_bottle_only_if = T.let(only_if, T.nilable(Symbol)) if only_if.present? && block.present? raise ArgumentError, "Do not pass both a preset condition and a block to `pour_bottle?`" end block ||= case only_if when :clt_installed lambda do |_| on_macos do T.bind(self, PourBottleCheck) reason(+<<~EOS)  The bottle needs the Xcode Command Line Tools to be installed at /Library/Developer/CommandLineTools.  Development tools provided by Xcode.app are not sufficient.   You can install the Xcode Command Line Tools, if desired, with:  xcode-select --install  EOS  satisfy { MacOS::CLT.installed? } end end when :default_prefix lambda do |_| T.bind(self, PourBottleCheck) reason(<<~EOS)  The bottle (and many others) needs to be installed into #{Homebrew::DEFAULT_PREFIX}.  EOS  satisfy { HOMEBREW_PREFIX.to_s == Homebrew::DEFAULT_PREFIX } end else raise ArgumentError, "Invalid preset `pour_bottle?` condition" if only_if.present? end @pour_bottle_check.instance_eval(&T.unsafe(block)) end

.preserve_rpath(value: true) ⇒ Boolean

Preserve @rpath install names when fixing dynamic linkage on macOS.

By default, Homebrew rewrites library install names (including those starting with @rpath) to use absolute paths. This can break tools like macdeployqt that expect @rpath-based install names to remain unchanged.

Call this method to skip rewriting install names that start with @rpath.

Example

preserve_rpath

Parameters:

  • value (Boolean) (defaults to: true)

Returns:

  • (Boolean) 
 4188 4189 4190
 
# File 'formula.rb', line 4188 def preserve_rpath(value: true) @preserve_rpath = value end

.preserve_rpath? ⇒ Boolean

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Check if @rpath install names should be preserved.

Returns:

  • (Boolean) 
 4196 4197 4198
 
# File 'formula.rb', line 4196 def preserve_rpath? @preserve_rpath == true end

.racks ⇒ Array<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.

An array of all racks currently installed.

Returns:

 2317 2318 2319 2320 2321 2322 2323 2324 2325
 
# File 'formula.rb', line 2317 def self.racks Formula.cache[:racks] ||= if HOMEBREW_CELLAR.directory? HOMEBREW_CELLAR.subdirs.reject do |rack| rack.symlink? || rack.basename.to_s.start_with?(".") || rack.subdirs.empty? end else [] end end

.resource(name, klass = Resource, &block) ⇒ void

This method returns an undefined value.

Additional downloads can be defined as resources and accessed in the install method. Resources can also be defined inside a stable or head block. This mechanism replaces ad-hoc "subformula" classes.

Example

resource "additional_files" do url "https://example.com/additional-stuff.tar.gz" sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2" end

Parameters:

 3937 3938 3939 3940 3941
 
# File 'formula.rb', line 3937 def resource(name, klass = Resource, &block) specs.each do |spec| spec.resource(name, klass, &block) unless spec.resource_defined?(name) end end

.revision(val = T.unsafe(nil)) ⇒ Integer?

Used for creating new Homebrew versions of software without new upstream versions. For example, if we bump the major version of a library that this Formula depends_on then we may need to update the revision of this Formula to install a new version linked against the new library version. 0 if unset.

Example

revision 1

Parameters:

  • val (Integer) (defaults to: T.unsafe(nil))

Returns:

  • (Integer, nil) 
 3694 3695 3696
 
# File 'formula.rb', line 3694 def revision(val = T.unsafe(nil)) val.nil? ? @revision : @revision = T.let(val, T.nilable(Integer)) end

.service(&block) ⇒ T.proc.returns(T.untyped)?

Service can be used to define services. This method evaluates the DSL specified in the service block of the Formula (if it exists) and sets the instance variables of a Service object accordingly. This is used by brew install to generate a service file.

Example

service do run [opt_bin/"foo"] end

Parameters:

  • block (T.proc.returns(T.untyped), nil)

Returns:

  • (T.proc.returns(T.untyped), nil) 
 4403 4404 4405 4406 4407
 
# File 'formula.rb', line 4403 def service(&block) return @service_block unless block @service_block = T.let(block, T.nilable(T.proc.returns(T.untyped))) end

.service? ⇒ 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.

Checks whether a service specification is defined or not.

It returns true when a service block is present in the Formula and false otherwise.

Returns:

  • (Boolean) 
 3659 3660 3661
 
# File 'formula.rb', line 3659 def service? @service_block.present? end

.sha256(val) ⇒ void

This method returns an undefined value.

To verify the cached download's integrity and security we verify the SHA-256 hash matches what we've declared in the Formula. To quickly fill this value you can leave it blank and run brew fetch --force and it'll tell you the currently valid value.

Example

sha256 "2a2ba417eebaadcb4418ee7b12fe2998f26d6e6f7fda7983412ff66a741ab6f7"

Parameters:

 3819
 
# File 'formula.rb', line 3819 def sha256(val) = stable.sha256(val)

.skip_clean(*paths) ⇒ Set<String, Symbol>

Skip cleaning paths in a formula.

Sometimes the formula cleaner breaks things.

Examples

Preserve cleaned paths with:

skip_clean "bin/foo", "lib/bar"

Keep .la files with:

skip_clean :la

Parameters:

Returns:

 4166 4167 4168 4169 4170
 
# File 'formula.rb', line 4166 def skip_clean(*paths) paths.flatten! # Specifying :all is deprecated and will become an error  T.must(skip_clean_paths).merge(paths) end

.spec_syms ⇒ Array<Symbol>

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:

 3737
 
# File 'formula.rb', line 3737 def spec_syms = [:stable, :head].freeze

.specs ⇒ Array<SoftwareSpec>

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.

A list of the stable and head SoftwareSpecs.

Returns:

 3741 3742 3743 3744 3745
 
# File 'formula.rb', line 3741 def specs spec_syms.map do |sym| send(sym) end.freeze end

.stable(&block) ⇒ T.untyped

Allows adding depends_on and Patches just to the stable SoftwareSpec. This is required instead of using a conditional. It is preferable to also pull the url and sha256 into the block if one is added.

Example

stable do url "https://example.com/foo-1.0.tar.gz" sha256 "2a2ba417eebaadcb4418ee7b12fe2998f26d6e6f7fda7983412ff66a741ab6f7" depends_on "libxml2" depends_on "libffi" end

Parameters:

Returns:

  • (T.untyped) 
 3879 3880 3881 3882 3883
 
# File 'formula.rb', line 3879 def stable(&block) return T.must(@stable) unless block T.must(@stable).instance_eval(&block) end

.tap_aliases ⇒ 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.

An array of all tap aliases.

Returns:

 2364 2365 2366
 
# File 'formula.rb', line 2364 def self.tap_aliases @tap_aliases ||= T.let(Tap.reject(&:core_tap?).flat_map(&:aliases).sort, T.nilable(T::Array[String])) end

.tap_files ⇒ Array<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.

An array of all tap Formula files.

Returns:

 2278 2279 2280
 
# File 'formula.rb', line 2278 def self.tap_files @tap_files ||= T.let(Tap.reject(&:core_tap?).flat_map(&:formula_files), T.nilable(T::Array[Pathname])) end

.tap_names ⇒ 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.

An array of all tap Formula names.

Returns:

 2272 2273 2274
 
# File 'formula.rb', line 2272 def self.tap_names @tap_names ||= T.let(Tap.reject(&:core_tap?).flat_map(&:formula_names).sort, T.nilable(T::Array[String])) end

.test(&block) ⇒ T.untyped

A test is required for new formulae and makes us happy.

The block will create, run in and delete a temporary directory.

We want tests that don't require any user input and test the basic functionality of the application. For example, foo build-foo input.foo is a good test and foo --version or foo --help are bad tests. However, a bad test is better than no test at all.

Examples

(testpath/"test.file").write <<~EOS  writing some test file, if you need to EOS assert_equal "OK", shell_output("test_command test.file").strip

Need complete control over stdin, stdout?

require "open3" Open3.popen3("#{bin}/example", "argument") do |stdin, stdout, _| stdin.write("some text") stdin.close assert_equal "result", stdout.read end

The test will fail if it returns false, or if an exception is raised. Failed assertions and failed system commands will raise exceptions.

Parameters:

  • block (T.proc.returns(T.untyped))

Returns:

  • (T.untyped)

See Also:

 4327
 
# File 'formula.rb', line 4327 def test(&block) = define_method(:test, &block)

.url(val = T.unsafe(nil), specs = {}) ⇒ String

The URL used to download the source for the stable version of the formula. We prefer https for security and proxy reasons. If not inferable, specify the download strategy with using: ....

  • :git, :hg, :svn, :bzr, :fossil, :cvs,
  • :curl (normal file download, will also extract)
  • :homebrew_curl (use brewed curl)
  • :nounzip (without extracting)
  • :post (download via an HTTP POST request)

Examples

url "https://packed.sources.and.we.prefer.https.example.com/archive-1.2.3.tar.bz2" 
url "https://some.dont.provide.archives.example.com", using: :git, tag: "1.2.3", revision: "db8e4de5b2d6653f66aea53094624468caad15d2"

Parameters:

  • val (String) (defaults to: T.unsafe(nil))
  • specs (Hash{Symbol => T.anything}) (defaults to: {})

Returns:

 3772
 
# File 'formula.rb', line 3772 def url(val = T.unsafe(nil), specs = {}) = stable.url(val, specs)

.uses_from_macos(dep, bounds = {}) ⇒ void

This method returns an undefined value.

Indicates use of dependencies provided by macOS. On macOS this is a no-op (as we use the provided system libraries) unless :since specifies a minimum macOS version. On Linux this will act as depends_on.

Parameters:

 4023 4024 4025
 
# File 'formula.rb', line 4023 def uses_from_macos(dep, bounds = {}) specs.each { |spec| spec.uses_from_macos(dep, bounds) } end

.version(val = nil) ⇒ Version?

The version string for the stable version of the formula. The version is autodetected from the URL and/or tag so only needs to be declared if it cannot be autodetected correctly.

Example

version "1.2-final"

Parameters:

  • val (String, nil) (defaults to: nil)

Returns:

 3786
 
# File 'formula.rb', line 3786 def version(val = nil) = stable.version(val)

.version_scheme(val = T.unsafe(nil)) ⇒ Integer?

Used for creating new Homebrew version schemes. For example, if we want to change version scheme from one to another, then we may need to update version_scheme of this Formula to be able to use new version scheme, e.g. to move from 20151020 scheme to 1.0.0 we need to increment version_scheme. Without this, the prior scheme will always equate to a higher version. 0 if unset.

Example

version_scheme 1

Parameters:

  • val (Integer) (defaults to: T.unsafe(nil))

Returns:

  • (Integer, nil) 
 3714 3715 3716
 
# File 'formula.rb', line 3714 def version_scheme(val = T.unsafe(nil)) val.nil? ? @version_scheme : @version_scheme = T.let(val, T.nilable(Integer)) end

Instance Method Details

#active_log_prefix ⇒ 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.

The prefix, if any, to use in filenames for logging current activity.

Returns:

 1267 1268 1269 1270 1271 1272 1273
 
# File 'formula.rb', line 1267 def active_log_prefix if active_log_type "#{active_log_type}." else "" end end

#alias_changed? ⇒ 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.

Has the alias used to install the formula changed, or are different formulae already installed with this alias?

Returns:

  • (Boolean) 
 1774 1775 1776
 
# File 'formula.rb', line 1774 def alias_changed? installed_alias_target_changed? || supersedes_an_installed_formula? end

#aliases ⇒ Array<String>

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

All aliases for the formula.

Returns:

 713 714 715 716 717 718 719 720 721
 
# File 'formula.rb', line 713 def aliases @aliases ||= T.let( if (tap = self.tap) tap.alias_reverse_table.fetch(full_name, []).map { _1.split("/").fetch(-1) } else [] end, T.nilable(T::Array[String]) ) end

#allow_network_access!(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 10
 
# File 'sorbet/rbi/dsl/formula.rbi', line 10 def allow_network_access!(*args, &block); end

#any_installed_keg ⇒ Keg?

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 a Keg for the opt_prefix or installed_prefix if they exist. If not, return nil.

Returns:

 2465 2466 2467 2468 2469 2470
 
# File 'formula.rb', line 2465 def any_installed_keg Formula.cache[:any_installed_keg] ||= {} Formula.cache[:any_installed_keg][full_name] ||= if (installed_prefix = any_installed_prefix) Keg.new(installed_prefix) end end

#any_installed_prefix ⇒ Pathname?

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Get the path of any installed prefix.

Returns:

 2476 2477 2478 2479 2480 2481 2482
 
# File 'formula.rb', line 2476 def any_installed_prefix if optlinked? && opt_prefix.exist? opt_prefix elsif (latest_installed_prefix = installed_prefixes.last) latest_installed_prefix end end

#any_installed_version ⇒ PkgVersion?

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 the PkgVersion for this formula if it is installed. If not, return nil.

Returns:

 2487 2488 2489
 
# File 'formula.rb', line 2487 def any_installed_version any_installed_keg&.version end

#any_version_installed? ⇒ Boolean

If at least one version of Formula is installed.

Returns:

  • (Boolean) 
 775 776 777
 
# File 'formula.rb', line 775 def any_version_installed? installed_prefixes.any? { |keg| (keg/AbstractTab::FILENAME).file? } end

#api_source ⇒ T.untyped

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 API source data used to load this formula. Returns nil if the formula was not loaded from the API.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 585
 
# File 'formula.rb', line 585 delegate api_source: :"self.class"

#autobump? ⇒ 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.

Is the formula in the autobump list?

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 543
 
# File 'formula.rb', line 543 delegate autobump?: :"self.class"

#bash_completion ⇒ Pathname

The directory where the formula's bash completion files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1226
 
# File 'formula.rb', line 1226 def bash_completion = prefix/"etc/bash_completion.d"

#bin ⇒ Pathname

The directory where the formula's binaries should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Examples

Need to install into the #bin but the makefile doesn't mkdir -p prefix/bin?

bin.mkpath

No make install available?

bin.install "binary1"

Returns:

 924
 
# File 'formula.rb', line 924 def bin = prefix/"bin"

#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.

The Bottle object for the currently active SoftwareSpec.

Returns:

 495 496 497
 
# File 'formula.rb', line 495 def bottle @bottle ||= T.let(Bottle.new(self, bottle_specification), T.nilable(Bottle)) if bottled? end

#bottle_defined?(*args, &block) ⇒ 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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 19
 
# File 'sorbet/rbi/dsl/formula.rbi', line 19 def bottle_defined?(*args, &block); end

#bottle_for_tag(tag = nil) ⇒ 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.

The Bottle object for given tag.

Parameters:

Returns:

 501 502 503
 
# File 'formula.rb', line 501 def bottle_for_tag(tag = nil) Bottle.new(self, bottle_specification, tag) if bottled?(tag) end

#bottle_hash ⇒ Hash{String => T.untyped}

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 the bottle information for a formula.

Returns:

 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
 
# File 'formula.rb', line 2720 def bottle_hash hash = {} stable_spec = stable return hash unless stable_spec return hash unless bottle_defined? bottle_spec = stable_spec.bottle_specification hash["rebuild"] = bottle_spec.rebuild hash["root_url"] = bottle_spec.root_url hash["files"] = {} bottle_spec.collector.each_tag do |tag| tag_spec = bottle_spec.collector.specification_for(tag, no_older_versions: true) os_cellar = tag_spec.cellar os_cellar = os_cellar.inspect if os_cellar.is_a?(Symbol) checksum = tag_spec.checksum.hexdigest file_hash = {} file_hash["cellar"] = os_cellar filename = Bottle::Filename.create(self, tag, bottle_spec.rebuild) path, = Utils::Bottles.path_resolved_basename(bottle_spec.root_url, name, checksum, filename) file_hash["url"] = "#{bottle_spec.root_url}/#{path}" file_hash["sha256"] = checksum hash["files"][tag.to_sym] = file_hash end hash end

#bottle_prefix ⇒ 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 directory used for as the prefix for #etc and #var files on installation so, despite not being in HOMEBREW_CELLAR, they are installed there after pouring a bottle.

Returns:

 1259
 
# File 'formula.rb', line 1259 def bottle_prefix = prefix/".bottle"

#bottle_specification(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 22
 
# File 'sorbet/rbi/dsl/formula.rbi', line 22 def bottle_specification(*args, &block); end

#bottle_tab_attributes ⇒ Hash{String => T.untyped}

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:

 3304 3305 3306 3307 3308
 
# File 'formula.rb', line 3304 def bottle_tab_attributes return {} unless bottled? T.must(bottle).tab_attributes end

#bottle_tag?(*args, &block) ⇒ 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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 25
 
# File 'sorbet/rbi/dsl/formula.rbi', line 25 def bottle_tag?(*args, &block); end

#bottled?(*args, &block) ⇒ 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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 28
 
# File 'sorbet/rbi/dsl/formula.rbi', line 28 def bottled?(*args, &block); end

#brew(fetch: true, keep_tmp: false, debug_symbols: false, interactive: false, &_blk) ⇒ 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.

Yields |self,staging| with current working directory set to the uncompressed tarball where staging is a Mktemp staging context.

Parameters:

  • fetch (Boolean) (defaults to: true)
  • keep_tmp (Boolean) (defaults to: false)
  • debug_symbols (Boolean) (defaults to: false)
  • interactive (Boolean) (defaults to: false)
  • _blk (T.proc.params(arg0: Formula, arg1: Mktemp).void) 
 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
 
# File 'formula.rb', line 1638 def brew(fetch: true, keep_tmp: false, debug_symbols: false, interactive: false, &_blk) @prefix_returns_versioned_prefix = T.let(true, T.nilable(T::Boolean)) active_spec.fetch if fetch stage(interactive:, debug_symbols:) do |staging| staging.retain! if keep_tmp || debug_symbols prepare_patches fetch_patches if fetch begin yield self, staging rescue staging.retain! if interactive || debug? raise ensure %w[  config.log  CMakeCache.txt  CMakeConfigureLog.yaml  meson-log.txt  ].each do |logfile| Dir["**/#{logfile}"].each do |logpath| destdir = logs/File.dirname(logpath) mkdir_p destdir cp logpath, destdir end end end end ensure @prefix_returns_versioned_prefix = T.let(false, T.nilable(T::Boolean)) end

#cached_download(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 31
 
# File 'sorbet/rbi/dsl/formula.rbi', line 31 def cached_download(*args, &block); end

#caveats ⇒ 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.

Warn the user about any Homebrew-specific issues or quirks for this package. These should not contain setup instructions that would apply to installation through a different package manager on a different OS.

Example

def caveats <<~EOS  Are optional. Something the user must be warned about?  EOS end 
def caveats s = <<~EOS  Print some important notice to the user when `brew info [formula]` is  called or when brewing a formula.  This is optional. You can use all the vars like #{version} here.  EOS  s += "Some issue only on older systems" if MacOS.version < :monterey s end

Returns:

 1470
 
# File 'formula.rb', line 1470 def caveats = nil

#caveats_with_placeholders ⇒ 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:

 2803 2804 2805 2806
 
# File 'formula.rb', line 2803 def caveats_with_placeholders caveats&.gsub(HOMEBREW_PREFIX, HOMEBREW_PREFIX_PLACEHOLDER) &.gsub(HOMEBREW_CELLAR, HOMEBREW_CELLAR_PLACEHOLDER) end

#clear_cache(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 34
 
# File 'sorbet/rbi/dsl/formula.rbi', line 34 def clear_cache(*args, &block); end

#compiler_failures(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 37
 
# File 'sorbet/rbi/dsl/formula.rbi', line 37 def compiler_failures(*args, &block); end

#conflicts ⇒ Array<FormulaConflict>

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Returns a list of FormulaConflict objects indicating any formulae that conflict with this one and why.

Returns:

 2438
 
# File 'formula.rb', line 2438 def conflicts = T.must(self.class.conflicts)

#core_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.

True if this formula is provided by Homebrew itself.

Returns:

  • (Boolean) 
 2397 2398 2399
 
# File 'formula.rb', line 2397 def core_formula? !!tap&.core_tap? end

#current_installed_alias_target ⇒ 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:

 1753 1754 1755
 
# File 'formula.rb', line 1753 def current_installed_alias_target Formulary.factory(T.must(installed_alias_name)) if installed_alias_path end

#declared_deps(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 40
 
# File 'sorbet/rbi/dsl/formula.rbi', line 40 def declared_deps(*args, &block); end

#deny_network_access!(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 43
 
# File 'sorbet/rbi/dsl/formula.rbi', line 43 def deny_network_access!(*args, &block); end

#dependencies_hash ⇒ Hash{String => T.untyped}

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:

 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871
 
# File 'formula.rb', line 2809 def dependencies_hash # Create a hash of spec names (stable/head) to the list of dependencies under each  dependencies = self.class.spec_syms.to_h do |sym| [sym, send(sym)&.declared_deps] end # Implicit dependencies are only needed when installing from source  # since they are only used to download and unpack source files.  # @see DependencyCollector  dependencies.transform_values! { |deps| deps&.reject(&:implicit?) } hash = {} dependencies.each do |spec_sym, spec_deps| next if spec_deps.nil? dep_hash = if spec_sym == :stable hash else next if spec_deps == dependencies[:stable] hash["#{spec_sym}_dependencies"] ||= {} end dep_hash["build_dependencies"] = spec_deps.select(&:build?) .reject(&:uses_from_macos?) .map(&:name) .uniq dep_hash["dependencies"] = spec_deps.reject(&:optional?) .reject(&:recommended?) .reject(&:build?) .reject(&:test?) .reject(&:uses_from_macos?) .map(&:name) .uniq dep_hash["test_dependencies"] = spec_deps.select(&:test?) .reject(&:uses_from_macos?) .map(&:name) .uniq dep_hash["recommended_dependencies"] = spec_deps.select(&:recommended?) .reject(&:uses_from_macos?) .map(&:name) .uniq dep_hash["optional_dependencies"] = spec_deps.select(&:optional?) .reject(&:uses_from_macos?) .map(&:name) .uniq uses_from_macos_deps = spec_deps.select(&:uses_from_macos?).uniq dep_hash["uses_from_macos"] = uses_from_macos_deps.map do |dep| if dep.tags.length >= 2 { dep.name => dep.tags } elsif dep.tags.present? { dep.name => dep.tags.first } else dep.name end end dep_hash["uses_from_macos_bounds"] = uses_from_macos_deps.map(&:bounds) end hash end

#deprecated? ⇒ 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.

Whether this Formula is deprecated (i.e. warns on installation). Defaults to false.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 1536
 
# File 'formula.rb', line 1536 delegate deprecated?: :"self.class"

#deprecated_flags(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 49
 
# File 'sorbet/rbi/dsl/formula.rbi', line 49 def deprecated_flags(*args, &block); end

#deprecated_options(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 52
 
# File 'sorbet/rbi/dsl/formula.rbi', line 52 def deprecated_options(*args, &block); end

#deprecation_date ⇒ T.untyped

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 date that this Formula was or becomes deprecated. Returns nil if no date is specified.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) —

    Date

See Also:

 1543
 
# File 'formula.rb', line 1543 delegate deprecation_date: :"self.class"

#deprecation_reason ⇒ T.untyped

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 reason this Formula is deprecated. Returns nil if no reason is specified or the formula is not deprecated.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1550
 
# File 'formula.rb', line 1550 delegate deprecation_reason: :"self.class"

#deprecation_replacement_cask ⇒ T.untyped

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 replacement cask for this deprecated Formula. Returns nil if no replacement is specified or the formula is not deprecated.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1564
 
# File 'formula.rb', line 1564 delegate deprecation_replacement_cask: :"self.class"

#deprecation_replacement_formula ⇒ T.untyped

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 replacement formula for this deprecated Formula. Returns nil if no replacement is specified or the formula is not deprecated.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1557
 
# File 'formula.rb', line 1557 delegate deprecation_replacement_formula: :"self.class"

#deps(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 67
 
# File 'sorbet/rbi/dsl/formula.rbi', line 67 def deps(*args, &block); end

#desc ⇒ T.untyped

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 description of the software.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 508
 
# File 'formula.rb', line 508 delegate desc: :"self.class"

#deuniversalize_machos(*targets) ⇒ void

This method returns an undefined value.

Replaces a universal binary with its native slice.

If called with no parameters, does this with all compatible universal binaries in a Formula's Keg.

Raises an error if no universal binaries are found to deuniversalize.

Parameters:

 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
 
# File 'formula.rb', line 2063 def deuniversalize_machos(*targets) if targets.none? targets = any_installed_keg&.mach_o_files&.select do |file| file.arch == :universal && file.archs.include?(Hardware::CPU.arch) end end raise "No universal binaries found to deuniversalize" if targets.blank? targets.compact.each do |target| extract_macho_slice_from(Pathname(target), Hardware::CPU.arch) end end

#disable_date ⇒ T.untyped

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 date that this Formula was or becomes disabled. Returns nil if no date is specified.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) —

    Date

See Also:

 1578
 
# File 'formula.rb', line 1578 delegate disable_date: :"self.class"

#disable_reason ⇒ T.untyped

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 reason this Formula is disabled. Returns nil if no reason is specified or the formula is not disabled.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1585
 
# File 'formula.rb', line 1585 delegate disable_reason: :"self.class"

#disable_replacement_cask ⇒ T.untyped

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 replacement cask for this disabled Formula. Returns nil if no replacement is specified or the formula is not disabled.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1599
 
# File 'formula.rb', line 1599 delegate disable_replacement_cask: :"self.class"

#disable_replacement_formula ⇒ T.untyped

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 replacement formula for this disabled Formula. Returns nil if no replacement is specified or the formula is not disabled.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 1592
 
# File 'formula.rb', line 1592 delegate disable_replacement_formula: :"self.class"

#disabled? ⇒ 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.

Whether this Formula is disabled (i.e. cannot be installed). Defaults to false.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 1571
 
# File 'formula.rb', line 1571 delegate disabled?: :"self.class"

#doc ⇒ Pathname

The directory where the formula's documentation should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 932
 
# File 'formula.rb', line 932 def doc = share/"doc"/name

#downloader(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 88
 
# File 'sorbet/rbi/dsl/formula.rbi', line 88 def downloader(*args, &block); end

#eligible_kegs_for_cleanup(quiet: false) ⇒ Array<Keg>

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:

  • quiet (Boolean) (defaults to: false)

Returns:

 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242
 
# File 'formula.rb', line 3201 def eligible_kegs_for_cleanup(quiet: false) eligible_for_cleanup = [] if latest_version_installed? eligible_kegs = if head? && (head_prefix = latest_head_prefix) head, stable = installed_kegs.partition { |keg| keg.version.head? } # Remove newest head and stable kegs.  head - [Keg.new(head_prefix)] + T.must(stable.sort_by(&:scheme_and_version).slice(0...-1)) else installed_kegs.select do |keg| tab = keg.tab if version_scheme > tab.version_scheme true elsif version_scheme == tab.version_scheme pkg_version > keg.version else false end end end unless eligible_kegs.empty? eligible_kegs.each do |keg| if keg.linked? opoo "Skipping (old) #{keg} due to it being linked" unless quiet elsif pinned? && keg == Keg.new(@pin.path.resolved_path) opoo "Skipping (old) #{keg} due to it being pinned" unless quiet elsif (keepme_refs = keg.keepme_refs.presence) opoo "Skipping #{keg} as it is needed by #{keepme_refs.join(", ")}" unless quiet else eligible_for_cleanup << keg end end end elsif !installed_prefixes.empty? && !pinned? # If the rack only has one version installed, don't complain  # that we can't tell which one to keep. Don't complain at all if the  # only installed version is a pinned formula.  opoo "Skipping #{full_name}: most recent version #{pkg_version} not installed" unless quiet end eligible_for_cleanup end

#elisp ⇒ Pathname

The directory where Emacs Lisp files should be installed, with the formula name appended to avoid linking conflicts.

Example

To install an Emacs mode included with a software package:

elisp.install "contrib/emacs/example-mode.el"

Returns:

 1154
 
# File 'formula.rb', line 1154 def elisp = prefix/"share/emacs/site-lisp"/name

#enqueue_resources_and_patches(download_queue:) ⇒ 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:

 3283 3284 3285 3286 3287 3288 3289
 
# File 'formula.rb', line 3283 def enqueue_resources_and_patches(download_queue:) resources.each do |resource| download_queue.enqueue(resource) resource.patches.select(&:external?).each { |patch| download_queue.enqueue(patch.resource) } end patchlist.select(&:external?).each { |patch| download_queue.enqueue(patch.resource) } end

#ensure_installed!(reason: "", latest: false, output_to_stderr: true, quiet: false) ⇒ T.self_type

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.

Ensure the given formula is installed. This is useful for installing a utility formula (e.g. shellcheck for brew style).

Parameters:

  • reason (String) (defaults to: "")
  • latest (Boolean) (defaults to: false)
  • output_to_stderr (Boolean) (defaults to: true)
  • quiet (Boolean) (defaults to: false)

Returns:

  • (T.self_type) 
 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
 
# File 'formula.rb', line 328 def ensure_installed!(reason: "", latest: false, output_to_stderr: true, quiet: false) if output_to_stderr || quiet file = if quiet File::NULL else $stderr end # Call this method itself with redirected stdout  redirect_stdout(file) do return ensure_installed!(latest:, reason:, output_to_stderr: false) end end reason = " for #{reason}" if reason.present? unless any_version_installed? ohai "Installing `#{name}`#{reason}..." safe_system HOMEBREW_BREW_FILE, "install", "--formula", full_name end if latest && !latest_version_installed? ohai "Upgrading `#{name}`#{reason}..." safe_system HOMEBREW_BREW_FILE, "upgrade", "--formula", full_name end self end

#env(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 91
 
# File 'sorbet/rbi/dsl/formula.rbi', line 91 def env(*args, &block); end

#etc ⇒ Pathname

The directory where the formula's configuration files should be installed. Anything using etc.install will not overwrite other files on e.g. upgrades but will write a new file named *.default. This directory is not inside the HOMEBREW_CELLAR so it persists across upgrades.

Returns:

 1182
 
# File 'formula.rb', line 1182 def etc = (HOMEBREW_PREFIX/"etc").extend(InstallRenamed)

#fetch_bottle_tab(quiet: 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:

  • quiet (Boolean) (defaults to: false) 
 3297 3298 3299 3300 3301
 
# File 'formula.rb', line 3297 def fetch_bottle_tab(quiet: false) return unless bottled? T.must(bottle).fetch_tab(quiet: quiet) end

#fetch_fully_loaded_formula!(download_queue: 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:

 598 599 600 601 602
 
# File 'formula.rb', line 598 def fetch_fully_loaded_formula!(download_queue: nil) return unless loaded_from_stub? Homebrew::API::Formula.fetch_formula_json!(name, download_queue:) end

#fetch_patches ⇒ 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.

 3292 3293 3294
 
# File 'formula.rb', line 3292 def fetch_patches patchlist.select(&:external?).each(&:fetch) end

#fish_completion ⇒ Pathname

The directory where the formula's fish completion files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1244
 
# File 'formula.rb', line 1244 def fish_completion = share/"fish/vendor_completions.d"

#fish_function ⇒ Pathname

The directory where the formula's fish function files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1217
 
# File 'formula.rb', line 1217 def fish_function = share/"fish/vendor_functions.d"

#frameworks ⇒ Pathname

The directory where the formula's Frameworks should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only. This is not symlinked into HOMEBREW_PREFIX.

Returns:

 1163
 
# File 'formula.rb', line 1163 def frameworks = prefix/"Frameworks"

#full_installed_alias_name ⇒ 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:

 427
 
# File 'formula.rb', line 427 def full_installed_alias_name = full_name_with_optional_tap(installed_alias_name)

#full_installed_specified_name ⇒ 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.

The name (including tap) specified to install this formula.

Returns:

 462 463 464
 
# File 'formula.rb', line 462 def full_installed_specified_name full_installed_alias_name || full_name end

#full_specified_name ⇒ 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.

The name (including tap) specified to find this formula.

Returns:

 450 451 452
 
# File 'formula.rb', line 450 def full_specified_name full_alias_name || full_name end

#fully_loaded_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:

 588 589 590 591 592 593 594 595
 
# File 'formula.rb', line 588 def fully_loaded_formula @fully_loaded_formula ||= if loaded_from_stub? json_contents = Homebrew::API::Formula.formula_json(name) Formulary.from_json_contents(name, json_contents) else self end end

#generate_completions_from_executable(*commands, base_name: nil, shells: [:bash, :zsh, :fish], shell_parameter_format: nil) ⇒ void

This method returns an undefined value.

Generate shell completions for a formula for bash, zsh, fish, and optionally pwsh using the formula's executable.

Examples

Using default values for optional arguments.

generate_completions_from_executable(bin/"foo", "completions") # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "bash") (zsh_completion/"_foo").write Utils.safe_popen_read({ "SHELL" => "zsh" }, bin/"foo", "completions", "zsh") (fish_completion/"foo.fish").write Utils.safe_popen_read({ "SHELL" => "fish" }, bin/"foo", "completions", "fish")

If your executable can generate completions for PowerShell, you must pass ":pwsh" explicitly along with any other supported shells. This will pass "powershell" as the completion argument.

generate_completions_from_executable(bin/"foo", "completions", shells: [:bash, :pwsh]) # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "bash") (pwsh_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "pwsh" }, bin/"foo", "completions", "powershell")

Selecting shells and using a different base_name.

generate_completions_from_executable(bin/"foo", "completions", shells: [:bash, :zsh], base_name: "bar") # translates to (bash_completion/"bar").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "bash") (zsh_completion/"_bar").write Utils.safe_popen_read({ "SHELL" => "zsh" }, bin/"foo", "completions", "zsh")

Using predefined shell_parameter_format :flag.

generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :flag, shells: [:bash]) # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "--bash")

Using predefined shell_parameter_format :arg.

generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :arg, shells: [:bash]) # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "--shell=bash")

Using predefined shell_parameter_format :none.

generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :none, shells: [:bash]) # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions")

Using predefined shell_parameter_format :click.

generate_completions_from_executable(bin/"foo", shell_parameter_format: :click, shells: [:zsh]) # translates to (zsh_completion/"_foo").write Utils.safe_popen_read({ "SHELL" => "zsh", "_FOO_COMPLETE" => "zsh_source" }, bin/"foo")

Using predefined shell_parameter_format :clap.

generate_completions_from_executable(bin/"foo", shell_parameter_format: :clap, shells: [:zsh]) # translates to (zsh_completion/"_foo").write Utils.safe_popen_read({ "SHELL" => "zsh", "COMPLETE" => "zsh" }, bin/"foo")

Using custom shell_parameter_format.

generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: "--selected-shell=", shells: [:bash]) # translates to (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "--selected-shell=bash")

Parameters:

  • commands (Pathname, String) —

    the path to the executable and any passed subcommand(s) to use for generating the completion scripts.

  • base_name (String, nil) (defaults to: nil) —

    the base name of the generated completion script. Defaults to the name of the executable if installed within formula's bin or sbin. Otherwise falls back to the formula name.

  • shells (Array<Symbol>) (defaults to: [:bash, :zsh, :fish]) —

    the shells to generate completion scripts for. Defaults to [:bash, :zsh, :fish].

  • shell_parameter_format (Symbol, String, nil) (defaults to: nil) —

    specify how shells should each be passed to the executable. Takes either a String representing a prefix, or one of [:flag, :arg, :none, :click, :clap]. Defaults to plainly passing the shell.

 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
 
# File 'formula.rb', line 2212 def generate_completions_from_executable(*commands, base_name: nil, shells: [:bash, :zsh, :fish], shell_parameter_format: nil) executable = commands.first.to_s base_name ||= File.basename(executable) if executable.start_with?(bin.to_s, sbin.to_s) base_name ||= name completion_script_path_map = { bash: bash_completion/base_name, zsh: zsh_completion/"_#{base_name}", fish: fish_completion/"#{base_name}.fish", pwsh: pwsh_completion/"_#{base_name}.ps1", } shells.each do |shell| popen_read_env = { "SHELL" => shell.to_s } script_path = completion_script_path_map[shell] # Go's cobra and Rust's clap accept "powershell".  shell_argument = (shell == :pwsh) ? "powershell" : shell.to_s shell_parameter = if shell_parameter_format.nil? shell_argument.to_s elsif shell_parameter_format == :flag "--#{shell_argument}" elsif shell_parameter_format == :arg "--shell=#{shell_argument}" elsif shell_parameter_format == :none nil elsif shell_parameter_format == :click prog_name = File.basename(executable).upcase.tr("-", "_") popen_read_env["_#{prog_name}_COMPLETE"] = "#{shell_argument}_source" nil elsif shell_parameter_format == :clap popen_read_env["COMPLETE"] = shell_argument.to_s nil else "#{shell_parameter_format}#{shell_argument}" end popen_read_args = %w[] popen_read_args << commands popen_read_args << shell_parameter if shell_parameter.present? popen_read_args.flatten! popen_read_options = {} popen_read_options[:err] = :err unless ENV["HOMEBREW_STDERR"] script_path.dirname.mkpath script_path.write Utils.safe_popen_read(popen_read_env, *popen_read_args, **popen_read_options) end end

#head? ⇒ 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.

Is the currently active SoftwareSpec a #head build?

Returns:

  • (Boolean) 
 474 475 476
 
# File 'formula.rb', line 474 def head? active_spec == head end

#head_only? ⇒ 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.

Is this formula HEAD-only?

Returns:

  • (Boolean) 
 480 481 482
 
# File 'formula.rb', line 480 def head_only? !!head && !stable end

#head_version_outdated?(version, fetch_head: 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:

  • version (PkgVersion)
  • fetch_head (Boolean) (defaults to: false)

Returns:

  • (Boolean) 
 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
 
# File 'formula.rb', line 811 def head_version_outdated?(version, fetch_head: false) tab = Tab.for_keg(prefix(version)) return true if tab.version_scheme < version_scheme tab_stable_version = tab.stable_version return true if stable && tab_stable_version && tab_stable_version < T.must(stable).version return false unless fetch_head return false unless head&.downloader.is_a?(VCSDownloadStrategy) downloader = T.must(head).downloader with_context quiet: true do downloader.commit_outdated?(version.version.commit) end end

#homepage ⇒ T.untyped

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 homepage for the software.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 518
 
# File 'formula.rb', line 518 delegate homepage: :"self.class"

#include ⇒ Pathname

The directory where the formula's headers should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Example

No make install available?

include.install "example.h"

Returns:

 948
 
# File 'formula.rb', line 948 def include = prefix/"include"

#info ⇒ Pathname

The directory where the formula's info files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 956
 
# File 'formula.rb', line 956 def info = share/"info"

#inreplace(paths, before = nil, after = nil, audit_result: true, global: true, &block) ⇒ void

This method returns an undefined value.

Sometimes we have to change a bit before we install. Mostly we prefer a patch, but if you need the prefix of this formula in the patch you have to resort to inreplace, because in the patch you don't have access to any variables defined by the formula, as only HOMEBREW_PREFIX is available in the embedded patch.

Examples

inreplace supports regular expressions:

inreplace "somefile.cfg", /look[for]what?/, "replace by #{bin}/tool"

inreplace supports blocks:

inreplace "Makefile" do |s| s.gsub! "/usr/local", HOMEBREW_PREFIX.to_s end

Parameters:

See Also:

 3001 3002 3003 3004 3005 3006
 
# File 'formula.rb', line 3001 def inreplace(paths, before = nil, after = nil, audit_result: true, global: true, &block) Utils::Inreplace.inreplace(paths, before, after, audit_result:, global:, &block) rescue Utils::Inreplace::Error => e onoe e.to_s raise BuildError.new(self, "inreplace", Array(paths), {}) 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.

This method is overridden in Formula subclasses to provide the installation instructions. The sources (from url) are downloaded, hash-checked and then Homebrew changes into a temporary directory where the archive is unpacked or repository cloned.

Example

def install system "./configure", "--prefix=#{prefix}" system "make", "install" end 
 2964
 
# File 'formula.rb', line 2964 def install; end

#install_etc_var ⇒ 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.

 1403 1404 1405 1406 1407 1408 1409 1410 1411
 
# File 'formula.rb', line 1403 def install_etc_var etc_var_dirs = [bottle_prefix/"etc", bottle_prefix/"var"] Find.find(*etc_var_dirs.select(&:directory?)) do |path| path = Pathname.new(path) path.extend(InstallRenamed) path.cp_path_sub(bottle_prefix, HOMEBREW_PREFIX) path end end

#installed_alias_name ⇒ 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:

 424
 
# File 'formula.rb', line 424 def installed_alias_name = installed_alias_path&.basename&.to_s

#installed_alias_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 alias path that was used to install this formula, if it exists. Can differ from #alias_path, which is the alias used to find the formula, and is specified to this instance.

Returns:

 411 412 413 414 415 416 417 418 419 420 421
 
# File 'formula.rb', line 411 def installed_alias_path build_tab = build path = build_tab.source["path"] if build_tab.is_a?(Tab) return unless path&.match?(%r{#{HOMEBREW_TAP_DIR_REGEX}/Aliases}o) path = Pathname(path) return unless path.symlink? path end

#installed_alias_target_changed? ⇒ 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.

Has the target of the alias used to install this formula changed? Returns false if the formula wasn't installed with an alias.

Returns:

  • (Boolean) 
 1760 1761 1762 1763 1764 1765
 
# File 'formula.rb', line 1760 def installed_alias_target_changed? target = current_installed_alias_target return false unless target target.name != name end

#installed_kegs ⇒ Array<Keg>

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.

All currently installed kegs.

Returns:

 900 901 902
 
# File 'formula.rb', line 900 def installed_kegs installed_prefixes.map { |dir| Keg.new(dir) } end

#installed_prefixes ⇒ Array<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.

All currently installed prefix directories.

Returns:

 891 892 893 894 895 896
 
# File 'formula.rb', line 891 def installed_prefixes possible_names.map { |name| HOMEBREW_CELLAR/name } .select(&:directory?) .flat_map(&:subdirs) .sort_by(&:basename) end

#installed_specified_name ⇒ 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.

The name specified to install this formula.

Returns:

 456 457 458
 
# File 'formula.rb', line 456 def installed_specified_name installed_alias_name || name end

#internal_dependencies_hash(spec_symbol) ⇒ Hash{String => T.untyped}?

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:

Returns:

Raises:

  • (ArgumentError) 
 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
 
# File 'formula.rb', line 2874 def internal_dependencies_hash(spec_symbol) raise ArgumentError, "Unsupported spec: #{spec_symbol}" unless [:stable, :head].include?(spec_symbol) return unless (spec = public_send(spec_symbol)) spec.declared_deps.each_with_object({}) do |dep, dep_hash| # Implicit dependencies are only needed when installing from source  # since they are only used to download and unpack source files.  # @see DependencyCollector  next if dep.implicit? metadata_hash = {} metadata_hash[:tags] = dep.tags if dep.tags.present? metadata_hash[:uses_from_macos] = dep.bounds.presence if dep.uses_from_macos? dep_hash[dep.name] = metadata_hash.presence end end

#keg_only? ⇒ Boolean

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Rarely, you don't want your library symlinked into the main prefix. See gettext.rb for an example.

Returns:

  • (Boolean)

See Also:

 1478 1479 1480 1481 1482
 
# File 'formula.rb', line 1478 def keg_only? return false unless keg_only_reason keg_only_reason.applicable? end

#keg_only_reason(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 97
 
# File 'sorbet/rbi/dsl/formula.rbi', line 97 def keg_only_reason(*args, &block); end

#kext_prefix ⇒ Pathname

The directory where the formula's kernel extensions should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only. This is not symlinked into HOMEBREW_PREFIX.

Returns:

 1172
 
# File 'formula.rb', line 1172 def kext_prefix = prefix/"Library/Extensions"

#latest_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.

If the alias has changed value, return the new formula. Otherwise, return self.

Returns:

 1781 1782 1783
 
# File 'formula.rb', line 1781 def latest_formula installed_alias_target_changed? ? T.must(current_installed_alias_target) : self end

#latest_head_prefix ⇒ 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:

 805 806 807 808
 
# File 'formula.rb', line 805 def latest_head_prefix head_version = latest_head_version prefix(head_version) if head_version end

#latest_head_version ⇒ PkgVersion?

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:

 793 794 795 796 797 798 799 800 801 802
 
# File 'formula.rb', line 793 def latest_head_version head_versions = installed_prefixes.filter_map do |pn| pn_pkgversion = PkgVersion.parse(pn.basename.to_s) pn_pkgversion if pn_pkgversion.head? end head_versions.max_by do |pn_pkgversion| [Keg.new(prefix(pn_pkgversion)).tab.source_modified_time, pn_pkgversion.revision] end end

#latest_installed_prefix ⇒ 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 latest prefix for this formula. Checks for #head and then #stable's #prefix.

Returns:

 830 831 832 833 834 835 836 837 838
 
# File 'formula.rb', line 830 def latest_installed_prefix if head && (head_version = latest_head_version) && !head_version_outdated?(head_version) T.must(latest_head_prefix) elsif stable && (stable_prefix = prefix(PkgVersion.new(T.must(stable).version, revision))).directory? stable_prefix else prefix end end

#latest_version_installed? ⇒ 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.

If this Formula is installed. This is actually just a check for if the #latest_installed_prefix directory exists and is not empty.

Returns:

  • (Boolean) 
 767 768 769
 
# File 'formula.rb', line 767 def latest_version_installed? (dir = latest_installed_prefix).directory? && !dir.children.empty? end

#launchd_service_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 generated launchd service file path.

Returns:

 1295
 
# File 'formula.rb', line 1295 def launchd_service_path = (any_installed_prefix || opt_prefix)/"#{plist_name}.plist"

#lib ⇒ Pathname

The directory where the formula's libraries should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Example

No make install available?

lib.install "example.dylib"

Returns:

 972
 
# File 'formula.rb', line 972 def lib = prefix/"lib"

#libexec ⇒ Pathname

The directory where the formula's binaries should be installed. This is not symlinked into HOMEBREW_PREFIX. It is commonly used to install files that we do not wish to be symlinked into HOMEBREW_PREFIX from one of the other directories and instead manually create symlinks or wrapper scripts into e.g. #bin.

Example

libexec.install "foo.jar" bin.write_jar_script libexec/"foo.jar", "foo"

Returns:

 989
 
# File 'formula.rb', line 989 def libexec = prefix/"libexec"

#license ⇒ T.untyped

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 SPDX ID of the software license.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 513
 
# File 'formula.rb', line 513 delegate license: :"self.class"

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:

Returns:

  • (Boolean)

See Also:

 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
 
# File 'formula.rb', line 1497 def link_overwrite?(path) # Don't overwrite files not created by Homebrew.  return false if path.stat.uid != HOMEBREW_ORIGINAL_BREW_FILE.stat.uid # Don't overwrite files belong to other keg except when that  # keg's formula is deleted.  begin keg = Keg.for(path) rescue NotAKegError, Errno::ENOENT # file doesn't belong to any keg.  else tab_tap = keg.tab.tap # this keg doesn't below to any core/tap formula, most likely coming from a DIY install.  return false if tab_tap.nil? begin f = Formulary.factory(keg.name) rescue FormulaUnavailableError # formula for this keg is deleted, so defer to allowlist  rescue TapFormulaAmbiguityError return false # this keg belongs to another formula  else # this keg belongs to another unrelated formula  return false unless f.possible_names.include?(keg.name) end end to_check = path.relative_path_from(HOMEBREW_PREFIX).to_s T.must(self.class.link_overwrite_paths).any? do |p| p.to_s == to_check || to_check.start_with?("#{p.to_s.chomp("/")}/") || /^#{Regexp.escape(p.to_s).gsub('\*', ".*?")}$/.match?(to_check) end end

#linked? ⇒ Boolean

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Is the formula linked?

Returns:

  • (Boolean) 
 862
 
# File 'formula.rb', line 862 def linked? = linked_keg.symlink?

#linked_keg ⇒ Pathname

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

The link status symlink directory for this Formula. You probably want #opt_prefix instead.

Returns:

 784 785 786 787 788 789 790
 
# File 'formula.rb', line 784 def linked_keg linked_keg = possible_names.map { |name| HOMEBREW_LINKED_KEGS/name } .find(&:directory?) return linked_keg if linked_keg.present? HOMEBREW_LINKED_KEGS/name end

#linked_version ⇒ PkgVersion?

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.

PkgVersion of the linked keg for the formula.

Returns:

 878 879 880 881 882
 
# File 'formula.rb', line 878 def linked_version return unless linked? Keg.for(linked_keg).version end

#livecheck ⇒ T.untyped

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 livecheck specification for the software.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 523
 
# File 'formula.rb', line 523 delegate livecheck: :"self.class"

#livecheck_defined? ⇒ 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.

Is a livecheck specification defined for the software?

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 528
 
# File 'formula.rb', line 528 delegate livecheck_defined?: :"self.class"

#livecheckable? ⇒ 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.

This is a legacy alias for #livecheck_defined?.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 533
 
# File 'formula.rb', line 533 delegate livecheckable?: :"self.class"

#loaded_from_api? ⇒ 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.

Whether this formula was loaded using the formulae.brew.sh API.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 574
 
# File 'formula.rb', line 574 delegate loaded_from_api?: :"self.class"

#loaded_from_stub? ⇒ 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.

Whether this formula was loaded using the formulae.brew.sh API.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 579
 
# File 'formula.rb', line 579 delegate loaded_from_stub?: :"self.class"

#loader_path ⇒ String

Linker variable for the directory containing the program or shared object.

Returns:

 2040
 
# File 'formula.rb', line 2040 def loader_path = "@loader_path"

#lock ⇒ 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:

 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
 
# File 'formula.rb', line 1672 def lock @lock = T.let(FormulaLock.new(name), T.nilable(FormulaLock)) T.must(@lock).lock oldnames.each do |oldname| next unless (oldname_rack = HOMEBREW_CELLAR/oldname).exist? next if oldname_rack.resolved_path != rack oldname_lock = FormulaLock.new(oldname) oldname_lock.lock @oldname_locks << oldname_lock end end

#logs ⇒ 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 directory where the formula's installation or test logs will be written.

Returns:

 1263
 
# File 'formula.rb', line 1263 def logs = HOMEBREW_LOGS + name

#man ⇒ Pathname

The root directory where the formula's manual pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only. Often one of the more specific man functions should be used instead, e.g. #man1.

Returns:

 999
 
# File 'formula.rb', line 999 def man = share/"man"

#man1 ⇒ Pathname

The directory where the formula's man1 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Example

No make install available?

man1.install "example.1"

Returns:

 1015
 
# File 'formula.rb', line 1015 def man1 = man/"man1"

#man2 ⇒ Pathname

The directory where the formula's man2 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1023
 
# File 'formula.rb', line 1023 def man2 = man/"man2"

#man3 ⇒ Pathname

The directory where the formula's man3 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Example

No make install available?

man3.install "man.3"

Returns:

 1039
 
# File 'formula.rb', line 1039 def man3 = man/"man3"

#man4 ⇒ Pathname

The directory where the formula's man4 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1047
 
# File 'formula.rb', line 1047 def man4 = man/"man4"

#man5 ⇒ Pathname

The directory where the formula's man5 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1055
 
# File 'formula.rb', line 1055 def man5 = man/"man5"

#man6 ⇒ Pathname

The directory where the formula's man6 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1063
 
# File 'formula.rb', line 1063 def man6 = man/"man6"

#man7 ⇒ Pathname

The directory where the formula's man7 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1071
 
# File 'formula.rb', line 1071 def man7 = man/"man7"

#man8 ⇒ Pathname

The directory where the formula's man8 pages should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1079
 
# File 'formula.rb', line 1079 def man8 = man/"man8"

#migration_needed? ⇒ 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) 
 1704 1705 1706
 
# File 'formula.rb', line 1704 def migration_needed? !oldnames_to_migrate.empty? && !rack.exist? end

#missing_dependencies(hide: []) ⇒ 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.

Returns a list of formulae depended on by this formula that aren't installed.

Parameters:

Returns:

 2552 2553 2554 2555 2556 2557 2558 2559 2560
 
# File 'formula.rb', line 2552 def missing_dependencies(hide: []) runtime_formula_dependencies.select do |f| hide.include?(f.name) || f.installed_prefixes.empty? end # If we're still getting unavailable formulae at this stage the best we can # do is just return no results. rescue FormulaUnavailableError [] end

#mkdir(name, &block) ⇒ T.untyped

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.

A version of FileUtils.mkdir that also changes to that folder in a block.

Parameters:

Returns:

  • (T.untyped) 
 3263 3264 3265 3266 3267 3268
 
# File 'formula.rb', line 3263 def mkdir(name, &block) result = FileUtils.mkdir_p(name) return result unless block FileUtils.chdir(name, &block) end

#mktemp(prefix = name, retain: false, retain_in_cache: false, &block) ⇒ 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.

Create a temporary directory then yield. When the block returns, recursively delete the temporary directory. Passing opts[:retain] or calling do |staging| ... staging.retain! in the block will skip the deletion and retain the temporary directory's contents.

Parameters:

  • prefix (String) (defaults to: name)
  • retain (Boolean) (defaults to: false)
  • retain_in_cache (Boolean) (defaults to: false)
  • block (T.proc.params(arg0: Mktemp).void) 
 3256 3257 3258
 
# File 'formula.rb', line 3256 def mktemp(prefix = name, retain: false, retain_in_cache: false, &block) Mktemp.new(prefix, retain:, retain_in_cache:).run(&block) end

#network_access_allowed?(*args, &block) ⇒ 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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 118
 
# File 'sorbet/rbi/dsl/formula.rbi', line 118 def network_access_allowed?(*args, &block); end

#new_formula_available? ⇒ 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) 
 1748 1749 1750
 
# File 'formula.rb', line 1748 def new_formula_available? installed_alias_target_changed? && !latest_formula.latest_version_installed? end

#no_autobump! ⇒ T.untyped

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.

Exclude the formula from the autobump list.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 538
 
# File 'formula.rb', line 538 delegate no_autobump!: :"self.class"

#no_autobump_defined? ⇒ 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.

Is a no_autobump! method defined?

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 548
 
# File 'formula.rb', line 548 delegate no_autobump_defined?: :"self.class"

#no_autobump_message(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 127
 
# File 'sorbet/rbi/dsl/formula.rbi', line 127 def no_autobump_message(*args, &block); end

#old_installed_formulae ⇒ 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.

Returns:

 1786 1787 1788 1789 1790 1791 1792 1793
 
# File 'formula.rb', line 1786 def old_installed_formulae # If this formula isn't the current target of the alias,  # it doesn't make sense to say that other formulae are older versions of it  # because we don't know which came first.  return [] if alias_path.nil? || installed_alias_target_changed? self.class.installed_with_alias_path(alias_path).reject { |f| f.name == name } end

#oldnames ⇒ Array<String>

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Old names for the formula.

Returns:

 699 700 701 702 703 704 705 706 707
 
# File 'formula.rb', line 699 def oldnames @oldnames ||= T.let( if (tap = self.tap) Tap.tap_migration_oldnames(tap, name) + tap.formula_reverse_renames.fetch(name, []) else [] end, T.nilable(T::Array[String]) ) end

#oldnames_to_migrate ⇒ 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:

 1693 1694 1695 1696 1697 1698 1699 1700 1701
 
# File 'formula.rb', line 1693 def oldnames_to_migrate oldnames.select do |oldname| old_rack = HOMEBREW_CELLAR/oldname next false unless old_rack.directory? next false if old_rack.subdirs.empty? tap == Tab.for_keg(old_rack.subdirs.min).tap end end

#on_system_blocks_exist? ⇒ 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, nil) 
 2893 2894 2895
 
# File 'formula.rb', line 2893 def on_system_blocks_exist? self.class.on_system_blocks_exist? || @on_system_blocks_exist end

#opt_bin ⇒ Pathname

Same as #bin, but relative to #opt_prefix instead of #prefix.

Returns:

 1332
 
# File 'formula.rb', line 1332 def opt_bin = opt_prefix/"bin"

#opt_elisp ⇒ Pathname

Same as #elisp, but relative to #opt_prefix instead of #prefix.

Returns:

 1374
 
# File 'formula.rb', line 1374 def opt_elisp = opt_prefix/"share/emacs/site-lisp"/name

#opt_frameworks ⇒ Pathname

Same as #frameworks, but relative to #opt_prefix instead of #prefix.

Returns:

 1380
 
# File 'formula.rb', line 1380 def opt_frameworks = opt_prefix/"Frameworks"

#opt_include ⇒ Pathname

Same as #include, but relative to #opt_prefix instead of #prefix.

Returns:

 1338
 
# File 'formula.rb', line 1338 def opt_include = opt_prefix/"include"

#opt_lib ⇒ Pathname

Same as #lib, but relative to #opt_prefix instead of #prefix.

Returns:

 1344
 
# File 'formula.rb', line 1344 def opt_lib = opt_prefix/"lib"

#opt_libexec ⇒ Pathname

Same as #libexec, but relative to #opt_prefix instead of #prefix.

Returns:

 1350
 
# File 'formula.rb', line 1350 def opt_libexec = opt_prefix/"libexec"

#opt_pkgshare ⇒ Pathname

Same as #pkgshare, but relative to #opt_prefix instead of #prefix.

Returns:

 1368
 
# File 'formula.rb', line 1368 def opt_pkgshare = opt_prefix/"share"/name

#opt_prefix ⇒ Pathname

A stable path for this formula, when installed. Contains the formula name but no version number. Only the active version will be linked here if multiple versions are installed.

This is the preferred way to refer to a formula in plists or from another formula, as the path is stable even when the software is updated.

Example

args << "--with-readline=#{Formula["readline"].opt_prefix}" if build.with? "readline"

Returns:

 1326
 
# File 'formula.rb', line 1326 def opt_prefix = HOMEBREW_PREFIX/"opt"/name

#opt_sbin ⇒ Pathname

Same as #sbin, but relative to #opt_prefix instead of #prefix.

Returns:

 1356
 
# File 'formula.rb', line 1356 def opt_sbin = opt_prefix/"sbin"

#opt_share ⇒ Pathname

Same as #share, but relative to #opt_prefix instead of #prefix.

Returns:

 1362
 
# File 'formula.rb', line 1362 def opt_share = opt_prefix/"share"

#option_defined? ⇒ 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.

If a named option is defined for the currently active SoftwareSpec.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 758
 
# File 'formula.rb', line 758 delegate option_defined?: :active_spec

#options(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 133
 
# File 'sorbet/rbi/dsl/formula.rbi', line 133 def options(*args, &block); end

#optlinked? ⇒ 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.

Is the formula linked to opt?

Returns:

  • (Boolean) 
 866
 
# File 'formula.rb', line 866 def optlinked? = opt_prefix.symlink?

#outdated?(fetch_head: false) ⇒ Boolean

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Check whether the installed formula is outdated.

Parameters:

  • fetch_head (Boolean) (defaults to: false)

Returns:

  • (Boolean) 
 1799 1800 1801 1802 1803
 
# File 'formula.rb', line 1799 def outdated?(fetch_head: false) !outdated_kegs(fetch_head:).empty? rescue Migrator::MigrationNeededError true end

#outdated_kegs(fetch_head: false) ⇒ Array<Keg>

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:

  • fetch_head (Boolean) (defaults to: false)

Returns:

Raises:

 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
 
# File 'formula.rb', line 1709 def outdated_kegs(fetch_head: false) raise Migrator::MigrationNeededError.new(oldnames_to_migrate.first, name) if migration_needed? cache_key = "#{full_name}-#{fetch_head}" Formula.cache[:outdated_kegs] ||= {} Formula.cache[:outdated_kegs][cache_key] ||= begin all_kegs = [] current_version = T.let(false, T::Boolean) installed_kegs.each do |keg| all_kegs << keg version = keg.version next if version.head? next if version_scheme > keg.version_scheme && pkg_version != version next if version_scheme == keg.version_scheme && pkg_version > version # don't consider this keg current if there's a newer formula available  next if follow_installed_alias? && new_formula_available? # this keg is the current version of the formula, but only consider it current  # if it's actually linked - an unlinked current version means we're outdated  next if !keg.optlinked? && !keg.linked? && !pinned? current_version = true break end if current_version || ((head_version = latest_head_version) && !head_version_outdated?(head_version, fetch_head:)) [] else all_kegs += old_installed_formulae.flat_map(&:installed_kegs) all_kegs.sort_by(&:scheme_and_version) end end end

#patch ⇒ 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.

 1611 1612 1613 1614 1615 1616
 
# File 'formula.rb', line 1611 def patch return if patchlist.empty? ohai "Patching" patchlist.each(&:apply) end

#patchlist(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 136
 
# File 'sorbet/rbi/dsl/formula.rbi', line 136 def patchlist(*args, &block); end

#pin(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 139
 
# File 'sorbet/rbi/dsl/formula.rbi', line 139 def pin(*args, &block); end

#pinnable?(*args, &block) ⇒ 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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean) 
 142
 
# File 'sorbet/rbi/dsl/formula.rbi', line 142 def pinnable?(*args, &block); end

#pinned_version(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 148
 
# File 'sorbet/rbi/dsl/formula.rbi', line 148 def pinned_version(*args, &block); end

#pkg_version ⇒ PkgVersion

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 PkgVersion for this formula with version and #revision information.

Returns:

 625
 
# File 'formula.rb', line 625 def pkg_version = PkgVersion.new(version, revision)

#pkgetc ⇒ Pathname

A subdirectory of etc with the formula name suffixed, e.g. $HOMEBREW_PREFIX/etc/openssl@1.1. Anything using pkgetc.install will not overwrite other files on e.g. upgrades but will write a new file named *.default.

Returns:

 1191
 
# File 'formula.rb', line 1191 def pkgetc = (HOMEBREW_PREFIX/"etc"/name).extend(InstallRenamed)

#pkgshare ⇒ Pathname

The directory where the formula's shared files should be installed, with the name of the formula appended to avoid linking conflicts. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Example

No make install available?

pkgshare.install "examples"

Returns:

 1139
 
# File 'formula.rb', line 1139 def pkgshare = prefix/"share"/name

#plist_name ⇒ 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.

The generated launchd plist service name.

Returns:

 1287
 
# File 'formula.rb', line 1287 def plist_name = service.plist_name

#possible_names ⇒ 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:

 1830 1831 1832
 
# File 'formula.rb', line 1830 def possible_names [name, *oldnames, *aliases].compact end

#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.

Can be overridden to run commands on both source and bottle installation.

 1395
 
# File 'formula.rb', line 1395 def post_install; end

#post_install_defined? ⇒ 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) 
 1398 1399 1400
 
# File 'formula.rb', line 1398 def post_install_defined? method(:post_install).owner != Formula end

#pour_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.

Indicates that this formula supports bottles. (Not necessarily that one should be used in the current installation run.) Can be overridden to selectively disable bottles from formulae. Defaults to true so overridden version does not have to check if bottles are supported. Replaced by pour_bottle?'s satisfy method if it is specified.

Returns:

  • (Boolean) 
 1389
 
# File 'formula.rb', line 1389 def pour_bottle? = true

#pour_bottle_check_unsatisfied_reason(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 151
 
# File 'sorbet/rbi/dsl/formula.rbi', line 151 def pour_bottle_check_unsatisfied_reason(*args, &block); end

#prefix(version = pkg_version) ⇒ Pathname

The directory in the Cellar that the formula is installed to. This directory points to #opt_prefix if it exists and if #prefix is not called from within the same formula's #install or #post_install methods. Otherwise, return the full path to the formula's keg (versioned Cellar path).

Parameters:

Returns:

 847 848 849 850 851 852 853 854 855 856
 
# File 'formula.rb', line 847 def prefix(version = pkg_version) versioned_prefix = versioned_prefix(version) version = PkgVersion.parse(version) if version.is_a?(String) if !@prefix_returns_versioned_prefix && version == pkg_version && versioned_prefix.directory? && Keg.new(versioned_prefix).optlinked? opt_prefix else versioned_prefix end end

#prefix_linked?(version = pkg_version) ⇒ 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.

If a formula's linked keg points to the prefix.

Parameters:

Returns:

  • (Boolean) 
 870 871 872 873 874
 
# File 'formula.rb', line 870 def prefix_linked?(version = pkg_version) return false unless linked? linked_keg.resolved_path == versioned_prefix(version) end

#preserve_rpath? ⇒ 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) 
 357
 
# File 'formula.rb', line 357 def preserve_rpath? = self.class.preserve_rpath?

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:

 2417 2418 2419 2420 2421 2422
 
# File 'formula.rb', line 2417 def print_tap_action(options = {}) return unless tap? verb = options[:verb] || "Installing" ohai "#{verb} #{name} from #{tap}" end

#pwsh_completion ⇒ Pathname

The directory where the formula's PowerShell completion files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1253
 
# File 'formula.rb', line 1253 def pwsh_completion = share/"pwsh/completions"

#rack ⇒ 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 parent of the prefix; the named directory in the Cellar containing all installed versions of this software.

Returns:

 887
 
# File 'formula.rb', line 887 def rack = HOMEBREW_CELLAR/name

#recursive_dependencies(&block) ⇒ Array<Dependency>

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Returns a list of Dependency objects in an installable order, which means if a depends on b then b will be ordered before a in this list.

Parameters:

Returns:

 2445 2446 2447 2448 2449 2450 2451
 
# File 'formula.rb', line 2445 def recursive_dependencies(&block) cache_key = "Formula#recursive_dependencies" cache_key += "-#{full_name}-#{Time.now.to_f}" if block Dependency.expand(self, cache_key:, &block) ensure Dependency.cache.delete(cache_key) if block end

#recursive_requirements(&block) ⇒ Requirements

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

The full set of Requirements for this formula's dependency tree.

Parameters:

Returns:

 2457 2458 2459 2460
 
# File 'formula.rb', line 2457 def recursive_requirements(&block) cache_key = "Formula#recursive_requirements" unless block Requirement.expand(self, cache_key:, &block) end

#require_universal_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) 
 1608
 
# File 'formula.rb', line 1608 def require_universal_deps? = false

#requirements(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 154
 
# File 'sorbet/rbi/dsl/formula.rbi', line 154 def requirements(*args, &block); end

#resource(name = T.unsafe(nil), klass = T.unsafe(nil), &block) ⇒ Resource?

TODO:

This should not actually take a block. All resources should be defined at the top-level using resource instead (see https://github.com/Homebrew/brew/issues/17203#issuecomment-2093654431).

A named Resource for the currently active SoftwareSpec. Additional downloads can be defined as #resources. Resource#stage will create a temporary directory and yield to a block.

Example

resource("additional_files").stage { bin.install "my/extra/tool" }

Parameters:

  • name (String) (defaults to: T.unsafe(nil))
  • klass (T.class_of(Resource)) (defaults to: T.unsafe(nil))
  • block (T.proc.bind(Resource).void, nil)

Returns:

 687 688 689 690 691 692 693
 
# File 'formula.rb', line 687 def resource(name = T.unsafe(nil), klass = T.unsafe(nil), &block) if klass.nil? active_spec.resource(*name, &block) else active_spec.resource(name, klass, &block) end end

#resources ⇒ T.untyped

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 Resources for the currently active SoftwareSpec.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 725
 
# File 'formula.rb', line 725 def_delegator :"active_spec.resources", :values, :resources

#rpath(source: bin, target: lib) ⇒ String

Executable/Library RPATH according to platform conventions.

Optionally specify a source or target depending on the location of the file containing the RPATH command and where its target is located.

Example

rpath #=> "@loader_path/../lib" rpath(target: frameworks) #=> "@loader_path/../Frameworks" rpath(source: libexec/"bin") #=> "@loader_path/../../lib"

Parameters:

Returns:

 2028 2029 2030 2031 2032 2033 2034
 
# File 'formula.rb', line 2028 def rpath(source: bin, target: lib) unless target.to_s.start_with?(HOMEBREW_PREFIX) raise "rpath `target` should only be used for paths inside `$HOMEBREW_PREFIX`!" end "#{loader_path}/#{target.relative_path_from(source)}" end

#ruby_source_checksum ⇒ Checksum?

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:

 2568 2569 2570
 
# File 'formula.rb', line 2568 def ruby_source_checksum Checksum.new(Digest::SHA256.file(path).hexdigest) if path.exist? end

#ruby_source_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.

Returns:

 2563 2564 2565
 
# File 'formula.rb', line 2563 def ruby_source_path path.relative_path_from(T.must(tap).path).to_s if tap && path.exist? end

#run_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.

 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
 
# File 'formula.rb', line 1414 def run_post_install @prefix_returns_versioned_prefix = T.let(true, T.nilable(T::Boolean)) build = self.build begin self.build = Tab.for_formula(self) new_env = { TMPDIR: HOMEBREW_TEMP, TEMP: HOMEBREW_TEMP, TMP: HOMEBREW_TEMP, _JAVA_OPTIONS: "-Djava.io.tmpdir=#{HOMEBREW_TEMP}", HOMEBREW_PATH: nil, PATH: PATH.new(ORIGINAL_PATHS), } with_env(new_env) do ENV.clear_sensitive_environment! ENV.activate_extensions! with_logging("post_install") do post_install end end ensure self.build = build @prefix_returns_versioned_prefix = T.let(false, T.nilable(T::Boolean)) end end

#run_test(keep_tmp: false) ⇒ T.untyped

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:

  • keep_tmp (Boolean) (defaults to: false)

Returns:

  • (T.untyped) 
 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935
 
# File 'formula.rb', line 2898 def run_test(keep_tmp: false) @prefix_returns_versioned_prefix = T.let(true, T.nilable(T::Boolean)) test_env = { TMPDIR: HOMEBREW_TEMP, TEMP: HOMEBREW_TEMP, TMP: HOMEBREW_TEMP, TERM: "dumb", PATH: PATH.new(ENV.fetch("PATH"), HOMEBREW_PREFIX/"bin"), HOMEBREW_TERM: ENV.fetch("TERM", nil), HOMEBREW_PATH: nil, }.merge(common_stage_test_env) test_env[:_JAVA_OPTIONS] += " -Djava.io.tmpdir=#{HOMEBREW_TEMP}" ENV.clear_sensitive_environment! Utils::Git.set_name_email! mktemp("#{name}-test") do |staging| staging.retain! if keep_tmp @testpath = T.let(staging.tmpdir, T.nilable(Pathname)) test_env[:HOME] = @testpath setup_home T.must(@testpath) begin with_logging("test") do with_env(test_env) do test end end # Handle all possible exceptions running formula tests.  rescue Exception # rubocop:disable Lint/RescueException  staging.retain! if debug? raise end end ensure @prefix_returns_versioned_prefix = T.let(false, T.nilable(T::Boolean)) @testpath = T.let(nil, T.nilable(Pathname)) end

#runtime_dependencies(read_from_tab: true, undeclared: true) ⇒ Array<Dependency>

This method is part of an internal API. This method may only be used internally in repositories owned by Homebrew, except in casks or formulae. Third parties should avoid using this method if possible, as it may be removed or changed without warning.

Returns a list of Dependency objects that are required at runtime.

Parameters:

  • read_from_tab (Boolean) (defaults to: true)
  • undeclared (Boolean) (defaults to: true)

Returns:

 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
 
# File 'formula.rb', line 2495 def runtime_dependencies(read_from_tab: true, undeclared: true) deps = if read_from_tab && undeclared && (tab_deps = any_installed_keg&.runtime_dependencies) tab_deps.filter_map do |d| full_name = d["full_name"] next unless full_name Dependency.new full_name end end begin deps ||= declared_runtime_dependencies unless undeclared deps ||= (declared_runtime_dependencies | undeclared_runtime_dependencies) rescue FormulaUnavailableError onoe "Could not get runtime dependencies from #{path}!" deps ||= [] end deps end

#runtime_formula_dependencies(read_from_tab: true, undeclared: true) ⇒ 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.

Returns a list of Formula objects that are required at runtime.

Parameters:

  • read_from_tab (Boolean) (defaults to: true)
  • undeclared (Boolean) (defaults to: true)

Returns:

 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529
 
# File 'formula.rb', line 2517 def runtime_formula_dependencies(read_from_tab: true, undeclared: true) cache_key = "#{full_name}-#{read_from_tab}-#{undeclared}" Formula.cache[:runtime_formula_dependencies] ||= {} Formula.cache[:runtime_formula_dependencies][cache_key] ||= runtime_dependencies( read_from_tab:, undeclared:, ).filter_map do |d| d.to_formula rescue FormulaUnavailableError nil end end

#runtime_installed_formula_dependents ⇒ 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.

Returns:

 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
 
# File 'formula.rb', line 2532 def runtime_installed_formula_dependents # `any_installed_keg` and `runtime_dependencies` `select`s ensure  # that we don't end up with something `Formula#runtime_dependencies` can't  # read from a `Tab`.  Formula.cache[:runtime_installed_formula_dependents] ||= {} Formula.cache[:runtime_installed_formula_dependents][full_name] ||= Formula.installed .select(&:any_installed_keg) .select(&:runtime_dependencies) .select do |f| f.runtime_formula_dependencies.any? do |dep| full_name == dep.full_name rescue name == dep.name end end end

#sbin ⇒ Pathname

The directory where the formula's sbin binaries should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only. Generally we try to migrate these to #bin instead.

Returns:

 1088
 
# File 'formula.rb', line 1088 def sbin = prefix/"sbin"

#selective_patch(is_data: 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:

  • is_data (Boolean) (defaults to: false) 
 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
 
# File 'formula.rb', line 1619 def selective_patch(is_data: false) patches = patchlist.select { |p| p.is_a?(DATAPatch) == is_data } return if patches.empty? patchtype = if is_data "DATA" else "non-DATA" end ohai "Applying #{patchtype} patches" patches.each(&:apply) end

#serialized_requirements ⇒ Array<Hash{String => T.untyped}>

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:

 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
 
# File 'formula.rb', line 2777 def serialized_requirements requirements = self.class.spec_syms.to_h do |sym| [sym, send(sym)&.requirements] end merge_spec_dependables(requirements).map do |data| req = data[:dependable] req_name = req.name.dup req_name.prepend("maximum_") if req.respond_to?(:comparator) && req.comparator == "<=" req_version = if req.respond_to?(:version) req.version elsif req.respond_to?(:arch) req.arch end { "name" => req_name, "cask" => req.cask, "download" => req.download, "version" => req_version, "contexts" => req.tags, "specs" => data[:specs], } end end

#service ⇒ Homebrew::Service

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 service specification for the software.

Returns:

 1307 1308 1309
 
# File 'formula.rb', line 1307 def service @service ||= T.let(Homebrew::Service.new(self, &self.class.service), T.nilable(Homebrew::Service)) end

#service? ⇒ 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.

Is a service specification defined for the software?

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (Boolean)

See Also:

 555
 
# File 'formula.rb', line 555 delegate service?: :"self.class"

#service_name ⇒ 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.

The generated service name.

Returns:

 1291
 
# File 'formula.rb', line 1291 def service_name = service.service_name

#share ⇒ Pathname

The directory where the formula's shared files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Examples

Need a custom directory?

(share/"concept").mkpath

Installing something into another custom directory?

(share/"concept2").install "ducks.txt"

Install ./example_code/simple/ones to share/demos:

(share/"demos").install "example_code/simple/ones"

Install ./example_code/simple/ones to share/demos/examples:

(share/"demos").install "example_code/simple/ones" => "examples"

Returns:

 1122
 
# File 'formula.rb', line 1122 def share = prefix/"share"

#shared_library(name, version = nil) ⇒ String

Shared library names according to platform conventions.

Optionally specify a version to restrict the shared library to a specific version. The special string "*" matches any version.

If name is specified as "*", match any shared library of any version.

Example

shared_library("foo") #=> foo.dylib shared_library("foo", 1) #=> foo.1.dylib shared_library("foo", "*") #=> foo.2.dylib, foo.1.dylib, foo.dylib shared_library("*") #=> foo.dylib, bar.dylib

Parameters:

  • name (String)
  • version (String, Integer, nil) (defaults to: nil)

Returns:

 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
 
# File 'formula.rb', line 2002 def shared_library(name, version = nil) return "*.dylib" if name == "*" && (version.blank? || version == "*") infix = if version == "*" "{,.*}" elsif version.present? ".#{version}" end "#{name}#{infix}.dylib" end

#skip_clean?(path) ⇒ 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:

Returns:

  • (Boolean)

See Also:

 1488 1489 1490 1491 1492 1493
 
# File 'formula.rb', line 1488 def skip_clean?(path) return true if path.extname == ".la" && T.must(self.class.skip_clean_paths).include?(:la) to_check = path.relative_path_from(prefix).to_s T.must(self.class.skip_clean_paths).include? to_check end

#skip_cxxstdlib_check? ⇒ 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) 
 1602 1603 1604 1605
 
# File 'formula.rb', line 1602 def skip_cxxstdlib_check? # odeprecated "`Formula#skip_cxxstdlib_check?`"  false end

#specified_name ⇒ 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.

The name specified to find this formula.

Returns:

 444 445 446
 
# File 'formula.rb', line 444 def specified_name alias_name || name end

#specified_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 path that was specified to find this formula.

Returns:

 431 432 433 434 435 436 437 438 439 440
 
# File 'formula.rb', line 431 def specified_path return Homebrew::API::Formula.cached_json_file_path if loaded_from_api? return alias_path if alias_path&.exist? return @unresolved_path if @unresolved_path.exist? return local_bottle_path if local_bottle_path.presence&.exist? alias_path || @unresolved_path end

#stable? ⇒ 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.

Is the currently active SoftwareSpec a #stable build?

Returns:

  • (Boolean) 
 468 469 470
 
# File 'formula.rb', line 468 def stable? active_spec == stable end

#std_cabal_v2_args ⇒ Array<String>

Standard parameters for Cabal-v2 builds.

Returns:

 1847 1848 1849 1850 1851 1852 1853 1854 1855
 
# File 'formula.rb', line 1847 def std_cabal_v2_args # cabal-install's dependency-resolution backtracking strategy can  # easily need more than the default 2,000 maximum number of  # "backjumps," since Hackage is a fast-moving, rolling-release  # target. The highest known needed value by a formula was 43,478  # for git-annex, so 100,000 should be enough to avoid most  # gratuitous backjumps build failures.  ["--jobs=#{ENV.make_jobs}", "--max-backjumps=100000", "--install-method=copy", "--installdir=#{bin}"] end

#std_cargo_args(root: prefix, path: ".") ⇒ Array<String>

Standard parameters for Cargo builds.

Parameters:

Returns:

 1863 1864 1865
 
# File 'formula.rb', line 1863 def std_cargo_args(root: prefix, path: ".") ["--jobs", ENV.make_jobs.to_s, "--locked", "--root=#{root}", "--path=#{path}"] end

#std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST") ⇒ Array<String>

Standard parameters for CMake builds.

Setting CMAKE_FIND_FRAMEWORK to "LAST" tells CMake to search for our libraries before trying to utilize Frameworks, many of which will be from 3rd party installs.

Parameters:

Returns:

 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892
 
# File 'formula.rb', line 1881 def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST") %W[  -DCMAKE_INSTALL_PREFIX=#{install_prefix}  -DCMAKE_INSTALL_LIBDIR=#{install_libdir}  -DCMAKE_BUILD_TYPE=Release  -DCMAKE_FIND_FRAMEWORK=#{find_framework}  -DCMAKE_VERBOSE_MAKEFILE=ON  -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=#{HOMEBREW_LIBRARY_PATH}/cmake/trap_fetchcontent_provider.cmake  -Wno-dev  -DBUILD_TESTING=OFF  ] end

#std_configure_args(prefix: self.prefix, libdir: "lib") ⇒ Array<String>

Standard parameters for configure builds.

Parameters:

Returns:

 1903 1904 1905 1906
 
# File 'formula.rb', line 1903 def std_configure_args(prefix: self.prefix, libdir: "lib") libdir = Pathname(libdir).expand_path(prefix) ["--disable-debug", "--disable-dependency-tracking", "--prefix=#{prefix}", "--libdir=#{libdir}"] end

#std_go_args(output: bin/name, ldflags: nil, gcflags: nil, tags: nil) ⇒ Array<String>

Standard parameters for Go builds.

Parameters:

Returns:

 1919 1920 1921 1922 1923 1924 1925
 
# File 'formula.rb', line 1919 def std_go_args(output: bin/name, ldflags: nil, gcflags: nil, tags: nil) args = ["-trimpath", "-o=#{output}"] args += ["-tags=#{Array(tags).join(" ")}"] if tags args += ["-ldflags=#{Array(ldflags).join(" ")}"] if ldflags args += ["-gcflags=#{Array(gcflags).join(" ")}"] if gcflags args end

#std_meson_args ⇒ Array<String>

Standard parameters for Meson builds.

Returns:

 1931 1932 1933
 
# File 'formula.rb', line 1931 def std_meson_args ["--prefix=#{prefix}", "--libdir=#{lib}", "--buildtype=release", "--wrap-mode=nofallback"] end

#std_npm_args(prefix: libexec) ⇒ Array<String>

Standard parameters for npm builds.

Parameters:

Returns:

 1939 1940 1941 1942 1943 1944 1945
 
# File 'formula.rb', line 1939 def std_npm_args(prefix: libexec) require "language/node" return Language::Node.std_npm_install_args(Pathname(prefix)) if prefix Language::Node.local_npm_install_args end

#std_pip_args(prefix: self.prefix, build_isolation: false) ⇒ Array<String>

Standard parameters for pip builds.

Parameters:

  • prefix (false, String, Pathname) (defaults to: self.prefix)
  • build_isolation (Boolean) (defaults to: false)

Returns:

 1954 1955 1956 1957 1958 1959
 
# File 'formula.rb', line 1954 def std_pip_args(prefix: self.prefix, build_isolation: false) args = ["--verbose", "--no-deps", "--no-binary=:all:", "--ignore-installed", "--no-compile"] args << "--prefix=#{prefix}" if prefix args << "--no-build-isolation" unless build_isolation args end

#std_zig_args(prefix: self.prefix, release_mode: :fast) ⇒ Array<String>

Standard parameters for Zig builds.

release_mode can be set to either :safe, :fast or :small, with :fast being the default value.

Parameters:

Returns:

Raises:

  • (ArgumentError) 
 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
 
# File 'formula.rb', line 1971 def std_zig_args(prefix: self.prefix, release_mode: :fast) raise ArgumentError, "Invalid Zig release mode: #{release_mode}" if [:safe, :fast, :small].exclude?(release_mode) release_mode_downcased = release_mode.to_s.downcase release_mode_capitalized = release_mode.to_s.capitalize [ "--prefix", prefix.to_s, "--release=#{release_mode_downcased}", "-Doptimize=Release#{release_mode_capitalized}", "--summary", "all" ] end

#supersedes_an_installed_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.

Is this formula the target of an alias used to install an old formula?

Returns:

  • (Boolean) 
 1769
 
# File 'formula.rb', line 1769 def supersedes_an_installed_formula? = old_installed_formulae.any?

#synced_with_other_formulae? ⇒ 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.

Whether this Formula is version-synced with other formulae.

Returns:

  • (Boolean) 
 662 663 664 665 666
 
# File 'formula.rb', line 662 def synced_with_other_formulae? return false if @tap.nil? @tap.synced_versions_formulae.any? { |synced_formulae| synced_formulae.include?(name) } end

#system(cmd, *args) ⇒ void

This method returns an undefined value.

To call out to the system, we use the system method and we prefer you give the args separately as in the line below, otherwise a subshell has to be opened first.

Examples

system "./bootstrap.sh", "--arg1", "--prefix=#{prefix}"

For CMake and other build systems we have some necessary defaults in e.g. #std_cmake_args:

system "cmake", ".", *std_cmake_args

If the arguments given to configure (or make or cmake) are depending on options defined above, we usually make a list first and then use the args << if <condition> to append each:

args = ["--with-option1", "--with-option2"] args << "--without-gcc" if ENV.compiler == :clang

Most software still uses configure and make. Check with ./configure --help for what our options are.

system "./configure", "--disable-debug", "--disable-dependency-tracking", "--disable-silent-rules", "--prefix=#{prefix}", *args # our custom arg list (needs `*` to unpack)

If there is a "make install" available, please use it!

system "make", "install"

Parameters:

 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198
 
# File 'formula.rb', line 3093 def system(cmd, *args) verbose_using_dots = Homebrew::EnvConfig.verbose_using_dots? # remove "boring" arguments so that the important ones are more likely to  # be shown considering that we trim long ohai lines to the terminal width  pretty_args = args.dup unless verbose? case cmd when "./configure" pretty_args -= std_configure_args when "cabal" pretty_args -= std_cabal_v2_args when "cargo" pretty_args -= std_cargo_args when "cmake" pretty_args -= std_cmake_args when "go" pretty_args -= std_go_args when "meson" pretty_args -= std_meson_args when "zig" pretty_args -= std_zig_args when %r{(^|/)(pip|python)(?:[23](?:\.\d{1,2})?)?$} pretty_args -= std_pip_args end end pretty_args.each_index do |i| pretty_args[i] = "import setuptools..." if pretty_args[i].to_s.start_with? "import setuptools" end ohai "#{cmd} #{pretty_args * " "}".strip @exec_count ||= T.let(0, T.nilable(Integer)) @exec_count += 1 log_filename = format("#{logs}/#{active_log_prefix}%02<exec_count>d.%<cmd_base>s.log", exec_count: @exec_count, cmd_base: File.basename(cmd).split.first) logs.mkpath File.open(log_filename, "w") do |log| log.puts Time.now, "", cmd, args, "" log.flush if verbose? rd, wr = IO.pipe begin pid = fork do rd.close log.close exec_cmd(cmd, args, wr, log_filename) end wr.close if verbose_using_dots last_dot = Time.at(0) while (buf = rd.gets) log.puts buf # make sure dots printed with interval of at least 1 min.  next if (Time.now - last_dot) <= 60 print "." $stdout.flush last_dot = Time.now end puts else while (buf = rd.gets) log.puts buf puts buf end end ensure rd.close end else pid = fork do exec_cmd(cmd, args, log, log_filename) end end Process.wait(pid) $stdout.flush unless $CHILD_STATUS.success? log_lines = Homebrew::EnvConfig.fail_log_lines log.flush if !verbose? || verbose_using_dots puts "Last #{log_lines} lines from #{log_filename}:" Kernel.system "/usr/bin/tail", "-n", log_lines.to_s, log_filename end log.puts require "system_config" require "build_environment" env = ENV.to_hash SystemConfig.dump_verbose_config(log) log.puts BuildEnvironment.dump env, log raise BuildError.new(self, cmd, args, env) end end end

#systemd_service_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 generated systemd service file path.

Returns:

 1299
 
# File 'formula.rb', line 1299 def systemd_service_path = (any_installed_prefix || opt_prefix)/"#{service_name}.service"

#systemd_timer_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 generated systemd timer file path.

Returns:

 1303
 
# File 'formula.rb', line 1303 def systemd_timer_path = (any_installed_prefix || opt_prefix)/"#{service_name}.timer"

#tap? ⇒ 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.

True if this formula is provided by an external Tap.

Returns:

  • (Boolean) 
 2403 2404 2405 2406 2407
 
# File 'formula.rb', line 2403 def tap? return false unless tap !T.must(tap).core_tap? end

#tap_git_head ⇒ 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:

 2425 2426 2427 2428 2429
 
# File 'formula.rb', line 2425 def tap_git_head tap&.git_head rescue TapUnavailableError nil end

#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, nil) 
 2943
 
# File 'formula.rb', line 2943 def test; end

#test_defined? ⇒ 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) 
 2938 2939 2940
 
# File 'formula.rb', line 2938 def test_defined? method(:test).owner != Formula end

#test_fixtures(file) ⇒ 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:

Returns:

 2946 2947 2948
 
# File 'formula.rb', line 2946 def test_fixtures(file) HOMEBREW_LIBRARY_PATH/"test/support/fixtures"/file end

#time ⇒ Time

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.

Creates a new Time object for use in the formula as the build time.

Returns:

See Also:

 2046 2047 2048 2049 2050 2051 2052
 
# File 'formula.rb', line 2046 def time if ENV["SOURCE_DATE_EPOCH"].present? Time.at(ENV["SOURCE_DATE_EPOCH"].to_i).utc else Time.now.utc end end

#to_hash ⇒ Hash{String => T.untyped}

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:

 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679
 
# File 'formula.rb', line 2589 def to_hash hsh = { "name" => name, "full_name" => full_name, "tap" => tap&.name, "oldnames" => oldnames, "aliases" => aliases.sort, "versioned_formulae" => versioned_formulae.map(&:name), "desc" => desc, "license" => SPDX.license_expression_to_string(license), "homepage" => homepage, "versions" => { "stable" => stable&.version&.to_s, "head" => head&.version&.to_s, "bottle" => bottle_defined?, }, "urls" => urls_hash, "revision" => revision, "version_scheme" => version_scheme, "compatibility_version" => compatibility_version, "autobump" => autobump?, "no_autobump_message" => no_autobump_message, "skip_livecheck" => livecheck.skip?, "bottle" => {}, "pour_bottle_only_if" => self.class.pour_bottle_only_if&.to_s, "keg_only" => keg_only?, "keg_only_reason" => keg_only_reason&.to_hash, "options" => [], "build_dependencies" => [], "dependencies" => [], "test_dependencies" => [], "recommended_dependencies" => [], "optional_dependencies" => [], "uses_from_macos" => [], "uses_from_macos_bounds" => [], "requirements" => serialized_requirements, "conflicts_with" => conflicts.map(&:name), "conflicts_with_reasons" => conflicts.map(&:reason), "link_overwrite" => self.class.link_overwrite_paths.to_a, "caveats" => caveats_with_placeholders, "installed" => T.let([], T::Array[T::Hash[String, T.untyped]]), "linked_keg" => linked_version&.to_s, "pinned" => pinned?, "outdated" => outdated?, "deprecated" => deprecated?, "deprecation_date" => deprecation_date, "deprecation_reason" => deprecation_reason, "deprecation_replacement_formula" => deprecation_replacement_formula, "deprecation_replacement_cask" => deprecation_replacement_cask, "disabled" => disabled?, "disable_date" => disable_date, "disable_reason" => disable_reason, "disable_replacement_formula" => disable_replacement_formula, "disable_replacement_cask" => disable_replacement_cask, "post_install_defined" => post_install_defined?, "service" => (service.to_hash if service?), "tap_git_head" => tap_git_head, "ruby_source_path" => ruby_source_path, "ruby_source_checksum" => {}, } hsh["bottle"]["stable"] = bottle_hash if stable && bottle_defined? hsh["options"] = options.map do |opt| { "option" => opt.flag, "description" => opt.description } end hsh.merge!(dependencies_hash) hsh["installed"] = installed_kegs.sort_by(&:scheme_and_version).map do |keg| tab = keg.tab { "version" => keg.version.to_s, "used_options" => tab.used_options.as_flags, "built_as_bottle" => tab.built_as_bottle, "poured_from_bottle" => tab.poured_from_bottle, "time" => tab.time, "runtime_dependencies" => tab.runtime_dependencies, "installed_as_dependency" => tab.installed_as_dependency, "installed_on_request" => tab.installed_on_request, } end if (source_checksum = ruby_source_checksum) hsh["ruby_source_checksum"] = { "sha256" => source_checksum.hexdigest, } end hsh end

#to_hash_with_variations ⇒ Hash{String => T.untyped}

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:

 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716
 
# File 'formula.rb', line 2682 def to_hash_with_variations hash = to_hash # Take from API, merging in local install status.  if loaded_from_api? && (json_formula = api_source) && !Homebrew::EnvConfig.no_install_from_api? return json_formula.dup.merge( hash.slice("name", "installed", "linked_keg", "pinned", "outdated"), ) end variations = {} if path.exist? && on_system_blocks_exist? formula_contents = path.read OnSystem::VALID_OS_ARCH_TAGS.each do |bottle_tag| Homebrew::SimulateSystem.with_tag(bottle_tag) do variations_namespace = Formulary.class_s("Variations#{bottle_tag.to_sym.capitalize}") variations_formula_class = Formulary.load_formula(name, path, formula_contents, variations_namespace, flags: self.class.build_flags, ignore_errors: true) variations_formula = variations_formula_class.new(name, path, :stable, alias_path:, force_bottle:) variations_formula.to_hash.each do |key, value| next if value.to_s == hash[key].to_s variations[bottle_tag.to_sym] ||= {} variations[bottle_tag.to_sym][key] = value end end end end hash["variations"] = variations hash end

#unlock ⇒ Array<FormulaLock>

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:

 1687 1688 1689 1690
 
# File 'formula.rb', line 1687 def unlock @lock&.unlock @oldname_locks.each(&:unlock) end

#unpin(*args, &block) ⇒ T.untyped

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:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped) 
 163
 
# File 'sorbet/rbi/dsl/formula.rbi', line 163 def unpin(*args, &block); end

#update_head_version ⇒ 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.

 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
 
# File 'formula.rb', line 605 def update_head_version return unless head? head_spec = T.must(head) return unless head_spec.downloader.is_a?(VCSDownloadStrategy) return unless head_spec.downloader.cached_location.exist? path = if ENV["HOMEBREW_ENV"] ENV.fetch("PATH") else PATH.new(ORIGINAL_PATHS) end with_env(PATH: path) do head_spec.version.update_commit(head_spec.downloader.last_commit) end end

#urls_hash ⇒ Hash{String => Hash{String => T.untyped}}

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:

 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
 
# File 'formula.rb', line 2751 def urls_hash hash = {} if stable stable_spec = T.must(stable) hash["stable"] = { "url" => stable_spec.url, "tag" => stable_spec.specs[:tag], "revision" => stable_spec.specs[:revision], "using" => (stable_spec.using if stable_spec.using.is_a?(Symbol)), "checksum" => stable_spec.checksum&.to_s, } end if head hash["head"] = { "url" => T.must(head).url, "branch" => T.must(head).specs[:branch], "using" => (T.must(head).using if T.must(head).using.is_a?(Symbol)), } end hash end

#valid_platform? ⇒ 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.

True if this formula can be installed on this platform. Redefined in extend/os.

Returns:

  • (Boolean) 
 2412 2413 2414
 
# File 'formula.rb', line 2412 def valid_platform? requirements.none?(MacOSRequirement) && requirements.none?(LinuxRequirement) end

#var ⇒ Pathname

The directory where the formula's variable files should be installed. This directory is not inside the HOMEBREW_CELLAR so it persists across upgrades.

Returns:

 1199
 
# File 'formula.rb', line 1199 def var = HOMEBREW_PREFIX/"var"

#version ⇒ T.untyped

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 version for the currently active SoftwareSpec. The version is autodetected from the URL and/or tag so only needs to be declared if it cannot be autodetected correctly.

Parameters:

  • args (T.untyped)
  • block (T.untyped)

Returns:

  • (T.untyped)

See Also:

 562
 
# File 'formula.rb', line 562 delegate version: :active_spec

#versioned_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.

If this is a @-versioned formula.

Returns:

  • (Boolean) 
 629
 
# File 'formula.rb', line 629 def versioned_formula? = name.include?("@")

#versioned_formulae ⇒ 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.

Returns any @-versioned Formula objects for any Formula (including versioned formulae).

Returns:

 652 653 654 655 656 657 658
 
# File 'formula.rb', line 652 def versioned_formulae versioned_formulae_names.filter_map do |name| Formula[name] rescue FormulaUnavailableError nil end.sort_by(&:version).reverse end

#versioned_formulae_names ⇒ 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 any other @-versioned formulae names for any Formula (including versioned formulae).

Returns:

 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
 
# File 'formula.rb', line 633 def versioned_formulae_names versioned_names = if tap name_prefix = name.gsub(/(@[\d.]+)?$/, "") T.must(tap).prefix_to_versioned_formulae_names.fetch(name_prefix, []) elsif path.exist? Pathname.glob(path.to_s.gsub(/(@[\d.]+)?\.rb$/, "@*.rb")) .map { |path| path.basename(".rb").to_s } .sort else raise "Either tap or path is required to list versioned formulae" end versioned_names.reject do |versioned_name| versioned_name == name end end

#with_logging(log_type, &_block) ⇒ 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 a block with the given log type in effect for its duration.

Parameters:

  • log_type (String)
  • _block (T.proc.void) 
 1277 1278 1279 1280 1281 1282 1283
 
# File 'formula.rb', line 1277 def with_logging(log_type, &_block) old_log_type = @active_log_type @active_log_type = T.let(log_type, T.nilable(String)) yield ensure @active_log_type = old_log_type end

#xcodebuild(*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.

Runs xcodebuild without Homebrew's compiler environment variables set.

Parameters:

 3272 3273 3274 3275 3276 3277 3278 3279 3280
 
# File 'formula.rb', line 3272 def xcodebuild(*args) removed = ENV.remove_cc_etc begin self.system("xcodebuild", *args) ensure ENV.update(removed) end end

#zsh_completion ⇒ Pathname

The directory where the formula's zsh completion files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1235
 
# File 'formula.rb', line 1235 def zsh_completion = share/"zsh/site-functions"

#zsh_function ⇒ Pathname

The directory where the formula's zsh function files should be installed. This is symlinked into HOMEBREW_PREFIX after installation or with brew link for formulae that are not keg-only.

Returns:

 1208
 
# File 'formula.rb', line 1208 def zsh_function = share/"zsh/site-functions"