html2rss 0.32.4 → 0.33.0

data/lib/html2rss/cli/render.rb

@@ -10,116 +10,117 @@ module Html2rss
       # ANSI colors for recon verdict labels in text output.
       VERDICT_COLORS = { build: "\e[32m", defer: "\e[33m" }.freeze
 
-      module_function
-
-      ##
-      # @param results [Array<Hash>]
-      # @param format [String]
-      # @param batch_mode [Boolean]
-      # @return [void]
-      def inspect_output(results, format:, batch_mode:)
-        if format == 'json'
-          json(results, batch_mode)
-        else
-          results.each { |data| probe_card(ProbeView.from_wire(data)) }
+      class << self
+        ##
+        # @param results [Array<Hash>]
+        # @param format [String]
+        # @param batch_mode [Boolean]
+        # @return [void]
+        def inspect_output(results, format:, batch_mode:)
+          if format == 'json'
+            json(results, batch_mode)
+          else
+            results.each { |data| probe_card(ProbeView.from_wire(data)) }
+          end
         end
-      end
 
-      ##
-      # @param results [Array<Html2rss::Recon::Result>]
-      # @param format [String]
-      # @param batch_mode [Boolean]
-      # @param url_only [Boolean]
-      # @return [void]
-      def recon_output(results, format:, batch_mode:, url_only: false) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        if url_only
-          results.each { |r| puts r.requested_url }
-        elsif format == 'json'
-          json(results.map(&:to_h), batch_mode)
-        elsif format == 'tsv'
-          puts %w[verdict status requested_url final_url native_feed notes].join("\t")
-          results.each do |r|
-            row = [
-              r.verdict.to_s.upcase,
-              r.status || '-',
-              r.requested_url,
-              r.final_url,
-              r.native_feed || '-',
-              r.notes.join('; ')
-            ]
-            puts row.join("\t")
+        ##
+        # @param results [Array<Html2rss::Recon::Result>]
+        # @param format [String]
+        # @param batch_mode [Boolean]
+        # @param url_only [Boolean]
+        # @return [void]
+        def recon_output(results, format:, batch_mode:, url_only: false) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          if url_only
+            results.each { |r| puts r.requested_url }
+          elsif format == 'json'
+            json(results.map(&:to_h), batch_mode)
+          elsif format == 'tsv'
+            puts %w[verdict status requested_url final_url native_feed notes].join("\t")
+            results.each do |r|
+              row = [
+                r.verdict.to_s.upcase,
+                r.status || '-',
+                r.requested_url,
+                r.final_url,
+                r.native_feed || '-',
+                r.notes.join('; ')
+              ]
+              puts row.join("\t")
+            end
+          else
+            results.each { |r| probe_card(ProbeView.from_recon(r)) }
           end
-        else
-          results.each { |r| probe_card(ProbeView.from_recon(r)) }
         end
-      end
 
-      ##
-      # @param view [ProbeView]
-      # @return [void]
-      def probe_card(view) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        if view.verdict
-          color = VERDICT_COLORS.fetch(view.verdict.to_sym, "\e[31m")
-          puts "#{color}[#{view.verdict.to_s.upcase}]\e[0m #{view.requested}"
-        else
-          puts view.requested
-        end
-        probe_lines(view)
-        if view.alternate_feeds.any?
-          hrefs = view.alternate_feeds.filter_map { |f| ProbeView.wire_val(f, :href) }
-          puts "        Feeds:    #{hrefs.join(', ')}" if hrefs.any?
+        ##
+        # @param view [ProbeView]
+        # @return [void]
+        def probe_card(view) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          if view.verdict
+            color = VERDICT_COLORS.fetch(view.verdict.to_sym, "\e[31m")
+            puts "#{color}[#{view.verdict.to_s.upcase}]\e[0m #{view.requested}"
+          else
+            puts view.requested
+          end
+          probe_lines(view)
+          if view.alternate_feeds.any?
+            hrefs = view.alternate_feeds.filter_map { |f| ProbeView.wire_val(f, :href) }
+            puts "        Feeds:    #{hrefs.join(', ')}" if hrefs.any?
+          end
+          puts "        Feed:     #{view.native_feed}" if view.native_feed
+          puts "        Notes:    #{view.notes.join(', ')}" if view.notes.any?
+          puts "        Strategy: #{view.strategy}" if view.strategy
+          puts ''
         end
-        puts "        Feed:     #{view.native_feed}" if view.native_feed
-        puts "        Notes:    #{view.notes.join(', ')}" if view.notes.any?
-        puts "        Strategy: #{view.strategy}" if view.strategy
-        puts ''
-      end
 
-      ##
-      # @param result [Html2rss::Test::Result]
-      # @param source [String]
-      # @return [void]
-      def test_card(result, source) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        if result.success
-          puts "\e[32m✓ Schema valid\e[0m (#{source})"
-          dur = "#{result.duration_seconds}s"
-          puts "\e[32m✓ Extracted #{result.item_count} items in #{dur}\e[0m (strategy: #{result.strategy_used})"
-          puts "\nChannel: #{result.channel_title} (#{result.channel_url})"
-          if result.sample_items.any?
-            puts 'Sample items:'
-            result.sample_items.each_with_index do |item, i|
-              puts "  #{i + 1}. #{"#{item[:published_at]} | " if item[:published_at]}#{item[:title]}"
-              puts "     #{item[:url]}"
+        ##
+        # @param result [Html2rss::Test::Result]
+        # @param source [String]
+        # @return [void]
+        def test_card(result, source) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          if result.success
+            puts "\e[32m✓ Schema valid\e[0m (#{source})"
+            dur = "#{result.duration_seconds}s"
+            puts "\e[32m✓ Extracted #{result.item_count} items in #{dur}\e[0m (strategy: #{result.strategy_used})"
+            puts "\nChannel: #{result.channel_title} (#{result.channel_url})"
+            if result.sample_items.any?
+              puts 'Sample items:'
+              result.sample_items.each_with_index do |item, i|
+                puts "  #{i + 1}. #{"#{item[:published_at]} | " if item[:published_at]}#{item[:title]}"
+                puts "     #{item[:url]}"
+              end
+            end
+          else
+            $stderr.puts "\e[31m✗ Test failed\e[0m (#{source})" # rubocop:disable Style/StderrPuts
+            $stderr.puts "  Error: #{result.error_message}" if result.error_message # rubocop:disable Style/StderrPuts
+            result.validation_issues&.each do |issue|
+              $stderr.puts "  Schema error #{issue}" # rubocop:disable Style/StderrPuts
             end
-          end
-        else
-          $stderr.puts "\e[31m✗ Test failed\e[0m (#{source})" # rubocop:disable Style/StderrPuts
-          $stderr.puts "  Error: #{result.error_message}" if result.error_message # rubocop:disable Style/StderrPuts
-          result.validation_issues&.each do |issue|
-            $stderr.puts "  Schema error #{issue}" # rubocop:disable Style/StderrPuts
           end
         end
-      end
 
-      ##
-      # @param data [Object]
-      # @param batch_mode [Boolean]
-      # @return [void]
-      def json(data, batch_mode)
-        payload = batch_mode ? data : data.first
-        puts JSON.pretty_generate(payload)
-      end
+        ##
+        # @param data [Object]
+        # @param batch_mode [Boolean]
+        # @return [void]
+        def json(data, batch_mode)
+          payload = batch_mode ? data : data.first
+          puts JSON.pretty_generate(payload)
+        end
 
-      ##
-      # @param view [ProbeView]
-      # @return [void]
-      def probe_lines(view)
-        if view.final && view.final != view.requested
-          puts "        Final:    #{view.final} (HTTP #{view.status || 'ERR'})"
+        private
+
+        ##
+        # @param view [ProbeView]
+        # @return [void]
+        def probe_lines(view)
+          if view.final && view.final != view.requested
+            puts "        Final:    #{view.final} (HTTP #{view.status || 'ERR'})"
+          end
+          puts "        Surface:  #{view.surface} (#{view.articles_count} articles)"
         end
-        puts "        Surface:  #{view.surface} (#{view.articles_count} articles)"
       end
-      private_class_method :probe_lines
     end
   end
 end

data/lib/html2rss/cli/validate.rb

@@ -5,15 +5,13 @@ module Html2rss
     ##
     # Validate command: file/glob/stdin branching and multi-file reporting.
     module Validate
-      module_function
-
       ##
       # @param files [Array<String>]
       # @param params [Hash]
       # @param quiet [Boolean]
       # @return [void]
       # @raise [Thor::Error]
-      def run(files, params:, quiet:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def self.run(files, params:, quiet:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         if files.size == 2 && File.file?(files[0].to_s) && !File.exist?(files[1].to_s)
           raise Thor::Error, "No such file: #{files[1]}" if path_like_config?(files[1])
 
@@ -45,7 +43,7 @@ module Html2rss
       ##
       # @param files [Array<String>]
       # @return [Array<String>]
-      def resolve_files(files)
+      def self.resolve_files(files)
         return ['-'] if files.empty? || files == ['-']
 
         resolved = []

data/lib/html2rss/cli.rb

@@ -114,24 +114,26 @@ module Html2rss
     method_option :explain, type: :boolean, desc: 'Print capture diagnostics to stderr', default: false
     # @param target [String, nil] URL or local HTML file
     # @return [void]
-    def capture(target = nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def capture(target = nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       strategy, local_file_path, url = prepare_auto_inputs(target, options[:input])
       topics = options[:topics]&.split(',')&.map(&:strip)
 
-      result = Html2rss::Capture.build(
-        url,
-        strategy:,
-        items_selector: options[:items_selector],
-        topics:,
-        title: options[:title],
-        summary: options[:summary],
-        force: options[:force],
-        enhance: options[:enhance],
-        limit: options[:limit]&.to_i,
-        max_redirects: options[:max_redirects],
-        max_requests: options[:max_requests],
-        local_file_path:
-      )
+      result = execute_feed do
+        Html2rss::Capture.build(
+          url,
+          strategy:,
+          items_selector: options[:items_selector],
+          topics:,
+          title: options[:title],
+          summary: options[:summary],
+          force: options[:force],
+          enhance: options[:enhance],
+          limit: options[:limit],
+          max_redirects: options[:max_redirects],
+          max_requests: options[:max_requests],
+          local_file_path:
+        )
+      end
 
       if result.native_feed? && !options[:force]
         $stderr.puts "First-party RSS/Atom feed detected at #{result.native_feed}. Use --force to capture anyway." # rubocop:disable Style/StderrPuts
@@ -158,15 +160,17 @@ module Html2rss
     # @return [void]
     def test(config_input = nil, feed_name = nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       raw_content, input_source = read_config_input(config_input)
-      result = Html2rss.test(
-        raw_content,
-        feed_name,
-        min_items: options.fetch(:min_items, 1).to_i,
-        params: options[:params] || {},
-        strategy: options[:strategy],
-        strict_quality: options.fetch(:strict_quality, false),
-        compare_enhance: options.fetch(:compare_enhance, false)
-      )
+      result = execute_feed do
+        Html2rss.test(
+          raw_content,
+          feed_name,
+          min_items: options.fetch(:min_items, 1),
+          params: options[:params] || {},
+          strategy: options[:strategy],
+          strict_quality: options.fetch(:strict_quality, false),
+          compare_enhance: options.fetch(:compare_enhance, false)
+        )
+      end
 
       if options[:json]
         puts JSON.pretty_generate(result.to_h)
@@ -202,7 +206,7 @@ module Html2rss
                  Config.from_yaml(raw_content)
                end
       config[:params] = options[:params] || {}
-      apply_runtime_request_overrides!(config)
+      execute_feed { apply_runtime_request_overrides!(config) }
       apply_local_file_input!(config, options[:input]) if options[:input]
 
       run_feed_command { Html2rss.apply(config) }
@@ -421,7 +425,9 @@ module Html2rss
            Html2rss::RequestService::BotasaurusConnectionFailed,
            Html2rss::RequestService::BotasaurusServiceError,
            Html2rss::RequestService::BlockedSurfaceDetected,
-           Html2rss::NoFeedItemsExtracted => error
+           Html2rss::NoFeedItemsExtracted,
+           Html2rss::InvalidOption,
+           Html2rss::Url::InvalidUrlError => error
       raise Thor::Error, error.message
     end
 
@@ -433,7 +439,7 @@ module Html2rss
         max_redirects: options[:max_redirects],
         max_requests: options[:max_requests],
         local_file_path:,
-        limit: options[:limit]&.to_i,
+        limit: options[:limit],
         keep_different_domain: options[:keep_different_domain]
       )
     end

data/lib/html2rss/config/request_controls.rb

@@ -52,6 +52,8 @@ module Html2rss
       # @param max_requests [Integer, nil]
       # @return [RequestControls]
       def self.from_shortcut(strategy:, max_redirects: nil, max_requests: nil)
+        strategy = Option.strategy(strategy) unless strategy.nil?
+        check_budgets!(max_redirects, max_requests)
         keys = []
         keys << :strategy unless strategy.nil? || strategy == Config.default_strategy_name
         keys << :max_redirects unless max_redirects.nil?
@@ -68,7 +70,8 @@ module Html2rss
       # @param max_requests [Integer, nil]
       # @return [RequestControls]
       def self.from_cli_options(strategy:, max_redirects: nil, max_requests: nil)
-        strategy_sym = strategy&.to_sym
+        strategy_sym = Option.strategy(strategy) if strategy
+        check_budgets!(max_redirects, max_requests)
         keys = []
         keys << :strategy if strategy
         keys << :max_redirects unless max_redirects.nil?
@@ -76,7 +79,12 @@ module Html2rss
         new(strategy: strategy_sym, max_redirects:, max_requests:, explicit_keys: keys)
       end
 
-      private_class_method :explicit_keys_for, :request_value_for, :request_key?
+      def self.check_budgets!(max_redirects, max_requests)
+        Option.integer(:max_redirects, max_redirects, min: 0, optional: true)
+        Option.integer(:max_requests, max_requests, min: 1, optional: true)
+      end
+
+      private_class_method :explicit_keys_for, :request_value_for, :request_key?, :check_budgets!
 
       ##
       # @param strategy [Symbol, nil] effective request strategy

data/lib/html2rss/config/schema.rb

@@ -7,8 +7,6 @@ module Html2rss
     ##
     # JSON export adapter from the runtime validators to the packaged schema artifact.
     module Schema
-      module_function
-
       # Canonical filename for the exported config JSON schema artifact.
       SCHEMA_FILENAME = 'html2rss-config.schema.json'
 
@@ -16,7 +14,7 @@ module Html2rss
       # Returns the exported configuration JSON Schema.
       #
       # @return [Hash{String => Object}] JSON Schema represented as a Ruby hash
-      def json_schema
+      def self.json_schema
         load_json_schema_extension!
         Builder.call
       end
@@ -26,7 +24,7 @@ module Html2rss
       #
       # @param pretty [Boolean] whether to pretty-print the JSON output
       # @return [String] serialized JSON Schema
-      def json_schema_json(pretty: true)
+      def self.json_schema_json(pretty: true)
         pretty ? JSON.pretty_generate(json_schema) : JSON.generate(json_schema)
       end
 
@@ -34,7 +32,7 @@ module Html2rss
       # Resolves the packaged schema path used by downstream tools.
       #
       # @return [String] absolute path to the packaged JSON schema file
-      def path
+      def self.path
         search_path = File.expand_path(__dir__)
 
         loop do
@@ -51,7 +49,7 @@ module Html2rss
       end
 
       # @return [void]
-      def load_json_schema_extension!
+      def self.load_json_schema_extension!
         require 'dry/schema/extensions/json_schema'
         Dry::Schema.load_extensions(:json_schema)
       end
@@ -221,7 +219,7 @@ module Html2rss
       #
       # @param schema [Hash] dry-schema JSON schema fragment for a selector
       # @return [Hash] same schema with registry $ref wiring applied
-      def apply_selector_registry_refs!(schema)
+      def self.apply_selector_registry_refs!(schema)
         properties = schema.fetch(:properties)
         properties[:extractor] = extractor_wire_schema
         properties[:post_process] = post_process_wire_schema
@@ -229,7 +227,7 @@ module Html2rss
       end
 
       # @return [Hash{Symbol => Object}]
-      def extractor_wire_schema
+      def self.extractor_wire_schema
         {
           description: 'Extractor used to pull a value from the selected element.',
           oneOf: registry_ref_list('extractors', Selectors::Extractors::NAME_TO_CLASS)
@@ -237,7 +235,7 @@ module Html2rss
       end
 
       # @return [Hash{Symbol => Object}]
-      def post_process_wire_schema
+      def self.post_process_wire_schema
         {
           type: 'array',
           description: 'Ordered transforms applied to the extracted value.',
@@ -251,7 +249,7 @@ module Html2rss
       # @param catalog [String] $defs catalog name (`extractors` or `post_processors`)
       # @param registry [Hash{Symbol => Class}]
       # @return [Array<Hash>] oneOf entries of `{ '$ref' => ... }`
-      def registry_ref_list(catalog, registry)
+      def self.registry_ref_list(catalog, registry)
         registry.keys.sort.map do |name|
           { '$ref' => "#/$defs/#{catalog}/#{name}" }
         end

data/lib/html2rss/config/selectors_validator.rb

@@ -216,6 +216,7 @@ module Html2rss
         def array_selector_shape_error(key, selector)
           return "`#{key}` must be an array" unless selector.is_a?(Array)
           return "`#{key}` must contain at least one element" if selector.empty?
+          return "`#{key}` must contain only selector names" unless selector.all? { _1 in String | Symbol }
 
           nil
         end

data/lib/html2rss/config/validator.rb

@@ -158,15 +158,15 @@ module Html2rss
         if (url_string = values.dig(:channel, :url)) && !url_string.empty?
           begin
             Html2rss::Url.for_channel(url_string)
-          rescue ArgumentError => error
+          rescue Html2rss::Url::InvalidUrlError => error
             key(%i[channel url]).failure(error.message)
           end
         end
 
         if (image_string = values.dig(:channel, :image)) && !image_string.empty?
           begin
-            Html2rss::Url.from_absolute(image_string)
-          rescue ArgumentError => error
+            Html2rss::Url.from_absolute_web(image_string)
+          rescue Html2rss::Url::InvalidUrlError => error
             key(%i[channel image]).failure(error.message)
           end
         end

data/lib/html2rss/config.rb

@@ -131,7 +131,7 @@ module Html2rss
       def auto_source_config(url:, items_selector: nil, request_controls: nil, limit: nil,
                              keep_different_domain: nil)
         auto_source = AutoSource::DEFAULT_CONFIG
-        auto_source = auto_source.merge(limit:) unless limit.nil?
+        auto_source = auto_source.merge(limit: Option.integer(:limit, limit, min: 1)) unless limit.nil?
         unless keep_different_domain.nil?
           auto_source = auto_source.merge(
             cleanup: auto_source[:cleanup].merge(keep_different_domain:)

data/lib/html2rss/defaults.rb

@@ -57,7 +57,7 @@ module Html2rss
     # @return [Logger] the logger
     # @raise [ArgumentError] if logger is not a Logger
     def logger=(logger)
-      raise ArgumentError, 'logger must be a Logger' unless logger.is_a?(::Logger)
+      raise ArgumentError, 'logger must be a Logger' unless logger.is_a?(Logger)
 
       @logger = logger
       @logger.level = @log_level
@@ -114,20 +114,9 @@ module Html2rss
     #
     # @param strategy [Symbol, String, nil] the strategy plan name
     # @return [Symbol, nil] the normalized strategy plan name
-    # @raise [ArgumentError] if the strategy plan is unknown
+    # @raise [InvalidOption] if the strategy plan is unknown
     def default_strategy=(strategy)
-      if strategy.nil?
-        @default_strategy = nil
-      else
-        unless strategy.is_a?(Symbol) || strategy.is_a?(String)
-          raise ArgumentError, 'strategy must be a Symbol or String'
-        end
-
-        normalized = strategy.to_sym
-        raise ArgumentError, "unknown strategy: #{strategy}" unless FeedPipeline::StrategyPlan.valid?(normalized)
-
-        @default_strategy = normalized
-      end
+      @default_strategy = (Option.strategy(strategy) unless strategy.nil?)
     end
 
     ##
@@ -171,8 +160,8 @@ module Html2rss
     # @return [void]
     def initialize_copy(other)
       super
-      @headers = @headers.dup if @headers.is_a?(Hash)
-      @stylesheets = @stylesheets.map(&:dup) if @stylesheets.is_a?(Array)
+      @headers = other.headers.dup if other.headers.is_a?(Hash)
+      @stylesheets = other.stylesheets.map(&:dup)
     end
 
     private

data/lib/html2rss/doctor/botasaurus.rb

@@ -32,15 +32,13 @@ module Html2rss
         end
       end
 
-      module_function
-
       ENV_VAR = 'BOTASAURUS_SCRAPER_URL'
       private_constant :ENV_VAR
 
       ##
       # @param sample_url [String, nil] optional URL for a sample scrape smoke test
       # @return [Result]
-      def call(sample_url: nil) # rubocop:disable Metrics/AbcSize
+      def self.call(sample_url: nil) # rubocop:disable Metrics/AbcSize
         env = env_check
         checks = [env_check_record(env)]
         return missing_env_failure(checks) unless checks.first.ok
@@ -57,7 +55,7 @@ module Html2rss
 
       ##
       # @return [Hash{Symbol => Object}]
-      def env_check
+      def self.env_check
         base = ENV.fetch(ENV_VAR, '').strip
         {
           configured: MCP::Runtime.botasaurus_configured?,
@@ -69,7 +67,7 @@ module Html2rss
       ##
       # @param base_url [String]
       # @return [Hash{Symbol => Object}]
-      def health_check(base_url)
+      def self.health_check(base_url)
         endpoint = "#{Url.for_channel(base_url).to_s.chomp('/')}/health"
         response = health_session.get(endpoint)
         raise response.error if response.is_a?(HTTPX::ErrorResponse)
@@ -80,60 +78,54 @@ module Html2rss
         { ok: false, error: "#{error.class}: #{error.message}" }
       end
 
-      def health_session
+      def self.health_session
         HTTPX.with(timeout: { operation_timeout: 5, request_timeout: 5, total_request_timeout: 5 },
                    resolver_class: :system)
       end
-      module_function :health_session
       private_class_method :health_session
 
       ##
       # @param url [String]
       # @return [Hash{Symbol => Object}]
-      def sample_scrape(url)
+      def self.sample_scrape(url)
         wire = PageRecon::Diagnostics.call(url:, strategy: :botasaurus).to_wire_h
         {
           ok: wire[:status].to_i.between?(200, 399),
           status: wire[:status],
           articles_count: wire[:articles_count]
         }
-      rescue StandardError => error
+      rescue Html2rss::Error => error
         { ok: false, error: "#{error.class}: #{error.message}" }
       end
 
-      def env_check_record(env = env_check)
+      def self.env_check_record(env = env_check)
         Check.new(name: :env, ok: env[:configured], detail: { var: env[:var], base_url_set: !env[:base_url].nil? })
       end
-      module_function :env_check_record
       private_class_method :env_check_record
 
-      def health_check_record(base_url)
+      def self.health_check_record(base_url)
         return Check.new(name: :health, ok: false, detail: { error: 'missing base URL' }) unless base_url
 
         health = health_check(base_url)
         Check.new(name: :health, ok: health[:ok], detail: health)
       end
-      module_function :health_check_record
       private_class_method :health_check_record
 
-      def sample_scrape_record(url)
+      def self.sample_scrape_record(url)
         sample = sample_scrape(url)
         Check.new(name: :sample_scrape, ok: sample[:ok], detail: sample)
       end
-      module_function :sample_scrape_record
       private_class_method :sample_scrape_record
 
-      def missing_env_failure(checks)
+      def self.missing_env_failure(checks)
         Log.info("doctor botasaurus: #{ENV_VAR} unset")
         failure(checks, "Set #{ENV_VAR} to the scrape-api base URL.")
       end
-      module_function :missing_env_failure
       private_class_method :missing_env_failure
 
-      def failure(checks, message)
+      def self.failure(checks, message)
         Result.new(ok: false, checks:, message:)
       end
-      module_function :failure
       private_class_method :failure
     end
   end