From 827492021711d688a4426ae5fda1071b02d2abe4 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 9 May 2023 02:15:28 +0200 Subject: [PATCH] Rename `OS::Mac::Version` to `MacOSVersion`. --- Library/Homebrew/ast_constants.rb | 4 +- Library/Homebrew/brew.sh | 2 +- Library/Homebrew/cask/audit.rb | 4 +- Library/Homebrew/cask/cask.rb | 2 +- Library/Homebrew/cask/cask_loader.rb | 4 +- Library/Homebrew/cask/download.rb | 4 +- Library/Homebrew/cask/dsl/depends_on.rb | 4 +- Library/Homebrew/cask/macos.rb | 2 - .../Homebrew/dev-cmd/dispatch-build-bottle.rb | 4 +- Library/Homebrew/exceptions.rb | 10 -- Library/Homebrew/extend/on_system.rb | 8 +- Library/Homebrew/extend/os/mac/diagnostic.rb | 2 +- Library/Homebrew/extend/os/mac/hardware.rb | 2 +- Library/Homebrew/extend/os/mac/readall.rb | 2 +- .../Homebrew/extend/os/mac/simulate_system.rb | 2 +- .../Homebrew/extend/os/mac/utils/bottles.rb | 4 +- Library/Homebrew/formula.rb | 2 +- Library/Homebrew/formula_auditor.rb | 4 +- Library/Homebrew/formulary.rb | 4 +- Library/Homebrew/github_runner.rb | 2 +- Library/Homebrew/github_runner_matrix.rb | 6 +- Library/Homebrew/global.rb | 2 +- .../Homebrew/livecheck/strategy/sparkle.rb | 4 +- Library/Homebrew/macos_version.rb | 162 ++++++++++++++++++ Library/Homebrew/macos_versions.rb | 20 --- Library/Homebrew/os.rb | 1 + Library/Homebrew/os/linux.rb | 5 +- Library/Homebrew/os/mac.rb | 13 +- Library/Homebrew/os/mac/sdk.rb | 16 +- Library/Homebrew/os/mac/version.rb | 124 -------------- Library/Homebrew/os/mac/xcode.rb | 10 +- Library/Homebrew/readall.rb | 2 +- .../requirements/macos_requirement.rb | 8 +- .../rubocops/cask/constants/stanza.rb | 4 +- .../Homebrew/rubocops/extend/formula_cop.rb | 2 +- Library/Homebrew/rubocops/lines.rb | 2 +- .../shared/on_system_conditionals_helper.rb | 4 +- Library/Homebrew/simulate_system.rb | 4 +- Library/Homebrew/software_spec.rb | 8 +- Library/Homebrew/test/cask/cask_spec.rb | 4 +- .../Homebrew/test/cask/dsl/caveats_spec.rb | 4 +- .../dev-cmd/determine-test-runners_spec.rb | 4 +- Library/Homebrew/test/formula_spec.rb | 4 +- .../test/github_runner_matrix_spec.rb | 2 +- Library/Homebrew/test/github_runner_spec.rb | 2 +- .../version_spec.rb => macos_version_spec.rb} | 11 +- .../Homebrew/test/os/mac/diagnostic_spec.rb | 16 +- Library/Homebrew/test/os/mac/formula_spec.rb | 2 +- Library/Homebrew/test/os/mac/sdk_spec.rb | 30 ++-- Library/Homebrew/test/software_spec_spec.rb | 4 +- .../Homebrew/test/test_runner_formula_spec.rb | 12 +- .../test/utils/bottles/bottles_spec.rb | 2 +- .../Homebrew/test/utils/bottles/tag_spec.rb | 6 +- Library/Homebrew/test_runner_formula.rb | 2 +- Library/Homebrew/utils/bottles.rb | 6 +- Library/Homebrew/version.rb | 2 +- 56 files changed, 293 insertions(+), 289 deletions(-) create mode 100644 Library/Homebrew/macos_version.rb delete mode 100644 Library/Homebrew/macos_versions.rb delete mode 100644 Library/Homebrew/os/mac/version.rb rename Library/Homebrew/test/{os/mac/version_spec.rb => macos_version_spec.rb} (90%) diff --git a/Library/Homebrew/ast_constants.rb b/Library/Homebrew/ast_constants.rb index 7622f0a2d3..cc778677fa 100644 --- a/Library/Homebrew/ast_constants.rb +++ b/Library/Homebrew/ast_constants.rb @@ -1,7 +1,7 @@ # typed: true # frozen_string_literal: true -require "macos_versions" +require "macos_version" FORMULA_COMPONENT_PRECEDENCE_LIST = [ [{ name: :include, type: :method_call }], @@ -29,7 +29,7 @@ FORMULA_COMPONENT_PRECEDENCE_LIST = [ [{ name: :depends_on, type: :method_call }], [{ name: :uses_from_macos, type: :method_call }], [{ name: :on_macos, type: :block_call }], - *MacOSVersions::SYMBOLS.keys.map do |os_name| + *MacOSVersion::SYMBOLS.keys.map do |os_name| [{ name: :"on_#{os_name}", type: :block_call }] end, [{ name: :on_system, type: :block_call }], diff --git a/Library/Homebrew/brew.sh b/Library/Homebrew/brew.sh index dd7aec3392..069c8b7d8f 100644 --- a/Library/Homebrew/brew.sh +++ b/Library/Homebrew/brew.sh @@ -461,7 +461,7 @@ esac # TODO: bump version when new macOS is released or announced # and also update references in docs/Installation.md, # https://github.com/Homebrew/install/blob/HEAD/install.sh and -# MacOSVersions::SYMBOLS +# MacOSVersion::SYMBOLS HOMEBREW_MACOS_NEWEST_UNSUPPORTED="14" # TODO: bump version when new macOS is released and also update # references in docs/Installation.md and diff --git a/Library/Homebrew/cask/audit.rb b/Library/Homebrew/cask/audit.rb index 17c1c4611c..606470b528 100644 --- a/Library/Homebrew/cask/audit.rb +++ b/Library/Homebrew/cask/audit.rb @@ -549,8 +549,8 @@ module Cask return if min_os.blank? begin - min_os_string = OS::Mac::Version.new(min_os).strip_patch - rescue MacOSVersionError + min_os_string = MacOSVersion.new(min_os).strip_patch + rescue MacOSVersion::Error return end diff --git a/Library/Homebrew/cask/cask.rb b/Library/Homebrew/cask/cask.rb index 8932110cf9..1fe172a1ac 100644 --- a/Library/Homebrew/cask/cask.rb +++ b/Library/Homebrew/cask/cask.rb @@ -316,7 +316,7 @@ module Cask begin if @dsl.on_system_blocks_exist? [:arm, :intel].each do |arch| - MacOSVersions::SYMBOLS.each_key do |os_name| + MacOSVersion::SYMBOLS.each_key do |os_name| bottle_tag = ::Utils::Bottles::Tag.new(system: os_name, arch: arch) next unless bottle_tag.valid_combination? diff --git a/Library/Homebrew/cask/cask_loader.rb b/Library/Homebrew/cask/cask_loader.rb index 4c2302a8c8..0f3825ad7c 100644 --- a/Library/Homebrew/cask/cask_loader.rb +++ b/Library/Homebrew/cask/cask_loader.rb @@ -303,13 +303,13 @@ module Cask dep_type = dep_value.keys.first if dep_type == :== version_symbols = dep_value[dep_type].map do |version| - MacOSVersions::SYMBOLS.key(version) || version + MacOSVersion::SYMBOLS.key(version) || version end next [dep_key, version_symbols] end version_symbol = dep_value[dep_type].first - version_symbol = MacOSVersions::SYMBOLS.key(version_symbol) || version_symbol + version_symbol = MacOSVersion::SYMBOLS.key(version_symbol) || version_symbol [dep_key, "#{dep_type} :#{version_symbol}"] end.compact depends_on(**dep_hash) diff --git a/Library/Homebrew/cask/download.rb b/Library/Homebrew/cask/download.rb index 16fa062ecf..74b0d61373 100644 --- a/Library/Homebrew/cask/download.rb +++ b/Library/Homebrew/cask/download.rb @@ -32,9 +32,9 @@ module Cask @checksum ||= cask.sha256 if cask.sha256 != :no_check end - sig { override.returns(T.nilable(::Version)) } + sig { override.returns(T.nilable(Version)) } def version - @version ||= ::Version.create(cask.version) + @version ||= Version.create(cask.version) end sig { diff --git a/Library/Homebrew/cask/dsl/depends_on.rb b/Library/Homebrew/cask/dsl/depends_on.rb index 7af6ff40e0..e56faf0893 100644 --- a/Library/Homebrew/cask/dsl/depends_on.rb +++ b/Library/Homebrew/cask/dsl/depends_on.rb @@ -59,7 +59,7 @@ module Cask begin @macos = if args.count > 1 MacOSRequirement.new([args], comparator: "==") - elsif MacOSVersions::SYMBOLS.key?(args.first) + elsif MacOSVersion::SYMBOLS.key?(args.first) MacOSRequirement.new([args.first], comparator: "==") elsif (md = /^\s*(?<|>|[=<>]=)\s*:(?\S+)\s*$/.match(first_arg)) MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: md[:comparator]) @@ -68,7 +68,7 @@ module Cask else # rubocop:disable Lint/DuplicateBranch MacOSRequirement.new([args.first], comparator: "==") end - rescue MacOSVersionError => e + rescue MacOSVersion::Error, TypeError => e raise "invalid 'depends_on macos' value: #{e}" end end diff --git a/Library/Homebrew/cask/macos.rb b/Library/Homebrew/cask/macos.rb index 1587de3456..8db4eeeb0a 100644 --- a/Library/Homebrew/cask/macos.rb +++ b/Library/Homebrew/cask/macos.rb @@ -1,8 +1,6 @@ # typed: true # frozen_string_literal: true -require "os/mac/version" - module OS module Mac module_function diff --git a/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb b/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb index dfd525d5bc..660fef326a 100644 --- a/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb +++ b/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb @@ -53,9 +53,9 @@ module Homebrew os, arch = element.then do |s| tag = Utils::Bottles::Tag.from_symbol(s.to_sym) [tag.to_macos_version, tag.arch] - rescue ArgumentError, MacOSVersionError + rescue ArgumentError, MacOSVersion::Error os, arch = s.split("-", 2) - [MacOS::Version.new(os), arch&.to_sym] + [MacOSVersion.new(os), arch&.to_sym] end if arch.present? && arch != :x86_64 diff --git a/Library/Homebrew/exceptions.rb b/Library/Homebrew/exceptions.rb index 1d0f56ab14..6ed3ef6092 100644 --- a/Library/Homebrew/exceptions.rb +++ b/Library/Homebrew/exceptions.rb @@ -767,16 +767,6 @@ class ChildProcessError < RuntimeError end end -# Raised when a macOS version is unsupported. -class MacOSVersionError < RuntimeError - attr_reader :version - - def initialize(version) - @version = version - super "unknown or unsupported macOS version: #{version.inspect}" - end -end - # Raised when `detected_perl_shebang` etc cannot detect the shebang. class ShebangDetectionError < RuntimeError def initialize(type, reason) diff --git a/Library/Homebrew/extend/on_system.rb b/Library/Homebrew/extend/on_system.rb index 7d8670a65f..49a07da88b 100644 --- a/Library/Homebrew/extend/on_system.rb +++ b/Library/Homebrew/extend/on_system.rb @@ -18,7 +18,7 @@ module OnSystem def self.os_condition_met?(os_name, or_condition = nil) return Homebrew::SimulateSystem.send("simulating_or_running_on_#{os_name}?") if BASE_OS_OPTIONS.include?(os_name) - raise ArgumentError, "Invalid OS condition: #{os_name.inspect}" unless MacOSVersions::SYMBOLS.key?(os_name) + raise ArgumentError, "Invalid OS condition: #{os_name.inspect}" unless MacOSVersion::SYMBOLS.key?(os_name) if or_condition.present? && [:or_newer, :or_older].exclude?(or_condition) raise ArgumentError, "Invalid OS `or_*` condition: #{or_condition.inspect}" @@ -26,13 +26,13 @@ module OnSystem return false if Homebrew::SimulateSystem.simulating_or_running_on_linux? - base_os = OS::Mac::Version.from_symbol(os_name) + base_os = MacOSVersion.from_symbol(os_name) current_os = if Homebrew::SimulateSystem.current_os == :macos # Assume the oldest macOS version when simulating a generic macOS version # Version::NULL is always treated as less than any other version. Version::NULL else - OS::Mac::Version.from_symbol(Homebrew::SimulateSystem.current_os) + MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os) end return current_os >= base_os if or_condition == :or_newer @@ -115,7 +115,7 @@ module OnSystem sig { params(base: Class).void } def self.setup_macos_methods(base) - MacOSVersions::SYMBOLS.each_key do |os_name| + MacOSVersion::SYMBOLS.each_key do |os_name| base.define_method("on_#{os_name}") do |or_condition = nil, &block| @on_system_blocks_exist = true diff --git a/Library/Homebrew/extend/os/mac/diagnostic.rb b/Library/Homebrew/extend/os/mac/diagnostic.rb index d7920fa2fd..95f8e42e7a 100644 --- a/Library/Homebrew/extend/os/mac/diagnostic.rb +++ b/Library/Homebrew/extend/os/mac/diagnostic.rb @@ -445,7 +445,7 @@ module Homebrew path_version = sdk.path.basename.to_s[MacOS::SDK::VERSIONED_SDK_REGEX, 1] next true if path_version.blank? - sdk.version == MacOS::Version.new(path_version).strip_patch + sdk.version == MacOSVersion.new(path_version).strip_patch end if locator.source == :clt diff --git a/Library/Homebrew/extend/os/mac/hardware.rb b/Library/Homebrew/extend/os/mac/hardware.rb index fb3273b7df..cbe49c8424 100644 --- a/Library/Homebrew/extend/os/mac/hardware.rb +++ b/Library/Homebrew/extend/os/mac/hardware.rb @@ -5,7 +5,7 @@ module Hardware sig { params(version: T.nilable(Version)).returns(Symbol) } def self.oldest_cpu(version = nil) version = if version - MacOS::Version.new(version.to_s) + MacOSVersion.new(version.to_s) else MacOS.version end diff --git a/Library/Homebrew/extend/os/mac/readall.rb b/Library/Homebrew/extend/os/mac/readall.rb index 4f180a0550..a0a2e5c161 100644 --- a/Library/Homebrew/extend/os/mac/readall.rb +++ b/Library/Homebrew/extend/os/mac/readall.rb @@ -7,7 +7,7 @@ module Readall return true if os_name == :linux current_macos_version = if os_name.is_a?(Symbol) - MacOS::Version.from_symbol(os_name) + MacOSVersion.from_symbol(os_name) else MacOS.version end diff --git a/Library/Homebrew/extend/os/mac/simulate_system.rb b/Library/Homebrew/extend/os/mac/simulate_system.rb index 053d361869..62f0d2d3bb 100644 --- a/Library/Homebrew/extend/os/mac/simulate_system.rb +++ b/Library/Homebrew/extend/os/mac/simulate_system.rb @@ -9,7 +9,7 @@ module Homebrew sig { returns(T::Boolean) } def simulating_or_running_on_macos? - os.blank? || [:macos, *MacOSVersions::SYMBOLS.keys].include?(os) + os.blank? || [:macos, *MacOSVersion::SYMBOLS.keys].include?(os) end sig { returns(Symbol) } diff --git a/Library/Homebrew/extend/os/mac/utils/bottles.rb b/Library/Homebrew/extend/os/mac/utils/bottles.rb index 7d601f14f4..d0a11ad720 100644 --- a/Library/Homebrew/extend/os/mac/utils/bottles.rb +++ b/Library/Homebrew/extend/os/mac/utils/bottles.rb @@ -35,7 +35,7 @@ module Utils def find_older_compatible_tag(tag) tag_version = begin tag.to_macos_version - rescue MacOSVersionError + rescue MacOSVersion::Error nil end @@ -45,7 +45,7 @@ module Utils next if candidate.arch != tag.arch candidate.to_macos_version <= tag_version - rescue MacOSVersionError + rescue MacOSVersion::Error false end end diff --git a/Library/Homebrew/formula.rb b/Library/Homebrew/formula.rb index cd0e48d073..f61f106a62 100644 --- a/Library/Homebrew/formula.rb +++ b/Library/Homebrew/formula.rb @@ -2249,7 +2249,7 @@ class Formula variations = {} - os_versions = [*MacOSVersions::SYMBOLS.keys, :linux] + os_versions = [*MacOSVersion::SYMBOLS.keys, :linux] begin if path.exist? && self.class.on_system_blocks_exist? diff --git a/Library/Homebrew/formula_auditor.rb b/Library/Homebrew/formula_auditor.rb index 8a07d0fc5a..c55db2f9a1 100644 --- a/Library/Homebrew/formula_auditor.rb +++ b/Library/Homebrew/formula_auditor.rb @@ -757,7 +757,7 @@ module Homebrew newest_committed_revision ||= previous_revision newest_committed_url ||= stable.url end - rescue MacOSVersionError + rescue MacOSVersion::Error break end @@ -893,7 +893,7 @@ module Homebrew # The formula has no variations, so all OS-version-arch triples depend on GCC. return false if variations.blank? - MacOSVersions::SYMBOLS.each_key do |macos_version| + MacOSVersion::SYMBOLS.each_key do |macos_version| [:arm, :intel].each do |arch| bottle_tag = Utils::Bottles::Tag.new(system: macos_version, arch: arch) next unless bottle_tag.valid_combination? diff --git a/Library/Homebrew/formulary.rb b/Library/Homebrew/formulary.rb index e293510307..d3514a050c 100644 --- a/Library/Homebrew/formulary.rb +++ b/Library/Homebrew/formulary.rb @@ -91,7 +91,7 @@ module Formulary # 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, MacOSVersionError => e + rescue NameError, ArgumentError, ScriptError, MethodDeprecatedError, MacOSVersion::Error => e if e.is_a?(Ignorable::ExceptionMixin) e.ignore else @@ -223,7 +223,7 @@ module Formulary when :arch req["version"]&.to_sym when :macos, :maximum_macos - MacOSVersions::SYMBOLS.key(req["version"]) + MacOSVersion::SYMBOLS.key(req["version"]) else req["version"] end diff --git a/Library/Homebrew/github_runner.rb b/Library/Homebrew/github_runner.rb index 91da9f7454..46086288c3 100644 --- a/Library/Homebrew/github_runner.rb +++ b/Library/Homebrew/github_runner.rb @@ -8,7 +8,7 @@ class GitHubRunner < T::Struct const :platform, Symbol const :arch, Symbol const :spec, T.any(LinuxRunnerSpec, MacOSRunnerSpec) - const :macos_version, T.nilable(OS::Mac::Version) + const :macos_version, T.nilable(MacOSVersion) prop :active, T::Boolean, default: false sig { returns(T::Boolean) } diff --git a/Library/Homebrew/github_runner_matrix.rb b/Library/Homebrew/github_runner_matrix.rb index 84fc2bd978..2154c968f0 100644 --- a/Library/Homebrew/github_runner_matrix.rb +++ b/Library/Homebrew/github_runner_matrix.rb @@ -90,7 +90,7 @@ class GitHubRunnerMatrix platform: Symbol, arch: Symbol, spec: RunnerSpec, - macos_version: T.nilable(OS::Mac::Version), + macos_version: T.nilable(MacOSVersion), ).returns(GitHubRunner) } def create_runner(platform, arch, spec, macos_version = nil) @@ -120,8 +120,8 @@ class GitHubRunnerMatrix ephemeral_suffix << "-deps" if @dependent_matrix ephemeral_suffix.freeze - MacOSVersions::SYMBOLS.each_value do |version| - macos_version = OS::Mac::Version.new(version) + MacOSVersion::SYMBOLS.each_value do |version| + macos_version = MacOSVersion.new(version) next if macos_version.unsupported_release? # Intel Big Sur is a bit slower than the other runners, diff --git a/Library/Homebrew/global.rb b/Library/Homebrew/global.rb index b59bcdc6ca..33a863003c 100644 --- a/Library/Homebrew/global.rb +++ b/Library/Homebrew/global.rb @@ -73,7 +73,7 @@ HOMEBREW_BOTTLES_EXTNAME_REGEX = /\.([a-z0-9_]+)\.bottle\.(?:(\d+)\.)?tar\.gz$/. require "extend/module" require "env_config" -require "macos_versions" +require "macos_version" require "os" require "messages" require "default_prefix" diff --git a/Library/Homebrew/livecheck/strategy/sparkle.rb b/Library/Homebrew/livecheck/strategy/sparkle.rb index 4fc45aa2c7..311547ce8d 100644 --- a/Library/Homebrew/livecheck/strategy/sparkle.rb +++ b/Library/Homebrew/livecheck/strategy/sparkle.rb @@ -107,8 +107,8 @@ module Homebrew if (minimum_system_version = item.elements["minimumSystemVersion"]&.text&.gsub(/\A\D+|\D+\z/, "")) macos_minimum_system_version = begin - OS::Mac::Version.new(minimum_system_version).strip_patch - rescue MacOSVersionError + MacOSVersion.new(minimum_system_version).strip_patch + rescue MacOSVersion::Error nil end diff --git a/Library/Homebrew/macos_version.rb b/Library/Homebrew/macos_version.rb new file mode 100644 index 0000000000..988e1621cb --- /dev/null +++ b/Library/Homebrew/macos_version.rb @@ -0,0 +1,162 @@ +# typed: true +# frozen_string_literal: true + +require "version" + +# A macOS version. +# +# @api private +class MacOSVersion < Version + # Raised when a macOS version is unsupported. + class Error < RuntimeError + sig { returns(T.nilable(T.any(String, Symbol))) } + attr_reader :version + + def initialize(version) + @version = version + super "unknown or unsupported macOS version: #{version.inspect}" + end + end + + # NOTE: When removing symbols here, ensure that they are added + # to `DEPRECATED_MACOS_VERSIONS` in `MacOSRequirement`. + SYMBOLS = { + ventura: "13", + monterey: "12", + big_sur: "11", + catalina: "10.15", + mojave: "10.14", + high_sierra: "10.13", + sierra: "10.12", + el_capitan: "10.11", + }.freeze + + sig { params(version: Symbol).returns(T.attached_class) } + def self.from_symbol(version) + str = SYMBOLS.fetch(version) { raise MacOSVersion::Error, version } + new(str) + end + + sig { params(version: T.nilable(String)).void } + def initialize(version) + raise MacOSVersion::Error, version unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(version) + + super(version) + + @comparison_cache = {} + end + + sig { override.params(other: T.untyped).returns(T.nilable(Integer)) } + def <=>(other) + return @comparison_cache[other] if @comparison_cache.key?(other) + + result = case other + when Symbol + if SYMBOLS.key?(other) && to_sym == other + 0 + else + v = SYMBOLS.fetch(other) { other.to_s } + super(v) + end + else + super + end + + @comparison_cache[other] = result unless frozen? + + result + end + + sig { returns(T.self_type) } + def strip_patch + return self if null? + + # Big Sur is 11.x but Catalina is 10.15.x. + if T.must(major) >= 11 + self.class.new(major.to_s) + else + major_minor + end + end + + sig { returns(Symbol) } + def to_sym + return @sym if defined?(@sym) + + sym = SYMBOLS.invert.fetch(strip_patch.to_s, :dunno) + + @sym = sym unless frozen? + + sym + end + + sig { returns(String) } + def pretty_name + return @pretty_name if defined?(@pretty_name) + + pretty_name = to_sym.to_s.split("_").map(&:capitalize).join(" ").freeze + + @pretty_name = pretty_name unless frozen? + + pretty_name + end + + sig { returns(T::Boolean) } + def outdated_release? + self < HOMEBREW_MACOS_OLDEST_SUPPORTED + end + + sig { returns(T::Boolean) } + def prerelease? + self >= HOMEBREW_MACOS_NEWEST_UNSUPPORTED + end + + sig { returns(T::Boolean) } + def unsupported_release? + outdated_release? || prerelease? + end + + sig { returns(T::Boolean) } + def requires_nehalem_cpu? + return false if null? + + require "hardware" + + return Hardware.oldest_cpu(self) == :nehalem if Hardware::CPU.intel? + + raise ArgumentError, "Unexpected architecture: #{Hardware::CPU.arch}. This only works with Intel architecture." + end + # https://en.wikipedia.org/wiki/Nehalem_(microarchitecture) + alias requires_sse4? requires_nehalem_cpu? + alias requires_sse41? requires_nehalem_cpu? + alias requires_sse42? requires_nehalem_cpu? + alias requires_popcnt? requires_nehalem_cpu? + + # Represents the absence of a version. + # NOTE: Constructor needs to called with an arbitrary macOS-like version which is then set to `nil`. + NULL = MacOSVersion.new("10.0").tap { |v| v.instance_variable_set(:@version, nil) }.freeze +end + +require "lazy_object" + +MacOSVersionError = LazyObject.new do # rubocop:disable Style/MutableConstant + # odeprecated "MacOSVersionError", "MacOSVersion::Error" + MacOSVersion::Error +end + +module MacOSVersions + SYMBOLS = LazyObject.new do # rubocop:disable Style/MutableConstant + # odeprecated "MacOSVersions::SYMBOLS", "MacOSVersion::SYMBOLS" + MacOSVersion::SYMBOLS + end +end + +module OS + module Mac + # TODO: Replace `::Version` with `Version` when this is removed. + Version = LazyObject.new do # rubocop:disable Style/MutableConstant + # odeprecated "OS::Mac::Version", "MacOSVersion" + MacOSVersion + end + end +end diff --git a/Library/Homebrew/macos_versions.rb b/Library/Homebrew/macos_versions.rb deleted file mode 100644 index 16d4bd47e4..0000000000 --- a/Library/Homebrew/macos_versions.rb +++ /dev/null @@ -1,20 +0,0 @@ -# typed: true -# frozen_string_literal: true - -# Helper functions for querying operating system information. -# -# @api private -module MacOSVersions - # TODO: when removing symbols here, ensure that they are added to - # DEPRECATED_MACOS_VERSIONS in MacOSRequirement. - SYMBOLS = { - ventura: "13", - monterey: "12", - big_sur: "11", - catalina: "10.15", - mojave: "10.14", - high_sierra: "10.13", - sierra: "10.12", - el_capitan: "10.11", - }.freeze -end diff --git a/Library/Homebrew/os.rb b/Library/Homebrew/os.rb index 4743f6b727..899fbf10b7 100644 --- a/Library/Homebrew/os.rb +++ b/Library/Homebrew/os.rb @@ -55,6 +55,7 @@ module OS if OS.mac? require "os/mac" + require "hardware" # Don't tell people to report issues on unsupported configurations. if !OS::Mac.version.prerelease? && !OS::Mac.version.outdated_release? && diff --git a/Library/Homebrew/os/linux.rb b/Library/Homebrew/os/linux.rb index 9273a6b5f7..709dd2d57e 100644 --- a/Library/Homebrew/os/linux.rb +++ b/Library/Homebrew/os/linux.rb @@ -1,7 +1,6 @@ # typed: true # frozen_string_literal: true -require "os/mac/version" require "utils" module OS @@ -54,11 +53,11 @@ module OS raise "Loaded OS::Linux on generic OS!" if ENV["HOMEBREW_TEST_GENERIC_OS"] def self.version - Version::NULL + MacOSVersion::NULL end def self.full_version - Version::NULL + MacOSVersion::NULL end def self.languages diff --git a/Library/Homebrew/os/mac.rb b/Library/Homebrew/os/mac.rb index 3936b46d5f..f49766082f 100644 --- a/Library/Homebrew/os/mac.rb +++ b/Library/Homebrew/os/mac.rb @@ -1,7 +1,8 @@ # typed: true # frozen_string_literal: true -require "os/mac/version" +require "macos_version" + require "os/mac/xcode" require "os/mac/sdk" require "os/mac/keg" @@ -18,25 +19,25 @@ module OS # This can be compared to numerics, strings, or symbols # using the standard Ruby Comparable methods. - sig { returns(Version) } + sig { returns(MacOSVersion) } def self.version @version ||= full_version.strip_patch end # This can be compared to numerics, strings, or symbols # using the standard Ruby Comparable methods. - sig { returns(Version) } + sig { returns(MacOSVersion) } def self.full_version @full_version ||= if ENV["HOMEBREW_FAKE_EL_CAPITAN"] # for Portable Ruby building - Version.new("10.11.6") + MacOSVersion.new("10.11.6") else - Version.new(VERSION) + MacOSVersion.new(VERSION) end end sig { params(version: String).void } def self.full_version=(version) - @full_version = Version.new(version.chomp) + @full_version = MacOSVersion.new(version.chomp) @version = nil end diff --git a/Library/Homebrew/os/mac/sdk.rb b/Library/Homebrew/os/mac/sdk.rb index 09cc68e61c..baa2b55985 100644 --- a/Library/Homebrew/os/mac/sdk.rb +++ b/Library/Homebrew/os/mac/sdk.rb @@ -1,8 +1,6 @@ # typed: true # frozen_string_literal: true -require "os/mac/version" - module OS module Mac # Class representing a macOS SDK. @@ -12,7 +10,7 @@ module OS # 11.x SDKs are explicitly excluded - we want the MacOSX11.sdk symlink instead. VERSIONED_SDK_REGEX = /MacOSX(10\.\d+|\d+)\.sdk$/.freeze - sig { returns(OS::Mac::Version) } + sig { returns(MacOSVersion) } attr_reader :version sig { returns(Pathname) } @@ -21,7 +19,7 @@ module OS sig { returns(Symbol) } attr_reader :source - sig { params(version: OS::Mac::Version, path: T.any(String, Pathname), source: Symbol).void } + sig { params(version: MacOSVersion, path: T.any(String, Pathname), source: Symbol).void } def initialize(version, path, source) @version = version @path = Pathname.new(path) @@ -39,7 +37,7 @@ module OS class NoSDKError < StandardError; end - sig { params(version: OS::Mac::Version).returns(SDK) } + sig { params(version: MacOSVersion).returns(SDK) } def sdk_for(version) sdk = all_sdks.find { |s| s.version == version } raise NoSDKError if sdk.nil? @@ -77,7 +75,7 @@ module OS @all_sdks end - sig { params(version: T.nilable(OS::Mac::Version)).returns(T.nilable(SDK)) } + sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) } def sdk_if_applicable(version = nil) sdk = begin if version.blank? @@ -110,7 +108,7 @@ module OS all_sdks.max_by(&:version) end - sig { params(sdk_path: Pathname).returns(T.nilable(OS::Mac::Version)) } + sig { params(sdk_path: Pathname).returns(T.nilable(MacOSVersion)) } def read_sdk_version(sdk_path) sdk_settings = sdk_path/"SDKSettings.json" sdk_settings_string = sdk_settings.read if sdk_settings.exist? @@ -131,8 +129,8 @@ module OS return if version_string.blank? begin - OS::Mac::Version.new(version_string).strip_patch - rescue MacOSVersionError + MacOSVersion.new(version_string).strip_patch + rescue MacOSVersion::Error nil end end diff --git a/Library/Homebrew/os/mac/version.rb b/Library/Homebrew/os/mac/version.rb deleted file mode 100644 index 57d0df7e87..0000000000 --- a/Library/Homebrew/os/mac/version.rb +++ /dev/null @@ -1,124 +0,0 @@ -# typed: true -# frozen_string_literal: true - -require "exceptions" -require "hardware" -require "version" - -module OS - module Mac - # A macOS version. - # - # @api private - class Version < ::Version - sig { params(version: Symbol).returns(T.attached_class) } - def self.from_symbol(version) - str = MacOSVersions::SYMBOLS.fetch(version) { raise MacOSVersionError, version } - new(str) - end - - sig { params(value: T.nilable(String)).void } - def initialize(value) - version ||= value - - raise MacOSVersionError, version unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(version) - - super(version) - - @comparison_cache = {} - end - - sig { override.params(other: T.untyped).returns(T.nilable(Integer)) } - def <=>(other) - return @comparison_cache[other] if @comparison_cache.key?(other) - - result = case other - when Symbol - if MacOSVersions::SYMBOLS.key?(other) && to_sym == other - 0 - else - v = MacOSVersions::SYMBOLS.fetch(other) { other.to_s } - super(v) - end - else - super - end - - @comparison_cache[other] = result unless frozen? - - result - end - - sig { returns(T.self_type) } - def strip_patch - return self if null? - - # Big Sur is 11.x but Catalina is 10.15.x. - if T.must(major) >= 11 - self.class.new(major.to_s) - else - major_minor - end - end - - sig { returns(Symbol) } - def to_sym - return @sym if defined?(@sym) - - sym = MacOSVersions::SYMBOLS.invert.fetch(strip_patch.to_s, :dunno) - - @sym = sym unless frozen? - - sym - end - - sig { returns(String) } - def pretty_name - return @pretty_name if defined?(@pretty_name) - - pretty_name = to_sym.to_s.split("_").map(&:capitalize).join(" ").freeze - - @pretty_name = pretty_name unless frozen? - - pretty_name - end - - sig { returns(T::Boolean) } - def outdated_release? - self < HOMEBREW_MACOS_OLDEST_SUPPORTED - end - - sig { returns(T::Boolean) } - def prerelease? - self >= HOMEBREW_MACOS_NEWEST_UNSUPPORTED - end - - sig { returns(T::Boolean) } - def unsupported_release? - outdated_release? || prerelease? - end - - # For {OS::Mac::Version} compatibility. - sig { returns(T::Boolean) } - def requires_nehalem_cpu? - return false if null? - - unless Hardware::CPU.intel? - raise "Unexpected architecture: #{Hardware::CPU.arch}. This only works with Intel architecture." - end - - Hardware.oldest_cpu(self) == :nehalem - end - # https://en.wikipedia.org/wiki/Nehalem_(microarchitecture) - # Ensure any extra methods are also added to version/null.rb - alias requires_sse4? requires_nehalem_cpu? - alias requires_sse41? requires_nehalem_cpu? - alias requires_sse42? requires_nehalem_cpu? - alias requires_popcnt? requires_nehalem_cpu? - - # Represents the absence of a version. - # NOTE: Constructor needs to called with an arbitrary macOS-like version which is then set to `nil`. - NULL = Version.new("10.0").tap { |v| v.instance_variable_set(:@version, nil) }.freeze - end - end -end diff --git a/Library/Homebrew/os/mac/xcode.rb b/Library/Homebrew/os/mac/xcode.rb index 4cc61a5762..e1b28f87d8 100755 --- a/Library/Homebrew/os/mac/xcode.rb +++ b/Library/Homebrew/os/mac/xcode.rb @@ -15,7 +15,7 @@ module OS # Bump these when a new version is available from the App Store and our # CI systems have been updated. # This may be a beta version for a beta macOS. - sig { params(macos: MacOS::Version).returns(String) } + sig { params(macos: MacOSVersion).returns(String) } def self.latest_version(macos: MacOS.version) latest_stable = "14.3" case macos @@ -136,12 +136,12 @@ module OS @sdk_locator ||= XcodeSDKLocator.new end - sig { params(version: T.nilable(MacOS::Version)).returns(T.nilable(SDK)) } + sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) } def self.sdk(version = nil) sdk_locator.sdk_if_applicable(version) end - sig { params(version: T.nilable(MacOS::Version)).returns(T.nilable(Pathname)) } + sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(Pathname)) } def self.sdk_path(version = nil) sdk(version)&.path end @@ -283,12 +283,12 @@ module OS @sdk_locator ||= CLTSDKLocator.new end - sig { params(version: T.nilable(MacOS::Version)).returns(T.nilable(SDK)) } + sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) } def self.sdk(version = nil) sdk_locator.sdk_if_applicable(version) end - sig { params(version: T.nilable(MacOS::Version)).returns(T.nilable(Pathname)) } + sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(Pathname)) } def self.sdk_path(version = nil) sdk(version)&.path end diff --git a/Library/Homebrew/readall.rb b/Library/Homebrew/readall.rb index 3a777ffe37..c093811d8f 100644 --- a/Library/Homebrew/readall.rb +++ b/Library/Homebrew/readall.rb @@ -77,7 +77,7 @@ module Readall success = false unless valid_casks?(tap.cask_files) else arches = [:arm, :intel] - os_names = [*MacOSVersions::SYMBOLS.keys, :linux] + os_names = [*MacOSVersion::SYMBOLS.keys, :linux] arches.each do |arch| os_names.each do |os_name| bottle_tag = Utils::Bottles::Tag.new(system: os_name, arch: arch) diff --git a/Library/Homebrew/requirements/macos_requirement.rb b/Library/Homebrew/requirements/macos_requirement.rb index ddcba52f97..adad00255e 100644 --- a/Library/Homebrew/requirements/macos_requirement.rb +++ b/Library/Homebrew/requirements/macos_requirement.rb @@ -21,11 +21,11 @@ class MacOSRequirement < Requirement def initialize(tags = [], comparator: ">=") @version = begin if comparator == "==" && tags.first.respond_to?(:map) - tags.first.map { |s| OS::Mac::Version.from_symbol(s) } + tags.first.map { |s| MacOSVersion.from_symbol(s) } else - OS::Mac::Version.from_symbol(tags.first) unless tags.empty? + MacOSVersion.from_symbol(tags.first) unless tags.empty? end - rescue MacOSVersionError => e + rescue MacOSVersion::Error => e if DISABLED_MACOS_VERSIONS.include?(e.version) odisabled "depends_on :macos => :#{e.version}" elsif DEPRECATED_MACOS_VERSIONS.include?(e.version) @@ -41,7 +41,7 @@ class MacOSRequirement < Requirement end # Otherwise fallback to the oldest allowed if comparator is >=. - OS::Mac::Version.new(HOMEBREW_MACOS_OLDEST_ALLOWED) if comparator == ">=" + MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED) if comparator == ">=" end @comparator = comparator diff --git a/Library/Homebrew/rubocops/cask/constants/stanza.rb b/Library/Homebrew/rubocops/cask/constants/stanza.rb index cca0537428..54fcdb73fc 100644 --- a/Library/Homebrew/rubocops/cask/constants/stanza.rb +++ b/Library/Homebrew/rubocops/cask/constants/stanza.rb @@ -5,11 +5,11 @@ module RuboCop module Cask # Constants available globally for use in all cask cops. module Constants - ON_SYSTEM_METHODS = [:arm, :intel, *MacOSVersions::SYMBOLS.keys].map { |option| :"on_#{option}" }.freeze + ON_SYSTEM_METHODS = [:arm, :intel, *MacOSVersion::SYMBOLS.keys].map { |option| :"on_#{option}" }.freeze ON_SYSTEM_METHODS_STANZA_ORDER = [ :arm, :intel, - *MacOSVersions::SYMBOLS.reverse_each.to_h.keys, # Oldest OS blocks first since that's more common in Casks. + *MacOSVersion::SYMBOLS.reverse_each.to_h.keys, # Oldest OS blocks first since that's more common in Casks. ].map { |option, _| :"on_#{option}" }.freeze STANZA_GROUPS = [ diff --git a/Library/Homebrew/rubocops/extend/formula_cop.rb b/Library/Homebrew/rubocops/extend/formula_cop.rb index 86801438ab..2ad09eaa4b 100644 --- a/Library/Homebrew/rubocops/extend/formula_cop.rb +++ b/Library/Homebrew/rubocops/extend/formula_cop.rb @@ -212,7 +212,7 @@ module RuboCop end def on_system_methods - @on_system_methods ||= [:intel, :arm, :macos, :linux, :system, *MacOSVersions::SYMBOLS.keys].map do |m| + @on_system_methods ||= [:intel, :arm, :macos, :linux, :system, *MacOSVersion::SYMBOLS.keys].map do |m| :"on_#{m}" end end diff --git a/Library/Homebrew/rubocops/lines.rb b/Library/Homebrew/rubocops/lines.rb index 1967bc4ca7..0fbe27452a 100644 --- a/Library/Homebrew/rubocops/lines.rb +++ b/Library/Homebrew/rubocops/lines.rb @@ -1,7 +1,7 @@ # typed: true # frozen_string_literal: true -require "macos_versions" +require "macos_version" require "rubocops/extend/formula_cop" require "rubocops/shared/on_system_conditionals_helper" diff --git a/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb b/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb index 432b42ed5e..c6e0142afb 100644 --- a/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb +++ b/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb @@ -1,7 +1,7 @@ # typed: true # frozen_string_literal: true -require "macos_versions" +require "macos_version" require "rubocops/shared/helper_functions" module RuboCop @@ -15,7 +15,7 @@ module RuboCop ARCH_OPTIONS = [:arm, :intel].freeze BASE_OS_OPTIONS = [:macos, :linux].freeze - MACOS_VERSION_OPTIONS = MacOSVersions::SYMBOLS.keys.freeze + MACOS_VERSION_OPTIONS = MacOSVersion::SYMBOLS.keys.freeze ON_SYSTEM_OPTIONS = [*ARCH_OPTIONS, *BASE_OS_OPTIONS, *MACOS_VERSION_OPTIONS, :system].freeze MACOS_VERSION_CONDITIONALS = { diff --git a/Library/Homebrew/simulate_system.rb b/Library/Homebrew/simulate_system.rb index 741aa41b48..055ffa072d 100644 --- a/Library/Homebrew/simulate_system.rb +++ b/Library/Homebrew/simulate_system.rb @@ -11,7 +11,7 @@ module Homebrew sig { params(new_os: Symbol).void } def os=(new_os) - os_options = [:macos, :linux, *MacOSVersions::SYMBOLS.keys] + os_options = [:macos, :linux, *MacOSVersion::SYMBOLS.keys] raise "Unknown OS: #{new_os}" unless os_options.include?(new_os) @os = new_os @@ -31,7 +31,7 @@ module Homebrew sig { returns(T::Boolean) } def simulating_or_running_on_macos? - [:macos, *MacOSVersions::SYMBOLS.keys].include?(os) + [:macos, *MacOSVersion::SYMBOLS.keys].include?(os) end sig { returns(T::Boolean) } diff --git a/Library/Homebrew/software_spec.rb b/Library/Homebrew/software_spec.rb index b9f83b6c5f..b6474b857a 100644 --- a/Library/Homebrew/software_spec.rb +++ b/Library/Homebrew/software_spec.rb @@ -11,7 +11,7 @@ require "dependency_collector" require "utils/bottles" require "patch" require "compilers" -require "os/mac/version" +require "macos_version" require "extend/on_system" class SoftwareSpec @@ -203,8 +203,8 @@ class SoftwareSpec return if Homebrew::SimulateSystem.current_os == :macos && !bounds.key?(:since) if Homebrew::SimulateSystem.current_os != :macos - current_os = MacOS::Version.from_symbol(Homebrew::SimulateSystem.current_os) - since_os = MacOS::Version.from_symbol(bounds[:since]) if bounds.key?(:since) + current_os = MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os) + since_os = MacOSVersion.from_symbol(bounds[:since]) if bounds.key?(:since) return if current_os >= since_os end end @@ -609,7 +609,7 @@ class BottleSpecification # Give arm64 bottles a higher priority so they are first priority = (tag.arch == :arm64) ? "2" : "1" "#{priority}.#{version}_#{tag}" - rescue MacOSVersionError + rescue MacOSVersion::Error # Sort non-MacOS tags below MacOS tags. "0.#{tag}" end diff --git a/Library/Homebrew/test/cask/cask_spec.rb b/Library/Homebrew/test/cask/cask_spec.rb index fab20eb310..4e465b1156 100644 --- a/Library/Homebrew/test/cask/cask_spec.rb +++ b/Library/Homebrew/test/cask/cask_spec.rb @@ -220,7 +220,7 @@ describe Cask::Cask, :cask do context "when loaded from cask file" do it "returns expected hash" do - allow(MacOS).to receive(:version).and_return(MacOS::Version.new("13")) + allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13")) hash = Cask::CaskLoader.load("everything").to_h @@ -304,7 +304,7 @@ describe Cask::Cask, :cask do catalina: "10.15", mojave: "10.14", } - stub_const("MacOSVersions::SYMBOLS", symbols) + stub_const("MacOSVersion::SYMBOLS", symbols) # For consistency, always run on Monterey and ARM MacOS.full_version = "12" diff --git a/Library/Homebrew/test/cask/dsl/caveats_spec.rb b/Library/Homebrew/test/cask/dsl/caveats_spec.rb index 3108ace46c..dd47a8a79d 100644 --- a/Library/Homebrew/test/cask/dsl/caveats_spec.rb +++ b/Library/Homebrew/test/cask/dsl/caveats_spec.rb @@ -16,7 +16,7 @@ describe Cask::DSL::Caveats, :cask do let(:cask) { instance_double(Cask::Cask) } it "points to System Preferences on macOS Monterey and earlier" do - allow(MacOS).to receive(:version).and_return(MacOS::Version.new("12")) + allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12")) caveats.eval_caveats do kext end @@ -24,7 +24,7 @@ describe Cask::DSL::Caveats, :cask do end it "points to System Settings on macOS Ventura and later" do - allow(MacOS).to receive(:version).and_return(MacOS::Version.new("13")) + allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13")) caveats.eval_caveats do kext end diff --git a/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb b/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb index c66583052d..c3e24cd988 100644 --- a/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb +++ b/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb @@ -22,8 +22,8 @@ describe "brew determine-test-runners" do end let(:all_runners) do out = [] - MacOSVersions::SYMBOLS.each_value do |v| - macos_version = OS::Mac::Version.new(v) + MacOSVersion::SYMBOLS.each_value do |v| + macos_version = MacOSVersion.new(v) next if macos_version.unsupported_release? out << v diff --git a/Library/Homebrew/test/formula_spec.rb b/Library/Homebrew/test/formula_spec.rb index 511d45baf4..0cb2279d80 100644 --- a/Library/Homebrew/test/formula_spec.rb +++ b/Library/Homebrew/test/formula_spec.rb @@ -978,10 +978,10 @@ describe Formula do catalina: "10.15", mojave: "10.14", } - stub_const("MacOSVersions::SYMBOLS", symbols) + stub_const("MacOSVersion::SYMBOLS", symbols) # For consistency, always run on Monterey and ARM - allow(MacOS).to receive(:version).and_return(MacOS::Version.new("12")) + allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12")) allow(Hardware::CPU).to receive(:type).and_return(:arm) formula_path.dirname.mkpath diff --git a/Library/Homebrew/test/github_runner_matrix_spec.rb b/Library/Homebrew/test/github_runner_matrix_spec.rb index 12e9ba8e37..c9c0c361fe 100644 --- a/Library/Homebrew/test/github_runner_matrix_spec.rb +++ b/Library/Homebrew/test/github_runner_matrix_spec.rb @@ -13,7 +13,7 @@ describe GitHubRunnerMatrix do end let(:newest_supported_macos) do - MacOSVersions::SYMBOLS.find { |_, v| !OS::Mac::Version.new(v).prerelease? } + MacOSVersion::SYMBOLS.find { |_, v| !MacOSVersion.new(v).prerelease? } end let(:testball) { TestRunnerFormula.new(Testball.new) } diff --git a/Library/Homebrew/test/github_runner_spec.rb b/Library/Homebrew/test/github_runner_spec.rb index f869363f21..bcbadf07bc 100644 --- a/Library/Homebrew/test/github_runner_spec.rb +++ b/Library/Homebrew/test/github_runner_spec.rb @@ -5,7 +5,7 @@ require "github_runner" describe GitHubRunner do let(:runner) do spec = MacOSRunnerSpec.new(name: "macOS 11-arm64", runner: "11-arm64", timeout: 90, cleanup: true) - version = OS::Mac::Version.new("11") + version = MacOSVersion.new("11") described_class.new(platform: :macos, arch: :arm64, spec: spec, macos_version: version) end diff --git a/Library/Homebrew/test/os/mac/version_spec.rb b/Library/Homebrew/test/macos_version_spec.rb similarity index 90% rename from Library/Homebrew/test/os/mac/version_spec.rb rename to Library/Homebrew/test/macos_version_spec.rb index 9792051d5b..34a010833d 100644 --- a/Library/Homebrew/test/os/mac/version_spec.rb +++ b/Library/Homebrew/test/macos_version_spec.rb @@ -1,9 +1,8 @@ # frozen_string_literal: true -require "version" -require "os/mac/version" +require "macos_version" -describe OS::Mac::Version do +describe MacOSVersion do let(:version) { described_class.new("10.14") } let(:big_sur_major) { described_class.new("11.0") } let(:big_sur_update) { described_class.new("11.1") } @@ -54,7 +53,7 @@ describe OS::Mac::Version do it "raises an error if the version is not a valid macOS version" do expect do described_class.new("1.2") - end.to raise_error(MacOSVersionError, 'unknown or unsupported macOS version: "1.2"') + end.to raise_error(MacOSVersion::Error, 'unknown or unsupported macOS version: "1.2"') end it "creates a new version from a valid macOS version" do @@ -67,7 +66,7 @@ describe OS::Mac::Version do it "raises an error if the symbol is not a valid macOS version" do expect do described_class.from_symbol(:foo) - end.to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :foo") + end.to raise_error(MacOSVersion::Error, "unknown or unsupported macOS version: :foo") end it "creates a new version from a valid macOS version" do @@ -81,7 +80,7 @@ describe OS::Mac::Version do expect(described_class.new("10.14").pretty_name).to eq("Mojave") end - specify "#requires_nehalem_cpu?" do + specify "#requires_nehalem_cpu?", :needs_macos do expect(Hardware::CPU).to receive(:type).at_least(:twice).and_return(:intel) expect(described_class.new("10.14").requires_nehalem_cpu?).to be true expect(described_class.new("10.12").requires_nehalem_cpu?).to be false diff --git a/Library/Homebrew/test/os/mac/diagnostic_spec.rb b/Library/Homebrew/test/os/mac/diagnostic_spec.rb index 314dd7ef78..b2183082ae 100644 --- a/Library/Homebrew/test/os/mac/diagnostic_spec.rb +++ b/Library/Homebrew/test/os/mac/diagnostic_spec.rb @@ -8,7 +8,7 @@ describe Homebrew::Diagnostic::Checks do specify "#check_for_unsupported_macos" do ENV.delete("HOMEBREW_DEVELOPER") - macos_version = OS::Mac::Version.new("10.14") + macos_version = MacOSVersion.new("10.14") allow(OS::Mac).to receive(:version).and_return(macos_version) allow(OS::Mac).to receive(:full_version).and_return(macos_version) allow(OS::Mac.version).to receive(:outdated_release?).and_return(false) @@ -19,7 +19,7 @@ describe Homebrew::Diagnostic::Checks do end specify "#check_if_xcode_needs_clt_installed" do - macos_version = OS::Mac::Version.new("10.11") + macos_version = MacOSVersion.new("10.11") allow(OS::Mac).to receive(:version).and_return(macos_version) allow(OS::Mac).to receive(:full_version).and_return(macos_version) allow(OS::Mac::Xcode).to receive(:installed?).and_return(true) @@ -31,7 +31,7 @@ describe Homebrew::Diagnostic::Checks do end specify "#check_ruby_version" do - macos_version = OS::Mac::Version.new("10.12") + macos_version = MacOSVersion.new("10.12") allow(OS::Mac).to receive(:version).and_return(macos_version) allow(OS::Mac).to receive(:full_version).and_return(macos_version) stub_const("RUBY_VERSION", "1.8.6") @@ -41,7 +41,7 @@ describe Homebrew::Diagnostic::Checks do end describe "#check_if_supported_sdk_available" do - let(:macos_version) { OS::Mac::Version.new("11") } + let(:macos_version) { MacOSVersion.new("11") } before do allow(DevelopmentTools).to receive(:installed?).and_return(true) @@ -87,8 +87,8 @@ describe Homebrew::Diagnostic::Checks do it "doesn't trigger when SDK versions are as expected" do allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::CLT.sdk_locator) allow_any_instance_of(OS::Mac::CLTSDKLocator).to receive(:all_sdks).and_return([ - OS::Mac::SDK.new(OS::Mac::Version.new("11"), "/some/path/MacOSX.sdk", :clt), - OS::Mac::SDK.new(OS::Mac::Version.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt), + OS::Mac::SDK.new(MacOSVersion.new("11"), "/some/path/MacOSX.sdk", :clt), + OS::Mac::SDK.new(MacOSVersion.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt), ]) expect(checks.check_broken_sdks).to be_nil @@ -96,7 +96,7 @@ describe Homebrew::Diagnostic::Checks do it "triggers when the CLT SDK version doesn't match the folder name" do allow_any_instance_of(OS::Mac::CLTSDKLocator).to receive(:all_sdks).and_return([ - OS::Mac::SDK.new(OS::Mac::Version.new("10.14"), "/some/path/MacOSX10.15.sdk", :clt), + OS::Mac::SDK.new(MacOSVersion.new("10.14"), "/some/path/MacOSX10.15.sdk", :clt), ]) expect(checks.check_broken_sdks) @@ -106,7 +106,7 @@ describe Homebrew::Diagnostic::Checks do it "triggers when the Xcode SDK version doesn't match the folder name" do allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::Xcode.sdk_locator) allow_any_instance_of(OS::Mac::XcodeSDKLocator).to receive(:all_sdks).and_return([ - OS::Mac::SDK.new(OS::Mac::Version.new("10.14"), "/some/path/MacOSX10.15.sdk", :xcode), + OS::Mac::SDK.new(MacOSVersion.new("10.14"), "/some/path/MacOSX10.15.sdk", :xcode), ]) expect(checks.check_broken_sdks) diff --git a/Library/Homebrew/test/os/mac/formula_spec.rb b/Library/Homebrew/test/os/mac/formula_spec.rb index 593c5fdebf..8a91e72e4a 100644 --- a/Library/Homebrew/test/os/mac/formula_spec.rb +++ b/Library/Homebrew/test/os/mac/formula_spec.rb @@ -7,7 +7,7 @@ describe Formula do describe "#uses_from_macos" do before do allow(OS).to receive(:mac?).and_return(true) - allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.from_symbol(:sierra)) + allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra)) end it "adds a macOS dependency to all specs if the OS version meets requirements" do diff --git a/Library/Homebrew/test/os/mac/sdk_spec.rb b/Library/Homebrew/test/os/mac/sdk_spec.rb index ad3c731d75..fd9b5e9ac0 100644 --- a/Library/Homebrew/test/os/mac/sdk_spec.rb +++ b/Library/Homebrew/test/os/mac/sdk_spec.rb @@ -3,15 +3,15 @@ describe OS::Mac::CLTSDKLocator do subject(:locator) { described_class.new } - let(:big_sur_sdk) { OS::Mac::SDK.new(OS::Mac::Version.new("11"), "/some/path/MacOSX.sdk", :clt) } - let(:catalina_sdk) { OS::Mac::SDK.new(OS::Mac::Version.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt) } + let(:big_sur_sdk) { OS::Mac::SDK.new(MacOSVersion.new("11"), "/some/path/MacOSX.sdk", :clt) } + let(:catalina_sdk) { OS::Mac::SDK.new(MacOSVersion.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt) } specify "#sdk_for" do allow(locator).to receive(:all_sdks).and_return([big_sur_sdk, catalina_sdk]) - expect(locator.sdk_for(OS::Mac::Version.new("11"))).to eq(big_sur_sdk) - expect(locator.sdk_for(OS::Mac::Version.new("10.15"))).to eq(catalina_sdk) - expect { locator.sdk_for(OS::Mac::Version.new("10.14")) }.to raise_error(described_class::NoSDKError) + expect(locator.sdk_for(MacOSVersion.new("11"))).to eq(big_sur_sdk) + expect(locator.sdk_for(MacOSVersion.new("10.15"))).to eq(catalina_sdk) + expect { locator.sdk_for(MacOSVersion.new("10.14")) }.to raise_error(described_class::NoSDKError) end describe "#sdk_if_applicable" do @@ -20,27 +20,27 @@ describe OS::Mac::CLTSDKLocator do end it "returns the requested SDK" do - expect(locator.sdk_if_applicable(OS::Mac::Version.new("11"))).to eq(big_sur_sdk) - expect(locator.sdk_if_applicable(OS::Mac::Version.new("10.15"))).to eq(catalina_sdk) + expect(locator.sdk_if_applicable(MacOSVersion.new("11"))).to eq(big_sur_sdk) + expect(locator.sdk_if_applicable(MacOSVersion.new("10.15"))).to eq(catalina_sdk) end it "returns the latest SDK if the requested version is not found" do - expect(locator.sdk_if_applicable(OS::Mac::Version.new("10.14"))).to eq(big_sur_sdk) - expect(locator.sdk_if_applicable(OS::Mac::Version.new("12"))).to eq(big_sur_sdk) + expect(locator.sdk_if_applicable(MacOSVersion.new("10.14"))).to eq(big_sur_sdk) + expect(locator.sdk_if_applicable(MacOSVersion.new("12"))).to eq(big_sur_sdk) end it "returns the SDK matching the OS version if no version is specified" do - allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("10.15")) + allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("10.15")) expect(locator.sdk_if_applicable).to eq(catalina_sdk) end it "returns the latest SDK on older OS versions when there's no matching SDK" do - allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("10.14")) + allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("10.14")) expect(locator.sdk_if_applicable).to eq(big_sur_sdk) end it "returns nil if the OS is newer than all SDKs" do - allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("12")) + allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("12")) expect(locator.sdk_if_applicable).to be_nil end end @@ -59,7 +59,7 @@ describe OS::Mac::CLTSDKLocator do sdk = sdks.first expect(sdk.path).to eq(big_sur_sdk_prefix/"MacOSX.sdk") - expect(sdk.version).to eq(OS::Mac::Version.new("11")) + expect(sdk.version).to eq(MacOSVersion.new("11")) expect(sdk.source).to eq(:clt) end @@ -71,7 +71,7 @@ describe OS::Mac::CLTSDKLocator do sdk = sdks.first expect(sdk.path).to eq(mojave_broken_sdk_prefix/"MacOSX10.14.sdk") - expect(sdk.version).to eq(OS::Mac::Version.new("10.15")) + expect(sdk.version).to eq(MacOSVersion.new("10.15")) expect(sdk.source).to eq(:clt) end @@ -83,7 +83,7 @@ describe OS::Mac::CLTSDKLocator do sdk = sdks.first expect(sdk.path).to eq(high_sierra_sdk_prefix/"MacOSX10.13.sdk") - expect(sdk.version).to eq(OS::Mac::Version.new("10.13")) + expect(sdk.version).to eq(MacOSVersion.new("10.13")) expect(sdk.source).to eq(:clt) end diff --git a/Library/Homebrew/test/software_spec_spec.rb b/Library/Homebrew/test/software_spec_spec.rb index 959627298a..dc93aa2ac6 100644 --- a/Library/Homebrew/test/software_spec_spec.rb +++ b/Library/Homebrew/test/software_spec_spec.rb @@ -176,7 +176,7 @@ describe SoftwareSpec do context "when running on macOS", :needs_macos do before do allow(OS).to receive(:mac?).and_return(true) - allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.from_symbol(:sierra)) + allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra)) end it "adds a macOS dependency if the OS version meets requirements" do @@ -212,7 +212,7 @@ describe SoftwareSpec do it "raises an error if passing invalid OS versions" do expect do spec.uses_from_macos("foo", since: :bar) - end.to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :bar") + end.to raise_error(MacOSVersion::Error, "unknown or unsupported macOS version: :bar") end end end diff --git a/Library/Homebrew/test/test_runner_formula_spec.rb b/Library/Homebrew/test/test_runner_formula_spec.rb index 7b1667a917..30c7e5dd74 100644 --- a/Library/Homebrew/test/test_runner_formula_spec.rb +++ b/Library/Homebrew/test/test_runner_formula_spec.rb @@ -240,14 +240,14 @@ describe TestRunnerFormula do context "when a formula has a versioned MacOSRequirement" do context "when passed a compatible macOS version" do it "returns true" do - expect(described_class.new(needs_modern_compiler).compatible_with?(OS::Mac::Version.new("13"))) + expect(described_class.new(needs_modern_compiler).compatible_with?(MacOSVersion.new("13"))) .to be(true) end end context "when passed an incompatible macOS version" do it "returns false" do - expect(described_class.new(needs_modern_compiler).compatible_with?(OS::Mac::Version.new("11"))) + expect(described_class.new(needs_modern_compiler).compatible_with?(MacOSVersion.new("11"))) .to be(false) end end @@ -255,8 +255,8 @@ describe TestRunnerFormula do context "when a formula has an unversioned MacOSRequirement" do it "returns true" do - MacOSVersions::SYMBOLS.each_value do |v| - version = OS::Mac::Version.new(v) + MacOSVersion::SYMBOLS.each_value do |v| + version = MacOSVersion.new(v) expect(described_class.new(xcode_helper).compatible_with?(version)).to be(true) end end @@ -264,8 +264,8 @@ describe TestRunnerFormula do context "when a formula has no declared MacOSRequirement" do it "returns true" do - MacOSVersions::SYMBOLS.each_value do |v| - version = OS::Mac::Version.new(v) + MacOSVersion::SYMBOLS.each_value do |v| + version = MacOSVersion.new(v) expect(described_class.new(testball).compatible_with?(version)).to be(true) expect(described_class.new(linux_kernel_requirer).compatible_with?(version)).to be(true) expect(described_class.new(old_non_portable_software).compatible_with?(version)).to be(true) diff --git a/Library/Homebrew/test/utils/bottles/bottles_spec.rb b/Library/Homebrew/test/utils/bottles/bottles_spec.rb index fb492384f0..57adf15a2f 100644 --- a/Library/Homebrew/test/utils/bottles/bottles_spec.rb +++ b/Library/Homebrew/test/utils/bottles/bottles_spec.rb @@ -5,7 +5,7 @@ require "utils/bottles" describe Utils::Bottles do describe "#tag", :needs_macos do it "returns :big_sur or :arm64_big_sur on Big Sur" do - allow(MacOS).to receive(:version).and_return(MacOS::Version.new("11.0")) + allow(MacOS).to receive(:version).and_return(MacOSVersion.new("11.0")) if Hardware::CPU.intel? expect(described_class.tag).to eq(:big_sur) else diff --git a/Library/Homebrew/test/utils/bottles/tag_spec.rb b/Library/Homebrew/test/utils/bottles/tag_spec.rb index 1d6b60fd03..af9b78d735 100644 --- a/Library/Homebrew/test/utils/bottles/tag_spec.rb +++ b/Library/Homebrew/test/utils/bottles/tag_spec.rb @@ -8,7 +8,7 @@ describe Utils::Bottles::Tag do tag = described_class.from_symbol(symbol) expect(tag.system).to eq(:big_sur) expect(tag.arch).to eq(:arm64) - expect(tag.to_macos_version).to eq(OS::Mac::Version.from_symbol(:big_sur)) + expect(tag.to_macos_version).to eq(MacOSVersion.from_symbol(:big_sur)) expect(tag.macos?).to be true expect(tag.linux?).to be false expect(tag.to_sym).to eq(symbol) @@ -19,7 +19,7 @@ describe Utils::Bottles::Tag do tag = described_class.from_symbol(symbol) expect(tag.system).to eq(:big_sur) expect(tag.arch).to eq(:x86_64) - expect(tag.to_macos_version).to eq(OS::Mac::Version.from_symbol(:big_sur)) + expect(tag.to_macos_version).to eq(MacOSVersion.from_symbol(:big_sur)) expect(tag.macos?).to be true expect(tag.linux?).to be false expect(tag.to_sym).to eq(symbol) @@ -30,7 +30,7 @@ describe Utils::Bottles::Tag do tag = described_class.from_symbol(symbol) expect(tag.system).to eq(:linux) expect(tag.arch).to eq(:x86_64) - expect { tag.to_macos_version }.to raise_error(MacOSVersionError) + expect { tag.to_macos_version }.to raise_error(MacOSVersion::Error) expect(tag.macos?).to be false expect(tag.linux?).to be true expect(tag.to_sym).to eq(symbol) diff --git a/Library/Homebrew/test_runner_formula.rb b/Library/Homebrew/test_runner_formula.rb index 163e30dc7d..e0da75f3f4 100644 --- a/Library/Homebrew/test_runner_formula.rb +++ b/Library/Homebrew/test_runner_formula.rb @@ -68,7 +68,7 @@ class TestRunnerFormula formula.requirements.find { |r| r.is_a?(MacOSRequirement) && r.version_specified? } end - sig { params(macos_version: OS::Mac::Version).returns(T::Boolean) } + sig { params(macos_version: MacOSVersion).returns(T::Boolean) } def compatible_with?(macos_version) # Assign to a variable to assist type-checking. requirement = versioned_macos_requirement diff --git a/Library/Homebrew/utils/bottles.rb b/Library/Homebrew/utils/bottles.rb index 1ef0334cea..233a7aa80b 100644 --- a/Library/Homebrew/utils/bottles.rb +++ b/Library/Homebrew/utils/bottles.rb @@ -189,9 +189,9 @@ module Utils to_sym.to_s end - sig { returns(OS::Mac::Version) } + sig { returns(MacOSVersion) } def to_macos_version - @to_macos_version ||= OS::Mac::Version.from_symbol(system) + @to_macos_version ||= MacOSVersion.from_symbol(system) end sig { returns(T::Boolean) } @@ -203,7 +203,7 @@ module Utils def macos? to_macos_version true - rescue MacOSVersionError + rescue MacOSVersion::Error false end diff --git a/Library/Homebrew/version.rb b/Library/Homebrew/version.rb index 741a57f5de..9cf2fbcc54 100644 --- a/Library/Homebrew/version.rb +++ b/Library/Homebrew/version.rb @@ -341,9 +341,9 @@ class Version parse(specs.fetch(:tag, url), detected_from_url: true) end - # TODO: `odeprecate` this and just use `Version.new`. sig { params(val: String).returns(Version) } def self.create(val) + # odeprecate "Version.create", "Version.new" new(val) end