livecheck: add content parameter to strategies, expand test coverage

Library/Homebrew/livecheck/strategic.rb

@@ -22,20 +22,19 @@ def match?(url); end
       #
       # @param url the URL of the content to check
       # @param regex a regex for matching versions in content
-      # @param provided_content content to check instead of
-      #   fetching
+      # @param content content to check instead of fetching
       # @param options options to modify behavior
       # @param block a block to match the content
       sig {
         abstract.params(
-          url:              String,
-          regex:            T.nilable(Regexp),
-          provided_content: T.nilable(String),
-          options:          Options,
-          block:            T.nilable(Proc),
+          url:     String,
+          regex:   T.nilable(Regexp),
+          content: T.nilable(String),
+          options: Options,
+          block:   T.nilable(Proc),
         ).returns(T::Hash[Symbol, T.anything])
       }
-      def find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block); end
+      def find_versions(url:, regex: nil, content: nil, options: Options.new, &block); end
     end
   end
 end

Library/Homebrew/livecheck/strategy/apache.rb

@@ -70,8 +70,8 @@ def self.generate_input_values(url)
           regex_prefix = Regexp.escape(match[:prefix] || "").gsub("\\-", "-")
 
           # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
-          suffix = match[:suffix]&.sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
-          regex_suffix = Regexp.escape(suffix || "").gsub("\\-", "-")
+          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
+          regex_suffix = Regexp.escape(suffix).gsub("\\-", "-")
 
           # Example directory regex: `%r{href=["']?v?(\d+(?:\.\d+)+)/}i`
           # Example file regexes:
@@ -86,23 +86,26 @@ def self.generate_input_values(url)
         # to {PageMatch.find_versions} to identify versions in the content.
         #
         # @param url [String] the URL of the content to check
-        # @param regex [Regexp] a regex used for matching versions in content
+        # @param regex [Regexp, nil] a regex for matching versions in content
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
-          override(allow_incompatible: true).params(
+          override.params(
             url:     String,
             regex:   T.nilable(Regexp),
+            content: T.nilable(String),
             options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
           PageMatch.find_versions(
             url:     generated[:url],
             regex:   regex || generated[:regex],
+            content:,
             options:,
             &block
           )

Library/Homebrew/livecheck/strategy/bitbucket.rb

@@ -94,23 +94,26 @@ def self.generate_input_values(url)
         # to {PageMatch.find_versions} to identify versions in the content.
         #
         # @param url [String] the URL of the content to check
-        # @param regex [Regexp] a regex used for matching versions in content
+        # @param regex [Regexp, nil] a regex for matching versions in content
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
-          override(allow_incompatible: true).params(
+          override.params(
             url:     String,
             regex:   T.nilable(Regexp),
+            content: T.nilable(String),
             options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
           PageMatch.find_versions(
             url:     generated[:url],
             regex:   regex || generated[:regex],
+            content:,
             options:,
             &block
           )

Library/Homebrew/livecheck/strategy/cpan.rb

@@ -73,23 +73,26 @@ def self.generate_input_values(url)
         # to {PageMatch.find_versions} to identify versions in the content.
         #
         # @param url [String] the URL of the content to check
-        # @param regex [Regexp] a regex used for matching versions in content
+        # @param regex [Regexp, nil] a regex for matching versions in content
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
-          override(allow_incompatible: true).params(
+          override.params(
             url:     String,
             regex:   T.nilable(Regexp),
+            content: T.nilable(String),
             options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
           PageMatch.find_versions(
             url:     generated[:url],
             regex:   regex || generated[:regex],
+            content:,
             options:,
             &block
           )

Library/Homebrew/livecheck/strategy/crate.rb

@@ -73,35 +73,32 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp, nil] a regex for matching versions in content
-        # @param provided_content [String, nil] content to check instead of
-        #   fetching
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           override.params(
-            url:              String,
-            regex:            T.nilable(Regexp),
-            provided_content: T.nilable(String),
-            options:          Options,
-            block:            T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            content: T.nilable(String),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
-          match_data[:cached] = true if provided_content.is_a?(String)
+          match_data[:cached] = true if content
 
           generated = generate_input_values(url)
           return match_data if generated.blank?
 
           match_data[:url] = generated[:url]
 
-          content = if provided_content
-            provided_content
-          else
+          unless match_data[:cached]
             match_data.merge!(Strategy.page_content(match_data[:url], options:))
-            match_data[:content]
+            content = match_data[:content]
           end
-          return match_data unless content
+          return match_data if content.blank?
 
           Json.versions_from_content(content, regex || DEFAULT_REGEX, &block || DEFAULT_BLOCK).each do |match_text|
             match_data[:matches][match_text] = Version.new(match_text)

Library/Homebrew/livecheck/strategy/electron_builder.rb

@@ -34,21 +34,20 @@ def self.match?(url)
         # Checks the YAML content at the URL for new versions.
         #
         # @param url [String] the URL of the content to check
-        # @param regex [Regexp, nil] a regex used for matching versions
-        # @param provided_content [String, nil] content to use in place of
-        #   fetching via `Strategy#page_content`
+        # @param regex [Regexp, nil] a regex for matching versions in content
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           override.params(
-            url:              String,
-            regex:            T.nilable(Regexp),
-            provided_content: T.nilable(String),
-            options:          Options,
-            block:            T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            content: T.nilable(String),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           if regex.present? && !block_given?
             raise ArgumentError,
                   "#{Utils.demodulize(name)} only supports a regex when using a `strategy` block"
@@ -57,7 +56,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, options: Options
           Yaml.find_versions(
             url:,
             regex:,
-            provided_content:,
+            content:,
             options:,
             &block || proc { |yaml| yaml["version"] }
           )

Library/Homebrew/livecheck/strategy/extract_plist.rb

@@ -162,10 +162,10 @@ def self.find_versions(cask:, url: nil, regex: nil, content: nil, options: Optio
           end
 
           match_data = { matches: {}, regex:, url: }
-          match_data[:cached] = true if content
 
-          if match_data[:cached]
-            items = Json.parse_json(T.must(content)).transform_values do |obj|
+          items = if content
+            match_data[:cached] = true
+            Json.parse_json(content).transform_values do |obj|
               short_version = obj.dig("bundle_version", "short_version")
               version = obj.dig("bundle_version", "version")
               Item.new(bundle_version: BundleVersion.new(short_version, version))
@@ -177,7 +177,7 @@ def self.find_versions(cask:, url: nil, regex: nil, content: nil, options: Optio
               UnversionedCaskChecker.new(cask)
             end
 
-            items = unversioned_cask_checker.all_versions.transform_values { |v| Item.new(bundle_version: v) }
+            unversioned_cask_checker.all_versions.transform_values { |v| Item.new(bundle_version: v) }
           end
           return match_data if items.blank?
 

Library/Homebrew/livecheck/strategy/git.rb

@@ -153,7 +153,7 @@ def self.tags_from_content(content)
         # group around the version text.
         #
         # @param content [String] the content to check
-        # @param regex [Regexp, nil] a regex to identify versions
+        # @param regex [Regexp, nil] a regex for matching versions in content
         # @return [Array]
         sig {
           params(
@@ -187,29 +187,26 @@ def self.versions_from_content(content, regex = nil, &block)
         #
         # @param url [String] the URL of the Git repository to check
         # @param regex [Regexp, nil] a regex for matching versions in content
-        # @param provided_content [String, nil] content to check instead of
-        #   fetching
+        # @param content [String, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           override.params(
-            url:              String,
-            regex:            T.nilable(Regexp),
-            provided_content: T.nilable(String),
-            options:          Options,
-            block:            T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            content: T.nilable(String),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
+          match_data[:cached] = true if content
           return match_data if url.blank?
 
-          content = if provided_content.is_a?(String)
-            match_data[:cached] = true
-            provided_content
-          else
+          unless match_data[:cached]
             match_data.merge!(ls_remote_tags(url))
-            match_data[:content]
+            content = match_data[:content]
           end
           return match_data if content.blank?
 

Library/Homebrew/livecheck/strategy/github_latest.rb

@@ -62,7 +62,7 @@ def self.generate_input_values(url)
           match = url.delete_suffix(".git").match(GithubReleases::URL_MATCH_REGEX)
           return values if match.blank?
 
-          values[:url] = "https://api.github.com/repos/#{match[:username]}/#{match[:repository]}/releases/latest"
+          values[:url] = "#{GitHub::API_URL}/repos/#{match[:username]}/#{match[:repository]}/releases/latest"
           values[:username] = match[:username]
           values[:repository] = match[:repository]
 
@@ -73,27 +73,36 @@ def self.generate_input_values(url)
         # 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
+        # @param regex [Regexp] a regex for matching versions in content
+        # @param content [Hash, nil] content to check instead of fetching
         # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
-          override(allow_incompatible: true).params(
+          override.params(
             url:     String,
-            regex:   Regexp,
+            regex:   T.nilable(Regexp),
+            content: T.nilable(String),
             options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.anything])
         }
-        def self.find_versions(url:, regex: GithubReleases::DEFAULT_REGEX, options: Options.new, &block)
+        def self.find_versions(url:, regex: nil, content: nil, options: Options.new, &block)
+          regex ||= GithubReleases::DEFAULT_REGEX
           match_data = { matches: {}, regex:, url: }
+          match_data[:cached] = true if content
 
           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])
-          GithubReleases.versions_from_content(release, regex, &block).each do |match_text|
+          unless match_data[:cached]
+            match_data[:content] = GitHub::API.open_rest(generated[:url], parse_json: false)
+            content = match_data[:content]
+          end
+          return match_data if content.blank?
+
+          GithubReleases.versions_from_content(content, regex, &block).each do |match_text|
             match_data[:matches][match_text] = Version.new(match_text)
           end