Module: Formulary Private
- Extended by:
- Cachable
- Defined in:
- formulary.rb
Overview
This module is part of a private API. This module may only be used in the Homebrew/brew repository. Third parties should avoid using this module if possible, as it may be removed or changed without warning.
The Formulary is responsible for creating instances of Formula. It is not meant to be used directly from formulae.
Defined Under Namespace
Classes: AliasAPILoader, AliasLoader, BottleLoader, FormulaAPILoader, FormulaContentsLoader, FormulaLoader, FromPathLoader, FromUrlLoader, NullLoader, TapLoader
Constant Summary collapse
- URL_START_REGEX =
This constant is part of a private API. This constant may only be used in the Homebrew/brew repository. Third parties should avoid using this constant if possible, as it may be removed or changed without warning.
%r{(https?|ftp|file)://}.freeze
- API_SUPPORTED_REQUIREMENTS =
This constant is part of a private API. This constant may only be used in the Homebrew/brew repository. Third parties should avoid using this constant if possible, as it may be removed or changed without warning.
:codesign and custom requirement classes are not supported
[:arch, :linux, :macos, :maximum_macos, :xcode].freeze
Class Method Summary collapse
-
.canonical_name(ref) ⇒ Object
private
-
.class_s(name) ⇒ Object
private
-
.clear_cache ⇒ Object
private
-
.convert_to_deprecate_disable_reason_string_or_symbol(string) ⇒ Object
private
-
.convert_to_string_or_symbol(string) ⇒ Object
private
-
.core_alias_path(name) ⇒ Object
private
-
.core_path(name) ⇒ Object
private
-
.enable_factory_cache! ⇒ void
private
-
.ensure_utf8_encoding(io) ⇒ Object
private
-
.factory(ref, spec = :stable, alias_path: nil, from: T.unsafe(nil), warn: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil)) ⇒ Formula
private
Return a Formula instance for the given reference.
-
.factory_cached? ⇒ Boolean
private
-
.find_formula_in_tap(name, tap) ⇒ Pathname
private
-
.formula_class_defined_from_api?(name) ⇒ Boolean
private
-
.formula_class_defined_from_path?(path) ⇒ Boolean
private
-
.formula_class_get_from_api(name) ⇒ Object
private
-
.formula_class_get_from_path(path) ⇒ Object
private
-
.from_contents(name, path, contents, spec = :stable, alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil)) ⇒ Formula
private
Return a Formula instance directly from contents.
-
.from_keg(keg, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ Formula
private
Return a Formula instance for the given keg.
-
.from_rack(rack, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ Formula
private
Return a Formula instance for the given rack.
-
.keg_only?(rack) ⇒ Boolean
private
Return whether given rack is keg-only.
-
.load_formula(name, path, contents, namespace, flags:, ignore_errors:) ⇒ Object
private
-
.load_formula_from_api(name, flags:) ⇒ T.class_of(Formula)
private
-
.load_formula_from_path(name, path, flags:, ignore_errors:) ⇒ T.class_of(Formula)
private
-
.loader_for(ref, from: nil, warn: true) ⇒ Object
private
-
.path(ref) ⇒ Object
private
-
.resolve(name, spec: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ Formula
private
-
.tap_paths(name, taps = Tap) ⇒ Object
private
-
.to_rack(ref) ⇒ Object
private
Methods included from Cachable
Class Method Details
.canonical_name(ref) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
910 911 912 913 914 915 916 |
# File 'formulary.rb', line 910 def self.canonical_name(ref) loader_for(ref).name rescue TapFormulaAmbiguityError # If there are multiple tap formulae with the name of ref, # then ref is the canonical name ref.downcase end |
.class_s(name) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
438 439 440 441 442 443 444 |
# File 'formulary.rb', line 438 def self.class_s(name) class_name = name.capitalize class_name.gsub!(/[-_.\s]([a-zA-Z0-9])/) { T.must(Regexp.last_match(1)).upcase } class_name.tr!("+", "x") class_name.sub!(/(.)@(\d)/, "\\1AT\\2") class_name end |
.clear_cache ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
# File 'formulary.rb', line 50 def self.clear_cache cache.each do |type, cached_objects| next if type == :formulary_factory cached_objects.each_value do |klass| class_name = klass.name # Already removed from namespace. next if class_name.nil? namespace = Utils.deconstantize(class_name) next if Utils.deconstantize(namespace) != name remove_const(Utils.demodulize(namespace).to_sym) end end super end |
.convert_to_deprecate_disable_reason_string_or_symbol(string) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
452 453 454 455 456 457 |
# File 'formulary.rb', line 452 def self.convert_to_deprecate_disable_reason_string_or_symbol(string) require "deprecate_disable" return string unless DeprecateDisable::DEPRECATE_DISABLE_REASONS.keys.map(&:to_s).include?(string) string.to_sym end |
.convert_to_string_or_symbol(string) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
446 447 448 449 450 |
# File 'formulary.rb', line 446 def self.convert_to_string_or_symbol(string) return string[1..].to_sym if string.start_with?(":") string end |
.core_alias_path(name) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
991 992 993 |
# File 'formulary.rb', line 991 def self.core_alias_path(name) CoreTap.instance.alias_dir/name.to_s.downcase end |
.core_path(name) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
987 988 989 |
# File 'formulary.rb', line 987 def self.core_path(name) find_formula_in_tap(name.to_s.downcase, CoreTap.instance) end |
.enable_factory_cache! ⇒ 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.
26 27 28 |
# File 'formulary.rb', line 26 def self.enable_factory_cache! @factory_cache = true end |
.ensure_utf8_encoding(io) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
434 435 436 |
# File 'formulary.rb', line 434 def self.ensure_utf8_encoding(io) io.set_encoding(Encoding::UTF_8) end |
.factory(ref, spec = :stable, alias_path: nil, from: T.unsafe(nil), warn: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil)) ⇒ 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.
Return a Formula instance for the given reference.
ref
is a string containing:
- a formula name
- a formula pathname
- a formula URL
- a local bottle reference
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 |
# File 'formulary.rb', line 743 def self.factory( ref, spec = :stable, alias_path: nil, from: T.unsafe(nil), warn: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil) ) cache_key = "#{ref}-#{spec}-#{alias_path}-#{from}" return cache[:formulary_factory][cache_key] if factory_cached? && cache[:formulary_factory]&.key?(cache_key) = { from: from, warn: warn }.compact = { alias_path: alias_path, force_bottle: force_bottle, flags: flags, ignore_errors: ignore_errors }.compact formula = loader_for(ref, **) .get_formula(spec, **) if factory_cached? cache[:formulary_factory] ||= {} cache[:formulary_factory][cache_key] ||= formula end formula end |
.factory_cached? ⇒ 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.
30 31 32 |
# File 'formulary.rb', line 30 def self.factory_cached? !@factory_cache.nil? end |
.find_formula_in_tap(name, tap) ⇒ 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.
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 |
# File 'formulary.rb', line 1008 def self.find_formula_in_tap(name, tap) filename = if name.end_with?(".rb") name else "#{name}.rb" end Tap.formula_files_by_name(tap) .fetch(name, tap.formula_dir/filename) end |
.formula_class_defined_from_api?(name) ⇒ 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.
38 39 40 |
# File 'formulary.rb', line 38 def self.formula_class_defined_from_api?(name) cache.key?(:api) && cache[:api].key?(name) end |
.formula_class_defined_from_path?(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.
34 35 36 |
# File 'formulary.rb', line 34 def self.formula_class_defined_from_path?(path) cache.key?(:path) && cache[:path].key?(path) end |
.formula_class_get_from_api(name) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
46 47 48 |
# File 'formulary.rb', line 46 def self.formula_class_get_from_api(name) cache[:api].fetch(name) end |
.formula_class_get_from_path(path) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
42 43 44 |
# File 'formulary.rb', line 42 def self.formula_class_get_from_path(path) cache[:path].fetch(path) end |
.from_contents(name, path, contents, spec = :stable, alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil)) ⇒ 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.
Return a Formula instance directly from contents.
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 |
# File 'formulary.rb', line 878 def self.from_contents( name, path, contents, spec = :stable, alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil), ignore_errors: T.unsafe(nil) ) = { alias_path: alias_path, force_bottle: force_bottle, flags: flags, ignore_errors: ignore_errors, }.compact FormulaContentsLoader.new(name, path, contents).get_formula(spec, **) end |
.from_keg(keg, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ 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.
Return a Formula instance for the given keg.
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 |
# File 'formulary.rb', line 828 def self.from_keg( keg, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil) ) tab = Tab.for_keg(keg) tap = tab.tap spec ||= tab.spec formula_name = keg.rack.basename.to_s = { alias_path: alias_path, from: :keg, warn: false, force_bottle: force_bottle, flags: flags, }.compact f = if tap.nil? factory(formula_name, spec, **) else begin factory("#{tap}/#{formula_name}", spec, **) rescue FormulaUnavailableError # formula may be migrated to different tap. Try to search in core and all taps. factory(formula_name, spec, **) end end f.build = tab T.cast(f.build, Tab). = Tab.(f., tab.).as_flags f.version.update_commit(keg.version.version.commit) if f.head? && keg.version.head? f end |
.from_rack(rack, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ 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.
Return a Formula instance for the given rack.
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 |
# File 'formulary.rb', line 788 def self.from_rack( rack, spec = T.unsafe(nil), alias_path: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil) ) kegs = rack.directory? ? rack.subdirs.map { |d| Keg.new(d) } : [] keg = kegs.find(&:linked?) || kegs.find(&:optlinked?) || kegs.max_by(&:version) = { alias_path: alias_path, force_bottle: force_bottle, flags: flags, }.compact if keg from_keg(keg, *spec, **) else factory(rack.basename.to_s, *spec, from: :rack, warn: false, **) end end |
.keg_only?(rack) ⇒ 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.
Return whether given rack is keg-only.
811 812 813 814 815 |
# File 'formulary.rb', line 811 def self.keg_only?(rack) Formulary.from_rack(rack).keg_only? rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError false end |
.load_formula(name, path, contents, namespace, flags:, ignore_errors:) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'formulary.rb', line 85 def self.load_formula(name, path, contents, namespace, flags:, ignore_errors:) raise "Formula loading disabled by HOMEBREW_DISABLE_LOAD_FORMULA!" if Homebrew::EnvConfig.disable_load_formula? require "formula" require "ignorable" mod = Module.new remove_const(namespace) if const_defined?(namespace) const_set(namespace, mod) eval_formula = lambda do # Set `BUILD_FLAGS` in the formula's namespace so we can # access them from within the formula's class scope. mod.const_set(:BUILD_FLAGS, flags) mod.module_eval(contents, path) rescue NameError, ArgumentError, ScriptError, MethodDeprecatedError, MacOSVersion::Error => e if e.is_a?(Ignorable::ExceptionMixin) e.ignore else remove_const(namespace) raise FormulaUnreadableError.new(name, e) end end if ignore_errors Ignorable.hook_raise(&eval_formula) else eval_formula.call end class_name = class_s(name) begin mod.const_get(class_name) rescue NameError => e class_list = mod.constants .map { |const_name| mod.const_get(const_name) } .select { |const| const.is_a?(Class) } new_exception = FormulaClassUnavailableError.new(name, path, class_name, class_list) remove_const(namespace) raise new_exception, "", e.backtrace end end |
.load_formula_from_api(name, flags:) ⇒ T.class_of(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.
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 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 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 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 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 |
# File 'formulary.rb', line 141 def self.load_formula_from_api(name, flags:) namespace = :"FormulaNamespaceAPI#{Digest::MD5.hexdigest(name)}" mod = Module.new remove_const(namespace) if const_defined?(namespace) const_set(namespace, mod) mod.const_set(:BUILD_FLAGS, flags) class_name = class_s(name) json_formula = Homebrew::API::Formula.all_formulae[name] json_formula = Homebrew::API.merge_variations(json_formula) uses_from_macos_names = json_formula["uses_from_macos"].map do |dep| next dep unless dep.is_a? Hash dep.keys.first end requirements = {} json_formula["requirements"].map do |req| req_name = req["name"].to_sym next if API_SUPPORTED_REQUIREMENTS.exclude?(req_name) req_version = case req_name when :arch req["version"]&.to_sym when :macos, :maximum_macos MacOSVersion::SYMBOLS.key(req["version"]) else req["version"] end = [] << req_version if req_version.present? += req["contexts"].map do |tag| case tag when String tag.to_sym when Hash tag.deep_transform_keys(&:to_sym) else tag end end spec_hash = .empty? ? req_name : { req_name => } specs = req["specs"] specs ||= ["stable", "head"] # backwards compatibility specs.each do |spec| requirements[spec.to_sym] ||= [] requirements[spec.to_sym] << spec_hash end end add_deps = lambda do |spec| T.bind(self, SoftwareSpec) dep_json = json_formula.fetch("#{spec}_dependencies", json_formula) dep_json["dependencies"].each do |dep| # Backwards compatibility check - uses_from_macos used to be a part of dependencies on Linux next if !json_formula.key?("uses_from_macos_bounds") && uses_from_macos_names.include?(dep) && !Homebrew::SimulateSystem.simulating_or_running_on_macos? depends_on dep end [:build, :test, :recommended, :optional].each do |type| dep_json["#{type}_dependencies"].each do |dep| # Backwards compatibility check - uses_from_macos used to be a part of dependencies on Linux next if !json_formula.key?("uses_from_macos_bounds") && uses_from_macos_names.include?(dep) && !Homebrew::SimulateSystem.simulating_or_running_on_macos? depends_on dep => type end end dep_json["uses_from_macos"].each_with_index do |dep, index| bounds = dep_json.fetch("uses_from_macos_bounds", [])[index] || {} bounds.deep_transform_keys!(&:to_sym) bounds.deep_transform_values! { |val| val.is_a?(String) ? val.to_sym : val } if dep.is_a?(Hash) uses_from_macos dep.deep_transform_values(&:to_sym).merge(bounds) else uses_from_macos dep, bounds end end end klass = Class.new(::Formula) do @loaded_from_api = true desc json_formula["desc"] homepage json_formula["homepage"] license SPDX.string_to_license_expression(json_formula["license"]) revision json_formula["revision"] version_scheme json_formula["version_scheme"] if (urls_stable = json_formula["urls"]["stable"].presence) stable do url_spec = { tag: urls_stable["tag"], revision: urls_stable["revision"] }.compact url urls_stable["url"], **url_spec version json_formula["versions"]["stable"] sha256 urls_stable["checksum"] if urls_stable["checksum"].present? instance_exec(:stable, &add_deps) requirements[:stable]&.each do |req| depends_on req end end end if (urls_head = json_formula["urls"]["head"].presence) head do url_spec = { branch: urls_head["branch"] }.compact url urls_head["url"], **url_spec instance_exec(:head, &add_deps) requirements[:head]&.each do |req| depends_on req end end end if (bottles_stable = json_formula["bottle"]["stable"].presence) bottle do if Homebrew::EnvConfig.bottle_domain == HOMEBREW_BOTTLE_DEFAULT_DOMAIN root_url HOMEBREW_BOTTLE_DEFAULT_DOMAIN else root_url Homebrew::EnvConfig.bottle_domain end rebuild bottles_stable["rebuild"] bottles_stable["files"].each do |tag, bottle_spec| cellar = Formulary.convert_to_string_or_symbol bottle_spec["cellar"] sha256 cellar: cellar, tag.to_sym => bottle_spec["sha256"] end end end if (keg_only_reason = json_formula["keg_only_reason"].presence) reason = Formulary.convert_to_string_or_symbol keg_only_reason["reason"] keg_only reason, keg_only_reason["explanation"] end if (deprecation_date = json_formula["deprecation_date"].presence) reason = Formulary.convert_to_deprecate_disable_reason_string_or_symbol json_formula["deprecation_reason"] deprecate! date: deprecation_date, because: reason end if (disable_date = json_formula["disable_date"].presence) reason = Formulary.convert_to_deprecate_disable_reason_string_or_symbol json_formula["disable_reason"] disable! date: disable_date, because: reason end json_formula["conflicts_with"].each_with_index do |conflict, index| conflicts_with conflict, because: json_formula.dig("conflicts_with_reasons", index) end json_formula["link_overwrite"]&.each do |overwrite_path| link_overwrite overwrite_path end def install raise "Cannot build from source from abstract formula." end @post_install_defined_boolean = json_formula["post_install_defined"] @post_install_defined_boolean = true if @post_install_defined_boolean.nil? # Backwards compatibility def post_install_defined? self.class.instance_variable_get(:@post_install_defined_boolean) end if (service_hash = json_formula["service"].presence) service_hash = Homebrew::Service.deserialize(service_hash) service do T.bind(self, Homebrew::Service) if (run_params = service_hash.delete(:run).presence) case run_params when Hash run(**run_params) when Array, String run run_params end end if (name_params = service_hash.delete(:name).presence) name(**name_params) end service_hash.each do |key, arg| public_send(key, arg) end end end @caveats_string = json_formula["caveats"] def caveats self.class.instance_variable_get(:@caveats_string) &.gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX) &.gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR) &.gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home) end @tap_git_head_string = json_formula["tap_git_head"] def tap_git_head self.class.instance_variable_get(:@tap_git_head_string) end @oldnames_array = json_formula["oldnames"] || [json_formula["oldname"]].compact def oldnames self.class.instance_variable_get(:@oldnames_array) end @aliases_array = json_formula["aliases"] def aliases self.class.instance_variable_get(:@aliases_array) end @versioned_formulae_array = json_formula["versioned_formulae"] def versioned_formulae_names self.class.instance_variable_get(:@versioned_formulae_array) end @ruby_source_path_string = json_formula["ruby_source_path"] def ruby_source_path self.class.instance_variable_get(:@ruby_source_path_string) end @ruby_source_checksum_hash = json_formula["ruby_source_checksum"] def ruby_source_checksum checksum_hash = self.class.instance_variable_get(:@ruby_source_checksum_hash) Checksum.new(checksum_hash["sha256"]) if checksum_hash&.key?("sha256") end end klass = T.cast(klass, T.class_of(Formula)) mod.const_set(class_name, klass) cache[:api] ||= {} cache[:api][name] = klass end |
.load_formula_from_path(name, path, flags:, ignore_errors:) ⇒ T.class_of(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.
132 133 134 135 136 137 138 |
# File 'formulary.rb', line 132 def self.load_formula_from_path(name, path, flags:, ignore_errors:) contents = path.open("r") { |f| ensure_utf8_encoding(f).read } namespace = "FormulaNamespace#{Digest::MD5.hexdigest(path.to_s)}" klass = load_formula(name, path, contents, namespace, flags: flags, ignore_errors: ignore_errors) cache[:path] ||= {} cache[:path][path] = klass end |
.loader_for(ref, from: nil, warn: true) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 |
# File 'formulary.rb', line 922 def self.loader_for(ref, from: nil, warn: true) case ref when HOMEBREW_BOTTLES_EXTNAME_REGEX return BottleLoader.new(ref) when URL_START_REGEX return FromUrlLoader.new(ref, from: from) when HOMEBREW_TAP_FORMULA_REGEX if ref.match?(%r{^homebrew/(?:homebrew-)?core/}i) && !Homebrew::EnvConfig.no_install_from_api? name = ref.split("/", 3).last return FormulaAPILoader.new(name) if Homebrew::API::Formula.all_formulae.key?(name) return AliasAPILoader.new(name) if Homebrew::API::Formula.all_aliases.key?(name) end return TapLoader.new(ref, from: from, warn: warn) end pathname_ref = Pathname.new(ref) return FromPathLoader.new(ref) if File.extname(ref) == ".rb" && pathname_ref..exist? unless Homebrew::EnvConfig.no_install_from_api? return FormulaAPILoader.new(ref) if Homebrew::API::Formula.all_formulae.key?(ref) return AliasAPILoader.new(ref) if Homebrew::API::Formula.all_aliases.key?(ref) end formula_with_that_name = core_path(ref) return FormulaLoader.new(ref, formula_with_that_name) if formula_with_that_name.file? possible_alias = if pathname_ref.absolute? pathname_ref else core_alias_path(ref) end return AliasLoader.new(possible_alias) if possible_alias.symlink? possible_tap_formulae = tap_paths(ref) raise TapFormulaAmbiguityError.new(ref, possible_tap_formulae) if possible_tap_formulae.size > 1 if possible_tap_formulae.size == 1 path = possible_tap_formulae.first.resolved_path name = path.basename(".rb").to_s return FormulaLoader.new(name, path) end if CoreTap.instance.formula_renames.key?(ref) return TapLoader.new("#{CoreTap.instance}/#{ref}", from: from, warn: warn) end possible_taps = Tap.select { |tap| tap.formula_renames.key?(ref) } if possible_taps.size > 1 possible_tap_newname_formulae = possible_taps.map { |tap| "#{tap}/#{tap.formula_renames[ref]}" } raise TapFormulaWithOldnameAmbiguityError.new(ref, possible_tap_newname_formulae) end return TapLoader.new("#{possible_taps.first}/#{ref}", from: from, warn: warn) unless possible_taps.empty? possible_keg_formula = Pathname.new("#{HOMEBREW_PREFIX}/opt/#{ref}/.brew/#{ref}.rb") return FormulaLoader.new(ref, possible_keg_formula) if possible_keg_formula.file? possible_cached_formula = Pathname.new("#{HOMEBREW_CACHE_FORMULA}/#{ref}.rb") return FormulaLoader.new(ref, possible_cached_formula) if possible_cached_formula.file? NullLoader.new(ref) end |
.path(ref) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
918 919 920 |
# File 'formulary.rb', line 918 def self.path(ref) loader_for(ref).path end |
.resolve(name, spec: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil)) ⇒ 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.
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 |
# File 'formulary.rb', line 390 def self.resolve( name, spec: T.unsafe(nil), force_bottle: T.unsafe(nil), flags: T.unsafe(nil) ) = { force_bottle: force_bottle, flags: flags, }.compact if name.include?("/") || File.exist?(name) f = factory(name, *spec, **) if f.any_version_installed? tab = Tab.for_formula(f) resolved_spec = spec || tab.spec f.active_spec = resolved_spec if f.send(resolved_spec) f.build = tab if f.head? && tab.tabfile k = Keg.new(tab.tabfile.parent) f.version.update_commit(k.version.version.commit) if k.version.head? end end else rack = to_rack(name) if (alias_path = factory(name, **).alias_path) [:alias_path] = alias_path end f = from_rack(rack, *spec, **) end # If this formula was installed with an alias that has since changed, # then it was specified explicitly in ARGV. (Using the alias would # instead have found the new formula.) # # Because of this, the user is referring to this specific formula, # not any formula targeted by the same alias, so in this context # the formula shouldn't be considered outdated if the alias used to # install it has changed. f.follow_installed_alias = false f end |
.tap_paths(name, taps = Tap) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
995 996 997 998 999 1000 1001 1002 1003 1004 1005 |
# File 'formulary.rb', line 995 def self.tap_paths(name, taps = Tap) name = name.to_s.downcase taps.map do |tap| formula_path = find_formula_in_tap(name, tap) alias_path = tap.alias_dir/name next alias_path if !formula_path.exist? && alias_path.exist? formula_path end.select(&:file?) end |
.to_rack(ref) ⇒ Object
This method is part of a private API. This method may only be used in the Homebrew/brew repository. Third parties should avoid using this method if possible, as it may be removed or changed without warning.
897 898 899 900 901 902 903 904 905 906 907 908 |
# File 'formulary.rb', line 897 def self.to_rack(ref) # If using a fully-scoped reference, check if the formula can be resolved. factory(ref) if ref.include? "/" # Check whether the rack with the given name exists. if (rack = HOMEBREW_CELLAR/File.basename(ref, ".rb")).directory? return rack.resolved_path end # Use canonical name to locate rack. (HOMEBREW_CELLAR/canonical_name(ref)).resolved_path end |