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

Inherits:
Object
  • Object
show all
Extended by:
T::Sig
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, **_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

  • _unused (Hash{Symbol => T.untyped}, nil)
  • block (T.proc.params(arg0: String, arg1: T.nilable(Regexp)).returns(T.any(String, T::Array[String], NilClass)), nil)

Returns:



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'livecheck/strategy/page_match.rb', line 92

def self.find_versions(url:, regex: nil, provided_content: nil, **_unused, &block)
  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))
    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.proc.params(arg0: String, arg1: T.nilable(Regexp)).returns(T.any(String, T::Array[String], NilClass)), nil)

Returns:



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

def self.versions_from_content(content, regex, &block)
  return Strategy.handle_block_return(block.call(content, regex)) if block
  return [] if regex.blank?

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