MacOS::Version: add (and use) architecture.

Library/Homebrew/dev-cmd/dispatch-build-bottle.rb

@@ -36,13 +36,8 @@ module Homebrew
     args = dispatch_build_bottle_args.parse
 
     # Fixup version for ARM/Apple Silicon
-    arm_regex = Regexp.union(/^arm64_/, /-arm$/)
+    # TODO: fix label name to be 11-arm64 instead and remove this.
-    arm_label = if arm_regex.match?(args.macos)
+    args.macos&.gsub!(/^11-arm$/, "11-arm64")
-      args.macos&.gsub!(arm_regex, "")
-      true
-    else
-      false
-    end
 
     macos = args.macos&.yield_self do |s|
       MacOS::Version.from_symbol(s.to_sym)
@@ -53,7 +48,8 @@ module Homebrew
     raise UsageError, "Must specify --macos option" if macos.blank?
 
     # Fixup label for ARM/Apple Silicon
-    macos_label = if arm_label
+    macos_label = if macos.arch == :arm64
+      # TODO: fix label name to be 11-arm64 instead.
       "#{macos}-arm"
     else
       macos.to_s

Library/Homebrew/extend/os/mac/utils/bottles.rb

@@ -42,7 +42,10 @@ module Utils
         return if tag_version.blank?
 
         keys.find do |key|
-          MacOS::Version.from_symbol(key) <= tag_version
+          key_version = MacOS::Version.from_symbol(key)
+          next if key_version.arch != tag_version.arch
+
+          key_version <= tag_version
         rescue MacOSVersionError
           false
         end

Library/Homebrew/os/mac/version.rb

@@ -13,6 +13,8 @@ module OS
     class Version < ::Version
       extend T::Sig
 
+      attr_reader :arch
+
       SYMBOLS = {
         big_sur:     "11",
         catalina:    "10.15",
@@ -25,20 +27,37 @@ module OS
 
       sig { params(sym: Symbol).returns(T.attached_class) }
       def self.from_symbol(sym)
-        @all_archs_regex ||= /^#{Regexp.union(Hardware::CPU::ALL_ARCHS.map(&:to_s))}_/
+        version, arch = version_arch(sym)
-        sym_without_arch = sym.to_s
+        version ||= sym
-                              .sub(@all_archs_regex, "")
+        str = SYMBOLS.fetch(version.to_sym) { raise MacOSVersionError, sym }
-                              .to_sym
+        new(str, arch: arch)
-        str = SYMBOLS.fetch(sym_without_arch) { raise MacOSVersionError, sym }
-        new(str)
       end
 
-      sig { params(value: T.nilable(String)).void }
+      sig { params(value: T.any(String, Symbol)).returns(T::Array[String]) }
-      def initialize(value)
+      def self.version_arch(value)
-        raise MacOSVersionError, value unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(value)
+        @all_archs_regex ||= begin
+          all_archs = Hardware::CPU::ALL_ARCHS.map(&:to_s)
+          /^((#{Regexp.union(all_archs)})_)?([\w.]+)(-(#{Regexp.union(all_archs)}))?$/
+        end
+        match = @all_archs_regex.match(value)
+        return [] unless match
 
-        super(value)
+        version = match[3]
+        arch = match[2] || match[5]
+        [version, arch]
+      end
 
+      sig { params(value: T.nilable(String), arch: T.nilable(String)).void }
+      def initialize(value, arch: nil)
+        version, arch = Version.version_arch(value) if value.present? && arch.nil?
+        version ||= value
+        arch    ||= "intel"
+
+        raise MacOSVersionError, version unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(version)
+
+        super(version)
+
+        @arch = arch.to_sym
         @comparison_cache = {}
       end
 

Library/Homebrew/test/os/mac/version_spec.rb

@@ -62,12 +62,44 @@ describe OS::Mac::Version do
         described_class.new("1.2")
       }.to raise_error(MacOSVersionError, 'unknown or unsupported macOS version: "1.2"')
     end
+
+    it "creates a new version from a valid macOS version" do
+      string_version = described_class.new("11")
+      expect(string_version).to eq(:big_sur)
+      expect(string_version.arch).to eq(:intel)
+    end
+
+    it "creates a new version from a valid macOS version with architecture" do
+      string_version = described_class.new("11-arm64")
+      expect(string_version).to eq(:big_sur)
+      expect(string_version.arch).to eq(:arm64)
+    end
+
+    it "creates a new version from a valid macOS version and architecture" do
+      string_version = described_class.new("11", arch: "arm64")
+      expect(string_version).to eq(:big_sur)
+      expect(string_version.arch).to eq(:arm64)
+    end
   end
 
-  specify "#from_symbol" do
+  describe "#from_symbol" do
-    expect(described_class.from_symbol(:mojave)).to eq(version)
+    it "raises an error if the symbol is not a valid macOS version" do
-    expect { described_class.from_symbol(:foo) }
+      expect {
-      .to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :foo")
+        described_class.from_symbol(:foo)
+      }.to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :foo")
+    end
+
+    it "creates a new version from a valid macOS version" do
+      symbol_version = described_class.from_symbol(:mojave)
+      expect(symbol_version).to eq(version)
+      expect(symbol_version.arch).to eq(:intel)
+    end
+
+    it "creates a new version from a valid macOS version with architecture" do
+      symbol_version = described_class.from_symbol(:arm64_big_sur)
+      expect(symbol_version).to eq(:big_sur)
+      expect(symbol_version.arch).to eq(:arm64)
+    end
   end
 
   specify "#pretty_name" do