admin/brew
1
0
Fork 0
Code Issues Packages Projects Releases 6 Wiki Activity

Fix namespacing

Browse Source
This commit is contained in:
Douglas Eichelberger 2024-09-13 12:22:52 -07:00
parent 7cd329c116
commit bb80f063dc
22 changed files with 278 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Library/Homebrew/attestation.rb
View File

@ -60,7 +60,7 @@ module Homebrew
return false if Homebrew::EnvConfig.no_verify_attestations?
return true if Homebrew::EnvConfig.verify_attestations?
return false if ENV.fetch("CI", false)
return false if OS.unsupported_configuration?
return false if ::OS.unsupported_configuration?
# Always check credentials last to avoid unnecessary credential extraction.
(Homebrew::EnvConfig.developer? || Homebrew::EnvConfig.devcmdrun?) && GitHub::API.credentials.present?

4
Library/Homebrew/dev-cmd/bottle.rb
View File

@ -394,10 +394,10 @@ module Homebrew
# On Linux, GCC installation can be moved so long as the whole directory tree is moved together:
# https://gcc-help.gcc.gnu.narkive.com/GnwuCA7l/moving-gcc-from-the-installation-path-is-it-allowed.
when Version.formula_optionally_versioned_regex(:gcc)
Regexp.union(%r{#{cellar_regex}/gcc}, %r{#{prefix_regex}/opt/gcc}) if OS.linux?
Regexp.union(%r{#{cellar_regex}/gcc}, %r{#{prefix_regex}/opt/gcc}) if ::OS.linux?
# binutils is relocatable for the same reason: https://github.com/Homebrew/brew/pull/11899#issuecomment-906804451.
when Version.formula_optionally_versioned_regex(:binutils)
%r{#{cellar_regex}/binutils} if OS.linux?
%r{#{cellar_regex}/binutils} if ::OS.linux?
end
# rubocop:enable Homebrew/MoveToExtendOS

4
Library/Homebrew/dev-cmd/tests.rb
View File

@ -116,12 +116,12 @@ module Homebrew
# TODO: Refactor and move to extend/os
# rubocop:disable Homebrew/MoveToExtendOS
unless OS.mac?
unless ::OS.mac?
bundle_args << "--tag" << "~needs_macos" << "--tag" << "~cask"
files = files.grep_v(%r{^test/(os/mac|cask)(/.*|_spec\.rb)$})
end
unless OS.linux?
unless ::OS.linux?
bundle_args << "--tag" << "~needs_linux"
files = files.grep_v(%r{^test/os/linux(/.*|_spec\.rb)$})
end

32
Library/Homebrew/extend/os/linux/cleanup.rb
View File

@ -2,26 +2,30 @@
# frozen_string_literal: true
module Homebrew
module CleanupLinux
extend T::Helpers
module OS
module Linux
module Cleanup
extend T::Helpers
requires_ancestor { Cleanup }
requires_ancestor { Homebrew::Cleanup }
sig { returns(T::Boolean) }
def use_system_ruby?
return false if Homebrew::EnvConfig.force_vendor_ruby?
sig { returns(T::Boolean) }
def use_system_ruby?
return false if Homebrew::EnvConfig.force_vendor_ruby?
rubies = [which("ruby"), which("ruby", ORIGINAL_PATHS)].compact
system_ruby = Pathname.new("/usr/bin/ruby")
rubies << system_ruby if system_ruby.exist?
rubies = [which("ruby"), which("ruby", ORIGINAL_PATHS)].compact
system_ruby = Pathname.new("/usr/bin/ruby")
rubies << system_ruby if system_ruby.exist?
check_ruby_version = HOMEBREW_LIBRARY_PATH/"utils/ruby_check_version_script.rb"
rubies.uniq.any? do |ruby|
quiet_system ruby, "--enable-frozen-string-literal", "--disable=gems,did_you_mean,rubyopt",
check_ruby_version, RUBY_VERSION
check_ruby_version = HOMEBREW_LIBRARY_PATH/"utils/ruby_check_version_script.rb"
rubies.uniq.any? do |ruby|
quiet_system ruby, "--enable-frozen-string-literal", "--disable=gems,did_you_mean,rubyopt",
check_ruby_version, RUBY_VERSION
end
end
end
end
end
end
Homebrew::Cleanup.prepend(Homebrew::CleanupLinux)
Homebrew::Cleanup.prepend(Homebrew::OS::Linux::Cleanup)

33
Library/Homebrew/extend/os/linux/cli/parser.rb Normal file
View File

@ -0,0 +1,33 @@
# typed: strict
# frozen_string_literal: true
module Homebrew
module OS
module Linux
module CLI
module Parser
extend T::Helpers
requires_ancestor { Homebrew::CLI::Parser }
sig { void }
def set_default_options
args["formula?"] = true if args.respond_to?(:formula?)
end
sig { void }
def validate_options
return unless args.respond_to?(:cask?)
return unless args.cask?
# NOTE: We don't raise an error here because we don't want
# to print the help page or a stack trace.
odie "Invalid `--cask` usage: Casks do not work on Linux"
end
end
end
end
end
end
Homebrew::CLI::Parser.prepend(Homebrew::OS::Linux::CLI::Parser)

12
Library/Homebrew/extend/os/linux/diagnostic.rb
View File

@ -95,11 +95,11 @@ module Homebrew
end
def check_glibc_minimum_version
return unless OS::Linux::Glibc.below_minimum_version?
return unless ::OS::Linux::Glibc.below_minimum_version?
<<~EOS
Your system glibc #{OS::Linux::Glibc.system_version} is too old.
We only support glibc #{OS::Linux::Glibc.minimum_version} or later.
Your system glibc #{::OS::Linux::Glibc.system_version} is too old.
We only support glibc #{::OS::Linux::Glibc.minimum_version} or later.
#{please_create_pull_requests}
We recommend updating to a newer version via your distribution's
package manager, upgrading your distribution to the latest version,
@ -108,11 +108,11 @@ module Homebrew
end
def check_kernel_minimum_version
return unless OS::Linux::Kernel.below_minimum_version?
return unless ::OS::Linux::Kernel.below_minimum_version?
<<~EOS
Your Linux kernel #{OS.kernel_version} is too old.
We only support kernel #{OS::Linux::Kernel.minimum_version} or later.
Your Linux kernel #{::OS.kernel_version} is too old.
We only support kernel #{::OS::Linux::Kernel.minimum_version} or later.
You will be unable to use binary packages (bottles).
#{please_create_pull_requests}
We recommend updating to a newer version via your distribution's

92
Library/Homebrew/extend/os/linux/formula.rb
View File

@ -1,52 +1,58 @@
# typed: true # rubocop:disable Sorbet/StrictSigil
# frozen_string_literal: true
module FormulaLinux
extend T::Helpers
module Homebrew
module OS
module Linux
module Formula
extend T::Helpers
requires_ancestor { Formula }
requires_ancestor { ::Formula }
sig { params(name: String, version: T.nilable(T.any(String, Integer))).returns(String) }
def shared_library(name, version = nil)
suffix = if version == "*" || (name == "*" && version.blank?)
"{,.*}"
elsif version.present?
".#{version}"
sig { params(name: String, version: T.nilable(T.any(String, Integer))).returns(String) }
def shared_library(name, version = nil)
suffix = if version == "*" || (name == "*" && version.blank?)
"{,.*}"
elsif version.present?
".#{version}"
end
"#{name}.so#{suffix}"
end
sig { returns(String) }
def loader_path
"$ORIGIN"
end
sig { params(targets: T.nilable(T.any(Pathname, String))).void }
def deuniversalize_machos(*targets); end
sig { params(spec: SoftwareSpec).void }
def add_global_deps_to_spec(spec)
return unless DevelopmentTools.needs_build_formulae?
@global_deps ||= begin
dependency_collector = spec.dependency_collector
related_formula_names = Set.new([
name,
*aliases,
*versioned_formulae_names,
])
[
dependency_collector.gcc_dep_if_needed(related_formula_names),
dependency_collector.glibc_dep_if_needed(related_formula_names),
].compact.freeze
end
@global_deps.each { |dep| spec.dependency_collector.add(dep) }
end
sig { returns(T::Boolean) }
def valid_platform?
requirements.none?(MacOSRequirement)
end
end
end
"#{name}.so#{suffix}"
end
sig { returns(String) }
def loader_path
"$ORIGIN"
end
sig { params(targets: T.nilable(T.any(Pathname, String))).void }
def deuniversalize_machos(*targets); end
sig { params(spec: SoftwareSpec).void }
def add_global_deps_to_spec(spec)
return unless DevelopmentTools.needs_build_formulae?
@global_deps ||= begin
dependency_collector = spec.dependency_collector
related_formula_names = Set.new([
name,
*aliases,
*versioned_formulae_names,
])
[
dependency_collector.gcc_dep_if_needed(related_formula_names),
dependency_collector.glibc_dep_if_needed(related_formula_names),
].compact.freeze
end
@global_deps.each { |dep| spec.dependency_collector.add(dep) }
end
sig { returns(T::Boolean) }
def valid_platform?
requirements.none?(MacOSRequirement)
end
end
Formula.prepend(FormulaLinux)
Formula.prepend(Homebrew::OS::Linux::Formula)

2
Library/Homebrew/extend/os/linux/install.rb
View File

@ -78,7 +78,7 @@ module Homebrew
private_class_method :symlink_ld_so
def self.setup_preferred_gcc_libs
gcc_opt_prefix = HOMEBREW_PREFIX/"opt/#{OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA}"
gcc_opt_prefix = HOMEBREW_PREFIX/"opt/#{::OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA}"
glibc_installed = (HOMEBREW_PREFIX/"opt/glibc/bin/ld.so").readable?
return unless gcc_opt_prefix.readable?

29
Library/Homebrew/extend/os/linux/parser.rb
View File

@ -1,29 +0,0 @@
# typed: strict
# frozen_string_literal: true
module Homebrew
module CLI
module ParserLinux
extend T::Helpers
requires_ancestor { Homebrew::CLI::Parser }
sig { void }
def set_default_options
args["formula?"] = true if args.respond_to?(:formula?)
end
sig { void }
def validate_options
return unless args.respond_to?(:cask?)
return unless args.cask?
# NOTE: We don't raise an error here because we don't want
# to print the help page or a stack trace.
odie "Invalid `--cask` usage: Casks do not work on Linux"
end
end
end
end
Homebrew::CLI::Parser.prepend(Homebrew::CLI::ParserLinux)

18
Library/Homebrew/extend/os/mac/cleaner.rb
View File

@ -1,13 +1,19 @@
# typed: strict
# frozen_string_literal: true
module CleanerMac
private
module Homebrew
module OS
module MacOS
module Cleaner
private
sig { params(path: Pathname).returns(T::Boolean) }
def executable_path?(path)
path.mach_o_executable? || path.text_executable?
sig { params(path: Pathname).returns(T::Boolean) }
def executable_path?(path)
path.mach_o_executable? || path.text_executable?
end
end
end
end
end
Cleaner.prepend(CleanerMac)
Cleaner.prepend(Homebrew::OS::MacOS::Cleaner)

16
Library/Homebrew/extend/os/mac/cleanup.rb
View File

@ -2,14 +2,18 @@
# frozen_string_literal: true
module Homebrew
module CleanupMac
sig { returns(T::Boolean) }
def use_system_ruby?
return false if Homebrew::EnvConfig.force_vendor_ruby?
module OS
module MacOS
module Cleanup
sig { returns(T::Boolean) }
def use_system_ruby?
return false if Homebrew::EnvConfig.force_vendor_ruby?
Homebrew::EnvConfig.developer? && ENV["HOMEBREW_USE_RUBY_FROM_PATH"].present?
Homebrew::EnvConfig.developer? && ENV["HOMEBREW_USE_RUBY_FROM_PATH"].present?
end
end
end
end
end
Homebrew::Cleanup.prepend(Homebrew::CleanupMac)
Homebrew::Cleanup.prepend(Homebrew::OS::MacOS::Cleanup)

32
Library/Homebrew/extend/os/mac/dev-cmd/bottle.rb
View File

@ -2,23 +2,27 @@
# frozen_string_literal: true
module Homebrew
module DevCmd
module BottleMac
sig { returns(T::Array[String]) }
def tar_args
if MacOS.version >= :catalina
["--no-mac-metadata", "--no-acls", "--no-xattrs"].freeze
else
[].freeze
end
end
module OS
module MacOS
module DevCmd
module Bottle
sig { returns(T::Array[String]) }
def tar_args
if ::MacOS.version >= :catalina
["--no-mac-metadata", "--no-acls", "--no-xattrs"].freeze
else
[].freeze
end
end
sig { params(gnu_tar_formula: Formula).returns(String) }
def gnu_tar(gnu_tar_formula)
"#{gnu_tar_formula.opt_bin}/gtar"
sig { params(gnu_tar_formula: Formula).returns(String) }
def gnu_tar(gnu_tar_formula)
"#{gnu_tar_formula.opt_bin}/gtar"
end
end
end
end
end
end
Homebrew::DevCmd::Bottle.prepend(Homebrew::DevCmd::BottleMac)
Homebrew::DevCmd::Bottle.prepend(Homebrew::OS::MacOS::DevCmd::Bottle)

6
Library/Homebrew/extend/os/mac/diagnostic.rb
View File

@ -110,9 +110,9 @@ module Homebrew
return if ENV["HOMEBREW_INTEGRATION_TEST"]
who = +"We"
what = if OS::Mac.version.prerelease?
what = if ::OS::Mac.version.prerelease?
"pre-release version"
elsif OS::Mac.version.outdated_release?
elsif ::OS::Mac.version.outdated_release?
who << " (and Apple)"
"old version"
end
@ -149,7 +149,7 @@ module Homebrew
#{MacOS::Xcode.update_instructions}
EOS
if OS::Mac.version.prerelease?
if ::OS::Mac.version.prerelease?
current_path = Utils.popen_read("/usr/bin/xcode-select", "-p")
message += <<~EOS
If #{MacOS::Xcode.latest_version} is installed, you may need to:

53
Library/Homebrew/extend/os/mac/formula.rb
View File

@ -1,36 +1,41 @@
# typed: strict
# frozen_string_literal: true
module FormulaMac
extend T::Helpers
module Homebrew
module OS
module MacOS
module Formula
extend T::Helpers
requires_ancestor { Formula }
requires_ancestor { ::Formula }
sig { returns(T::Boolean) }
def valid_platform?
requirements.none?(LinuxRequirement)
end
sig { returns(T::Boolean) }
def valid_platform?
requirements.none?(LinuxRequirement)
end
sig {
params(
install_prefix: T.any(String, Pathname),
install_libdir: T.any(String, Pathname),
find_framework: String,
).returns(T::Array[String])
}
def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST")
args = generic_std_cmake_args(install_prefix:, install_libdir:,
find_framework:)
sig {
params(
install_prefix: T.any(String, Pathname),
install_libdir: T.any(String, Pathname),
find_framework: String,
).returns(T::Array[String])
}
def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST")
args = generic_std_cmake_args(install_prefix:, install_libdir:, find_framework:)
# Avoid false positives for clock_gettime support on 10.11.
# CMake cache entries for other weak symbols may be added here as needed.
args << "-DHAVE_CLOCK_GETTIME:INTERNAL=0" if MacOS.version == "10.11" && MacOS::Xcode.version >= "8.0"
# Avoid false positives for clock_gettime support on 10.11.
# CMake cache entries for other weak symbols may be added here as needed.
args << "-DHAVE_CLOCK_GETTIME:INTERNAL=0" if ::MacOS.version == "10.11" && ::MacOS::Xcode.version >= "8.0"
# Ensure CMake is using the same SDK we are using.
args << "-DCMAKE_OSX_SYSROOT=#{MacOS.sdk_for_formula(self).path}" if MacOS.sdk_root_needed?
# Ensure CMake is using the same SDK we are using.
args << "-DCMAKE_OSX_SYSROOT=#{::MacOS.sdk_for_formula(self).path}" if ::MacOS.sdk_root_needed?
args
args
end
end
end
end
end
Formula.prepend(FormulaMac)
Formula.prepend(Homebrew::OS::MacOS::Formula)

22
Library/Homebrew/extend/os/mac/formula_installer.rb
View File

@ -1,16 +1,22 @@
# typed: strict
# frozen_string_literal: true
module FormulaInstallerMac
extend T::Helpers
module Homebrew
module OS
module MacOS
module FormulaInstaller
extend T::Helpers
requires_ancestor { FormulaInstaller }
requires_ancestor { ::FormulaInstaller }
sig { params(formula: Formula).returns(T.nilable(T::Boolean)) }
def fresh_install?(formula)
!Homebrew::EnvConfig.developer? && !OS::Mac.version.outdated_release? &&
(!installed_as_dependency? || !formula.any_version_installed?)
sig { params(formula: Formula).returns(T.nilable(T::Boolean)) }
def fresh_install?(formula)
!Homebrew::EnvConfig.developer? && !::OS::Mac.version.outdated_release? &&
(!installed_as_dependency? || !formula.any_version_installed?)
end
end
end
end
end
FormulaInstaller.prepend(FormulaInstallerMac)
FormulaInstaller.prepend(Homebrew::OS::MacOS::FormulaInstaller)

20
Library/Homebrew/extend/os/mac/linkage_checker.rb
View File

@ -1,14 +1,20 @@
# typed: strict
# frozen_string_literal: true
module LinkageCheckerMac
private
module Homebrew
module OS
module MacOS
module LinkageChecker
private
sig { returns(T::Boolean) }
def system_libraries_exist_in_cache?
# In macOS Big Sur and later, system libraries do not exist on-disk and instead exist in a cache.
MacOS.version >= :big_sur
sig { returns(T::Boolean) }
def system_libraries_exist_in_cache?
# In macOS Big Sur and later, system libraries do not exist on-disk and instead exist in a cache.
::MacOS.version >= :big_sur
end
end
end
end
end
LinkageChecker.prepend(LinkageCheckerMac)
LinkageChecker.prepend(Homebrew::OS::MacOS::LinkageChecker)

64
Library/Homebrew/extend/os/mac/readall.rb
View File

@ -1,42 +1,48 @@
# typed: strict
# frozen_string_literal: true
module ReadallMac
extend T::Helpers
module Homebrew
module OS
module MacOS
module Readall
extend T::Helpers
requires_ancestor { Kernel }
requires_ancestor { Kernel }
sig { params(tap: Tap, os_name: T.nilable(Symbol), arch: T.nilable(Symbol)).returns(T::Boolean) }
def valid_casks?(tap, os_name: nil, arch: Hardware::CPU.type)
return true if os_name == :linux
sig { params(tap: Tap, os_name: T.nilable(Symbol), arch: T.nilable(Symbol)).returns(T::Boolean) }
def valid_casks?(tap, os_name: nil, arch: Hardware::CPU.type)
return true if os_name == :linux
current_macos_version = if os_name.is_a?(Symbol)
MacOSVersion.from_symbol(os_name)
else
MacOS.version
end
current_macos_version = if os_name.is_a?(Symbol)
MacOSVersion.from_symbol(os_name)
else
::MacOS.version
end
success = T.let(true, T::Boolean)
tap.cask_files.each do |file|
cask = Cask::CaskLoader.load(file)
success = T.let(true, T::Boolean)
tap.cask_files.each do |file|
cask = Cask::CaskLoader.load(file)
# Fine to have missing URLs for unsupported macOS
macos_req = cask.depends_on.macos
next if macos_req&.version && Array(macos_req.version).none? do |macos_version|
current_macos_version.compare(macos_req.comparator, macos_version)
# Fine to have missing URLs for unsupported macOS
macos_req = cask.depends_on.macos
next if macos_req&.version && Array(macos_req.version).none? do |macos_version|
current_macos_version.compare(macos_req.comparator, macos_version)
end
raise "Missing URL" if cask.url.nil?
rescue Interrupt
raise
rescue Exception => e # rubocop:disable Lint/RescueException
os_and_arch = "macOS #{current_macos_version} on #{arch}"
onoe "Invalid cask (#{os_and_arch}): #{file}"
$stderr.puts e
success = false
end
success
end
end
raise "Missing URL" if cask.url.nil?
rescue Interrupt
raise
rescue Exception => e # rubocop:disable Lint/RescueException
os_and_arch = "macOS #{current_macos_version} on #{arch}"
onoe "Invalid cask (#{os_and_arch}): #{file}"
$stderr.puts e
success = false
end
success
end
end
Readall.singleton_class.prepend(ReadallMac)
Readall.singleton_class.prepend(Homebrew::OS::MacOS::Readall)

23
Library/Homebrew/extend/os/mac/simulate_system.rb
View File

@ -2,17 +2,22 @@
# frozen_string_literal: true
module Homebrew
module SimulateSystemMac
sig { returns(T::Boolean) }
def simulating_or_running_on_macos?
SimulateSystem.os.blank? || [:macos, *MacOSVersion::SYMBOLS.keys].include?(SimulateSystem.os)
end
module OS
module MacOS
module SimulateSystem
sig { returns(T::Boolean) }
def simulating_or_running_on_macos?
Homebrew::SimulateSystem.os.blank? || [:macos,
*MacOSVersion::SYMBOLS.keys].include?(Homebrew::SimulateSystem.os)
end
sig { returns(Symbol) }
def current_os
SimulateSystem.os || MacOS.version.to_sym
sig { returns(Symbol) }
def current_os
Homebrew::SimulateSystem.os || ::MacOS.version.to_sym
end
end
end
end
end
Homebrew::SimulateSystem.singleton_class.prepend(Homebrew::SimulateSystemMac)
Homebrew::SimulateSystem.singleton_class.prepend(Homebrew::OS::MacOS::SimulateSystem)

2
Library/Homebrew/extend/os/parser.rb
View File

@ -1,4 +1,4 @@
# typed: strict
# frozen_string_literal: true
require "extend/os/linux/parser" if OS.linux?
require "extend/os/linux/cli/parser" if OS.linux?

4
Library/Homebrew/formula_auditor.rb
View File

@ -504,9 +504,9 @@ module Homebrew
return unless @core_tap
return if formula.name != "glibc"
# Also allow LINUX_GLIBC_NEXT_CI_VERSION for when we're upgrading.
return if [OS::LINUX_GLIBC_CI_VERSION, OS::LINUX_GLIBC_NEXT_CI_VERSION].include?(formula.version.to_s)
return if [::OS::LINUX_GLIBC_CI_VERSION, ::OS::LINUX_GLIBC_NEXT_CI_VERSION].include?(formula.version.to_s)
problem "The glibc version must be #{OS::LINUX_GLIBC_CI_VERSION}, as needed by our CI on Linux. " \
problem "The glibc version must be #{::OS::LINUX_GLIBC_CI_VERSION}, as needed by our CI on Linux. " \
"The glibc formula is for users who have a system glibc with a lower version, " \
"which allows them to use our Linux bottles, which were compiled against system glibc on CI."
end

2
Library/Homebrew/rubocops/move_to_extend_os.rb
View File

@ -9,7 +9,7 @@ module RuboCop
MSG = "Move `OS.linux?` and `OS.mac?` calls to `extend/os`."
def_node_matcher :os_check?, <<~PATTERN
(send (const nil? :OS) {:mac? | :linux?})
(send (const {nil? cbase} :OS) {:mac? | :linux?})
PATTERN
def on_send(node)

14
Library/Homebrew/test/rubocops/move_to_extend_os_spec.rb
View File

@ -18,4 +18,18 @@ RSpec.describe RuboCop::Cop::Homebrew::MoveToExtendOS do
^^^^^^^ Homebrew/MoveToExtendOS: Move `OS.linux?` and `OS.mac?` calls to `extend/os`.
RUBY
end
it "registers an offense when using `::OS.linux?`" do
expect_offense(<<~RUBY)
::OS.linux?
^^^^^^^^^^^ Homebrew/MoveToExtendOS: Move `OS.linux?` and `OS.mac?` calls to `extend/os`.
RUBY
end
it "registers an offense when using `::OS.mac?`" do
expect_offense(<<~RUBY)
::OS.mac?
^^^^^^^^^ Homebrew/MoveToExtendOS: Move `OS.linux?` and `OS.mac?` calls to `extend/os`.
RUBY
end
end