html2rss 0.29.1 → 0.31.0

data/lib/html2rss/test.rb

@@ -12,27 +12,14 @@ module Html2rss
     ##
     # Closed failure classification for a failed test run.
     class FailureKind
-      # Closed set of test failure wire names.
-      NAMES = Set[:schema, :execution, :min_items, :quality].freeze
-
-      class << self
-        ##
-        # @param value [FailureKind, Symbol, String]
-        # @return [FailureKind]
-        def coerce(value)
-          return value if value.is_a?(self)
-
-          new(name: value.to_sym)
-        end
-      end
+      # Frozen name → instance table.
+      ALL = %i[schema execution min_items quality].to_h { |name| [name, new(name:)] }.freeze
+      private_class_method :new
 
       ##
-      # @param name [Symbol]
-      def initialize(name:)
-        raise ArgumentError, "unknown failure kind: #{name.inspect}" unless NAMES.include?(name)
-
-        super
-      end
+      # @param name [Symbol, String]
+      # @return [FailureKind]
+      def self.[](name) = ALL.fetch(name.to_sym) { raise ArgumentError, "unknown failure kind: #{name.inspect}" }
 
       ##
       # @return [Boolean]
@@ -59,19 +46,11 @@ module Html2rss
       def to_s = name.to_s
     end
 
+    QualityReport = Data.define(:warnings, :metrics, :native_feed, :defer_reason)
+
     ##
     # Ship-quality audit summary for a configuration test (warn-only).
-    QualityReport = Data.define(:warnings, :metrics, :native_feed, :defer_reason) do
-      ##
-      # @return [Hash{Symbol => Object}]
-      def to_h
-        {
-          warnings: warnings.map(&:to_s),
-          metrics:,
-          **(native_feed ? { native_feed:, defer_reason: defer_reason.to_s } : {})
-        }.compact
-      end
-
+    class QualityReport
       ##
       # @param audit [Html2rss::AutoSource::Cleanup::AuditResult]
       # @param native_feed [String, nil]
@@ -85,11 +64,18 @@ module Html2rss
         end
         new(warnings: report_warnings.freeze, metrics: audit.metrics, native_feed:, defer_reason:)
       end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def to_h
+        {
+          warnings: warnings.map(&:to_s),
+          metrics:,
+          **(native_feed ? { native_feed:, defer_reason: defer_reason.to_s } : {})
+        }.compact
+      end
     end
 
-    ##
-    # Immutable outcome of a configuration test. Success carries +rss+ XML from the
-    # first live extraction; failures carry a typed {FailureKind}.
     Result = Data.define(
       :success,
       :item_count,
@@ -98,13 +84,20 @@ module Html2rss
       :channel_url,
       :strategy_used,
       :duration_seconds,
-      :validation_errors,
+      :validation_issues,
       :error_message,
       :failure_kind,
       :rss,
       :quality_report,
-      :enhance_compare
-    ) do
+      :enhance_compare,
+      :response_body
+    )
+
+    ##
+    # Immutable outcome of a configuration test. Success carries +rss+ XML from the
+    # first live extraction; failures carry a typed {FailureKind}.
+    # +response_body+ is a copy of the fetched page for in-process readers and stays off {#to_h}.
+    class Result
       ##
       # @param success [Boolean]
       # @param item_count [Integer]
@@ -113,22 +106,23 @@ module Html2rss
       # @param channel_url [String, nil]
       # @param strategy_used [Symbol, nil]
       # @param duration_seconds [Float]
-      # @param validation_errors [Hash, nil]
+      # @param validation_issues [Array<Html2rss::Config::ValidationIssue>, nil]
       # @param error_message [String, nil]
       # @param failure_kind [FailureKind, nil]
       # @param rss [String, nil]
       # @param quality_report [QualityReport, nil]
       # @param enhance_compare [Hash, nil]
+      # @param response_body [String, nil] fetched page HTML copied from the pipeline response
       def initialize(success:, item_count:, sample_items:, channel_title:, channel_url:, # rubocop:disable Metrics/ParameterLists
-                     strategy_used:, duration_seconds:, validation_errors:, error_message:,
-                     failure_kind:, rss:, quality_report: nil, enhance_compare: nil)
+                     strategy_used:, duration_seconds:, validation_issues:, error_message:,
+                     failure_kind:, rss:, quality_report: nil, enhance_compare: nil, response_body: nil)
         super
       end
 
       ##
       # @return [Boolean] whether the schema validation succeeded
       def valid_schema?
-        validation_errors.nil? || validation_errors.empty?
+        validation_issues.nil? || validation_issues.empty?
       end
 
       ##
@@ -138,8 +132,8 @@ module Html2rss
       end
 
       ##
-      # @return [Hash{Symbol => Object}] hash representation
-      def to_h # rubocop:disable Metrics/MethodLength
+      # @return [Hash{Symbol => Object}] public test hash; +response_body+ stays off this wire
+      def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- wire serialization omits response_body
         {
           success:,
           item_count:,
@@ -148,7 +142,7 @@ module Html2rss
           channel_url:,
           strategy_used:,
           duration_seconds:,
-          validation_errors:,
+          validation_issues: validation_issues&.map(&:to_h),
           error_message:,
           failure_kind: failure_kind&.to_sym,
           rss:,
@@ -169,92 +163,113 @@ 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, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def 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.errors.to_h, raw_config) unless validation.success?
+      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
+      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+      execution_failure_result(error, raw_config, duration)
+    end
+
+    def 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)
+      quality_report_for(
+        feed_result.to_rss.items,
+        channel_url: raw_config.dig(:channel, :url).to_s,
+        config:,
+        feed_result:,
+        pipeline_outcome:
+      )
+    end
+    private_class_method :compile_quality_report
 
-      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      begin
-        feed_result, pipeline_outcome = extract_feed(raw_config)
-        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
-
-        rss_doc = feed_result.to_rss
-        rss_xml = rss_doc.to_s
-        item_count = rss_doc.items.size
-        sample_items = extract_samples(rss_doc.items)
-        quality_report = quality_report_for(
-          rss_doc.items,
-          channel_url: raw_config.dig(:channel, :url).to_s,
-          raw_config:,
-          feed_result:,
-          pipeline_outcome:
-        )
-        enhance_compare = build_enhance_compare(raw_config, pipeline_outcome) if compare_enhance
-
-        channel_title = feed_result.channel_title
-        channel_url = raw_config.dig(:channel, :url).to_s
-        strategy_used = feed_result.status.selected_strategy || raw_config[:strategy] || :faraday
-        min_items_passed = item_count >= min_items
-        quality_failed = strict_quality && min_items_passed && quality_failure?(quality_report)
-        passed = min_items_passed && !quality_failed
-        failure_kind, error_message = outcome_failure(min_items_passed:, quality_failed:, item_count:, min_items:,
-                                                      quality_report:)
-
-        log_strict_quality_failure(failure_kind, item_count) if quality_failed
-
-        Result.new(
-          success: passed,
-          item_count:,
-          sample_items:,
-          channel_title:,
-          channel_url:,
-          strategy_used:,
-          duration_seconds: duration.round(3),
-          validation_errors: nil,
-          error_message:,
-          failure_kind:,
-          rss: passed ? rss_xml : nil,
-          quality_report:,
-          enhance_compare:
-        )
-      rescue StandardError => error
-        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
-        execution_failure_result(error, raw_config, duration)
-      end
+    def 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)
+    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:)
+      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] ||
+                      RequestService.default_strategy_name
+
+      Result.new(
+        success: outcome.passed,
+        item_count: rss_doc.items.size,
+        sample_items: extract_samples(rss_doc.items),
+        channel_title: feed_result.channel_title,
+        channel_url: raw_config.dig(:channel, :url).to_s,
+        strategy_used:,
+        duration_seconds: duration.round(3),
+        validation_issues: nil,
+        error_message: outcome.error_message,
+        failure_kind: outcome.failure_kind,
+        rss: outcome.passed ? rss_doc.to_s : nil,
+        quality_report:,
+        enhance_compare:,
+        response_body:
+      )
     end
+    private_class_method :build_test_result
 
     def extract_samples(items, limit: 3)
       items.first(limit).map do |item|
+        article = feed_item_as_article(item)
         {
-          title: item.title.to_s.strip,
-          url: (item.respond_to?(:link) ? item.link : item.url).to_s,
-          published_at: (item.respond_to?(:pubDate) ? item.pubDate : item.published_at)
+          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).
     #
     # @param items [Array]
     # @param channel_url [String]
-    # @param raw_config [Hash]
+    # @param config [Html2rss::Config]
     # @param feed_result [Html2rss::FeedResult]
     # @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:, raw_config:, feed_result:, pipeline_outcome:, # rubocop:disable Metrics/ParameterLists
+    def 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, raw_config)&.to_s : nil
+      native_feed = probe_native_feed ? probe_native_feed_url(channel_url, config)&.to_s : nil
       report = QualityReport.from_audit(audit, native_feed:)
       report = append_url_mismatch_warning(report, channel_url, feed_result)
-      merge_enhance_audit(report, raw_config, pipeline_outcome)
+      merge_enhance_audit(report, config, pipeline_outcome)
     end
 
     def extract_feed(raw_config)
@@ -263,18 +278,15 @@ module Html2rss
     end
     private_class_method :extract_feed
 
-    def enhance_enabled?(raw_config)
-      config = Config.from_hash(raw_config)
+    def enhance_enabled?(config)
       return false unless config.selectors
 
       !!config.selectors.dig(:items, :enhance)
     end
     private_class_method :enhance_enabled?
 
-    def build_enhance_compare(raw_config, pipeline_outcome)
+    def build_enhance_compare(config, pipeline_outcome)
       return nil unless pipeline_outcome
-
-      config = Config.from_hash(raw_config)
       return nil unless config.selectors
 
       EnhanceAudit.compare(
@@ -285,10 +297,8 @@ module Html2rss
     end
     private_class_method :build_enhance_compare
 
-    def merge_enhance_audit(report, raw_config, pipeline_outcome) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- warning merge + metrics
-      return report unless pipeline_outcome && enhance_enabled?(raw_config)
-
-      config = Config.from_hash(raw_config)
+    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
 
       slice = EnhanceAudit.probe(
@@ -349,67 +359,11 @@ module Html2rss
     end
     private_class_method :url_mismatch?
 
-    def quality_failure?(quality_report)
-      metrics = quality_report.metrics
-      item_count = metrics[:item_count]
-      return false if item_count.zero?
-
-      duplicate_urls_failure?(metrics) || junk_title_ratio_failure?(metrics) || short_title_failure?(metrics)
-    end
-    private_class_method :quality_failure?
-
-    def 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)
-      metrics[:junk_title_count] > (metrics[:item_count] / 2.0)
-    end
-    private_class_method :junk_title_ratio_failure?
-
-    def short_title_failure?(metrics)
-      metrics[:short_title_count].positive?
-    end
-    private_class_method :short_title_failure?
-
-    def 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.coerce(:min_items),
-                "Extracted #{item_count} items (minimum required: #{min_items})"]
-      end
-
-      [FailureKind.coerce(:quality), quality_failure_message(quality_report)]
-    end
-    private_class_method :outcome_failure
-
-    def 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)
-      reasons = []
-      reasons << 'duplicate_urls' if duplicate_urls_failure?(metrics)
-      reasons << 'generic_titles' if junk_title_ratio_failure?(metrics)
-      reasons << 'short_titles' if short_title_failure?(metrics)
-      reasons
-    end
-    private_class_method :quality_failure_reasons
-
-    def 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
-
-    def probe_native_feed_url(channel_url, raw_config)
+    def probe_native_feed_url(channel_url, config)
       return nil if channel_url.to_s.empty?
 
-      config = Config.from_hash(raw_config)
       resources = FeedPipeline::RuntimePolicy.resources_for(config)
-      strategy = FeedPipeline::StrategyPlan.concrete_for_diagnostic(raw_config[:strategy])
+      strategy = FeedPipeline::StrategyPlan.concrete_for_diagnostic(config.strategy)
       session = RequestSession.build(
         config:, strategy:, budget: resources.budget, policy: resources.policy
       )
@@ -419,7 +373,7 @@ module Html2rss
     end
     private_class_method :probe_native_feed_url
 
-    def validation_failure_result(errors, raw_config) # rubocop:disable Metrics/MethodLength
+    def validation_failure_result(report, raw_config) # rubocop:disable Metrics/MethodLength
       Result.new(
         success: false,
         item_count: 0,
@@ -428,9 +382,9 @@ module Html2rss
         channel_url: raw_config.dig(:channel, :url),
         strategy_used: raw_config[:strategy],
         duration_seconds: 0.0,
-        validation_errors: errors,
+        validation_issues: report.issues,
         error_message: 'Configuration schema validation failed',
-        failure_kind: FailureKind.coerce(:schema),
+        failure_kind: FailureKind[:schema],
         rss: nil,
         quality_report: nil
       )
@@ -446,9 +400,9 @@ module Html2rss
         channel_url: raw_config.dig(:channel, :url),
         strategy_used: raw_config[:strategy],
         duration_seconds: duration.round(3),
-        validation_errors: nil,
+        validation_issues: nil,
         error_message: "#{error.class}: #{error.message}",
-        failure_kind: FailureKind.coerce(:execution),
+        failure_kind: FailureKind[:execution],
         rss: nil,
         quality_report: nil
       )

data/lib/html2rss/url.rb

@@ -42,14 +42,21 @@ module Html2rss
       url = Addressable::URI.parse(relative_url.to_s.strip)
       return new(url) if url.absolute?
 
-      base_uri = Addressable::URI.parse(base_url.to_s)
-      base_uri.path = '/' if base_uri.path.empty?
-
-      new(base_uri.join(url).normalize)
+      base_url.is_a?(self) ? base_url.join_uri(url) : join_parsed_base(base_url, url)
     rescue Addressable::URI::InvalidURIError
       raise ArgumentError, 'URL could not be parsed'
     end
 
+    # @param base_url [String]
+    # @param url [Addressable::URI]
+    # @return [Url]
+    def self.join_parsed_base(base_url, url)
+      uri = Addressable::URI.parse(base_url.to_s)
+      uri.path = '/' if uri.path.empty?
+      new(uri.join(url).normalize)
+    end
+    private_class_method :join_parsed_base
+
     ##
     # Creates a URL by sanitizing a raw URL string.
     # Removes spaces and extracts the first valid URL from the string.
@@ -305,6 +312,20 @@ module Html2rss
     # @return [String] the debug representation
     def inspect = "#<#{self.class}:#{object_id} @uri=#{@uri.inspect}>"
 
+    ##
+    # Resolves +relative_uri+ against this URL's already-parsed Addressable URI.
+    #
+    # @param relative_uri [Addressable::URI]
+    # @return [Url]
+    def join_uri(relative_uri)
+      base = @uri
+      if base.path.empty?
+        base = base.dup
+        base.path = '/'
+      end
+      self.class.new(base.join(relative_uri).normalize)
+    end
+
     protected
 
     # Scheme, authority, slash-stripped path, and query (fragment omitted).

data/lib/html2rss/version.rb

@@ -2,6 +2,6 @@
 
 module Html2rss
   # Current application version.
-  VERSION = '0.29.1'
+  VERSION = '0.31.0'
   public_constant :VERSION
 end

data/lib/html2rss.rb

@@ -11,20 +11,30 @@ loader.inflector.inflect(
 loader.setup
 
 require 'logger'
-require 'forwardable'
 require 'html2rss/defaults'
 
 ##
 # The Html2rss namespace.
 module Html2rss # rubocop:disable Metrics/ModuleLength
   ##
-  # The logger instance.
+  # Forwards debug/info/warn/error to {Html2rss.logger}.
   module Log
     class << self
-      extend Forwardable
+      ##
+      # @return [true]
+      def debug(...) = Html2rss.logger.debug(...)
 
-      def_delegator 'Html2rss', :logger
-      def_delegators :logger, :debug, :info, :warn, :error, :fatal, :unknown, :level, :level=, :formatter, :formatter=
+      ##
+      # @return [true]
+      def info(...) = Html2rss.logger.info(...)
+
+      ##
+      # @return [true]
+      def warn(...) = Html2rss.logger.warn(...)
+
+      ##
+      # @return [true]
+      def error(...) = Html2rss.logger.error(...)
     end
   end
 
@@ -33,7 +43,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Golden path step 1 (optional); use {.recon} for verdict and native_feed.
   #
   # @param url [String] source page URL
-  # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+  # @param strategy [Symbol] request strategy (:auto, :default, :botasaurus)
   # @param deep [Boolean] when true and strategy is :auto, one Botasaurus hop if configured
   # @return [Html2rss::PageRecon::Diagnostics::Report]
   def self.inspect(url, strategy: :auto, deep: false, **)
@@ -45,7 +55,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Golden path step 2 (optional); adds verdict beyond {.inspect}.
   #
   # @param url [String, Html2rss::Url] source page URL
-  # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+  # @param strategy [Symbol] request strategy (:auto, :default, :botasaurus)
   # @return [Html2rss::Recon::Result]
   def self.recon(url, strategy: :auto, **)
     Recon.call(url, strategy:, **)
@@ -56,7 +66,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Golden path step 3.
   #
   # @param url [String] source page URL
-  # @param strategy [Symbol] request strategy (+:auto+, +:faraday+, +:botasaurus+)
+  # @param strategy [Symbol] request strategy (+:auto+, +:default+, +:botasaurus+)
   # @option options [String, nil] :items_selector optional CSS selector hint for items
   # @option options [Array<String>, nil] :topics optional directory topics override
   # @option options [String, nil] :title optional title override
@@ -79,7 +89,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # @param config_input [Hash, String]
   # @param feed_name [String, nil]
   # @param params [Hash]
-  # @return [Dry::Validation::Result, Html2rss::Config::ValidationResult]
+  # @return [Html2rss::Config::ValidationReport]
   def self.validate(config_input, feed_name = nil, params: {})
     _raw, validation = Config.resolve_and_validate(config_input, feed_name:, params:)
     validation
@@ -140,7 +150,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Scrapes multiple URLs in parallel using auto-source article discovery.
   #
   # @param urls [Enumerable<String>] list of URLs to scrape
-  # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+  # @param strategy [Symbol] request strategy (:auto, :default, :botasaurus)
   # @param limit [Integer] max articles to keep per URL (default: 10)
   # @param concurrency [Integer] max worker threads (default: 5)
   # @return [Html2rss::Batch::BatchResult]
@@ -152,7 +162,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Inspects multiple URLs in parallel with per-URL error isolation.
   #
   # @param urls [Enumerable<String>] list of URLs to inspect
-  # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+  # @param strategy [Symbol] request strategy (:auto, :default, :botasaurus)
   # @param concurrency [Integer] max worker threads (default: 5)
   # @return [Html2rss::Batch::BatchResult]
   def self.batch_inspect(urls, strategy: :auto, concurrency: Batch::DEFAULT_CONCURRENCY)
@@ -163,7 +173,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # Runs recon across multiple URLs in parallel with per-URL error isolation.
   #
   # @param urls [Enumerable<String>] list of URLs to recon
-  # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+  # @param strategy [Symbol] request strategy (:auto, :default, :botasaurus)
   # @param concurrency [Integer] max worker threads (default: 5)
   # @option options [String, nil] :cache_dir optional HTML cache directory
   # @return [Html2rss::Batch::BatchResult]
@@ -179,7 +189,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
   # @param pretty [Boolean] whether to pretty-print JSON
   # @return [String]
   def self.schema_json(pretty: true)
-    Config.json_schema_json(pretty:)
+    Config::Schema.json_schema_json(pretty:)
   end
 
   ##
@@ -319,26 +329,24 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
     end
 
     ##
-    # @return [Object] the logger
+    # @return [Logger] the logger
     def logger
       defaults.logger
     end
 
     ##
-    # @param logger [Object] the new logger
+    # @param logger [Logger] the new logger
     def logger=(logger)
       configure { |config| config.logger = logger }
     end
 
-    private
-
     ##
     # Resets the global defaults (mainly for testing).
     #
     # @return [void]
     def reset_defaults!
       @defaults = nil
-      logger.level = defaults.log_level if logger.respond_to?(:level=)
+      logger.level = defaults.log_level
     end
   end
 
@@ -362,7 +370,7 @@ module Html2rss # rubocop:disable Metrics/ModuleLength
     end
   end
 
-  logger.level = defaults.log_level if logger.respond_to?(:level=)
+  logger.level = defaults.log_level
 end
 
 loader.eager_load

data/lib/tasks/config_schema.rake

@@ -7,10 +7,10 @@ require_relative '../html2rss'
 namespace :config do
   desc 'Generate config JSON schema'
   task :schema do
-    destination = Html2rss::Config.schema_path
+    destination = Html2rss::Config::Schema.path
 
     FileUtils.mkdir_p(File.dirname(destination))
-    File.write(destination, "#{Html2rss::Config.json_schema_json}\n")
+    File.write(destination, "#{Html2rss::Config::Schema.json_schema_json}\n")
 
     puts "Generated config schema at #{destination}"
   end