html2rss 0.29.1 → 0.31.0

data/lib/html2rss/config.rb

@@ -13,53 +13,8 @@ module Html2rss
   class Config # rubocop:disable Metrics/ClassLength
     # Raised when a configuration hash fails runtime validation.
     class InvalidConfig < Html2rss::Error; end
-    # Sentinel to differentiate omitted params from explicit `nil`.
-    UNSET = Object.new.freeze
-
-    ValidationResult = Data.define(:success, :errors_hash)
-
-    ##
-    # Duck-compatible with +Dry::Validation::Result+ for resolve-time outcomes
-    # (+#success?+, +#errors#to_h+). Used for parse failures so callers never see a Struct snowflake.
-    class ValidationResult
-      ##
-      # @param message [String]
-      # @return [Html2rss::Config::ValidationResult]
-      def self.parse_failure(message)
-        new(success: false, errors_hash: { parse: [message] })
-      end
-
-      ##
-      # @return [Boolean]
-      def success? = success
-
-      ##
-      # @return [self]
-      def errors = self
-
-      ##
-      # @return [Hash]
-      def to_h = errors_hash
-    end
 
     class << self
-      ##
-      # Returns the exported JSON Schema for html2rss configuration.
-      #
-      # @return [Hash{String => Object}] JSON Schema represented as a Ruby hash
-      def json_schema
-        Schema.json_schema
-      end
-
-      ##
-      # Returns the exported JSON Schema as JSON.
-      #
-      # @param pretty [Boolean] whether to pretty-print the JSON output
-      # @return [String] serialized JSON Schema
-      def json_schema_json(pretty: true)
-        pretty ? JSON.pretty_generate(json_schema) : JSON.generate(json_schema)
-      end
-
       ##
       # Resolves a Hash, YAML file path, or YAML string to a working config Hash and validates it.
       # The returned Hash is a deep copy — callers may stamp strategy/params without mutating input.
@@ -67,13 +22,14 @@ module Html2rss
       # @param config_input [Hash, String] config hash, YAML string, or file path
       # @param feed_name [String, nil] optional feed name for multi-feed files
       # @param params [Hash] dynamic feed params
-      # @return [Array(Hash, Dry::Validation::Result, Html2rss::Config::ValidationResult)]
+      # @return [Array(Hash, Html2rss::Config::ValidationReport)]
       def resolve_and_validate(config_input, feed_name: nil, params: {})
-        param_arg = params.empty? ? UNSET : params
-        working = HashUtil.deep_dup(resolve_raw_hash(config_input, feed_name))
-        [working, validate(working, params: param_arg)]
-      rescue StandardError => error
-        [{}, ValidationResult.parse_failure(error.message)]
+        raw = resolve_raw_hash(config_input, feed_name)
+      rescue Psych::Exception, ArgumentError => error
+        [{}, IssueMapper.parse_failure(error.message)]
+      else
+        working = HashUtil.deep_dup(raw)
+        [working, validate(working, params:)]
       end
 
       ##
@@ -81,24 +37,15 @@ module Html2rss
       #
       # @param config [Hash{Symbol => Object}] the configuration hash
       # @param params [Hash{Symbol => Object, Hash{String => Object, nil}}] dynamic parameters for string formatting
-      # @return [Dry::Validation::Result] validation result after defaults are applied
-      def validate(config, params: UNSET)
+      # @return [Html2rss::Config::ValidationReport]
+      def validate(config, params: {})
         prepared_config = prepare_for_validation(resolve_effective_config(config, params:))
-
-        Validator.new.call(prepared_config)
+        IssueMapper.from(Validator.new.call(prepared_config), values: prepared_config)
       rescue DynamicParams::ParamsMissing => error
         prepared_config = prepare_for_validation(HashUtil.deep_symbolize_keys(config, context: 'config'))
         prepared_config[:dynamic_params_error] = error.message
 
-        Validator.new.call(prepared_config)
-      end
-
-      ##
-      # Returns the packaged JSON Schema file path.
-      #
-      # @return [String] absolute path to the packaged JSON Schema file
-      def schema_path
-        Schema.path
+        IssueMapper.from(Validator.new.call(prepared_config), values: prepared_config)
       end
 
       ##
@@ -167,7 +114,7 @@ module Html2rss
       # @param config [Hash{Symbol => Object}] the configuration hash.
       # @param params [Hash{Symbol => Object, Hash{String => Object, nil}}] dynamic parameters for string formatting.
       # @return [Html2rss::Config] the configuration object.
-      def from_hash(config, params: UNSET)
+      def from_hash(config, params: {})
         new(resolve_effective_config(config, params:))
       end
 
@@ -214,6 +161,20 @@ module Html2rss
         Html2rss.defaults.default_strategy || :auto
       end
 
+      ##
+      # Normalizes raw config input with defaults.
+      #
+      # @param config [Hash{Symbol => Object}] raw config input
+      # @return [Hash{Symbol => Object}] config with defaults applied
+      def prepare_defaults(config)
+        config = HashUtil.deep_merge(default_config, config)
+        config = HashUtil.deep_merge({ selectors: Selectors::DEFAULT_CONFIG }, config) if config[:selectors]
+        if config[:auto_source]
+          config = HashUtil.deep_merge({ auto_source: Html2rss::AutoSource::DEFAULT_CONFIG }, config)
+        end
+        config
+      end
+
       private
 
       def default_request_config
@@ -227,7 +188,7 @@ module Html2rss
       def resolve_effective_config(config, params:)
         cfg = HashUtil.deep_symbolize_keys(config, context: 'config')
         p = parameter_defaults(cfg)
-        p.merge!(HashUtil.deep_symbolize_keys(params, context: 'params')) unless params.equal?(UNSET) || params.nil?
+        p.merge!(HashUtil.deep_symbolize_keys(params, context: 'params')) unless params.nil?
 
         cfg[:headers] = DynamicParams.call(cfg[:headers], p) if cfg[:headers]
         cfg[:channel] = DynamicParams.call(cfg[:channel], p) if cfg[:channel]
@@ -243,7 +204,7 @@ module Html2rss
       end
 
       def prepare_for_validation(config)
-        Config::Preparer.new.call(HashUtil.deep_dup(config))
+        prepare_defaults(HashUtil.deep_dup(config))
       end
 
       # @param config_input [Hash, String]
@@ -270,7 +231,7 @@ module Html2rss
     # @raise [InvalidConfig] if the configuration fails validation.
     def initialize(config)
       @request_controls = RequestControls.from_config(config)
-      prepared_config = Preparer.new.call(config)
+      prepared_config = self.class.prepare_defaults(config.dup)
       validated_config = validated_config_for(prepared_config)
 
       @config = validated_config.freeze
@@ -328,42 +289,15 @@ module Html2rss
 
     attr_reader :config
 
-    # Normalizes raw config input before validation.
-    class Preparer
-      ##
-      # @param config [Hash{Symbol => Object}] raw config input
-      # @return [Hash{Symbol => Object}] config with defaults applied
-      def call(config)
-        config = config.dup if config.frozen?
-
-        config = apply_default_config(config)
-        config = apply_default_selectors_config(config) if config[:selectors]
-        config = apply_default_auto_source_config(config) if config[:auto_source]
-
-        config
-      end
-
-      private
-
-      def apply_default_config(config)
-        HashUtil.deep_merge(Config.default_config, config)
-      end
-
-      def apply_default_selectors_config(config)
-        HashUtil.deep_merge({ selectors: Selectors::DEFAULT_CONFIG }, config)
-      end
-
-      def apply_default_auto_source_config(config)
-        HashUtil.deep_merge({ auto_source: Html2rss::AutoSource::DEFAULT_CONFIG }, config)
-      end
-    end
-
     def validated_config_for(config)
-      validator = Validator.new.call(config)
+      dry = Validator.new.call(config)
 
-      raise InvalidConfig, "Invalid configuration: #{validator.errors.to_h}" unless validator.success?
+      unless dry.success?
+        report = IssueMapper.from(dry, values: config)
+        raise InvalidConfig, "Invalid configuration: #{report}"
+      end
 
-      normalized_headers(validator.to_h)
+      normalized_headers(dry.to_h)
     end
 
     def normalized_headers(validated_config)

data/lib/html2rss/defaults.rb

@@ -4,13 +4,20 @@ module Html2rss
   ##
   # Global defaults for the Html2rss gem.
   class Defaults
-    # The valid symbol log levels.
-    VALID_LOG_LEVELS = %i[debug info warn error fatal unknown].freeze
-
-    # @return [Object] the logger
+    # Named Logger severities accepted by {#log_level=}.
+    LOG_LEVELS = {
+      debug: Logger::DEBUG,
+      info: Logger::INFO,
+      warn: Logger::WARN,
+      error: Logger::ERROR,
+      fatal: Logger::FATAL,
+      unknown: Logger::UNKNOWN
+    }.freeze
+
+    # @return [Logger] the logger
     attr_reader :logger
 
-    # @return [Proc, nil] the logger formatter
+    # @return [Proc, Logger::Formatter, nil] the logger formatter
     attr_reader :logger_formatter
 
     # @return [Symbol, Integer] the current log level
@@ -46,12 +53,15 @@ module Html2rss
     ##
     # Sets the logger.
     #
-    # @param logger [Object]
-    # @return [Object] the logger
+    # @param logger [Logger]
+    # @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)
+
       @logger = logger
-      @logger.level = @log_level if @logger.respond_to?(:level=)
-      @logger.formatter = @logger_formatter if @logger_formatter && @logger.respond_to?(:formatter=)
+      @logger.level = @log_level
+      @logger.formatter = @logger_formatter if @logger_formatter
     end
 
     ##
@@ -62,34 +72,39 @@ module Html2rss
     # @raise [ArgumentError] if the log level is invalid
     def log_level=(level)
       @log_level = normalize_log_level(level)
-      @logger.level = @log_level if @logger.respond_to?(:level=)
+      @logger.level = @log_level
     end
 
     ##
     # Sets the logger formatter.
     #
-    # @param formatter [Proc, #call, nil] the new logger formatter
-    # @return [Proc, #call, nil] the new logger formatter
-    # @raise [ArgumentError] if formatter does not respond to #call
+    # @param formatter [Proc, Logger::Formatter, nil] the new logger formatter
+    # @return [Proc, Logger::Formatter, nil] the new logger formatter
+    # @raise [ArgumentError] if formatter is not a Proc, Logger::Formatter, or nil
     def logger_formatter=(formatter)
-      raise ArgumentError, 'formatter must respond to #call or be nil' if formatter && !formatter.respond_to?(:call)
-
-      @logger_formatter = formatter
-      @logger.formatter = @logger_formatter if @logger.respond_to?(:formatter=)
+      @logger_formatter = case formatter
+                          when nil, Proc, Logger::Formatter
+                            formatter
+                          else
+                            raise ArgumentError, 'formatter must be a Proc, Logger::Formatter, or nil'
+                          end
+      @logger.formatter = @logger_formatter
     end
 
     ##
     # Sets the global request headers.
     #
-    # @param headers [Hash, Proc, #call, nil] the HTTP request headers to globally apply
-    # @return [Hash, Proc, #call, nil] the assigned headers
-    # @raise [ArgumentError] if headers is not a Hash or callable
+    # @param headers [Hash, Proc, nil] the HTTP request headers to globally apply
+    # @return [Hash, Proc, nil] the assigned headers
+    # @raise [ArgumentError] if headers is not a Hash, Proc, or nil
     def headers=(headers)
-      if headers && !headers.is_a?(Hash) && !headers.respond_to?(:call)
-        raise ArgumentError, 'headers must be a Hash or respond to #call'
-      end
-
-      @headers = headers.is_a?(Hash) ? headers.dup.freeze : headers
+      @headers = case headers
+                 when nil then nil
+                 when Hash then headers.dup.freeze
+                 when Proc then headers
+                 else
+                   raise ArgumentError, 'headers must be a Hash or Proc'
+                 end
     end
 
     ##
@@ -164,14 +179,11 @@ module Html2rss
 
     def normalize_log_level(level)
       if level.is_a?(Integer)
-        raise ArgumentError, "invalid log level: #{level}" unless level.between?(0, 5)
+        raise ArgumentError, "invalid log level: #{level}" unless LOG_LEVELS.value?(level)
 
         level
       else
-        sym = level.to_s.downcase.to_sym
-        raise ArgumentError, "invalid log level: #{level}" unless VALID_LOG_LEVELS.include?(sym)
-
-        Logger.const_get(sym.upcase)
+        LOG_LEVELS.fetch(level.to_s.downcase.to_sym) { raise ArgumentError, "invalid log level: #{level}" }
       end
     end
   end

data/lib/html2rss/doctor/botasaurus.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'faraday'
+require 'httpx'
 require 'json'
 
 module Html2rss
-  ##
-  # CLI runtime health checks for optional scrape dependencies.
   module Doctor
     ##
     # Preflight checks for Botasaurus scrape-api connectivity.
     module Botasaurus
+      Check = Data.define(:name, :ok, :detail)
+
       ##
       # One named doctor check outcome.
-      Check = Data.define(:name, :ok, :detail) do
+      class Check
         ##
         # @return [Hash{Symbol => Object}]
         def to_h
@@ -20,9 +20,11 @@ module Html2rss
         end
       end
 
+      Result = Data.define(:ok, :checks, :message)
+
       ##
       # Aggregate doctor command outcome.
-      Result = Data.define(:ok, :checks, :message) do
+      class Result
         ##
         # @return [Hash{Symbol => Object}]
         def to_h
@@ -68,15 +70,23 @@ module Html2rss
       # @param base_url [String]
       # @return [Hash{Symbol => Object}]
       def health_check(base_url)
-        uri = Url.for_channel(base_url)
-        client = Faraday.new(url: uri.to_s.chomp('/'), request: { timeout: 5 })
-        response = client.get('/health')
-        body = JSON.parse(response.body)
+        endpoint = "#{Url.for_channel(base_url).to_s.chomp('/')}/health"
+        response = health_session.get(endpoint)
+        raise response.error if response.is_a?(HTTPX::ErrorResponse)
+
+        body = JSON.parse(response.body.to_s)
         { ok: response.status == 200, status: response.status, version: body['version'] }
       rescue StandardError => error
         { ok: false, error: "#{error.class}: #{error.message}" }
       end
 
+      def 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}]

data/lib/html2rss/doctor.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ##
+  # CLI runtime health checks for optional scrape dependencies.
+  module Doctor
+  end
+end

data/lib/html2rss/error.rb

@@ -7,7 +7,7 @@ module Html2rss
   # Raised when auto fallback exhausts all concrete tiers and extractors find no feed items.
   class NoFeedItemsExtracted < Error
     # Categories that append shared surface guidance to the empty-feed message.
-    SURFACE_HINT_CATEGORIES = %i[app_shell blocked_surface high_entropy_surface].freeze
+    SURFACE_HINT_CATEGORIES = Set[:app_shell, :blocked_surface, :high_entropy_surface].freeze
 
     ##
     # @param attempts [Array<Hash{Symbol => Object}>] tier attempt diagnostics

data/lib/html2rss/feed_builder/rss.rb

@@ -34,16 +34,10 @@ module Html2rss
         private
 
         def add_item_string_values(article, item_maker)
-          {
-            title: article.title,
-            description: ItemPresentation.description_for(article),
-            author: article.author
-          }.each do |attr, value|
-            next if value.nil? || value.empty?
-
-            item_maker.public_send(:"#{attr}=", value)
-          end
-
+          item_maker.title = article.title
+          item_maker.author = article.author
+          description = ItemPresentation.description_for(article)
+          item_maker.description = description if description && !description.empty?
           item_maker.link = article.url.to_s if article.url
           item_maker.pubDate = article.published_at&.rfc2822
         end
@@ -96,12 +90,13 @@ module Html2rss
         @stylesheets.map { |style| Stylesheet.new(**style) }
       end
 
-      # rubocop:disable-next Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
       def make_channel(maker)
         channel_maker = maker.channel
-        %i[language title description ttl].each do |key|
-          channel_maker.public_send(:"#{key}=", channel.public_send(key))
-        end
+        channel_maker.language = channel.language
+        channel_maker.title = channel.title
+        channel_maker.description = channel.description
+        channel_maker.ttl = channel.ttl
 
         channel_maker.managingEditor = channel.author if channel.author
         channel_maker.author = channel.author if channel.author

data/lib/html2rss/feed_pipeline/README.md

@@ -2,25 +2,25 @@
 
 `:auto` is the default request plan for feed builds (`auto_source`, `auto_json_feed`, Capture, and MCP `scrape` / `capture`). `FeedPipeline::StrategyPlan` resolves it; `FeedPipeline::AutoFallback` executes `AutoFallback::CHAIN`.
 
-Use `:auto` when you want Faraday first and a browser-backed hop only if that fetch fails or yields zero items. Pin a concrete strategy (`faraday`, `botasaurus`, `local_file`) when you need a single transport.
+Use `:auto` when you want `default` (HTTPX) first and a browser-backed hop only if that fetch fails or yields zero items. Pin a concrete strategy (`default`, `botasaurus`, `local_file`) when you need a single transport.
 
 ## Chain
 
 `AutoFallback::CHAIN` is:
 
-1. **Faraday** — plain HTTP (faster, cheaper).
-2. **Botasaurus** — attempted when Faraday raises a fallback-eligible error (for example `BlockedSurfaceDetected` or timeout) or extracts zero feed items.
+1. **Default (HTTPX)** — plain HTTP (faster, cheaper).
+2. **Botasaurus** — attempted when default raises a fallback-eligible error (for example `BlockedSurfaceDetected` or timeout) or extracts zero feed items.
 
-Before escalating Faraday → Botasaurus on a **weak** auto-source extract (empty / below floor / high-entropy / app-shell / unsupported — not blocked), `FeedResolution` may probe up to five same-origin listing or native-feed candidates and rewrite the effective scrape URL via {ScrapeTarget}. Botasaurus then uses the resolved URL. Direct RSS/Atom entry URLs are parsed via `Syndication::Parser` without HTML AutoSource.
+Before escalating default → Botasaurus on a **weak** auto-source extract (empty / below floor / high-entropy / app-shell / unsupported — not blocked), `FeedResolution` may probe up to five same-origin listing or native-feed candidates and rewrite the effective scrape URL via {ScrapeTarget}. Botasaurus then uses the resolved URL. Direct RSS/Atom entry URLs are parsed via `Syndication::Parser` without HTML AutoSource.
 
-There is no Browserless / Puppeteer-in-gem tier. Pin `botasaurus` when you want browser rendering without Faraday first. Botasaurus needs `BOTASAURUS_SCRAPER_URL`.
+There is no Browserless / Puppeteer-in-gem tier. Pin `botasaurus` when you want browser rendering without default first. Botasaurus needs `BOTASAURUS_SCRAPER_URL`.
 
 ## Surfaces
 
 | Surface                                  | `:auto` behavior                                                                                                                   |
 | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| Gem / CLI `apply`, MCP `scrape`, Capture | Full AutoFallback chain (`faraday` → `botasaurus`)                                                                                 |
-| MCP `inspect`                            | Cheap diagnostic: `StrategyPlan.concrete_for_diagnostic` maps `auto` to Faraday (pin `botasaurus` when you need browser rendering) |
+| Gem / CLI `apply`, MCP `scrape`, Capture | Full AutoFallback chain (`default` → `botasaurus`)                                                                                 |
+| MCP `inspect`                            | Cheap diagnostic: `StrategyPlan.concrete_for_diagnostic` maps `auto` to default (pin `botasaurus` when you need browser rendering) |
 
 ## Fallback vs abort
 
@@ -28,7 +28,7 @@ These typically hop to the next chain member (among other `StandardError`s `Auto
 
 - `Html2rss::RequestService::BlockedSurfaceDetected`
 - `Html2rss::RequestService::RequestTimedOut`
-- Faraday connection / timeout errors
+- HTTPX connection / timeout errors
 - Empty extraction results when a later chain member may succeed
 
 These abort immediately (`AutoFallback::NON_FALLBACK_ERRORS`): unknown strategy, invalid URL, unsupported scheme, budget exceeded, private network denied, cross-origin follow-up denied, response too large.

data/lib/html2rss/feed_pipeline/auto_fallback.rb

@@ -8,7 +8,7 @@ module Html2rss
     # Hosted by the pipeline instance: session + extract call back into FeedPipeline.
     class AutoFallback # rubocop:disable Metrics/ClassLength -- attempt state + logging stay co-located
       # Ordered list of concrete request strategies attempted by the :auto plan.
-      CHAIN = %i[faraday botasaurus].freeze
+      CHAIN = %i[default botasaurus].freeze
 
       # Deterministic HTTP statuses that indicate permanent failure rather than anti-bot challenges.
       DETERMINISTIC_HTTP_STATUSES = Set[400, 404, 410, 422, 451].freeze

data/lib/html2rss/feed_pipeline/runtime_policy.rb

@@ -45,6 +45,20 @@ module Html2rss
       # @return [Html2rss::RequestService::Budget] shared budget for the feed build
       def self.budget_for(config) = resources_for(config).budget
 
+      ##
+      # Reserve enough HTTP request slots for the initial request plus predictable
+      # follow-ups.
+      #
+      # @param config [Html2rss::Config] validated feed config
+      # @return [Integer] number of reserved baseline request slots
+      def self.baseline_request_budget_for(config)
+        1 +
+          RequestSession::Pager.request_slots_for(config.selectors&.dig(:items, :pagination)) +
+          AutoSource.request_slots_for(config.auto_source) +
+          FeedResolution.request_slots_for(config.auto_source) +
+          StrategyPlan.resolve(config.strategy).request_slots
+      end
+
       class << self
         private
 
@@ -53,16 +67,6 @@ module Html2rss
 
           [baseline_request_budget_for(config), config.max_requests].max
         end
-
-        # Reserve enough HTTP request slots for the initial request plus predictable
-        # follow-ups.
-        def baseline_request_budget_for(config)
-          1 +
-            RequestSession::Pager.request_slots_for(config.selectors&.dig(:items, :pagination)) +
-            AutoSource.request_slots_for(config.auto_source) +
-            FeedResolution.request_slots_for(config.auto_source) +
-            StrategyPlan.resolve(config.strategy).request_slots
-        end
       end
     end
   end

data/lib/html2rss/feed_pipeline/strategy_plan.rb

@@ -8,16 +8,20 @@ module Html2rss
     # {RequestService} executes concrete adapters only. +:auto+ is resolved here before
     # any session or adapter call — plan vs transport locality.
     class StrategyPlan
+      Auto = Data.define
+
       # Feed-level auto plan: try {AutoFallback::CHAIN} until items are extracted.
-      Auto = Data.define do
+      class Auto
         # @return [Integer]
         def request_slots
           [AutoFallback::CHAIN.size - 1, 0].max
         end
       end
 
+      Concrete = Data.define(:strategy)
+
       # Concrete transport strategy name for {RequestService}.
-      Concrete = Data.define(:strategy) do
+      class Concrete
         # @return [Integer]
         def request_slots = 0
       end
@@ -42,7 +46,7 @@ module Html2rss
         end
 
         ##
-        # Cheap single-request diagnostic default: +:auto+ → +:faraday+.
+        # Cheap single-request diagnostic default: +:auto+ → +:default+.
         # Does not run {AutoFallback}. Prefer {resolve} for scrape/capture feeds.
         #
         # @param name [Symbol, String, nil] plan name (+nil+ → +:auto+)

data/lib/html2rss/feed_resolution/candidate_generator.rb

@@ -99,11 +99,8 @@ module Html2rss
 
       def segment_urls_for(sst, strategy, link_resolver)
         segmenter = AutoSource::Segmenter.new(sst, base_url: entry_url, strategy:, link_resolver:)
-        primary = AutoSource::Segmenter::PrimaryLink.new(segmenter)
-
         segmenter.call.filter_map do |segment|
-          link = segment.primary_link || primary.select(segment.root_node)
-          absolute_same_origin(link&.attrs&.href)
+          absolute_same_origin(segment.primary_link&.attrs&.href)
         end.uniq
       end
 

data/lib/html2rss/feed_resolution/diag.rb

@@ -2,9 +2,11 @@
 
 module Html2rss
   module FeedResolution
+    Diag = Data.define(:applied, :probe_count, :reason, :winner_score)
+
     ##
     # Wire-safe diagnostics for one entry-resolution attempt (Status / Marshal edge).
-    Diag = Data.define(:applied, :probe_count, :reason, :winner_score) do
+    class Diag
       ##
       # @param result [Html2rss::FeedResolution::Result]
       # @return [Diag]

data/lib/html2rss/feed_resolution/options.rb

@@ -2,9 +2,11 @@
 
 module Html2rss
   module FeedResolution
+    Options = Data.define(:enabled, :max_probes)
+
     ##
     # Typed +auto_source.entry_resolution+ options (one expansion from config Hash).
-    Options = Data.define(:enabled, :max_probes) do
+    class Options
       ##
       # @param auto_source [Hash, nil]
       # @return [Options]

data/lib/html2rss/feed_resolution/policy.rb

@@ -13,13 +13,13 @@ module Html2rss
       ##
       # @param config [Html2rss::Config]
       # @param articles [Array<Html2rss::Article>] typed extract results (count derived)
-      # @param surface_category [Html2rss::SurfaceCategory, Symbol, nil]
+      # @param surface_category [Html2rss::SurfaceCategory, Symbol]
       # @return [Boolean]
       def resolve?(config:, articles:, surface_category:)
         raise ArgumentError, 'articles must be an Array' unless articles.is_a?(Array)
         return false unless eligible_config?(config)
 
-        category = SurfaceCategory.coerce(surface_category)
+        category = SurfaceCategory[surface_category]
         return false if category.blocked?
 
         articles.size < ARTICLE_FLOOR || category.weak? || native_feed_majority?(articles)

data/lib/html2rss/html/article_extractor/date_extractor.rb

@@ -10,7 +10,7 @@ module Html2rss
         # @param time_zone [String] channel time zone for naive values
         # @return [DateTime, nil]
         def self.call(article_tag, leftover_lines: [], time_zone: 'UTC')
-          datetimes = article_tag.respond_to?(:css) ? article_tag.css('[datetime]').map { |tag| tag['datetime'] } : []
+          datetimes = article_tag.css('[datetime]').map { |tag| tag['datetime'] }
           ArticleRules::Date.earliest(datetimes, leftover_lines:, time_zone:)
         end
       end

data/lib/html2rss/html/article_extractor.rb

@@ -124,8 +124,7 @@ module Html2rss
       end
 
       def leftover_exclude_nodes_for(node)
-        times = node.respond_to?(:css) ? node.css('time') : []
-        [heading, selected_anchor, kicker_node, *times].compact
+        [heading, selected_anchor, kicker_node, *node.css('time')].compact
       end
 
       def heading_or_anchor_item?
@@ -156,8 +155,7 @@ module Html2rss
       end
 
       def immediate_card_parent
-        parent = article_tag.respond_to?(:parent) ? article_tag.parent : nil
-        Navigator.parent_until_condition(parent, method(:usable_walk_parent?))
+        Navigator.parent_until_condition(article_tag.parent, ->(node) { usable_walk_parent?(node) })
       end
 
       def usable_walk_parent?(node)