Improve FormulaStruct usage in Formulary

Author: Rylan12

Library/Homebrew/api/formula_struct.rb

@@ -1,23 +1,243 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "utils/spdx"
+
 class FormulaStruct < T::Struct
-  const :uses_from_macos, T::Array[T.any(String, T::Hash[String, String])], default: []
-  const :requirements, T::Array[T::Hash[String, T.untyped]], default: []
-  const :dependencies, T::Array[String], default: []
-  const :build_dependencies, T::Array[String], default: []
-  const :test_dependencies, T::Array[String], default: []
-  const :recommended_dependencies, T::Array[String], default: []
-  const :optional_dependencies, T::Array[String], default: []
-  const :stable_dependencies, T::Hash[String, T::Array[String]], default: { dependencies: [], build_dependencies: [], test_dependencies: [], recommended_dependencies: [], optional_dependencies: [], uses_from_macos_bounds: [] }
-  const :head_dependencies, T::Hash[String, T::Array[String]], default: { dependencies: [], build_dependencies: [], test_dependencies: [], recommended_dependencies: [], optional_dependencies: [], uses_from_macos_bounds: [] }
+  # `:codesign` and custom requirement classes are not supported.
+  API_SUPPORTED_REQUIREMENTS = [:arch, :linux, :macos, :maximum_macos, :xcode].freeze
+  private_constant :API_SUPPORTED_REQUIREMENTS
+
+  DeprecateDisableArgs = T.type_alias do
+    {
+      date:                String,
+      because:             T.nilable(T.any(String, Symbol)),
+      replacement_formula: T.nilable(String),
+      replacement_cask:    T.nilable(String),
+    }
+  end
+
+  DependencyArgs = T.type_alias do
+    T.any(
+      # Formula name: "foo"
+      String,
+      # Formula name and dependency type: { "foo" => :build }
+      T::Hash[String, Symbol],
+    )
+  end
+
+  RequirementArgs = T.type_alias do
+    T.any(
+      # Requirement name: :macos
+      Symbol,
+      # Requirement name and other info: { macos: :build }
+      T::Hash[Symbol, T::Array[T.anything]],
+    )
+  end
+
+  UsesFromMacOSArgs = T.type_alias do
+    [
+      T.any(String, T::Hash[T.any(String, Symbol), T.any(Symbol, T::Array[Symbol])]),
+      T::Hash[Symbol, Symbol],
+    ]
+  end
+
+  sig { params(hash: T::Hash[String, T.untyped]).returns(FormulaStruct) }
+  def self.from_hash(hash)
+    hash["license"] = SPDX.string_to_license_expression(hash["license"])
+
+    if (reason = hash["no_autobump_message"])
+      reason = reason.to_sym if NO_AUTOBUMP_REASONS_LIST.key?(reason.to_sym)
+      hash["no_autobump_args"] = { because: reason }
+    end
+
+    if (caveats = hash["caveats"])
+      hash["caveats"] = Formulary.replace_placeholders(caveats)
+    end
+
+    if (condition = hash["pour_bottle_only_if"])
+      hash["pour_bottle_args"] = { only_if: condition.to_sym }
+    end
+
+    if (keg_only_hash = hash["keg_only_reason"])
+      reason = Formulary.convert_to_string_or_symbol(keg_only_hash.fetch("reason"))
+      explanation = keg_only_hash.fetch("explanation")
+      hash["keg_only_args"] = [reason, explanation]
+    end
+
+    if (deprecation_date = hash["deprecation_date"])
+      hash["deprecate_args"] = {
+        date:                deprecation_date,
+        because:             DeprecateDisable.to_reason_string_or_symbol(hash["deprecation_reason"], type: :formula),
+        replacement_formula: hash["deprecation_replacement_formula"],
+        replacement_cask:    hash["deprecation_replacement_cask"],
+      }
+    end
+
+    if (disable_date = hash["disable_date"])
+      hash["disable_args"] = {
+        date:                disable_date,
+        because:             DeprecateDisable.to_reason_string_or_symbol(hash["disable_reason"], type: :formula),
+        replacement_formula: hash["disable_replacement_formula"],
+        replacement_cask:    hash["disable_replacement_cask"],
+      }
+    end
+
+    hash["stable_dependency_hash"] = {
+      "dependencies"             => hash["dependencies"] || [],
+      "build_dependencies"       => hash["build_dependencies"] || [],
+      "test_dependencies"        => hash["test_dependencies"] || [],
+      "recommended_dependencies" => hash["recommended_dependencies"] || [],
+      "optional_dependencies"    => hash["optional_dependencies"] || [],
+      "uses_from_macos"          => hash["uses_from_macos"] || [],
+      "uses_from_macos_bounds"   => hash["uses_from_macos_bounds"] || [],
+    }
+
+    conflicts_with = hash["conflicts_with"] || []
+    conflicts_with_reasons = hash["conflicts_with_reasons"] || []
+    hash["conflicts"] = conflicts_with.zip(conflicts_with_reasons).map do |name, because|
+      [name, { because: }]
+    end
+
+    # Rename some entries for clarity
+    hash["link_overwrite_paths"] = hash["link_overwrite"]
+    hash["requirements_array"] = hash["requirements"]
+    hash["head_dependency_hash"] = hash["head_dependencies"]
+
+    super
+  end
+
+  const :stable_dependency_hash, T::Hash[String, T::Array[String]], default: {}
+  const :head_dependency_hash, T::Hash[String, T::Array[String]], default: {}
   const :caveats, T.nilable(String)
   const :desc, String
   const :homepage, String
-  const :license, String
+  const :license, SPDX::LicenseExpression
   const :revision, Integer, default: 0
   const :version_scheme, Integer, default: 0
-  const :no_autobump_msg, T.nilable(String)
+  const :link_overwrite_paths, T::Array[String], default: []
+  const :post_install_defined, T::Boolean, default: false
+  const :service, T.nilable(T::Hash[String, T.untyped])
+  const :tap_git_head, String
+  const :oldnames, T.nilable(T::Array[String])
+  const :ruby_source_path, String
+  const :ruby_source_checksum, T::Hash[String, String]
+  const :aliases, T::Array[String], default: []
+  const :versioned_formulae, T::Array[String], default: []
+  const :bottle, T::Hash[String, T.untyped], default: {}
+  const :no_autobump_args, T.nilable({ because: T.any(String, Symbol) })
+  const :pour_bottle_args, T.nilable({ only_if: Symbol })
+  const :keg_only_args, T.nilable([T.any(String, Symbol), String])
+  const :deprecate_args, T.nilable(DeprecateDisableArgs)
+  const :disable_args, T.nilable(DeprecateDisableArgs)
+  const :conflicts, T::Array[[String, { because: T.nilable(String) }]], default: []
+
+  sig { returns(String) }
+  def ruby_source_sha256
+    ruby_source_checksum.fetch("sha256")
+  end
+
+  sig { returns(T::Boolean) }
+  def head?
+    urls["head"].present?
+  end
+
+  sig { returns([String, T::Hash[Symbol, T.anything]]) }
+  def head_url_args
+    url = T.must(urls.dig("head", "url"))
+    specs = {
+      branch: urls.dig("head", "branch"),
+      using:  urls.dig("head", "using")&.to_sym,
+    }.compact_blank
+    [url, specs]
+  end
+
+  sig { returns(T::Array[T.any(DependencyArgs, RequirementArgs)]) }
+  def head_dependencies
+    spec_dependencies(:head) + spec_requirements(:head)
+  end
+
+  sig { returns(T::Array[UsesFromMacOSArgs]) }
+  def head_uses_from_macos
+    spec_uses_from_macos(:head)
+  end
+
+  sig { returns(T::Boolean) }
+  def stable?
+    urls["stable"].present?
+  end
+
+  sig { returns([String, T::Hash[Symbol, T.anything]]) }
+  def stable_url_args
+    url = T.must(urls.dig("stable", "url"))
+    specs = {
+      tag:      urls.dig("stable", "tag"),
+      revision: urls.dig("stable", "revision"),
+      using:    urls.dig("stable", "using")&.to_sym,
+    }.compact_blank
+    [url, specs]
+  end
+
+  sig { returns(String) }
+  def stable_version
+    versions.fetch("stable")
+  end
+
+  sig { returns(T.nilable(String)) }
+  def stable_checksum
+    urls.dig("stable", "checksum")
+  end
+
+  sig { returns(T::Array[T.any(DependencyArgs, RequirementArgs)]) }
+  def stable_dependencies
+    spec_dependencies(:stable) + spec_requirements(:stable)
+  end
+
+  sig { returns(T::Array[UsesFromMacOSArgs]) }
+  def stable_uses_from_macos
+    spec_uses_from_macos(:stable)
+  end
+
+  sig { returns(T::Boolean) }
+  def bottle?
+    bottle["stable"].present?
+  end
+
+  sig { returns(Integer) }
+  def bottle_rebuild
+    bottle.dig("stable", "rebuild") || 0
+  end
+
+  sig { returns(T::Array[T::Hash[String, T.anything]]) }
+  def bottle_checksums
+    Array(bottle.dig("stable", "files")).map do |tag, bottle_spec|
+      {
+        cellar: Formulary.convert_to_string_or_symbol(bottle_spec.fetch("cellar")),
+        tag.to_sym => bottle_spec.fetch("sha256"),
+      }
+    end
+  end
+
+  # sig { returns(T::Boolean) }
+  # def service?
+  #   service.present?
+  # end
+
+  # def service_run_args
+  # end
+
+  # def service_name_args
+  # end
+
+  # def service_methods_and_args
+  # end
+
+  private
+
+  const :versions, T::Hash[String, String]
+  const :urls, T::Hash[String, T::Hash[String, T.nilable(String)]]
+  const :requirements_array, T::Array[T::Hash[String, T.untyped]], default: []
+  const :no_autobump_message, T.nilable(String)
   const :pour_bottle_only_if, T.nilable(String)
   const :keg_only_reason, T.nilable(T::Hash[String, String])
   const :deprecation_date, T.nilable(String)
@@ -30,33 +250,75 @@ class FormulaStruct < T::Struct
   const :disable_replacement_cask, T.nilable(String)
   const :conflicts_with, T::Array[String], default: []
   const :conflicts_with_reasons, T::Array[String], default: []
-  const :link_overwrite, T::Array[String], default: []
-  const :post_install_defined, T::Boolean, default: false
-  const :service, T.nilable(T::Hash[String, T.untyped])
-  const :tap_git_head, String
-  const :oldnames, T.nilable(T::Array[String])
-  const :oldname, T.nilable(String)
-  const :ruby_source_path, String
-  const :ruby_source_checksum, T::Hash[String, String]
-  const :urls, T::Hash[String, T::Hash[String, T.nilable(String)]]
-  const :ruby_source_sha256, T.nilable(String)
-  const :aliases, T::Array[String], default: []
-  const :versioned_formulae, T::Array[String], default: []
-  const :versions, T::Hash[String, String]
-  const :bottle, T::Hash[String, T.untyped], default: {}
-  const :uses_from_macos_bounds, T.nilable(T::Array[T::Hash[String, String]])
 
-  sig { params(hash: T::Hash[String, T.untyped]).returns(FormulaStruct) }
-  def self.from_hash(hash)
-    hash["stable_dependencies"] ||= {
-      "dependencies"             => hash["dependencies"] || [],
-      "build_dependencies"       => hash["build_dependencies"] || [],
-      "test_dependencies"        => hash["test_dependencies"] || [],
-      "recommended_dependencies" => hash["recommended_dependencies"] || [],
-      "optional_dependencies"    => hash["optional_dependencies"] || [],
-      "uses_from_macos_bounds"   => hash["uses_from_macos_bounds"] || [],
-    }
+  sig { params(spec: Symbol).returns(T::Array[DependencyArgs]) }
+  def spec_dependencies(spec)
+    deps_hash = send("#{spec}_dependency_hash")
+    dependencies = deps_hash.fetch("dependencies", [])
+    dependencies + [:build, :test, :recommended, :optional].filter_map do |type|
+      deps_hash["#{type}_dependencies"]&.map do |dep|
+        { dep => type }
+      end
+    end.flatten(1)
+  end
 
-    super
+  sig { params(spec: Symbol).returns(T::Array[UsesFromMacOSArgs]) }
+  def spec_uses_from_macos(spec)
+    deps_hash = send("#{spec}_dependency_hash")
+    zipped_array = deps_hash["uses_from_macos"]&.zip(deps_hash["uses_from_macos_bounds"])
+    return [] unless zipped_array
+
+    zipped_array.map do |entry, bounds|
+      bounds ||= {}
+      bounds = bounds.transform_keys(&:to_sym).transform_values(&:to_sym)
+
+      if entry.is_a?(Hash)
+        # The key is the dependency name, the value is the dep type. Only the type should be a symbol
+        entry = entry.deep_transform_values(&:to_sym)
+        # When passing both a dep type and bounds, uses_from_macos expects them both in the first argument
+        entry = entry.merge(bounds)
+        [entry, {}]
+      else
+        [entry, bounds]
+      end
+    end
+  end
+
+  sig { params(spec: Symbol).returns(T::Array[RequirementArgs]) }
+  def spec_requirements(spec)
+    requirements_array.filter_map do |req|
+      next unless req["specs"].include?(spec.to_s)
+
+      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_tags = []
+      req_tags << req_version if req_version.present?
+      req_tags += req["contexts"]&.map do |tag|
+        case tag
+        when String
+          tag.to_sym
+        when Hash
+          tag.deep_transform_keys(&:to_sym)
+        else
+          tag
+        end
+      end
+
+      if req_tags.empty?
+        req_name
+      else
+        { req_name => req_tags }
+      end
+    end
   end
 end

Library/Homebrew/dependency_collector.rb

@@ -160,7 +160,7 @@ def parse_string_spec(spec, tags)
 
   def parse_symbol_spec(spec, tags)
     # When modifying this list of supported requirements, consider
-    # whether `Formulary::API_SUPPORTED_REQUIREMENTS` should also be changed.
+    # whether `FormulaStruct::API_SUPPORTED_REQUIREMENTS` should also be changed.
     case spec
     when :arch          then ArchRequirement.new(tags)
     when :codesign      then CodesignRequirement.new(tags)

Library/Homebrew/formula.rb

@@ -3605,14 +3605,14 @@ def desc(val = T.unsafe(nil))
     # @see https://spdx.github.io/spdx-spec/latest/annexes/spdx-license-expressions/ SPDX license expression guide
     # @api public
     sig {
-      params(args: T.nilable(T.any(String, Symbol, T::Hash[T.any(String, Symbol), T.anything])))
-        .returns(T.nilable(T.any(String, Symbol, T::Hash[T.any(String, Symbol), T.anything])))
+      params(args: T.nilable(SPDX::LicenseExpression))
+        .returns(T.nilable(SPDX::LicenseExpression))
     }
     def license(args = nil)
       if args.nil?
         @licenses
       else
-        @licenses = T.let(args, T.nilable(T.any(String, Symbol, T::Hash[T.any(String, Symbol), T.anything])))
+        @licenses = T.let(args, T.nilable(SPDX::LicenseExpression))
       end
     end
 
@@ -3939,7 +3939,7 @@ def build_flags
     # ```
     #
     # @api public
-    sig { params(block: T.nilable(T.proc.returns(SoftwareSpec))).returns(T.untyped) }
+    sig { params(block: T.nilable(T.proc.void)).returns(T.untyped) }
     def stable(&block)
       return T.must(@stable) unless block