Merge pull request #20720 from Homebrew/chore/cask/regex_matrix

chore: switch cask-ci-matrix to cask methods

Author: MikeMcQuaid

Library/Homebrew/dev-cmd/generate-cask-ci-matrix.rb

@@ -115,70 +115,32 @@ def run
         end
       end
 
-      sig { params(cask_content: String).returns(T::Hash[T::Hash[Symbol, T.any(Symbol, String)], Float]) }
-      def filter_runners(cask_content)
-        # Retrieve arguments from `depends_on macos:`
-        required_macos = case cask_content
-        when /depends_on\s+macos:\s+\[([^\]]+)\]/
-          T.must(Regexp.last_match(1)).scan(/\s*(?:"([=<>]=)\s+)?:([^\s",]+)"?,?\s*/).map do |match|
-            {
-              version:    T.must(match[1]).to_sym,
-              comparator: match[0] || "==",
-            }
-          end
-        when /depends_on\s+macos:\s+"?:([^\s"]+)"?/ # e.g. `depends_on macos: :big_sur`
-          [
-            {
-              version:    T.must(Regexp.last_match(1)).to_sym,
-              comparator: "==",
-            },
-          ]
-        when /depends_on\s+macos:\s+"([=<>]=)\s+:([^\s"]+)"/ # e.g. `depends_on macos: ">= :monterey"`
-          [
-            {
-              version:    T.must(Regexp.last_match(2)).to_sym,
-              comparator: Regexp.last_match(1),
-            },
-          ]
-        when /depends_on\s+macos:/
-          # In this case, `depends_on macos:` is present but wasn't matched by the
-          # previous regexes. We want this to visibly fail so we can address the
-          # shortcoming instead of quietly defaulting to `RUNNERS`.
-          odie "Unhandled `depends_on macos` argument"
-        else
-          []
+      sig { params(cask: Cask::Cask).returns(T::Hash[T::Hash[Symbol, T.any(Symbol, String)], Float]) }
+      def filter_runners(cask)
+        filtered_macos_runners = RUNNERS.select do |runner, _|
+          cask.depends_on.macos.present? &&
+            cask.depends_on.macos.allows?(MacOSVersion.from_symbol(T.must(runner[:symbol]).to_sym))
         end
 
-        filtered_runners = RUNNERS.select do |runner, _|
-          required_macos.any? do |r|
-            MacOSVersion.from_symbol(runner.fetch(:symbol).to_sym).compare(
-              r.fetch(:comparator),
-              MacOSVersion.from_symbol(r.fetch(:version).to_sym),
-            )
-          end
+        filtered_runners = if filtered_macos_runners.any?
+          filtered_macos_runners
+        else
+          RUNNERS.dup
         end
-        filtered_runners = RUNNERS.dup if filtered_runners.empty?
 
-        archs = architectures(cask_content:)
+        archs = architectures(cask:)
         filtered_runners.select! do |runner, _|
           archs.include?(runner.fetch(:arch))
         end
 
-        RUNNERS
+        filtered_runners
       end
 
-      sig { params(cask_content: BasicObject).returns(T::Array[Symbol]) }
-      def architectures(cask_content:)
-        case cask_content
-        when /depends_on\s+arch:\s+:arm64/
-          [:arm]
-        when /depends_on\s+arch:\s+:x86_64/
-          [:intel]
-        when /\barch\b/, /\bon_(arm|intel)\b/
-          [:arm, :intel]
-        else
-          RUNNERS.keys.map { |r| r.fetch(:arch) }.uniq.sort
-        end
+      sig { params(cask: Cask::Cask).returns(T::Array[Symbol]) }
+      def architectures(cask:)
+        return RUNNERS.keys.map { |r| r.fetch(:arch).to_sym }.uniq.sort if cask.depends_on.arch.blank?
+
+        cask.depends_on.arch.map { |arch| arch[:type] }.uniq.sort
       end
 
       sig {
@@ -190,16 +152,12 @@ def random_runner(available_runners = ARM_RUNNERS)
          .first
       end
 
-      sig { params(cask_content: String).returns([T::Array[T::Hash[Symbol, T.any(Symbol, String)]], T::Boolean]) }
-      def runners(cask_content:)
-        filtered_runners = filter_runners(cask_content)
+      sig { params(cask: Cask::Cask).returns([T::Array[T::Hash[Symbol, T.any(Symbol, String)]], T::Boolean]) }
+      def runners(cask:)
+        filtered_runners = filter_runners(cask)
 
-        macos_version_found = cask_content.match?(/\bMacOS\s*\.version\b/m)
         filtered_macos_found = filtered_runners.keys.any? do |runner|
-          (
-            macos_version_found &&
-            cask_content.include?(runner[:symbol].inspect)
-          ) || cask_content.include?("on_#{runner[:symbol]}")
+          cask.to_hash_with_variations["variations"].key?(T.must(runner[:symbol]).to_sym)
         end
 
         if filtered_macos_found
@@ -254,11 +212,9 @@ def generate_matrix(tap, labels: [], cask_names: [], skip_install: false, new_ca
         cask_files_to_check.flat_map do |path|
           cask_token = path.basename(".rb")
 
-          audit_args = ["--online"]
+          audit_args = ["--online", "--signing"]
           audit_args << "--new" if T.must(changed_files[:added_files]).include?(path) || new_cask
 
-          audit_args << "--signing"
-
           audit_exceptions = []
 
           audit_exceptions << %w[homepage_https_availability] if labels.include?("ci-skip-homepage")
@@ -279,10 +235,10 @@ def generate_matrix(tap, labels: [], cask_names: [], skip_install: false, new_ca
 
           audit_args << "--except" << audit_exceptions.join(",") if audit_exceptions.any?
 
-          cask_content = path.read
+          cask = Cask::CaskLoader.load(path.expand_path)
 
-          runners, multi_os = runners(cask_content:)
-          runners.product(architectures(cask_content:)).filter_map do |runner, arch|
+          runners, multi_os = runners(cask:)
+          runners.product(architectures(cask:)).filter_map do |runner, arch|
             native_runner_arch = arch == runner.fetch(:arch)
             # If it's just a single OS test then we can just use the two real arch runners.
             next if !native_runner_arch && !multi_os