html2rss 0.32.4 → 0.33.0

data/lib/html2rss/syndication/parser.rb

@@ -6,136 +6,113 @@ module Html2rss
   module Syndication
     ##
     # Parses RSS 2.0 and Atom documents into AutoSource article hashes.
-    module Parser # rubocop:disable Metrics/ModuleLength -- feed formats + structured parse warn
-      module_function
-
-      ##
-      # @param response [Html2rss::RequestService::Response]
-      # @return [Array<Hash{Symbol => Object}>] article hashes (may be empty)
-      # @raise [ArgumentError] when the response is not a syndication feed
-      def parse_response(response)
-        raise ArgumentError, 'response is not a syndication feed' unless response.feed_response?
+    module Parser
+      class << self
+        ##
+        # @param response [Html2rss::RequestService::Response]
+        # @return [Array<Hash{Symbol => Object}>] article hashes (may be empty)
+        # @raise [ArgumentError] when the response is not a syndication feed
+        def parse_response(response)
+          raise ArgumentError, 'response is not a syndication feed' unless response.feed_response?
+
+          parse(response.body, base_url: response.url)
+        end
 
-        parse(response.body, base_url: response.url)
-      end
+        ##
+        # @param body [String] raw RSS/Atom document
+        # @param base_url [String, Html2rss::Url, nil] fallback base for relative item links
+        # @return [Array<Hash{Symbol => Object}>]
+        def parse(body, base_url: nil)
+          feed = RSS::Parser.parse(body.to_s, false)
+
+          items_from(feed).filter_map { |item| article_hash(item, base_url:) }
+        rescue RSS::Error => error
+          Log.warn({
+            event_name: 'syndication.parse_failed',
+            error_class: error.class.name,
+            message: "Syndication::Parser: failed to parse feed (#{error.class}: #{error.message})"
+          }.to_json)
+          []
+        end
 
-      ##
-      # @param body [String] raw RSS/Atom document
-      # @param base_url [String, Html2rss::Url, nil] fallback base for relative item links
-      # @return [Array<Hash{Symbol => Object}>]
-      def parse(body, base_url: nil)
-        feed = RSS::Parser.parse(body.to_s, false)
-        return [] unless feed
-
-        items_from(feed, base_url:).filter_map { |item| article_hash(item, base_url:) }
-      rescue RSS::Error => error
-        Log.warn({
-          event_name: 'syndication.parse_failed',
-          error_class: error.class.name,
-          message: "Syndication::Parser: failed to parse feed (#{error.class}: #{error.message})"
-        }.to_json)
-        []
-      end
+        private
 
-      def items_from(feed, base_url:) # rubocop:disable Lint/UnusedMethodArgument -- base reserved for callers
-        case feed
-        when RSS::Rss then Array(feed.items)
-        when RSS::Atom::Feed then Array(feed.entries)
-        else []
+        def items_from(feed)
+          case feed
+          when RSS::Rss then feed.items
+          when RSS::Atom::Feed then feed.entries
+          else []
+          end
         end
-      end
-      module_function :items_from
-      private_class_method :items_from
 
-      def article_hash(item, base_url:)
-        case item
-        when RSS::Rss::Channel::Item then rss_item_hash(item, base_url:)
-        when RSS::Atom::Entry, RSS::Atom::Feed::Entry then atom_entry_hash(item, base_url:)
+        def article_hash(item, base_url:)
+          case item
+          when RSS::Rss::Channel::Item then rss_item_hash(item, base_url:)
+          when RSS::Atom::Feed::Entry then atom_entry_hash(item, base_url:)
+          end
         end
-      end
-      module_function :article_hash
-      private_class_method :article_hash
-
-      def rss_item_hash(item, base_url:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- RSS item mapping
-        url = absolute_url(item.link, base_url:)
-        return unless url
-
-        {
-          id: present(item.guid&.content) || url.to_s,
-          title: present(item.title),
-          description: present(item.description),
-          url:,
-          published_at: item.date || item.pubDate,
-          author: present(item.author),
-          categories: Array(item.categories).filter_map { |cat| present(cat.content) }
-        }.compact
-      end
-      module_function :rss_item_hash
-      private_class_method :rss_item_hash
-
-      def atom_entry_hash(entry, base_url:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- Atom entry mapping
-        url = atom_link(entry, base_url:)
-        return unless url
-
-        {
-          id: present(entry.id&.content) || url.to_s,
-          title: present(atom_text(entry.title)),
-          description: present(atom_text(entry.content) || atom_text(entry.summary)),
-          url:,
-          published_at: entry.published&.content || entry.updated&.content,
-          author: present(atom_author(entry)),
-          categories: Array(entry.categories).filter_map { |cat| present(cat.term) }
-        }.compact
-      end
-      module_function :atom_entry_hash
-      private_class_method :atom_entry_hash
 
-      def atom_link(entry, base_url:)
-        links = Array(entry.links)
-        link = links.find { |node| node.rel.nil? || node.rel == 'alternate' } || links.first
-        absolute_url(link&.href, base_url:)
-      end
-      module_function :atom_link
-      private_class_method :atom_link
+        def rss_item_hash(item, base_url:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- RSS item mapping
+          url = absolute_url(item.link, base_url:)
+          return unless url
+
+          {
+            id: present(item.guid&.content) || url.to_s,
+            title: present(item.title),
+            description: present(item.description),
+            url:,
+            published_at: item.pubDate,
+            author: present(item.author),
+            categories: item.categories.filter_map { |cat| present(cat.content) }
+          }.compact
+        end
 
-      def atom_text(node)
-        return unless node.is_a?(RSS::Atom::TextConstruct) || node.is_a?(RSS::Atom::Feed::Entry::Content)
+        def atom_entry_hash(entry, base_url:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- Atom entry mapping
+          url = atom_link(entry, base_url:)
+          return unless url
+
+          {
+            id: present(entry.id&.content) || url.to_s,
+            title: present(entry.title&.content),
+            description: present(entry.content&.content || entry.summary&.content),
+            url:,
+            published_at: entry.published&.content || entry.updated&.content,
+            author: atom_author(entry),
+            categories: entry.categories.filter_map { |cat| present(cat.term) }
+          }.compact
+        end
 
-        node.content
-      end
-      module_function :atom_text
-      private_class_method :atom_text
+        def atom_link(entry, base_url:)
+          links = entry.links
+          link = links.find { |node| node.rel.nil? || node.rel == 'alternate' } || links.first
+          absolute_url(link&.href, base_url:)
+        end
 
-      def atom_author(entry)
-        author = Array(entry.author).first
-        return unless author
+        def atom_author(entry)
+          author = entry.author
+          return unless author
 
-        present(author.name&.content) || present(author.email&.content)
-      end
-      module_function :atom_author
-      private_class_method :atom_author
-
-      def absolute_url(raw, base_url:)
-        value = present(raw)
-        return unless value
+          present(author.name&.content) || present(author.email&.content)
+        end
 
-        if base_url
-          Html2rss::Url.from_relative(value, base_url)
-        else
-          Html2rss::Url.from_absolute(value)
+        def absolute_url(raw, base_url:)
+          value = present(raw)
+          return unless value
+
+          if base_url
+            Html2rss::Url.from_relative(value, base_url)
+          else
+            Html2rss::Url.from_absolute(value)
+          end
+        rescue Html2rss::Url::InvalidUrlError
+          nil
         end
-      rescue ArgumentError
-        nil
-      end
-      module_function :absolute_url
-      private_class_method :absolute_url
 
-      def present(value)
-        text = value.to_s.strip
-        text unless text.empty?
+        def present(value)
+          text = value.to_s.strip
+          text unless text.empty?
+        end
       end
-      module_function :present
-      private_class_method :present
     end
   end
 end

data/lib/html2rss/test/enhance_audit.rb

@@ -6,8 +6,6 @@ module Html2rss
     # Probes list-card +enhance+ value on cached listing HTML.
     # Sole owner of enhance_gains metrics and enhance-specific warn-only warnings.
     module EnhanceAudit # rubocop:disable Metrics/ModuleLength -- probe + compare + heuristics stay co-located
-      module_function
-
       TRACKED_KEYS = %i[title url description published_at categories author image id enclosures].freeze
       CURATOR_KEYS = %i[title url description published_at].freeze
       private_constant :TRACKED_KEYS, :CURATOR_KEYS
@@ -28,7 +26,7 @@ module Html2rss
       # @param selectors [Hash{Symbol => Object}]
       # @param time_zone [String]
       # @return [AuditSlice, nil] nil when selectors are absent
-      def probe(response:, selectors:, time_zone:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- per-item probe loop
+      def self.probe(response:, selectors:, time_zone:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- per-item probe loop
         return nil unless selectors&.dig(:items, :selector)
 
         selector_engine = Selectors.new(response, selectors:, time_zone:)
@@ -64,7 +62,7 @@ module Html2rss
       # @param selectors [Hash{Symbol => Object}]
       # @param time_zone [String]
       # @return [Hash{Symbol => Object}, nil]
-      def compare(response:, selectors:, time_zone:) # rubocop:disable Metrics/MethodLength -- enhance off/on stats + delta
+      def self.compare(response:, selectors:, time_zone:) # rubocop:disable Metrics/MethodLength -- enhance off/on stats + delta
         return nil unless selectors&.dig(:items, :selector)
 
         off = extraction_stats(response, selectors, time_zone, enhance: false)
@@ -84,7 +82,7 @@ module Html2rss
 
       ##
       # @return [EnhanceGains] zeroed gains for compare fallback
-      def empty_gains
+      def self.empty_gains
         EnhanceGains.new(
           items_probed: 0,
           keys_added: zero_keys_added,
@@ -93,12 +91,12 @@ module Html2rss
         )
       end
 
-      def zero_keys_added
+      def self.zero_keys_added
         TRACKED_KEYS.to_h { |key| [key, 0] }.freeze
       end
       private_class_method :zero_keys_added
 
-      def extraction_stats(response, selectors, time_zone, enhance:)
+      def self.extraction_stats(response, selectors, time_zone, enhance:)
         merged = selectors_with_enhance(selectors, enhance:)
         articles = Selectors.new(response, selectors: merged, time_zone:).articles
         {
@@ -108,14 +106,14 @@ module Html2rss
       end
       private_class_method :extraction_stats
 
-      def selectors_with_enhance(selectors, enhance:)
+      def self.selectors_with_enhance(selectors, enhance:)
         merged = HashUtil.deep_dup(selectors)
         merged[:items] = merged.fetch(:items, {}).merge(enhance:)
         merged
       end
       private_class_method :selectors_with_enhance
 
-      def keys_added(baseline, enhanced)
+      def self.keys_added(baseline, enhanced)
         enhanced.each_with_object({}) do |(key, value), counts|
           next if value.nil?
 
@@ -127,7 +125,7 @@ module Html2rss
       end
       private_class_method :keys_added
 
-      def merge_keys_added!(gains, item_keys)
+      def self.merge_keys_added!(gains, item_keys)
         gains[:items_probed] += 1
         item_keys.each do |key, count|
           next unless TRACKED_KEYS.include?(key)
@@ -138,13 +136,13 @@ module Html2rss
       end
       private_class_method :merge_keys_added!
 
-      def finalize_gains!(gains)
+      def self.finalize_gains!(gains)
         curator_total = CURATOR_KEYS.sum { |key| gains[:keys_added][key] }
         gains[:no_op] = curator_total.zero?
       end
       private_class_method :finalize_gains!
 
-      def append_item_warnings!(warnings, item:, enhanced:, item_keys:)
+      def self.append_item_warnings!(warnings, item:, enhanced:, item_keys:)
         curator_added = item_keys.slice(*CURATOR_KEYS)
         return if curator_added.empty?
         return unless curator_added.key?(:description)
@@ -160,7 +158,7 @@ module Html2rss
       end
       private_class_method :append_item_warnings!
 
-      def category_only_description?(description, enhanced)
+      def self.category_only_description?(description, enhanced)
         normalized = description.downcase
         return true if Html2rss::Html::ArticleRules::Description::TYPE_CHIPS.include?(normalized)
 
@@ -169,7 +167,7 @@ module Html2rss
       end
       private_class_method :category_only_description?
 
-      def image_only_description?(description, item)
+      def self.image_only_description?(description, item)
         images = item.css('img')
         return description == images.first['alt'].to_s.strip if images.size == 1 && images.first['alt']
 
@@ -177,7 +175,7 @@ module Html2rss
       end
       private_class_method :image_only_description?
 
-      def prose_shaped?(text)
+      def self.prose_shaped?(text)
         return false if text.match?(IMAGE_FILENAME)
         return false if text.match?(%r{\Ahttps?://}i)
         return false if text.match?(%r{\A/[\w./-]+\z})

data/lib/html2rss/test/policy.rb

@@ -6,8 +6,6 @@ module Html2rss
     # Pass/fail classification for a configuration test after live extraction.
     # Owns min_items vs quality thresholds; {Test.call} orchestrates only.
     module Policy
-      module_function
-
       Outcome = Data.define(:passed, :failure_kind, :error_message)
 
       ##
@@ -28,7 +26,7 @@ module Html2rss
       # @param strict_quality [Boolean]
       # @param quality_report [QualityReport]
       # @return [Outcome]
-      def evaluate(item_count:, min_items:, strict_quality:, quality_report:)
+      def self.evaluate(item_count:, min_items:, strict_quality:, quality_report:)
         min_items_passed = item_count >= min_items
         quality_failed = strict_quality && min_items_passed && quality_failure?(quality_report)
         passed = min_items_passed && !quality_failed
@@ -39,7 +37,7 @@ module Html2rss
         Outcome.new(passed:, failure_kind:, error_message:)
       end
 
-      def log_strict_quality_failure(failure_kind, item_count)
+      def self.log_strict_quality_failure(failure_kind, item_count)
         Log.info("Test strict quality: failure_kind=#{failure_kind.to_sym} item_count=#{item_count}")
       end
       private_class_method :log_strict_quality_failure
@@ -47,7 +45,7 @@ module Html2rss
       ##
       # @param quality_report [QualityReport]
       # @return [Boolean]
-      def quality_failure?(quality_report)
+      def self.quality_failure?(quality_report)
         metrics = quality_report.metrics
         item_count = metrics[:item_count]
         return false if item_count.zero?
@@ -62,7 +60,7 @@ module Html2rss
       # @param min_items [Integer]
       # @param quality_report [QualityReport]
       # @return [Array(FailureKind, nil), Array(String, nil)]
-      def outcome_failure(min_items_passed:, quality_failed:, item_count:, min_items:, quality_report:)
+      def self.outcome_failure(min_items_passed:, quality_failed:, item_count:, min_items:, quality_report:)
         return [nil, nil] if min_items_passed && !quality_failed
         unless min_items_passed
           return [FailureKind[:min_items],
@@ -72,13 +70,13 @@ module Html2rss
         [FailureKind[:quality], quality_failure_message(quality_report)]
       end
 
-      def quality_failure_message(quality_report)
+      def self.quality_failure_message(quality_report)
         reasons = quality_failure_reasons(quality_report.metrics)
         "Feed quality check failed (#{reasons.join(', ')})"
       end
       private_class_method :quality_failure_message
 
-      def quality_failure_reasons(metrics)
+      def self.quality_failure_reasons(metrics)
         reasons = []
         reasons << 'duplicate_urls' if duplicate_urls_failure?(metrics)
         reasons << 'generic_titles' if junk_title_ratio_failure?(metrics)
@@ -87,17 +85,17 @@ module Html2rss
       end
       private_class_method :quality_failure_reasons
 
-      def duplicate_urls_failure?(metrics)
+      def self.duplicate_urls_failure?(metrics)
         metrics[:item_count] >= 2 && metrics[:unique_url_count] < 2
       end
       private_class_method :duplicate_urls_failure?
 
-      def junk_title_ratio_failure?(metrics)
+      def self.junk_title_ratio_failure?(metrics)
         metrics[:junk_title_count] > (metrics[:item_count] / 2.0)
       end
       private_class_method :junk_title_ratio_failure?
 
-      def short_title_failure?(metrics)
+      def self.short_title_failure?(metrics)
         metrics[:short_title_count].positive?
       end
       private_class_method :short_title_failure?

data/lib/html2rss/test.rb

@@ -5,8 +5,6 @@ module Html2rss
   # Service that runs schema validation and live feed extraction on a configuration,
   # enforcing minimum item thresholds and capturing sample output.
   module Test # rubocop:disable Metrics/ModuleLength -- Result + FailureKind nest with owner
-    module_function
-
     FailureKind = Data.define(:name)
 
     ##
@@ -163,27 +161,27 @@ module Html2rss
     # @param strict_quality [Boolean] when true, fail on ship-quality audit thresholds
     # @param compare_enhance [Boolean] diagnostic enhance off vs on comparison on cached HTML
     # @return [Html2rss::Test::Result]
-    def call(config_input, feed_name = nil, min_items: 1, params: {}, strategy: nil, # rubocop:disable Metrics/ParameterLists
-             strict_quality: false, compare_enhance: false)
+    def self.call(config_input, feed_name = nil, min_items: 1, params: {}, strategy: nil, # rubocop:disable Metrics/ParameterLists
+                  strict_quality: false, compare_enhance: false)
       raw_config, validation = Config.resolve_and_validate(config_input, feed_name:, params:)
       return validation_failure_result(validation, raw_config) unless validation.success?
 
       config = build_test_config(raw_config, strategy, params)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, compare_enhance:)
-    rescue StandardError => error
+    rescue Html2rss::Error => error
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
       execution_failure_result(error, raw_config, duration)
     end
 
-    def build_test_config(raw_config, strategy, params)
+    def self.build_test_config(raw_config, strategy, params)
       raw_config[:strategy] = strategy.to_sym if strategy
       raw_config[:params] = params if params&.any?
       Config.from_hash(raw_config)
     end
     private_class_method :build_test_config
 
-    def compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
+    def self.compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
       quality_report_for(
         feed_result.to_rss.items,
         channel_url: raw_config.dig(:channel, :url).to_s,
@@ -194,20 +192,20 @@ module Html2rss
     end
     private_class_method :compile_quality_report
 
-    def execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, # rubocop:disable Metrics/ParameterLists
-                               compare_enhance:)
+    def self.execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, # rubocop:disable Metrics/ParameterLists
+                                    compare_enhance:)
       feed_result, pipeline_outcome = extract_feed(raw_config)
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
       quality_report = compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
       enhance_compare = build_enhance_compare(config, pipeline_outcome) if compare_enhance
 
       build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare,
-                        min_items:, strict_quality:, response_body: pipeline_outcome&.response&.body)
+                        min_items:, strict_quality:, response_body: pipeline_outcome.response.body)
     end
     private_class_method :execute_timed_pipeline
 
-    def build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
-                          min_items:, strict_quality:, response_body:)
+    def self.build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
+                               min_items:, strict_quality:, response_body:)
       rss_doc = feed_result.to_rss
       outcome = Policy.evaluate(item_count: rss_doc.items.size, min_items:, strict_quality:, quality_report:)
       strategy_used = feed_result.status.selected_strategy || raw_config[:strategy] ||
@@ -232,27 +230,14 @@ module Html2rss
     end
     private_class_method :build_test_result
 
-    def extract_samples(items, limit: 3)
+    def self.extract_samples(items, limit: 3)
       items.first(limit).map do |item|
-        article = feed_item_as_article(item)
-        {
-          title: article.title.to_s.strip,
-          url: article.url.to_s,
-          published_at: article.published_at
-        }
+        article = Article.new(title: item.title, url: item.link, published_at: item.pubDate)
+        { title: article.title.to_s.strip, url: article.url.to_s, published_at: article.published_at }
       end
     end
     private_class_method :extract_samples
 
-    def feed_item_as_article(item)
-      case item
-      when Article then item
-      else
-        Article.new(title: item.title, url: item.link, published_at: item.pubDate)
-      end
-    end
-    private_class_method :feed_item_as_article
-
     ##
     # Builds a ship-quality report for RSS items (shared by test and MCP apply).
     #
@@ -263,8 +248,8 @@ module Html2rss
     # @param pipeline_outcome [Html2rss::FeedPipeline::PipelineOutcome]
     # @param probe_native_feed [Boolean] when false, skip syndication discovery (apply ship gate)
     # @return [QualityReport]
-    def quality_report_for(items, channel_url:, config:, feed_result:, pipeline_outcome:, # rubocop:disable Metrics/ParameterLists
-                           probe_native_feed: true)
+    def self.quality_report_for(items, channel_url:, config:, feed_result:, pipeline_outcome:, # rubocop:disable Metrics/ParameterLists
+                                probe_native_feed: true)
       audit = AutoSource::Cleanup.audit_feed_items(items)
       native_feed = probe_native_feed ? probe_native_feed_url(channel_url, config)&.to_s : nil
       report = QualityReport.from_audit(audit, native_feed:)
@@ -272,21 +257,20 @@ module Html2rss
       merge_enhance_audit(report, config, pipeline_outcome)
     end
 
-    def extract_feed(raw_config)
+    def self.extract_feed(raw_config)
       outcome, feed_result = FeedPipeline.new(raw_config).to_outcome_and_result
       [feed_result, outcome]
     end
     private_class_method :extract_feed
 
-    def enhance_enabled?(config)
+    def self.enhance_enabled?(config)
       return false unless config.selectors
 
       !!config.selectors.dig(:items, :enhance)
     end
     private_class_method :enhance_enabled?
 
-    def build_enhance_compare(config, pipeline_outcome)
-      return nil unless pipeline_outcome
+    def self.build_enhance_compare(config, pipeline_outcome)
       return nil unless config.selectors
 
       EnhanceAudit.compare(
@@ -297,9 +281,8 @@ module Html2rss
     end
     private_class_method :build_enhance_compare
 
-    def merge_enhance_audit(report, config, pipeline_outcome) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- warning merge + metrics
-      return report unless pipeline_outcome && enhance_enabled?(config)
-      return report unless config.selectors
+    def self.merge_enhance_audit(report, config, pipeline_outcome) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- warning merge + metrics
+      return report unless enhance_enabled?(config)
 
       slice = EnhanceAudit.probe(
         response: pipeline_outcome.response,
@@ -320,7 +303,7 @@ module Html2rss
     end
     private_class_method :merge_enhance_audit
 
-    def enhance_gains_to_h(enhance_gains)
+    def self.enhance_gains_to_h(enhance_gains)
       {
         items_probed: enhance_gains.items_probed,
         keys_added: enhance_gains.keys_added,
@@ -330,7 +313,7 @@ module Html2rss
     end
     private_class_method :enhance_gains_to_h
 
-    def append_url_mismatch_warning(report, channel_url, feed_result)
+    def self.append_url_mismatch_warning(report, channel_url, feed_result)
       return report unless url_mismatch?(channel_url, feed_result)
 
       warnings = report.warnings.dup
@@ -344,22 +327,20 @@ module Html2rss
     end
     private_class_method :append_url_mismatch_warning
 
-    def url_mismatch?(channel_url, feed_result)
-      status = feed_result&.status
-      return false unless status
-
+    def self.url_mismatch?(channel_url, feed_result)
+      status = feed_result.status
       configured = channel_url.to_s
       final = status.scrape_url.to_s
       final = status.entry_url.to_s if final.empty?
       return false if configured.empty? || final.empty?
 
       !Url.from_absolute(configured).same_document?(Url.from_absolute(final))
-    rescue ArgumentError
+    rescue Html2rss::Url::InvalidUrlError
       false
     end
     private_class_method :url_mismatch?
 
-    def probe_native_feed_url(channel_url, config)
+    def self.probe_native_feed_url(channel_url, config)
       return nil if channel_url.to_s.empty?
 
       resources = FeedPipeline::RuntimePolicy.resources_for(config)
@@ -368,12 +349,12 @@ module Html2rss
         config:, strategy:, budget: resources.budget, policy: resources.policy
       )
       Syndication::Discovery.best_feed_url(page_url: channel_url, request_session: session)
-    rescue StandardError
+    rescue Html2rss::Error
       nil
     end
     private_class_method :probe_native_feed_url
 
-    def validation_failure_result(report, raw_config) # rubocop:disable Metrics/MethodLength
+    def self.validation_failure_result(report, raw_config) # rubocop:disable Metrics/MethodLength
       Result.new(
         success: false,
         item_count: 0,
@@ -391,7 +372,7 @@ module Html2rss
     end
     private_class_method :validation_failure_result
 
-    def execution_failure_result(error, raw_config, duration) # rubocop:disable Metrics/MethodLength
+    def self.execution_failure_result(error, raw_config, duration) # rubocop:disable Metrics/MethodLength
       Result.new(
         success: false,
         item_count: 0,