From 573d87cdfaa6fcc5e3b157b40f30861143991003 Mon Sep 17 00:00:00 2001 From: Sean Molenaar Date: Wed, 19 Apr 2023 11:08:36 +0200 Subject: [PATCH 1/5] feat: use API for GitHub latest release strategy --- .../livecheck/strategy/github_latest.rb | 63 ++++++++++++++++--- .../livecheck/strategy/github_latest_spec.rb | 4 +- 2 files changed, 59 insertions(+), 8 deletions(-) diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb index d8a3d97df8..f5a6e21f43 100644 --- a/Library/Homebrew/livecheck/strategy/github_latest.rb +++ b/Library/Homebrew/livecheck/strategy/github_latest.rb @@ -48,7 +48,10 @@ module Homebrew # The default regex used to identify a version from a tag when a regex # isn't provided. - DEFAULT_REGEX = %r{href=.*?/tag/v?(\d+(?:\.\d+)+)["' >]}i.freeze + DEFAULT_REGEX = /v?(\d+(?:\.\d+)+)/i.freeze + + # Keys in the JSON that could contain the version. + VERSION_KEYS = ["name", "tag_name"].freeze # Whether the strategy can be applied to the provided URL. # @@ -59,6 +62,42 @@ module Homebrew URL_MATCH_REGEX.match?(url) end + # Uses the regex to match release information in content or, if a block is + # provided, passes the page content to the block to handle matching. + # With either approach, an array of unique matches is returned. + # + # @param content [Array] list of releases + # @param regex [Regexp] a regex used for matching versions in the content + # @param block [Proc, nil] a block to match the content + # @return [Array] + sig { + params( + content: T::Array[T::Hash[String, T.untyped]], + regex: Regexp, + block: T.nilable(Proc), + ).returns(T::Array[String]) + } + def self.versions_from_content(content, regex, &block) + if block.present? + block_return_value = if regex.present? + yield(content, regex) + else + yield(content) + end + return Strategy.handle_block_return(block_return_value) + end + + content.reject(&:blank?).map do |release| + next if release["draft"] || release["prerelease"] + + value = T.let(nil, T.untyped) + VERSION_KEYS.find do |key| + value = release[key]&.match(regex)&.to_s + end + value + end.compact.uniq + end + # Extracts information from a provided URL and uses it to generate # various input values used by the strategy to check for new versions. # Some of these values act as defaults and can be overridden in a @@ -75,6 +114,8 @@ module Homebrew # Example URL: `https://github.com/example/example/releases/latest` values[:url] = "https://github.com/#{match[:username]}/#{match[:repository]}/releases/latest" + values[:username] = match[:username] + values[:repository] = match[:repository] values end @@ -87,18 +128,26 @@ module Homebrew # @return [Hash] sig { params( - url: String, - regex: T.nilable(Regexp), - unused: T.nilable(T::Hash[Symbol, T.untyped]), - block: T.nilable(Proc), + url: String, + regex: Regexp, + _unused: T.nilable(T::Hash[Symbol, T.untyped]), + block: T.nilable(Proc), ).returns(T::Hash[Symbol, T.untyped]) } - def self.find_versions(url:, regex: nil, **unused, &block) + def self.find_versions(url:, regex: DEFAULT_REGEX, **_unused, &block) + match_data = { matches: {}, regex: regex } generated = generate_input_values(url) + return match_data if generated.blank? - PageMatch.find_versions(url: generated[:url], regex: regex || DEFAULT_REGEX, **unused, &block) + release = GitHub.get_latest_release(generated[:username], generated[:repository]) + versions_from_content([release], regex, &block).each do |match_text| + match_data[:matches][match_text] = Version.new(match_text) + end + + match_data end end end + GitHubLatest = Homebrew::Livecheck::Strategy::GithubLatest end end diff --git a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb index d5307c5c35..4f95c44098 100644 --- a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb +++ b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb @@ -16,7 +16,9 @@ describe Homebrew::Livecheck::Strategy::GithubLatest do let(:generated) do { - url: "https://github.com/abc/def/releases/latest", + username: "abc", + url: "https://github.com/abc/def/releases/latest", + repository: "def", } end From 34e2779150a065ea4db5269f64cc78b508e94314 Mon Sep 17 00:00:00 2001 From: Sam Ford <1584702+samford@users.noreply.github.com> Date: Thu, 4 May 2023 11:12:31 -0400 Subject: [PATCH 2/5] GithubLatest: Move #generate_input_values `#generate_input_values` is called before `#versions_from_content` (in `#find_versions`), so it makes sense to move it above the latter. --- .../livecheck/strategy/github_latest.rb | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb index f5a6e21f43..c5f4a21b85 100644 --- a/Library/Homebrew/livecheck/strategy/github_latest.rb +++ b/Library/Homebrew/livecheck/strategy/github_latest.rb @@ -62,6 +62,28 @@ module Homebrew URL_MATCH_REGEX.match?(url) end + # Extracts information from a provided URL and uses it to generate + # various input values used by the strategy to check for new versions. + # Some of these values act as defaults and can be overridden in a + # `livecheck` block. + # + # @param url [String] the URL used to generate values + # @return [Hash] + sig { params(url: String).returns(T::Hash[Symbol, T.untyped]) } + def self.generate_input_values(url) + values = {} + + match = url.sub(/\.git$/i, "").match(URL_MATCH_REGEX) + return values if match.blank? + + # Example URL: `https://github.com/example/example/releases/latest` + values[:url] = "https://github.com/#{match[:username]}/#{match[:repository]}/releases/latest" + values[:username] = match[:username] + values[:repository] = match[:repository] + + values + end + # Uses the regex to match release information in content or, if a block is # provided, passes the page content to the block to handle matching. # With either approach, an array of unique matches is returned. @@ -98,28 +120,6 @@ module Homebrew end.compact.uniq end - # Extracts information from a provided URL and uses it to generate - # various input values used by the strategy to check for new versions. - # Some of these values act as defaults and can be overridden in a - # `livecheck` block. - # - # @param url [String] the URL used to generate values - # @return [Hash] - sig { params(url: String).returns(T::Hash[Symbol, T.untyped]) } - def self.generate_input_values(url) - values = {} - - match = url.sub(/\.git$/i, "").match(URL_MATCH_REGEX) - return values if match.blank? - - # Example URL: `https://github.com/example/example/releases/latest` - values[:url] = "https://github.com/#{match[:username]}/#{match[:repository]}/releases/latest" - values[:username] = match[:username] - values[:repository] = match[:repository] - - values - end - # Generates a URL and regex (if one isn't provided) and passes them # to {PageMatch.find_versions} to identify versions in the content. # From cfba45fb562f8b8315f2c6440c3b9dc8f6321cc7 Mon Sep 17 00:00:00 2001 From: Sam Ford <1584702+samford@users.noreply.github.com> Date: Thu, 4 May 2023 11:17:24 -0400 Subject: [PATCH 3/5] GithubLatest: Use API URL as generated value The generated URL should reflect what we're actually checking, which is now the `/releases/latest` API URL. --- Library/Homebrew/livecheck/strategy/github_latest.rb | 3 +-- Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb index c5f4a21b85..d616763f01 100644 --- a/Library/Homebrew/livecheck/strategy/github_latest.rb +++ b/Library/Homebrew/livecheck/strategy/github_latest.rb @@ -76,8 +76,7 @@ module Homebrew match = url.sub(/\.git$/i, "").match(URL_MATCH_REGEX) return values if match.blank? - # Example URL: `https://github.com/example/example/releases/latest` - values[:url] = "https://github.com/#{match[:username]}/#{match[:repository]}/releases/latest" + values[:url] = "https://api.github.com/repos/#{match[:username]}/#{match[:repository]}/releases/latest" values[:username] = match[:username] values[:repository] = match[:repository] diff --git a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb index 4f95c44098..194463da91 100644 --- a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb +++ b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb @@ -16,8 +16,8 @@ describe Homebrew::Livecheck::Strategy::GithubLatest do let(:generated) do { + url: "https://api.github.com/repos/abc/def/releases/latest", username: "abc", - url: "https://github.com/abc/def/releases/latest", repository: "def", } end From 303ac147a92638a7fe78502e859f87504e736c82 Mon Sep 17 00:00:00 2001 From: Sam Ford <1584702+samford@users.noreply.github.com> Date: Thu, 4 May 2023 12:27:42 -0400 Subject: [PATCH 4/5] GithubLatest: Include URL in match_data It's standard for the `match_data` to include the URL (e.g., as in `PageMatch`). This uses the provided URL by default, switching to the generated URL when available. --- Library/Homebrew/livecheck/strategy/github_latest.rb | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb index d616763f01..21136f2cb3 100644 --- a/Library/Homebrew/livecheck/strategy/github_latest.rb +++ b/Library/Homebrew/livecheck/strategy/github_latest.rb @@ -134,10 +134,13 @@ module Homebrew ).returns(T::Hash[Symbol, T.untyped]) } def self.find_versions(url:, regex: DEFAULT_REGEX, **_unused, &block) - match_data = { matches: {}, regex: regex } + match_data = { matches: {}, regex: regex, url: url } + generated = generate_input_values(url) return match_data if generated.blank? + match_data[:url] = generated[:url] + release = GitHub.get_latest_release(generated[:username], generated[:repository]) versions_from_content([release], regex, &block).each do |match_text| match_data[:matches][match_text] = Version.new(match_text) From efccc5d4bb96340b58bbc7ce6321734fd5d8b72d Mon Sep 17 00:00:00 2001 From: Sam Ford <1584702+samford@users.noreply.github.com> Date: Thu, 4 May 2023 16:12:16 -0400 Subject: [PATCH 5/5] GithubLatest: Update documentation --- .../livecheck/strategy/github_latest.rb | 54 +++++++++---------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb index 21136f2cb3..92792059b3 100644 --- a/Library/Homebrew/livecheck/strategy/github_latest.rb +++ b/Library/Homebrew/livecheck/strategy/github_latest.rb @@ -5,7 +5,8 @@ module Homebrew module Livecheck module Strategy # The {GithubLatest} strategy identifies versions of software at - # github.com by checking a repository's "latest" release page. + # github.com by checking a repository's "latest" release using the + # GitHub API. # # GitHub URLs take a few different formats: # @@ -13,22 +14,16 @@ module Homebrew # * `https://github.com/example/example/archive/v1.2.3.tar.gz` # * `https://github.com/downloads/example/example/example-1.2.3.tar.gz` # - # A repository's `/releases/latest` URL normally redirects to a release - # tag (e.g., `/releases/tag/1.2.3`). When there isn't a "latest" release, - # it will redirect to the `/releases` page. + # {GithubLatest} should only be used when the upstream repository has a + # "latest" release for a suitable version and the strategy is necessary + # or appropriate (e.g. {Git} returns an unreleased version or the + # `stable` URL is a release asset). The strategy can only be applied by + # using `strategy :github_latest` in a `livecheck` block. # - # This strategy should only be used when we know the upstream repository - # has a "latest" release and the tagged release is appropriate to use - # (e.g., "latest" isn't wrongly pointing to an unstable version, not - # picking up the actual latest version, etc.). The strategy can only be - # applied by using `strategy :github_latest` in a `livecheck` block. - # - # The default regex identifies versions like `1.2.3`/`v1.2.3` in `href` - # attributes containing the tag URL (e.g., - # `/example/example/releases/tag/v1.2.3`). This is a common tag format - # but a modified regex can be provided in a `livecheck` block to override - # the default if a repository uses a different format (e.g., - # `example-1.2.3`, `1.2.3d`, `1.2.3-4`, etc.). + # The default regex identifies versions like `1.2.3`/`v1.2.3` in the + # release's tag name. This is a common tag format but a modified regex + # can be provided in a `livecheck` block to override the default if a + # repository uses a different format (e.g. `1.2.3d`, `1.2.3-4`, etc.). # # @api public class GithubLatest @@ -50,8 +45,9 @@ module Homebrew # isn't provided. DEFAULT_REGEX = /v?(\d+(?:\.\d+)+)/i.freeze - # Keys in the JSON that could contain the version. - VERSION_KEYS = ["name", "tag_name"].freeze + # Keys in the release JSON that could contain the version. + # Tag name first since that is closer to other livechecks. + VERSION_KEYS = ["tag_name", "name"].freeze # Whether the strategy can be applied to the provided URL. # @@ -83,17 +79,17 @@ module Homebrew values end - # Uses the regex to match release information in content or, if a block is - # provided, passes the page content to the block to handle matching. - # With either approach, an array of unique matches is returned. + # Uses a regex to match the version from release JSON or, if a block is + # provided, passes the JSON to the block to handle matching. With + # either approach, an array of unique matches is returned. # - # @param content [Array] list of releases + # @param content [Array, Hash] list of releases or a single release # @param regex [Regexp] a regex used for matching versions in the content # @param block [Proc, nil] a block to match the content # @return [Array] sig { params( - content: T::Array[T::Hash[String, T.untyped]], + content: T.any(T::Array[T::Hash[String, T.untyped]], T::Hash[String, T.untyped]), regex: Regexp, block: T.nilable(Proc), ).returns(T::Array[String]) @@ -108,19 +104,23 @@ module Homebrew return Strategy.handle_block_return(block_return_value) end + content = [content] unless content.is_a?(Array) content.reject(&:blank?).map do |release| next if release["draft"] || release["prerelease"] value = T.let(nil, T.untyped) VERSION_KEYS.find do |key| - value = release[key]&.match(regex)&.to_s + match = release[key]&.match(regex) + next if match.blank? + + value = match[1] end value end.compact.uniq end - # Generates a URL and regex (if one isn't provided) and passes them - # to {PageMatch.find_versions} to identify versions in the content. + # Generates the GitHub API URL for the repository's "latest" release + # and identifies the version from the JSON response. # # @param url [String] the URL of the content to check # @param regex [Regexp] a regex used for matching versions in content @@ -142,7 +142,7 @@ module Homebrew match_data[:url] = generated[:url] release = GitHub.get_latest_release(generated[:username], generated[:repository]) - versions_from_content([release], regex, &block).each do |match_text| + versions_from_content(release, regex, &block).each do |match_text| match_data[:matches][match_text] = Version.new(match_text) end