livecheck: allow nil return from strategy blocks

Library/Homebrew/livecheck/strategy/apache.rb

@@ -52,7 +52,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/bitbucket.rb

@@ -59,7 +59,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/cpan.rb

@@ -50,7 +50,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/electron_builder.rb

@@ -37,19 +37,24 @@ module Homebrew
         sig {
           params(
             content: String,
-            block:   T.nilable(T.proc.params(arg0: Hash).returns(String)),
+            block:   T.nilable(T.proc.params(arg0: T::Hash[String, T.untyped]).returns(T.nilable(String))),
           ).returns(T.nilable(String))
         }
         def self.version_from_content(content, &block)
           require "yaml"
 
-          return unless (yaml = YAML.safe_load(content))
+          yaml = YAML.safe_load(content)
+          return if yaml.blank?
 
           if block
-            value = block.call(yaml)
+            case (value = block.call(yaml))
-            return value if value.is_a?(String)
+            when String
-
+              return value
-            raise TypeError, "Return value of `strategy :electron_builder` block must be a string."
+            when nil
+              return
+            else
+              raise TypeError, "Return value of `strategy :electron_builder` block must be a string."
+            end
           end
 
           yaml["version"]
@@ -65,7 +70,7 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: Hash).returns(String)),
+            block: T.nilable(T.proc.params(arg0: T::Hash[String, T.untyped]).returns(T.nilable(String))),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/extract_plist.rb

@@ -56,7 +56,7 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  Cask::Cask,
-            block: T.nilable(T.proc.params(arg0: T::Hash[String, Item]).returns(String)),
+            block: T.nilable(T.proc.params(arg0: T::Hash[String, Item]).returns(T.nilable(String))),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask:, &block)
@@ -69,13 +69,14 @@ module Homebrew
           versions = unversioned_cask_checker.all_versions.transform_values { |v| Item.new(bundle_version: v) }
 
           if block
-            match = block.call(versions)
+            case (value = block.call(versions))
-
+            when String
-            unless T.unsafe(match).is_a?(String)
+              match_data[:matches][value] = Version.new(value)
+            when nil
+              return match_data
+            else
               raise TypeError, "Return value of `strategy :extract_plist` block must be a string."
             end
-
-            match_data[:matches][match] = Version.new(match) if match
           elsif versions.any?
             versions.each_value do |item|
               version = item.bundle_version.nice_version

Library/Homebrew/livecheck/strategy/git.rb

@@ -81,8 +81,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: T::Array[String])
+            block: T.nilable(
-            .returns(T.any(T::Array[String], String))),
+              T.proc.params(arg0: T::Array[String]).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)
@@ -105,6 +106,8 @@ module Homebrew
               value.each do |tag|
                 match_data[:matches][tag] = Version.new(tag)
               end
+            when nil
+              return match_data
             else
               raise TypeError, "Return value of `strategy :git` block must be a string or array of strings."
             end

Library/Homebrew/livecheck/strategy/github_latest.rb

@@ -67,7 +67,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/gnome.rb

@@ -55,7 +55,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/gnu.rb

@@ -59,7 +59,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/hackage.rb

@@ -52,7 +52,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/header_match.rb

@@ -40,8 +40,7 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: T::Hash[String, String])
+            block: T.nilable(T.proc.params(arg0: T::Hash[String, String]).returns(T.nilable(String))),
-            .returns(T.any(T::Array[String], String))),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)
@@ -52,31 +51,40 @@ module Homebrew
           # Merge the headers from all responses into one hash
           merged_headers = headers.reduce(&:merge)
 
-          if block
+          version = if block
-            match = yield merged_headers, regex
+            case (value = block.call(merged_headers, regex))
+            when String
+              value
+            when nil
+              return match_data
+            else
+              raise TypeError, "Return value of `strategy :header_match` block must be a string."
+            end
           else
-            match = nil
+            value = nil
 
             if (filename = merged_headers["content-disposition"])
               if regex
-                match ||= filename[regex, 1]
+                value ||= filename[regex, 1]
               else
                 v = Version.parse(filename, detected_from_url: true)
-                match ||= v.to_s unless v.null?
+                value ||= v.to_s unless v.null?
               end
             end
 
             if (location = merged_headers["location"])
               if regex
-                match ||= location[regex, 1]
+                value ||= location[regex, 1]
               else
                 v = Version.parse(location, detected_from_url: true)
-                match ||= v.to_s unless v.null?
+                value ||= v.to_s unless v.null?
               end
             end
+
+            value
           end
 
-          match_data[:matches][match] = Version.new(match) if match
+          match_data[:matches][version] = Version.new(version) if version
 
           match_data
         end

Library/Homebrew/livecheck/strategy/launchpad.rb

@@ -50,7 +50,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/npm.rb

@@ -46,7 +46,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/page_match.rb

@@ -45,13 +45,24 @@ module Homebrew
         # @param regex [Regexp] a regex used for matching versions in the
         #   content
         # @return [Array]
+        sig {
+          params(
+            content: String,
+            regex:   Regexp,
+            block:   T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
+          ).returns(T::Array[String])
+        }
         def self.page_matches(content, regex, &block)
           if block
             case (value = block.call(content, regex))
             when String
               return [value]
             when Array
-              return value
+              return value.compact.uniq
+            when nil
+              return []
             else
               raise TypeError, "Return value of `strategy :page_match` block must be a string or array of strings."
             end
@@ -61,10 +72,10 @@ module Homebrew
             case match
             when String
               match
-            else
+            when Array
               match.first
             end
-          end.uniq
+          end.compact.uniq
         end
 
         # Checks the content at the URL for new versions, using the provided
@@ -78,10 +89,12 @@ module Homebrew
         sig {
           params(
             url:              String,
-            regex:            T.nilable(Regexp),
+            regex:            Regexp,
             cask:             T.nilable(Cask::Cask),
             provided_content: T.nilable(String),
-            block:            T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block:            T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, provided_content: nil, &block)

Library/Homebrew/livecheck/strategy/pypi.rb

@@ -56,7 +56,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/sourceforge.rb

@@ -62,7 +62,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/livecheck/strategy/sparkle.rb

@@ -144,7 +144,7 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: Item).returns(String)),
+            block: T.nilable(T.proc.params(arg0: Item).returns(T.nilable(String))),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)
@@ -156,19 +156,20 @@ module Homebrew
           content = match_data.delete(:content)
 
           if (item = item_from_content(content))
-            match = if block
+            version = if block
-              value = block.call(item)
+              case (value = block.call(item))
-
+              when String
-              unless T.unsafe(value).is_a?(String)
+                value
+              when nil
+                return match_data
+              else
                 raise TypeError, "Return value of `strategy :sparkle` block must be a string."
               end
-
-              value
             else
               item.bundle_version&.nice_version
             end
 
-            match_data[:matches][match] = Version.new(match) if match
+            match_data[:matches][version] = Version.new(version) if version
           end
 
           match_data

Library/Homebrew/livecheck/strategy/xorg.rb

@@ -85,7 +85,9 @@ module Homebrew
             url:   String,
             regex: T.nilable(Regexp),
             cask:  T.nilable(Cask::Cask),
-            block: T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
+            block: T.nilable(
+              T.proc.params(arg0: String, arg1: Regexp).returns(T.any(String, T::Array[String], NilClass)),
+            ),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url, regex, cask: nil, &block)

Library/Homebrew/test/livecheck/strategy/electron_builder_spec.rb

@@ -54,5 +54,14 @@ describe Homebrew::Livecheck::Strategy::ElectronBuilder do
 
       expect(version).to eq "1.2.4"
     end
+
+    it "allows a nil return from a strategy block" do
+      expect(electron_builder.version_from_content(electron_builder_yaml) { next }).to eq(nil)
+    end
+
+    it "errors on an invalid return type from a strategy block" do
+      expect { electron_builder.version_from_content(electron_builder_yaml) { 123 } }
+        .to raise_error(TypeError, "Return value of `strategy :electron_builder` block must be a string.")
+    end
   end
 end

Library/Homebrew/test/livecheck/strategy/page_match_spec.rb

@@ -72,9 +72,13 @@ describe Homebrew::Livecheck::Strategy::PageMatch do
     end
 
     it "finds matching text in page content using a strategy block" do
-      expect(page_match.page_matches(page_content, regex) { |content| content.scan(regex).map(&:first).uniq })
+      expect(page_match.page_matches(page_content, regex) { |content, regex| content.scan(regex).map(&:first).uniq })
         .to eq(page_content_matches)
     end
+
+    it "allows a nil return from a strategy block" do
+      expect(page_match.page_matches(page_content, regex) { next }).to eq([])
+    end
   end
 
   describe "::find_versions?" do