Class: Homebrew::Livecheck::Strategy::Json

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

Overview

The Json strategy fetches content at a URL, parses it as JSON, and provides the parsed data to a strategy block. If a regex is present in the livecheck block, it should be passed as the second argument to the strategy block.

This is a generic strategy that doesn’t contain any logic for finding versions, as the structure of JSON data varies. Instead, a strategy block must be used to extract version information from the JSON data.

This strategy is not applied automatically and it is necessary to use strategy :json in a livecheck block (in conjunction with a strategy block) to use it.

This strategy’s Json.find_versions method can be used in other strategies that work with JSON content, so it should only be necessary to write the version-finding logic that works with the parsed JSON data.

Constant Summary collapse

NICE_NAME = 
"JSON"
PRIORITY =

A priority of zero causes livecheck to skip the strategy. We do this for Homebrew::Livecheck::Strategy::Json so we can selectively apply it only when a strategy block 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 JSON content at the URL for versions, using the provided strategy block to extract version information.

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:

Raises:

  • (ArgumentError) 


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'livecheck/strategy/json.rb', line 111

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

  match_data = { matches: {}, regex: regex, url: url }
  return match_data if url.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::Json will technically match any HTTP URL but is only usable with a livecheck block containing a strategy block.

Parameters:

  • url (String) —

    the URL to match against

Returns:

  • (Boolean) 


45
46
47
 
# File 'livecheck/strategy/json.rb', line 45

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

.parse_json(content) ⇒ T.untyped

Parses JSON text and returns the parsed data.

Parameters:

  • content (String) —

    the JSON text to parse

Returns:

  • (T.untyped) 


52
53
54
55
56
57
58
59
60
 
# File 'livecheck/strategy/json.rb', line 52

def self.parse_json(content)
  require "json"

  begin
    JSON.parse(content)
  rescue JSON::ParserError
    raise "Content could not be parsed as JSON."
  end
end

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

Parses JSON text and identifies versions using a strategy block. If a regex is provided, it will be passed as the second argument to the strategy block (after the parsed JSON data).

Parameters:

  • content (String) —

    the JSON text to parse and check

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

    a regex used for matching versions in the content

  • block (T.untyped)

Returns:



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'livecheck/strategy/json.rb', line 76

def self.versions_from_content(content, regex = nil, &block)
  return [] if content.blank? || block.blank?

  json = parse_json(content)
  return [] if json.blank?

  block_return_value = if regex.present?
    yield(json, regex)
  elsif block.arity == 2
    raise "Two arguments found in `strategy` block but no regex provided."
  else
    yield(json)
  end
  Strategy.handle_block_return(block_return_value)
end