Class: Homebrew::Livecheck::Strategy::PageMatch

Inherits:
Object
  • Object
show all
Defined in:
livecheck/strategy/page_match.rb

Overview

The PageMatch strategy fetches content at a URL and scans it for matching text using the provided regex.

This strategy can be used in a livecheck block when no specific strategies apply to a given URL. Though PageMatch will technically match any HTTP URL, the strategy also requires a regex to function.

The PageMatch.find_versions method is also used within other strategies, to handle the process of identifying version text in content.

Constant Summary collapse

NICE_NAME =
"Page match"
PRIORITY =

A priority of zero causes livecheck to skip the strategy. We do this for Homebrew::Livecheck::Strategy::PageMatch so we can selectively apply it only when a regex is provided in a livecheck block.

0
URL_MATCH_REGEX =

The Regexp used to determine if the strategy applies to the URL.

%r{^https?://}i.freeze

Class Method Summary collapse

Class Method Details

.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block) ⇒ Hash{Symbol => T.untyped}

Checks the content at the URL for new versions, using the provided regex for matching.

Parameters:

  • url (String)

    the URL of the content to check

  • regex (Regexp, nil) (defaults to: nil)

    a regex used for matching versions

  • provided_content (String, nil) (defaults to: nil)

    page content to use in place of fetching via Strategy#page_content

  • homebrew_curl (Boolean) (defaults to: false)

    whether to use brewed curl with the URL

  • _unused (Hash{Symbol => T.untyped}, nil)
  • block (T.untyped)

Returns:



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
# File 'livecheck/strategy/page_match.rb', line 94

def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
  if regex.blank? && block.blank?
    raise ArgumentError, "#{T.must(name).demodulize} requires a regex or `strategy` block"
  end

  match_data = { matches: {}, regex: regex, url: url }
  return match_data if url.blank? || (regex.blank? && block.blank?)

  content = if provided_content.is_a?(String)
    match_data[:cached] = true
    provided_content
  else
    match_data.merge!(Strategy.page_content(url, homebrew_curl: homebrew_curl))
    match_data[:content]
  end
  return match_data if content.blank?

  versions_from_content(content, regex, &block).each do |match_text|
    match_data[:matches][match_text] = Version.new(match_text)
  end

  match_data
end

.match?(url) ⇒ Boolean

Whether the strategy can be applied to the provided URL. Homebrew::Livecheck::Strategy::PageMatch will technically match any HTTP URL but is only usable with a livecheck block containing a regex.

Parameters:

  • url (String)

    the URL to match against

Returns:

  • (Boolean)


38
39
40
# File 'livecheck/strategy/page_match.rb', line 38

def self.match?(url)
  URL_MATCH_REGEX.match?(url)
end

.versions_from_content(content, regex, &block) ⇒ Array<String>

Uses the regex to match text in the 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.

Parameters:

  • content (String)

    the page content to check

  • regex (Regexp, nil)

    a regex used for matching versions in the content

  • block (T.untyped)

Returns:



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
# File 'livecheck/strategy/page_match.rb', line 57

def self.versions_from_content(content, regex, &block)
  if block
    block_return_value = regex.present? ? yield(content, regex) : yield(content)
    return Strategy.handle_block_return(block_return_value)
  end

  return [] if regex.blank?

  content.scan(regex).map do |match|
    case match
    when String
      match
    when Array
      match.first
    end
  end.compact.uniq
end