mirror of
https://github.com/Homebrew/brew.git
synced 2026-08-12 22:29:27 +04:00
Mike McQuaid
204ea7e964
- Make every statically-poked method public and call it directly, keeping `public_send` only for dynamically-named public methods. - Read and write state through public `attr_*` accessors instead of instance variable reflection. - Enable `Homebrew/NoSendInTests` and `Homebrew/NoInstanceVariableAccessInTests` now the test suite is clean, so neither pattern creeps back in. - Keep rare justified disables, e.g. `Module#remove_const` is private core Ruby and raw memoisation state has no accessor.
832 lines
35 KiB
Ruby
832 lines
35 KiB
Ruby
# typed: strict
|
|
# frozen_string_literal: true
|
|
|
|
require "abstract_command"
|
|
require "bump"
|
|
require "fileutils"
|
|
require "formula"
|
|
require "livecheck/livecheck"
|
|
require "utils/tar"
|
|
|
|
module Homebrew
|
|
module DevCmd
|
|
class BumpFormulaPr < AbstractCommand
|
|
cmd_args do
|
|
description <<~EOS
|
|
Create a pull request to update <formula> with a new URL or a new tag.
|
|
|
|
If a <URL> is specified, the <SHA-256> checksum of the new download should also
|
|
be specified. A best effort to determine the <SHA-256> will be made if not supplied
|
|
by the user.
|
|
|
|
If a <tag> is specified, the Git commit <revision> corresponding to that tag
|
|
should also be specified. A best effort to determine the <revision> will be made
|
|
if the value is not supplied by the user.
|
|
|
|
If a <version> is specified, a best effort to determine the <URL> and <SHA-256> or
|
|
the <tag> and <revision> will be made if both values are not supplied by the user.
|
|
|
|
*Note:* this command cannot be used to transition a formula from a
|
|
URL-and-SHA-256 style specification into a tag-and-revision style specification,
|
|
nor vice versa. It must use whichever style specification the formula already uses.
|
|
EOS
|
|
switch "-n", "--dry-run",
|
|
description: "Print what would be done rather than doing it."
|
|
switch "--write-only",
|
|
description: "Make the expected file modifications without taking any Git actions."
|
|
switch "--commit",
|
|
depends_on: "--write-only",
|
|
description: "When passed with `--write-only`, generate a new commit after writing changes " \
|
|
"to the formula file."
|
|
switch "--no-audit",
|
|
description: "Don't run `brew audit` before opening the PR."
|
|
switch "--strict",
|
|
description: "Run `brew audit --strict` before opening the PR."
|
|
switch "--online",
|
|
description: "Run `brew audit --online` before opening the PR."
|
|
switch "--no-browse",
|
|
description: "Print the pull request URL instead of opening in a browser."
|
|
switch "--no-fork",
|
|
description: "Don't try to fork the repository."
|
|
comma_array "--mirror",
|
|
description: "Use the specified <URL> as a mirror URL. If <URL> is a comma-separated list " \
|
|
"of URLs, multiple mirrors will be added."
|
|
flag "--fork-org=",
|
|
description: "Use the specified GitHub organization for forking."
|
|
flag "--version=",
|
|
description: "Use the specified <version> to override the value parsed from the URL or tag. Note " \
|
|
"that `--version=0` can be used to delete an existing version override from a " \
|
|
"formula if it has become redundant."
|
|
flag "--message=",
|
|
description: "Prepend <message> to the default pull request message."
|
|
flag "--url=",
|
|
description: "Specify the <URL> for the new download. If a <URL> is specified, the <SHA-256> " \
|
|
"checksum of the new download should also be specified."
|
|
flag "--sha256=",
|
|
depends_on: "--url=",
|
|
description: "Specify the <SHA-256> checksum of the new download."
|
|
flag "--tag=",
|
|
description: "Specify the new git commit <tag> for the formula."
|
|
flag "--revision=",
|
|
description: "Specify the new commit <revision> corresponding to the specified git <tag> " \
|
|
"or specified <version>."
|
|
switch "-f", "--force",
|
|
description: "Remove all mirrors if `--mirror` was not specified."
|
|
switch "--install-dependencies",
|
|
description: "Install missing dependencies required to update resources."
|
|
flag "--python-package-name=",
|
|
description: "Use the specified <package-name> when finding Python resources for <formula>. " \
|
|
"If no package name is specified, it will be inferred from the formula's stable URL."
|
|
comma_array "--python-extra-packages=",
|
|
description: "Include these additional Python packages when finding resources."
|
|
comma_array "--python-exclude-packages=",
|
|
description: "Exclude these Python packages when finding resources."
|
|
comma_array "--bump-synced=",
|
|
hidden: true
|
|
flag "--resource-versions=",
|
|
description: "JSON-encoded resource version data from `brew bump`.",
|
|
hidden: true
|
|
|
|
conflicts "--dry-run", "--write-only"
|
|
conflicts "--no-audit", "--strict"
|
|
conflicts "--no-audit", "--online"
|
|
conflicts "--url", "--tag"
|
|
|
|
named_args :formula, max: 1, without_api: true
|
|
end
|
|
|
|
sig { override.void }
|
|
def run
|
|
Homebrew.install_bundler_gems!(groups: ["ast"])
|
|
require "utils/ast"
|
|
require "utils/pypi"
|
|
|
|
if args.revision.present? && args.tag.nil? && args.version.nil?
|
|
raise UsageError, "`--revision` must be passed with either `--tag` or `--version`!"
|
|
end
|
|
|
|
# As this command is simplifying user-run commands then let's just use a
|
|
# user path, too.
|
|
ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
|
|
|
|
# Use the user's browser, too.
|
|
ENV["BROWSER"] = Homebrew::EnvConfig.browser
|
|
|
|
@tap_retried = T.let(false, T.nilable(T::Boolean))
|
|
begin
|
|
formula = args.named.to_formulae.first
|
|
raise FormulaUnspecifiedError if formula.blank?
|
|
|
|
raise ArgumentError, "This formula is disabled!" if formula.disabled?
|
|
if formula.deprecation_reason == :does_not_build
|
|
raise ArgumentError, "This formula is deprecated and does not build!"
|
|
end
|
|
|
|
tap = formula.tap
|
|
raise ArgumentError, "This formula is not in a tap!" if tap.blank?
|
|
raise ArgumentError, "This formula's tap is not a Git repository!" unless tap.git?
|
|
rescue ArgumentError => e
|
|
odie e.message if @tap_retried
|
|
|
|
CoreTap.instance.install(force: true)
|
|
@tap_retried = true
|
|
retry
|
|
end
|
|
|
|
odie <<~EOS unless tap.allow_bump?(formula.name)
|
|
Whoops, the #{formula.name} formula has its version update
|
|
pull requests automatically opened by BrewTestBot every ~3 hours!
|
|
We'd still love your contributions, though, so try another one
|
|
that is excluded from autobump list (i.e. it has 'no_autobump!'
|
|
method or 'livecheck' block with 'skip'.)
|
|
EOS
|
|
|
|
if !args.write_only? && GitHub.too_many_open_prs?(tap)
|
|
odie "You have too many PRs open: close or merge some first!"
|
|
end
|
|
|
|
formula_spec = formula.stable
|
|
odie "#{formula}: no stable specification found!" if formula_spec.blank?
|
|
|
|
# This will be run by `brew audit` later so run it first to not start
|
|
# spamming during normal output.
|
|
Homebrew.install_bundler_gems!(groups: ["audit", "style"]) unless args.no_audit?
|
|
|
|
tap_remote_repo = tap.remote_repository
|
|
odie "#{tap.name} tap does not have a remote repository!" if tap_remote_repo.nil?
|
|
|
|
check_pull_requests(formula, tap_remote_repo, state: "open") unless args.write_only?
|
|
|
|
all_formulae = []
|
|
if args.bump_synced.present?
|
|
Array(args.bump_synced).each do |formula_name|
|
|
all_formulae << formula_name
|
|
end
|
|
else
|
|
all_formulae << args.named.first.to_s
|
|
end
|
|
|
|
return if all_formulae.empty?
|
|
|
|
added_release_info = Set.new
|
|
|
|
commits = all_formulae.filter_map do |formula_name|
|
|
commit_formula = Formula[formula_name]
|
|
raise FormulaUnspecifiedError if commit_formula.blank?
|
|
|
|
commit_formula_spec = commit_formula.stable
|
|
odie "#{commit_formula}: no stable specification found!" if commit_formula_spec.blank?
|
|
|
|
formula_pr_message = ""
|
|
|
|
new_url = args.url
|
|
new_version = args.version
|
|
|
|
check_new_version(commit_formula, tap_remote_repo, version: new_version) if new_version.present?
|
|
|
|
opoo "This formula has patches that may be resolved upstream." if commit_formula.patchlist.present?
|
|
if commit_formula.resources.any? { |resource| !resource.name.start_with?("homebrew-") }
|
|
opoo "This formula has resources that may need to be updated."
|
|
end
|
|
|
|
old_mirrors = commit_formula_spec.mirrors
|
|
new_mirrors ||= args.mirror
|
|
if new_url.present? && (new_mirror = determine_mirror(new_url))
|
|
new_mirrors ||= [new_mirror]
|
|
check_for_mirrors(commit_formula.name, old_mirrors, new_mirrors)
|
|
end
|
|
|
|
old_hash = commit_formula_spec.checksum&.hexdigest
|
|
|
|
new_hash = args.sha256
|
|
new_tag = args.tag
|
|
new_revision = args.revision
|
|
old_url = T.must(commit_formula_spec.url)
|
|
old_tag = commit_formula_spec.specs[:tag]
|
|
old_formula_version = formula_version(commit_formula)
|
|
old_version = old_formula_version.to_s
|
|
forced_version = new_version.present?
|
|
new_url_hash = if new_url.present? && new_hash.present?
|
|
check_new_version(commit_formula, tap_remote_repo, url: new_url) if new_version.blank?
|
|
true
|
|
elsif new_tag.present? && new_revision.present?
|
|
check_new_version(commit_formula, tap_remote_repo, url: old_url, tag: new_tag) if new_version.blank?
|
|
false
|
|
elsif old_hash.blank?
|
|
if new_tag.blank? && new_version.blank? && new_revision.blank?
|
|
raise UsageError, "#{formula}: no `--tag` or `--version` argument specified!"
|
|
end
|
|
|
|
if old_tag.present?
|
|
new_tag ||= old_tag.gsub(old_version, new_version)
|
|
if new_tag == old_tag
|
|
odie <<~EOS
|
|
You need to bump this formula manually since the new tag
|
|
and old tag are both #{new_tag}.
|
|
EOS
|
|
end
|
|
check_new_version(commit_formula, tap_remote_repo, url: old_url, tag: new_tag) if new_version.blank?
|
|
resource_path, forced_version = fetch_resource_and_forced_version(commit_formula, new_version, old_url,
|
|
tag: new_tag)
|
|
new_revision = Utils.popen_read("git", "-C", resource_path.to_s, "rev-parse", "-q", "--verify", "HEAD")
|
|
new_revision = new_revision.strip
|
|
elsif new_revision.blank?
|
|
odie "#{commit_formula}: the current URL requires specifying a `--revision=` argument."
|
|
end
|
|
false
|
|
elsif new_url.blank? && new_version.blank?
|
|
raise UsageError, "#{commit_formula}: no `--url` or `--version` argument specified!"
|
|
else
|
|
new_url ||= PyPI.update_pypi_url(old_url, new_version) if new_version.present?
|
|
|
|
if new_url.blank? && new_version.present?
|
|
new_url = update_url(old_url, old_version, new_version)
|
|
if new_mirrors.blank? && old_mirrors.present?
|
|
new_mirrors = old_mirrors.map do |old_mirror|
|
|
update_url(old_mirror, old_version, new_version)
|
|
end
|
|
end
|
|
end
|
|
if new_url == old_url
|
|
odie <<~EOS
|
|
You need to bump this formula manually since the new URL
|
|
and old URL are both:
|
|
#{new_url}
|
|
EOS
|
|
end
|
|
if new_url.blank?
|
|
odie "There was an issue generating the updated url, you may need to create the PR manually"
|
|
end
|
|
check_new_version(commit_formula, tap_remote_repo, url: new_url) if new_version.blank?
|
|
resource_path, forced_version = fetch_resource_and_forced_version(commit_formula, new_version, new_url)
|
|
Utils::Tar.validate_file(resource_path)
|
|
new_hash = resource_path.sha256
|
|
end
|
|
|
|
old_contents = commit_formula.path.read
|
|
formula_ast = Utils::AST::FormulaAST.new(old_contents)
|
|
|
|
formula_ast.remove_stanza(:revision) if commit_formula.revision.nonzero?
|
|
formula_ast.remove_stable_stanzas(:mirror) if commit_formula_spec.mirrors.present?
|
|
|
|
if new_url_hash.present?
|
|
formula_ast.replace_stable_stanza_value(:url, T.must(new_url))
|
|
formula_ast.replace_stable_stanza_value(:sha256, new_hash)
|
|
elsif new_tag.present?
|
|
formula_ast.replace_stable_stanza_hash_value(:url, :tag, new_tag)
|
|
formula_ast.replace_stable_stanza_hash_value(:url, :revision, T.must(new_revision))
|
|
elsif new_url.present?
|
|
formula_ast.replace_stable_stanza_value(:url, new_url)
|
|
formula_ast.replace_stable_stanza_hash_value(:url, :revision, T.must(new_revision))
|
|
else
|
|
formula_ast.replace_stable_stanza_hash_value(:url, :revision, T.must(new_revision))
|
|
end
|
|
|
|
stanzas_to_add = []
|
|
new_mirrors&.each { |mirror| stanzas_to_add << [:mirror, "mirror #{mirror.inspect}"] } if new_url.present?
|
|
if forced_version && new_version != "0"
|
|
if formula_ast.stable_stanza?(:version)
|
|
formula_ast.replace_stable_stanza_value(:version, T.must(new_version))
|
|
else
|
|
stanzas_to_add << [:version, T.must(new_version)]
|
|
end
|
|
elsif forced_version && new_version == "0"
|
|
formula_ast.remove_stable_stanza(:version) if formula_ast.stable_stanza?(:version)
|
|
end
|
|
formula_ast.add_stable_stanzas_after(:url, stanzas_to_add) if stanzas_to_add.present?
|
|
new_contents = formula_ast.process
|
|
commit_formula.path.atomic_write(new_contents) unless args.dry_run?
|
|
|
|
new_formula_version = formula_version(commit_formula, new_contents)
|
|
|
|
if new_formula_version < old_formula_version
|
|
commit_formula.path.atomic_write(old_contents) unless args.dry_run?
|
|
odie <<~EOS
|
|
You need to bump this formula manually since changing the version
|
|
from #{old_formula_version} to #{new_formula_version} would be a downgrade.
|
|
EOS
|
|
elsif new_formula_version == old_formula_version
|
|
commit_formula.path.atomic_write(old_contents) unless args.dry_run?
|
|
odie <<~EOS
|
|
You need to bump this formula manually since the new version
|
|
and old version are both #{new_formula_version}.
|
|
EOS
|
|
end
|
|
|
|
alias_rename = alias_update_pair(commit_formula, new_formula_version)
|
|
if alias_rename.present?
|
|
ohai "Renaming alias #{alias_rename.first} to #{alias_rename.last}"
|
|
alias_rename.map! { |a| tap.alias_dir/a }
|
|
end
|
|
|
|
resource_update_results = {}
|
|
unless args.dry_run?
|
|
resources_checked = PyPI.update_python_resources! formula,
|
|
version: new_formula_version.to_s,
|
|
package_name: args.python_package_name,
|
|
extra_packages: args.python_extra_packages,
|
|
exclude_packages: args.python_exclude_packages,
|
|
install_dependencies: args.install_dependencies?,
|
|
quiet: args.quiet?,
|
|
ignore_non_pypi_packages: true
|
|
|
|
resource_versions = parse_resource_versions_arg
|
|
resource_update_results.merge!(
|
|
update_matching_version_resources!(commit_formula,
|
|
version: new_formula_version.to_s,
|
|
resource_versions:),
|
|
)
|
|
|
|
if resource_versions.present?
|
|
resource_update_results.merge!(
|
|
update_resources!(commit_formula, resource_versions:),
|
|
)
|
|
end
|
|
end
|
|
|
|
checked_statuses = [:success, :up_to_date, :downgraded]
|
|
failed_updates = resource_update_results.reject { |_, v| checked_statuses.include?(v) }
|
|
downgraded_resources = resource_update_results.select { |_, v| v == :downgraded }
|
|
|
|
# Check if there are any resources that still need manual update:
|
|
unchecked_resources = commit_formula.resources.select do |resource|
|
|
next false if resource.name.start_with?("homebrew-")
|
|
next false if resource_update_results.key?(resource.name)
|
|
next false if resource.livecheck.formula == :parent
|
|
|
|
true
|
|
end
|
|
|
|
formula_checkboxes = []
|
|
|
|
if failed_updates.any? || (resources_checked.nil? && unchecked_resources.any?)
|
|
formula_checkboxes << "- [ ] `resource` blocks have been checked for updates."
|
|
|
|
if failed_updates.any?
|
|
formula_checkboxes << "#{failed_updates.map do |name, status|
|
|
" - Resource `#{name}` failed to auto-update (#{status})."
|
|
end.join("\n")}\n"
|
|
end
|
|
end
|
|
|
|
if downgraded_resources.any?
|
|
resource_names = downgraded_resources.keys.map { |name| "`#{name}`" }.join(", ")
|
|
verb = (downgraded_resources.size == 1) ? "was" : "were"
|
|
formula_checkboxes <<
|
|
"**Warning:** #{resource_names} #{verb} " \
|
|
"downgraded to match the latest upstream version."
|
|
end
|
|
|
|
annotation_comments = %w[TODO FIXME]
|
|
if annotation_comments.any? { |s| new_contents.include?("#{s}:") }
|
|
formula_checkboxes << "- [ ] TODO and FIXME comments have been checked."
|
|
end
|
|
|
|
if formula_checkboxes.present?
|
|
formula_pr_message += <<~EOS
|
|
|
|
|
|
#{formula_checkboxes.join("\n")}
|
|
EOS
|
|
end
|
|
|
|
if new_url =~ %r{^https://github\.com/([\w-]+)/([\w-]+)/archive/refs/tags/(v?[.0-9]+)\.tar\.}
|
|
owner = Regexp.last_match(1)
|
|
repo = Regexp.last_match(2)
|
|
tag = Regexp.last_match(3)
|
|
release_id = "#{owner}/#{repo}/#{tag}"
|
|
github_release_data = begin
|
|
GitHub::API.open_rest("#{GitHub::API_URL}/repos/#{owner}/#{repo}/releases/tags/#{tag}")
|
|
rescue GitHub::API::HTTPNotFoundError
|
|
# If this is a 404: we can't do anything.
|
|
nil
|
|
end
|
|
|
|
if github_release_data.present? && github_release_data["body"].present? &&
|
|
added_release_info.exclude?(release_id)
|
|
pre = "pre" if github_release_data["prerelease"].present?
|
|
# maximum length of PR body is 65,536 characters so let's truncate release notes to half of that.
|
|
body = Formatter.truncate(github_release_data["body"], max: 32_768)
|
|
|
|
# Ensure the URL is properly HTML encoded to handle any quotes or other special characters
|
|
html_url = CGI.escapeHTML(github_release_data["html_url"])
|
|
|
|
formula_pr_message += <<~XML
|
|
<details>
|
|
<summary>#{pre}release notes</summary>
|
|
<pre>#{body}</pre>
|
|
<p>View the full release notes at <a href="#{html_url}">#{html_url}</a>.</p>
|
|
</details>
|
|
XML
|
|
|
|
added_release_info << release_id
|
|
end
|
|
end
|
|
|
|
{
|
|
sourcefile_path: commit_formula.path,
|
|
old_contents:,
|
|
commit_message: "#{commit_formula.name} #{new_formula_version}",
|
|
additional_files: alias_rename,
|
|
formula_pr_message:,
|
|
formula_name: commit_formula.name,
|
|
new_version: new_formula_version,
|
|
}
|
|
end
|
|
|
|
commits.each do |commit|
|
|
commit_formula = Formula[commit[:formula_name]]
|
|
# For each formula, run `brew audit` to check for any issues.
|
|
audit_result = run_audit(commit_formula, commit[:additional_files],
|
|
skip_synced_versions: args.bump_synced.present?)
|
|
|
|
next unless audit_result
|
|
|
|
# If `brew audit` fails, revert the changes made to any formula.
|
|
commits.each do |revert|
|
|
revert_formula = Formula[revert[:formula_name]]
|
|
revert_formula.path.atomic_write(revert[:old_contents]) if !args.dry_run? && !args.write_only?
|
|
revert_alias_rename = revert[:additional_files]
|
|
if revert_alias_rename && (source = revert_alias_rename.first) && (destination = revert_alias_rename.last)
|
|
FileUtils.mv source, destination
|
|
end
|
|
end
|
|
|
|
odie "`brew audit` failed for #{commit[:formula_name]}!"
|
|
end
|
|
|
|
new_formula_version = commits.fetch(0)[:new_version]
|
|
|
|
pr_title = if args.bump_synced.nil?
|
|
"#{formula.name} #{new_formula_version}"
|
|
else
|
|
maximum_characters_in_title = 72
|
|
max = maximum_characters_in_title - new_formula_version.to_s.length - 1
|
|
"#{Formatter.truncate(Array(args.bump_synced).join(" "), max:)} #{new_formula_version}"
|
|
end
|
|
|
|
pr_message = Homebrew::Bump.pr_message("bump-formula-pr", user_message: args.message)
|
|
commits.each do |commit|
|
|
next if commit[:formula_pr_message].empty?
|
|
|
|
pr_message += "<h4>#{commit[:formula_name]}</h4>" if commits.length != 1
|
|
pr_message += "#{commit[:formula_pr_message]}<hr>"
|
|
end
|
|
|
|
return if args.write_only? && !args.commit?
|
|
|
|
url = Homebrew::Bump.create_pr(
|
|
Homebrew::Bump::BumpInfo.new(
|
|
package_tap: tap,
|
|
branch_name: "bump-#{formula.name}-#{new_formula_version}",
|
|
pr_title:,
|
|
pr_message:,
|
|
commits: commits.map do |commit|
|
|
Homebrew::Bump::Commit.new(
|
|
sourcefile_path: commit[:sourcefile_path],
|
|
old_contents: commit[:old_contents],
|
|
commit_message: commit[:commit_message],
|
|
additional_files: commit[:additional_files] || [],
|
|
)
|
|
end,
|
|
),
|
|
dry_run: args.dry_run?,
|
|
no_fork: args.no_fork? || args.write_only?,
|
|
fork_org: args.fork_org,
|
|
commit: args.commit?,
|
|
)
|
|
return if url.blank?
|
|
|
|
if args.no_browse?
|
|
puts url
|
|
else
|
|
exec_browser url
|
|
end
|
|
end
|
|
|
|
sig { params(formula: Formula, new_version: String).void }
|
|
def check_throttle(formula, new_version)
|
|
tap = formula.tap
|
|
return if tap.nil?
|
|
|
|
throttle_rate = formula.livecheck.throttle
|
|
throttle_days = formula.livecheck.throttle_days
|
|
return if throttle_rate.nil? && throttle_days.nil?
|
|
|
|
return if Livecheck.throttle_allows_bump?(
|
|
formula,
|
|
new_version,
|
|
throttle_rate: throttle_rate,
|
|
throttle_days: throttle_days,
|
|
)
|
|
|
|
throttle_items = []
|
|
throttle_items << "#{throttle_rate} releases on multiples of #{throttle_rate}" if throttle_rate
|
|
throttle_items << "#{throttle_days} #{Utils.pluralize("day", throttle_days)}" if throttle_days
|
|
|
|
odie "#{formula} should only be updated every #{throttle_items.join(" or ")}"
|
|
end
|
|
|
|
sig {
|
|
params(
|
|
formula: Formula,
|
|
version: String,
|
|
resource_versions: T.nilable(T::Hash[String, T::Hash[Symbol, T.nilable(String)]]),
|
|
).returns(T::Hash[String, Symbol])
|
|
}
|
|
def update_matching_version_resources!(formula, version:, resource_versions: nil)
|
|
resource_versions ||= {}
|
|
formula.resources
|
|
.select { |r| r.livecheck.formula == :parent && resource_versions[r.name].blank? }
|
|
.to_h { |resource| [resource.name, update_resource_block!(formula, resource, version)] }
|
|
end
|
|
|
|
sig {
|
|
params(
|
|
formula: Formula,
|
|
resource_versions: T::Hash[String, T::Hash[Symbol, T.nilable(String)]],
|
|
).returns(T::Hash[String, Symbol])
|
|
}
|
|
def update_resources!(formula, resource_versions:)
|
|
results = {}
|
|
|
|
formula.resources.each do |resource|
|
|
version_data = resource_versions[resource.name]
|
|
next if version_data.blank?
|
|
|
|
current_version = version_data[:current_version]
|
|
latest_version = version_data[:latest_version]
|
|
|
|
if current_version.blank? || latest_version.blank?
|
|
opoo "Could not determine versions for resource \"#{resource.name}\""
|
|
results[resource.name] = :version_unknown
|
|
next
|
|
end
|
|
|
|
if current_version == latest_version
|
|
results[resource.name] = :up_to_date
|
|
next
|
|
end
|
|
|
|
is_downgraded = Version.new(current_version) > Version.new(latest_version)
|
|
|
|
begin
|
|
result = update_resource_block!(formula, resource, latest_version)
|
|
results[resource.name] = if result == :success && is_downgraded
|
|
:downgraded
|
|
else
|
|
result
|
|
end
|
|
rescue => e
|
|
opoo "Failed to update resource \"#{resource.name}\": #{e}"
|
|
results[resource.name] = :fetch_failed
|
|
end
|
|
end
|
|
|
|
results
|
|
end
|
|
|
|
private
|
|
|
|
sig { params(url: String).returns(T.nilable(String)) }
|
|
def determine_mirror(url)
|
|
case url
|
|
when %r{.*ftp\.gnu\.org/gnu.*}
|
|
url.sub "ftp.gnu.org/gnu", "ftpmirror.gnu.org"
|
|
when %r{.*download\.savannah\.gnu\.org/*}
|
|
url.sub "download.savannah.gnu.org", "download-mirror.savannah.gnu.org"
|
|
when %r{.*www\.apache\.org/dyn/closer\.lua\?path=.*}
|
|
url.sub "www.apache.org/dyn/closer.lua?path=", "archive.apache.org/dist/"
|
|
when %r{.*mirrors\.ocf\.berkeley\.edu/debian.*}
|
|
url.sub "mirrors.ocf.berkeley.edu/debian", "mirrorservice.org/sites/ftp.debian.org/debian"
|
|
end
|
|
end
|
|
|
|
sig { params(formula: String, old_mirrors: T::Array[String], new_mirrors: T::Array[String]).void }
|
|
def check_for_mirrors(formula, old_mirrors, new_mirrors)
|
|
return if new_mirrors.present? || old_mirrors.empty?
|
|
|
|
if args.force?
|
|
opoo "#{formula}: Removing all mirrors because a `--mirror=` argument was not specified."
|
|
else
|
|
odie <<~EOS
|
|
#{formula}: a `--mirror=` argument for updating the mirror URL(s) was not specified.
|
|
Use `--force` to remove all mirrors.
|
|
EOS
|
|
end
|
|
end
|
|
|
|
sig { params(old_url: String, old_version: String, new_version: String).returns(String) }
|
|
def update_url(old_url, old_version, new_version)
|
|
new_url = old_url.gsub(old_version, new_version)
|
|
new_url.gsub!(old_version.tr(".", "_"), new_version.tr(".", "_")) if old_version.include?(".")
|
|
|
|
return new_url if (old_version_parts = old_version.split(".")).length < 2
|
|
return new_url if (new_version_parts = new_version.split(".")).length != old_version_parts.length
|
|
|
|
partial_old_version = old_version_parts[0..-2]&.join(".")
|
|
partial_new_version = new_version_parts[0..-2]&.join(".")
|
|
return new_url if partial_old_version.blank? || partial_new_version.blank?
|
|
|
|
new_url.gsub(%r{/(v?)#{Regexp.escape(partial_old_version)}/}, "/\\1#{partial_new_version}/")
|
|
end
|
|
|
|
sig {
|
|
params(formula_or_resource: T.any(Formula, Resource), new_version: T.nilable(String), url: String,
|
|
specs: String).returns(T::Array[T.untyped])
|
|
}
|
|
def fetch_resource_and_forced_version(formula_or_resource, new_version, url, **specs)
|
|
resource = Resource.new
|
|
resource.url(url, **specs)
|
|
resource.owner = if formula_or_resource.is_a?(Formula)
|
|
Resource.new(formula_or_resource.name)
|
|
else
|
|
owner = formula_or_resource.owner
|
|
raise "Owner of Resource#{formula_or_resource.name} is nil" if owner.nil?
|
|
|
|
Resource.new(owner.name)
|
|
end
|
|
forced_version = new_version && new_version != resource.version.to_s
|
|
resource.version(new_version) if forced_version
|
|
odie "Couldn't identify version, specify it using `--version=`." if resource.version.blank?
|
|
[resource.fetch, forced_version]
|
|
end
|
|
|
|
sig { params(formula: Formula, contents: T.nilable(String)).returns(Version) }
|
|
def formula_version(formula, contents = nil)
|
|
spec = :stable
|
|
name = formula.name
|
|
path = formula.path
|
|
if contents.present?
|
|
Formulary.from_contents(name, path, contents, spec).version
|
|
else
|
|
Formulary::FormulaLoader.new(name, path).get_formula(spec).version
|
|
end
|
|
end
|
|
|
|
sig {
|
|
params(formula: Formula, tap_remote_repo: String, state: T.nilable(String),
|
|
version: T.nilable(String)).void
|
|
}
|
|
def check_pull_requests(formula, tap_remote_repo, state: nil, version: nil)
|
|
tap = formula.tap
|
|
return if tap.nil?
|
|
|
|
# if we haven't already found open requests, try for an exact match across all pull requests
|
|
GitHub.check_for_duplicate_pull_requests(
|
|
formula.name, tap_remote_repo,
|
|
version:,
|
|
state:,
|
|
file: formula.path.relative_path_from(tap.path).to_s,
|
|
quiet: args.quiet?,
|
|
official_tap: tap.official?
|
|
)
|
|
end
|
|
|
|
sig {
|
|
params(formula: Formula, tap_remote_repo: String, version: T.nilable(String), url: T.nilable(String),
|
|
tag: T.nilable(String)).void
|
|
}
|
|
def check_new_version(formula, tap_remote_repo, version: nil, url: nil, tag: nil)
|
|
if version.nil?
|
|
specs = {}
|
|
specs[:tag] = tag if tag.present?
|
|
return if url.blank?
|
|
|
|
version = Version.detect(url, **specs).to_s
|
|
return if version.blank?
|
|
end
|
|
|
|
check_throttle(formula, version)
|
|
check_pull_requests(formula, tap_remote_repo, version:) unless args.write_only?
|
|
end
|
|
|
|
sig { params(formula: Formula, new_formula_version: Version).returns(T.nilable(T::Array[String])) }
|
|
def alias_update_pair(formula, new_formula_version)
|
|
versioned_alias = formula.aliases.grep(/^.*@\d+(\.\d+)?$/).first
|
|
return if versioned_alias.nil?
|
|
|
|
name, old_alias_version = versioned_alias.split("@")
|
|
return if old_alias_version.blank?
|
|
|
|
new_alias_regex = (old_alias_version.split(".").length == 1) ? /^\d+/ : /^\d+\.\d+/
|
|
new_alias_version, = *new_formula_version.to_s.match(new_alias_regex)
|
|
return if new_alias_version.blank?
|
|
return if Version.new(new_alias_version) <= Version.new(old_alias_version)
|
|
|
|
[versioned_alias, "#{name}@#{new_alias_version}"]
|
|
end
|
|
|
|
sig { returns(T.nilable(T::Hash[String, T::Hash[Symbol, T.nilable(String)]])) }
|
|
def parse_resource_versions_arg
|
|
return if (resource_versions = args.resource_versions).blank?
|
|
|
|
require "json"
|
|
resource_data = JSON.parse(resource_versions)
|
|
resource_data.to_h do |r|
|
|
[r["name"], { current_version: r["current_version"], latest_version: r["latest_version"] }]
|
|
end
|
|
rescue JSON::ParserError => e
|
|
opoo "Failed to parse --resource-versions JSON: #{e.message}"
|
|
nil
|
|
end
|
|
|
|
# TODO: Add support for resources using `tag` and/or `revision` instead of
|
|
# `url`+`sha256`, resource URLs with options, and resources inside `on_os`
|
|
# or `on_arch` blocks.
|
|
sig {
|
|
params(
|
|
formula: Formula,
|
|
resource: Resource,
|
|
new_version: String,
|
|
).returns(Symbol)
|
|
}
|
|
def update_resource_block!(formula, resource, new_version)
|
|
ohai "Updating resource \"#{resource.name}\" from #{resource.version} to #{new_version}"
|
|
|
|
old_url = T.must(resource.url)
|
|
new_url = update_url(old_url, resource.version.to_s, new_version)
|
|
|
|
if new_url == old_url
|
|
opoo <<~EOS
|
|
You need to bump resource "#{resource.name}" manually since the new URL
|
|
and old URL are both:
|
|
#{new_url}
|
|
EOS
|
|
return :url_unchanged
|
|
end
|
|
|
|
new_mirrors = resource.mirrors.map do |mirror|
|
|
update_url(mirror, resource.version.to_s, new_version)
|
|
end
|
|
resource_path, forced_version = fetch_resource_and_forced_version(resource, new_version, new_url)
|
|
Utils::Tar.validate_file(resource_path)
|
|
new_hash = resource_path.sha256
|
|
|
|
resource_name = resource.name.to_s
|
|
formula_ast = Utils::AST::FormulaAST.new(formula.path.read)
|
|
formula_ast.replace_resource_stanza_value(resource_name, :url, new_url, old_value: old_url)
|
|
|
|
resource.mirrors.each_with_index do |old_mirror, i|
|
|
next if new_mirrors[i].blank?
|
|
|
|
formula_ast.replace_resource_stanza_value(resource_name, :mirror, new_mirrors.fetch(i),
|
|
old_value: old_mirror)
|
|
end
|
|
|
|
if (old_checksum = resource.checksum&.hexdigest).present?
|
|
formula_ast.replace_resource_stanza_value(resource_name, :sha256, new_hash, old_value: old_checksum)
|
|
end
|
|
|
|
if forced_version
|
|
if formula_ast.resource_stanza?(resource_name, :version)
|
|
formula_ast.replace_resource_stanza_value(resource_name, :version, new_version)
|
|
else
|
|
formula_ast.add_stanzas_after(:sha256, [[:version, new_version]],
|
|
parent: formula_ast.resource(resource_name))
|
|
end
|
|
end
|
|
|
|
formula.path.atomic_write(formula_ast.process)
|
|
|
|
:success
|
|
end
|
|
|
|
sig {
|
|
params(formula: Formula, alias_rename: T.nilable(T::Array[String]),
|
|
skip_synced_versions: T::Boolean).returns(T::Boolean)
|
|
}
|
|
def run_audit(formula, alias_rename, skip_synced_versions: false)
|
|
audit_args = ["--formula"]
|
|
audit_args << "--strict" if args.strict?
|
|
audit_args << "--online" if args.online?
|
|
audit_args << "--except=synced_versions_formulae" if skip_synced_versions
|
|
if args.dry_run?
|
|
if args.no_audit?
|
|
ohai "Skipping `brew audit`"
|
|
elsif audit_args.present?
|
|
ohai "brew audit #{audit_args.join(" ")} #{formula.path.basename}"
|
|
else
|
|
ohai "brew audit #{formula.path.basename}"
|
|
end
|
|
return true
|
|
end
|
|
if alias_rename && (source = alias_rename.first) && (destination = alias_rename.last)
|
|
FileUtils.mv source, destination
|
|
end
|
|
failed_audit = false
|
|
if args.no_audit?
|
|
ohai "Skipping `brew audit`"
|
|
elsif audit_args.present?
|
|
system HOMEBREW_BREW_FILE.to_s, "audit", *audit_args, formula.full_name
|
|
failed_audit = !$CHILD_STATUS.success?
|
|
else
|
|
system HOMEBREW_BREW_FILE.to_s, "audit", formula.full_name
|
|
failed_audit = !$CHILD_STATUS.success?
|
|
end
|
|
failed_audit
|
|
end
|
|
end
|
|
end
|
|
end
|