085827f605
There are times where a regex isn't needed in a `strategy` block and these changes explicitly handle that situation. This allows the Symbol Proc format used in some `Sparkle` `livecheck` blocks (e.g., `strategy :sparkle, &:version`) to continue working instead of failing with a "wrong number of arguments (given 1, expected 0)" error. This error would occur because a Symbol Proc only only expects one argument (e.g., an `Item`, not an `Item` and a regex/nil). There's an argument to be made for avoiding the Symbol Proc format for `strategy` blocks but I haven't found a way of selectively disabling the Style/SymbolProc cop only for a `strategy` DSL method call. That is to say, if we don't use the Symbol Proc format, `brew style` will give a "Pass &:version as an argument to strategy instead of a block." offense. Besides that, this also replaces the `block` type signatures in livecheck strategies with `T.untyped`. Sorbet doesn't know how to handle a `Proc` with a variable number of arguments and can't be taught how (i.e., `T.any` with a `Proc` signature for each variation doesn't work). The aforementioned changes cause Sorbet to complain about there being both too many and too few arguments, so the only way to win is not to play the game. Hopefully we can restore the `block` type signatures in the future (if upstream resolves this years-old issue) but `T.untyped` seems to be our only option for now.
93 lines
2.9 KiB
Ruby
93 lines
2.9 KiB
Ruby
# typed: true
|
|
# frozen_string_literal: true
|
|
|
|
module Homebrew
|
|
module Livecheck
|
|
module Strategy
|
|
# The {ElectronBuilder} strategy fetches content at a URL and parses
|
|
# it as an electron-builder appcast in YAML format.
|
|
#
|
|
# This strategy is not applied automatically and it's necessary to use
|
|
# `strategy :electron_builder` in a `livecheck` block to apply it.
|
|
#
|
|
# @api private
|
|
class ElectronBuilder
|
|
extend T::Sig
|
|
|
|
NICE_NAME = "electron-builder"
|
|
|
|
# A priority of zero causes livecheck to skip the strategy. We do this
|
|
# for {ElectronBuilder} so we can selectively apply it when appropriate.
|
|
PRIORITY = 0
|
|
|
|
# The `Regexp` used to determine if the strategy applies to the URL.
|
|
URL_MATCH_REGEX = %r{^https?://.+/[^/]+\.ya?ml(?:\?[^/?]+)?$}i.freeze
|
|
|
|
# Whether the strategy can be applied to the provided URL.
|
|
#
|
|
# @param url [String] the URL to match against
|
|
# @return [Boolean]
|
|
sig { params(url: String).returns(T::Boolean) }
|
|
def self.match?(url)
|
|
URL_MATCH_REGEX.match?(url)
|
|
end
|
|
|
|
# Parses YAML text and identifies versions in it.
|
|
#
|
|
# @param content [String] the YAML text to parse and check
|
|
# @return [Array]
|
|
sig {
|
|
params(
|
|
content: String,
|
|
regex: T.nilable(Regexp),
|
|
block: T.untyped,
|
|
).returns(T::Array[String])
|
|
}
|
|
def self.versions_from_content(content, regex = nil, &block)
|
|
require "yaml"
|
|
|
|
yaml = YAML.safe_load(content)
|
|
return [] if yaml.blank?
|
|
|
|
if block
|
|
block_return_value = regex.present? ? yield(yaml, regex) : yield(yaml)
|
|
return Strategy.handle_block_return(block_return_value)
|
|
end
|
|
|
|
version = yaml["version"]
|
|
version.present? ? [version] : []
|
|
end
|
|
|
|
# Checks the YAML content at the URL for new versions.
|
|
#
|
|
# @param url [String] the URL of the content to check
|
|
# @return [Hash]
|
|
sig {
|
|
params(
|
|
url: String,
|
|
regex: T.nilable(Regexp),
|
|
_unused: T.nilable(T::Hash[Symbol, T.untyped]),
|
|
block: T.untyped,
|
|
).returns(T::Hash[Symbol, T.untyped])
|
|
}
|
|
def self.find_versions(url:, regex: nil, **_unused, &block)
|
|
if regex.present? && block.blank?
|
|
raise ArgumentError, "#{T.must(name).demodulize} only supports a regex when using a `strategy` block"
|
|
end
|
|
|
|
match_data = { matches: {}, url: url }
|
|
|
|
match_data.merge!(Strategy.page_content(url))
|
|
content = match_data.delete(:content)
|
|
|
|
versions_from_content(content, regex, &block).each do |version_text|
|
|
match_data[:matches][version_text] = Version.new(version_text)
|
|
end
|
|
|
|
match_data
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|