html2rss 0.28.0 → 0.29.1

data/lib/html2rss/page_recon/README.md

@@ -0,0 +1,69 @@
+# PageRecon — inspect diagnostics
+
+`PageRecon::Diagnostics` powers the **inspect** verb (CLI, MCP, `Html2rss.inspect`). It fetches once via `PageRecon.probe`, classifies the surface, counts cheap AutoSource articles, and reports redirect facts. Full curation contract: `CONTEXT.md` § Frozen contract.
+
+## What inspect reports
+
+| Field              | Meaning                                                                     |
+| ------------------ | --------------------------------------------------------------------------- |
+| `requested_url`    | URL you passed in                                                           |
+| `final_url`        | URL after redirects (may differ from requested)                             |
+| `status`           | HTTP status of the **final** response                                       |
+| `scheme_downgrade` | `true` when HTTPS entry landed on HTTP                                      |
+| `alternate_feeds`  | `rel=alternate` RSS/Atom links found in HTML                                |
+| `surface_category` | AutoSource surface class (`high_entropy_surface`, `unsupported_surface`, …) |
+| `articles_count`   | Cheap AutoSource extract (limit 10) — diagnostic only, not ship quality     |
+| `strategy`         | Concrete transport used (`inspect` maps `auto` → Faraday)                   |
+
+CLI text output omits `requested_url`; it prints the requested URL as the card title. The `Final:` line appears **only when** `final_url` differs from `requested_url`:
+
+```text
+https://apex.example/
+        Final:    https://www.example/ (HTTP 200)
+        Surface:  high_entropy_surface (10 articles)
+```
+
+That `Final:` line means the redirect **did** happen — not that inspect stopped at the apex host.
+
+## Apex → www redirects
+
+Some publishers redirect apex domains to `www` (301). html2rss follows redirects and records the landing URL in `final_url`.
+
+Observed behavior:
+
+```bash
+bin/html2rss inspect https://apex.example
+# Final: https://www.example/ (HTTP 200), high_entropy_surface, articles
+
+bin/html2rss inspect https://www.example
+# high_entropy_surface, articles (no Final: line — requested equals final)
+```
+
+Cross-host redirects (e.g. `apex.example` → `www.example`) no longer pin a stale `Host` header from the entry URL. `Config::RequestHeaders` omits `Host` by default; Faraday/Net::HTTP sets it per hop from the current request URL.
+
+When the first streamed fetch loses the redirect payload (empty body at the final URL), `FaradayStrategy` retries once without streaming so inspect/recon see the same HTML as a direct canonical URL fetch.
+
+### What to do
+
+1. **Prefer the canonical URL** — if you know the site lives on `www`, pass that URL to inspect, recon, capture, and scrape.
+2. **Read the `Final:` line** — when `final_url` differs from what you typed and status is 4xx, retry inspect on `final_url` before assuming the site is unreachable.
+3. **Do not treat apex 403 as “redirect skipped”** — check JSON output (`--format json`) for `requested_url` vs `final_url` when text output is ambiguous.
+4. **Blocked surfaces** — if the canonical URL still fails, try `strategy: botasaurus` on inspect (MCP) or escalate to recon/capture with browser strategy; Faraday-only inspect is intentionally cheap.
+
+## inspect ≠ recon
+
+| Verb    | Adds beyond diagnostics                                              |
+| ------- | -------------------------------------------------------------------- |
+| inspect | Scraper eligibility, XHR hints (Botasaurus), surface + article count |
+| recon   | Verdict (`:build` / `:defer` / `:drop`), native feed preference      |
+
+Follow golden-path `next_step` from MCP envelopes; do not call recon when inspect already answers the question.
+
+## Ownership
+
+| Concern                             | Owner                                                                |
+| ----------------------------------- | -------------------------------------------------------------------- |
+| Diagnostic fetch + assess           | `PageRecon::Diagnostics` → `PageRecon.probe`                         |
+| Surface class + cheap article count | `PageRecon::Assessment`                                              |
+| Redirect follow + terminal retry    | `RequestService::FaradayStrategy`                                    |
+| Outbound header normalization       | `Config::RequestHeaders` (no default `Host`; explicit override only) |

data/lib/html2rss/page_recon/diagnostics.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Html2rss
+  class PageRecon
+    ##
+    # Diagnostic inspect path (not Capture or Recon ownership). Fetches via {.probe},
+    # then adds scraper/XHR diagnostics for curation inspect surfaces.
+    module Diagnostics # rubocop:disable Metrics/ModuleLength -- diagnostic wire fields stay co-located
+      ##
+      # Typed diagnostic report for inspect wire payloads and Outcome policy.
+      Report = Data.define(:data) do
+        ##
+        # @return [Boolean]
+        def alternate_feeds?
+          Array(data[:alternate_feeds]).any?
+        end
+
+        ##
+        # @return [Integer]
+        def articles_count
+          data[:articles_count].to_i
+        end
+
+        ##
+        # @return [Hash{Symbol => Object}]
+        def to_wire_h
+          data
+        end
+      end
+
+      # Minimum HTML body size to treat zero-article weak surfaces as likely JS shells.
+      JS_SHELL_MIN_BODY_BYTES = 8_192
+      private_constant :JS_SHELL_MIN_BODY_BYTES
+
+      module_function
+
+      ##
+      # @param url [String]
+      # @param strategy [String, Symbol]
+      # @param deep [Boolean] when true and strategy is auto, one Botasaurus hop if configured
+      # @return [Report]
+      def call(url:, strategy: :auto, deep: false)
+        probe = PageRecon.probe(url, strategy: resolve_inspect_strategy(strategy, deep:))
+        recon = probe.result
+        response = probe.response
+
+        Report.new(data: build_data(probe, recon, response))
+      end
+
+      ##
+      # Runs diagnostic inspect across URLs with per-URL error isolation.
+      #
+      # @param urls [Enumerable<String>]
+      # @param strategy [Symbol, String]
+      # @param concurrency [Integer]
+      # @return [Array<Report>]
+      def batch(urls:, strategy: :auto, concurrency: Batch::DEFAULT_CONCURRENCY)
+        Batch.map(Array(urls), concurrency:) do |url|
+          call(url:, strategy:)
+        rescue StandardError => error
+          error_report(url, error)
+        end
+      end
+
+      ##
+      # @param response [Html2rss::RequestService::Response]
+      # @return [Hash] redacted XHR capture diagnostics (no query strings)
+      def xhr_capture_info(response)
+        captured = response.captured_responses
+        {
+          count: captured.size,
+          sample_endpoints: captured.first(5).filter_map { |entry| redacted_endpoint(entry) },
+          candidate_articles: captured.any? { |entry| xhr_candidate_articles?(entry) }
+        }
+      end
+
+      ##
+      # @param entry [Hash] captured response hash
+      # @return [String, nil] scheme+host+path only
+      def redacted_endpoint(entry)
+        raw = entry['url'] || entry[:url]
+        return unless raw
+
+        uri = URI.parse(raw.to_s)
+        return unless uri.scheme && uri.host
+
+        "#{uri.scheme}://#{uri.host}#{uri.path}"
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      ##
+      # @param entry [Hash] captured response hash
+      # @return [Boolean]
+      def xhr_candidate_articles?(entry)
+        body = entry['body'] || entry[:body]
+        return false unless body.is_a?(String)
+
+        document = JSON.parse(body, symbolize_names: true)
+        AutoSource::Scraper::JsonState::CandidateDetector.candidate_array?(document)
+      rescue JSON::ParserError
+        false
+      end
+
+      ##
+      # @param parsed [Object] parsed response body
+      # @return [Array<String>, Hash]
+      def scraper_info(parsed)
+        return { error: 'Response is not HTML' } unless parsed.is_a?(Nokogiri::HTML::Document)
+
+        begin
+          Html2rss::AutoSource::Scraper.from(parsed).map(&:name)
+        rescue Html2rss::AutoSource::Scraper::NoScraperFound => error
+          { none_found: error.category.to_s }
+        end
+      end
+
+      def build_data(probe, recon, response)
+        data = recon.to_h.merge(
+          strategy: probe.strategy,
+          scraper_eligibility: scraper_info(safe_parsed_body(response)),
+          html_present: html_present?(recon, response),
+          likely_js_shell: likely_js_shell?(recon, response),
+          redirect_summary: redirect_summary(recon)
+        )
+        data[:xhr_capture] = xhr_capture_info(response) if probe.strategy == :botasaurus
+        log_js_shell(data, response.body&.bytesize.to_i) if data[:likely_js_shell]
+        data
+      end
+      module_function :build_data
+      private_class_method :build_data
+
+      def resolve_inspect_strategy(strategy, deep:)
+        name = (strategy || :auto).to_sym
+        return :botasaurus if deep && name == :auto && MCP::Runtime.botasaurus_configured?
+
+        name
+      end
+      module_function :resolve_inspect_strategy
+      private_class_method :resolve_inspect_strategy
+
+      def html_present?(recon, response)
+        recon.html_response && !response.body.to_s.empty?
+      end
+      module_function :html_present?
+      private_class_method :html_present?
+
+      def likely_js_shell?(recon, response)
+        return false unless html_present?(recon, response)
+        return false if recon.articles_count.positive?
+        return false if recon.blocked_surface || recon.surface_category == :blocked_surface
+
+        return true if recon.surface_category == :app_shell
+
+        response.body.bytesize >= JS_SHELL_MIN_BODY_BYTES &&
+          SurfaceCategory.coerce(recon.surface_category).weak?
+      end
+      module_function :likely_js_shell?
+      private_class_method :likely_js_shell?
+
+      def redirect_summary(recon)
+        {
+          requested_url: recon.requested_url,
+          final_url: recon.final_url,
+          status: recon.status,
+          scheme_downgrade: recon.scheme_downgrade
+        }
+      end
+      module_function :redirect_summary
+      private_class_method :redirect_summary
+
+      def log_js_shell(data, body_bytesize)
+        Log.debug(
+          "Diagnostics js_shell: bytesize=#{body_bytesize} surface_category=#{data[:surface_category]}"
+        )
+      end
+      module_function :log_js_shell
+      private_class_method :log_js_shell
+
+      def safe_parsed_body(response)
+        return unless response.html_response?
+
+        response.parsed_body
+      rescue RequestService::UnsupportedResponseContentType
+        nil
+      end
+      module_function :safe_parsed_body
+      private_class_method :safe_parsed_body
+
+      def error_report(url, error) # rubocop:disable Metrics/MethodLength -- error hash mirrors success report shape
+        Report.new(
+          data: {
+            requested_url: url.to_s,
+            final_url: url.to_s,
+            status: nil,
+            scheme_downgrade: false,
+            alternate_feeds: [],
+            surface_category: :unsupported_surface,
+            articles_count: 0,
+            html_response: false,
+            content_type: nil,
+            strategy: nil,
+            scraper_eligibility: { error: "#{error.class} - #{error.message}" }
+          }
+        )
+      end
+      module_function :error_report
+      private_class_method :error_report
+    end
+  end
+end

data/lib/html2rss/page_recon.rb

@@ -2,10 +2,11 @@
 
 module Html2rss
   ##
-  # Shared page recon for MCP Inspect and FeedResolution probes.
+  # Shared page recon for MCP Inspect, curation Recon, and FeedResolution probes.
   #
   # Owns surface class, native feed hints, segment stats, and a cheap AutoSource
-  # article count — not request strategy selection or MCP next-step policy.
+  # article count. Diagnostic fetch for Inspect/Recon lives on {.probe} — not twin
+  # fetch helpers in those callers.
   class PageRecon # rubocop:disable Metrics/ClassLength -- recon bag stays co-located
     ##
     # Cheap surface + admission facts shared by AutoFallback gates and FeedResolution probes.
@@ -64,6 +65,11 @@ module Html2rss
       end
     end
 
+    ##
+    # Diagnostic fetch + assess bundle. One home for session build + initial GET + {call}.
+    # Consumed by curation {Html2rss::Recon} and {Html2rss::PageRecon::Diagnostics}.
+    Probe = Data.define(:session, :response, :result, :strategy)
+
     ##
     # @param response [Html2rss::RequestService::Response]
     # @param url [String, Html2rss::Url] requested entry URL
@@ -73,6 +79,54 @@ module Html2rss
       new(response:, url:).call
     end
 
+    ##
+    # Builds a request session, fetches the URL once, and runs full page recon.
+    #
+    # @param url [String, Html2rss::Url]
+    # @param strategy [Symbol] request strategy (:auto resolves to a concrete diagnostic strategy)
+    # @option options [Integer, nil] :max_redirects
+    # @option options [Integer, nil] :max_requests
+    # @return [Probe]
+    def self.probe(url, strategy: :auto, **)
+      url_obj = Url.from_absolute(url)
+      resolved = FeedPipeline::StrategyPlan.concrete_for_diagnostic(strategy)
+      session = build_probe_session(url_obj, resolved, **)
+      response = session.fetch_initial_response
+      Probe.new(
+        session:,
+        response:,
+        result: call(response:, url: url_obj, strategy: resolved),
+        strategy: resolved
+      )
+    end
+
+    ##
+    # @param url_obj [Html2rss::Url]
+    # @param strategy [Symbol]
+    # @option options [Integer, nil] :max_redirects
+    # @option options [Integer, nil] :max_requests
+    # @return [Html2rss::RequestSession]
+    def self.build_probe_session(url_obj, strategy, **options) # rubocop:disable Metrics/MethodLength
+      raw_config = Config.auto_source_config(
+        url: url_obj.to_s,
+        request_controls: Config::RequestControls.from_shortcut(
+          strategy:,
+          max_redirects: options[:max_redirects],
+          max_requests: options[:max_requests]
+        )
+      )
+      raw_config[:strategy] = strategy
+      config = Config.from_hash(raw_config)
+      resources = FeedPipeline::RuntimePolicy.resources_for(config)
+      RequestSession.build(
+        config:,
+        strategy: config.strategy,
+        budget: resources.budget,
+        policy: resources.policy
+      )
+    end
+    private_class_method :build_probe_session
+
     ##
     # Cheap page assessment for policy gates and probe scoring (fixed AutoSource limit).
     #

data/lib/html2rss/recon.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'uri'
+require 'fileutils'
+
+module Html2rss
+  ##
+  # Service that runs reconnaissance on a URL to discover redirect chains,
+  # native RSS/Atom feeds, surface categorization, and emit an actionable verdict.
+  module Recon # rubocop:disable Metrics/ModuleLength
+    module_function
+
+    Verdict = Data.define(:name)
+
+    ##
+    # Closed curation verdict (:build / :defer / :drop).
+    class Verdict
+      # Closed set of curation verdict wire names.
+      NAMES = Set[:build, :defer, :drop].freeze
+
+      class << self
+        ##
+        # @param value [Verdict, Symbol, String]
+        # @return [Verdict]
+        def coerce(value)
+          return value if value.is_a?(self)
+
+          new(name: value.to_sym)
+        end
+      end
+
+      ##
+      # @param name [Symbol]
+      def initialize(name:)
+        raise ArgumentError, "unknown verdict: #{name.inspect}" unless NAMES.include?(name)
+
+        super
+      end
+
+      ##
+      # @return [Boolean]
+      def build? = name == :build
+
+      ##
+      # @return [Boolean]
+      def defer? = name == :defer
+
+      ##
+      # @return [Boolean]
+      def drop? = name == :drop
+
+      ##
+      # @return [Symbol]
+      def to_sym = name
+
+      ##
+      # @return [String]
+      def to_s = name.to_s
+    end
+
+    ##
+    # Immutable outcome of a reconnaissance operation.
+    Result = Data.define(
+      :requested_url,
+      :final_url,
+      :status,
+      :verdict,
+      :native_feed,
+      :surface_category,
+      :articles_count,
+      :scheme_downgrade,
+      :notes,
+      :html_bytesize
+    ) do
+      ##
+      # @return [Boolean]
+      def build? = verdict.build?
+
+      ##
+      # @return [Boolean]
+      def defer? = verdict.defer?
+
+      ##
+      # @return [Boolean]
+      def drop? = verdict.drop?
+
+      ##
+      # @return [Boolean]
+      def native_feed? = !native_feed.nil?
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def to_h # rubocop:disable Metrics/MethodLength
+        {
+          requested_url: requested_url.to_s,
+          final_url: final_url.to_s,
+          status:,
+          verdict: verdict.to_sym,
+          native_feed: native_feed&.to_s,
+          surface_category: surface_category&.to_s,
+          articles_count:,
+          scheme_downgrade:,
+          notes:,
+          html_bytesize:
+        }.compact
+      end
+    end
+
+    ##
+    # Runs reconnaissance on a single URL.
+    #
+    # @param url [String, Html2rss::Url] source page URL
+    # @param strategy [Symbol] request strategy (:auto, :faraday, :botasaurus)
+    # @param cache_dir [String, nil] optional directory to cache raw HTML bodies
+    # @param cache_mutex [Mutex, nil] optional mutex serializing cache writes
+    # @option options [Integer, nil] :max_redirects optional maximum redirects
+    # @option options [Integer, nil] :max_requests optional request budget
+    # @return [Html2rss::Recon::Result]
+    def call(url, strategy: :auto, cache_dir: nil, cache_mutex: nil, **) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      url_obj = Url.from_absolute(url)
+
+      begin
+        probe = PageRecon.probe(url_obj, strategy:, **)
+      rescue StandardError => error
+        return error_result(url_obj, error)
+      end
+
+      cache_html_body(probe.response.body, url_obj, cache_dir, cache_mutex) if cache_dir && probe.response.body
+
+      recon = probe.result
+      native_feed, discovery_note = find_native_feed(url_obj, probe.session, probe.response)
+      notes = build_notes(recon, native_feed, probe.response)
+      notes << discovery_note if discovery_note
+      verdict = determine_verdict(recon, native_feed)
+
+      Result.new(
+        requested_url: url_obj,
+        final_url: probe.response.url,
+        status: probe.response.status,
+        verdict:,
+        native_feed:,
+        surface_category: SurfaceCategory.coerce(recon.surface_category),
+        articles_count: recon.articles_count,
+        scheme_downgrade: recon.scheme_downgrade,
+        notes:,
+        html_bytesize: probe.response.body&.bytesize
+      )
+    end
+
+    ##
+    # Runs batch reconnaissance across an Enumerable of URLs.
+    # Results are returned in input order. Concurrency uses a Thread pool
+    # (not Ractors) for I/O overlap with one loaded gem image.
+    #
+    # @param urls [Enumerable<String>] list of URLs
+    # @param strategy [Symbol] request strategy
+    # @param cache_dir [String, nil] optional directory to cache raw HTML bodies
+    # @param max_threads [Integer] concurrent worker count
+    # @option options [Integer, nil] :max_redirects optional maximum redirects
+    # @option options [Integer, nil] :max_requests optional request budget
+    # @return [Array<Html2rss::Recon::Result>]
+    def batch(urls, strategy: :auto, cache_dir: nil, max_threads: 5, **options)
+      url_list = urls.map { |u| u.to_s.strip }.reject(&:empty?)
+      return [] if url_list.empty?
+
+      FileUtils.mkdir_p(cache_dir) if cache_dir
+      cache_mutex = Mutex.new if cache_dir
+
+      Batch.map(url_list, concurrency: max_threads) do |target_url|
+        call(target_url, strategy:, cache_dir:, cache_mutex:, **options)
+      end
+    end
+
+    ##
+    # @param url_obj [Html2rss::Url]
+    # @param session [Html2rss::RequestSession]
+    # @param response [Html2rss::RequestService::Response]
+    # @return [Array(Html2rss::Url, nil), String, nil)] feed URL and optional discovery error note
+    def find_native_feed(url_obj, session, response)
+      feed = Syndication::Discovery.best_feed_url(
+        page_url: url_obj,
+        request_session: session,
+        parsed_body: (response.parsed_body if response.html_response?),
+        html: response.body
+      )
+      [feed, nil]
+    rescue StandardError => error
+      [nil, "discovery_error=#{error.class}: #{error.message}"]
+    end
+    private_class_method :find_native_feed
+
+    def build_notes(recon, native_feed, response)
+      notes = []
+      notes << "native_rss=#{native_feed}" if native_feed
+      if recon.scheme_downgrade
+        notes << 'scheme_downgrade'
+        notes << 'botasaurus_retry=Try strategy botasaurus once before DROP (HTTPS→HTTP may need JS fetch)'
+      end
+      notes << "blocked=#{recon.blocked_surface}" if recon.blocked_surface
+      notes << "html_bytes=#{response.body&.bytesize}" if response.body
+      notes
+    end
+    private_class_method :build_notes
+
+    def determine_verdict(recon, native_feed)
+      return Verdict.coerce(:drop) if recon.status.nil? || recon.status >= 400 || recon.scheme_downgrade
+      return Verdict.coerce(:defer) if native_feed
+
+      category = SurfaceCategory.coerce(recon.surface_category)
+      return Verdict.coerce(:drop) if category.blocked?
+
+      Verdict.coerce(:build)
+    end
+    private_class_method :determine_verdict
+
+    def error_result(url_obj, error) # rubocop:disable Metrics/MethodLength
+      Result.new(
+        requested_url: url_obj,
+        final_url: url_obj,
+        status: nil,
+        verdict: Verdict.coerce(:drop),
+        native_feed: nil,
+        surface_category: SurfaceCategory.coerce(:unsupported_surface),
+        articles_count: 0,
+        scheme_downgrade: false,
+        notes: ["error: #{error.class} - #{error.message}"],
+        html_bytesize: nil
+      )
+    end
+    private_class_method :error_result
+
+    # Writes the raw response body once under a host+url-digest filename.
+    #
+    # @param body [String]
+    # @param url_obj [Html2rss::Url]
+    # @param cache_dir [String]
+    # @param cache_mutex [Mutex, nil]
+    # @return [void]
+    def cache_html_body(body, url_obj, cache_dir, cache_mutex)
+      host = url_obj.host.to_s.delete_prefix('www.')
+      host = 'snapshot' if host.empty?
+      digest = Digest::SHA256.hexdigest(url_obj.to_s)[0, 12]
+      file_path = File.join(cache_dir, "#{host}-#{digest}.html")
+      writer = -> { File.write(file_path, body) }
+      cache_mutex ? cache_mutex.synchronize(&writer) : writer.call
+    rescue StandardError => error
+      Log.debug("Recon cache failed: #{error.message}")
+    end
+    private_class_method :cache_html_body
+  end
+end

data/lib/html2rss/request_service/blocked_surface.rb

@@ -18,6 +18,7 @@ module Html2rss
             /checking your browser before accessing/i,
             /please (?:enable|turn on) javascript and cookies/i,
             %r{cdn-cgi/challenge-platform}i,
+            /cf-challenge/i,
             /cloudflare ray id/i
           ],
           message: 'Blocked surface detected: Cloudflare anti-bot interstitial page. ' \

data/lib/html2rss/request_service/faraday_strategy.rb

@@ -10,7 +10,7 @@ module Html2rss
     ##
     # Strategy to use Faraday for the request.
     # @see https://rubygems.org/gems/faraday
-    # rubocop:disable Metrics/ClassLength -- terminal redirect retry colocated with Faraday transport
+    # rubocop:disable-next Metrics/ClassLength -- terminal redirect retry colocated with Faraday transport
     class FaradayStrategy < Strategy
       ##
       # Restores buffered streamed bytes so response middleware can process them.
@@ -59,9 +59,13 @@ module Html2rss
       def request_with_terminal_redirect_retry(response_guard, deadline:)
         faraday_request(response_guard, deadline:, streaming_buffer: true)
       rescue Faraday::FollowRedirects::RedirectLimitReached => error
-        raise error unless terminal_redirect_retryable?
+        raise RedirectLimitReached, error.message unless terminal_redirect_retryable?
 
-        retry_from_terminal_redirect!(response_guard, deadline:)
+        begin
+          retry_from_terminal_redirect!(response_guard, deadline:)
+        rescue Faraday::FollowRedirects::RedirectLimitReached => retry_error
+          raise RedirectLimitReached, retry_error.message
+        end
       end
 
       def terminal_redirect_retryable?
@@ -100,7 +104,9 @@ module Html2rss
 
         client.get do |req|
           apply_timeouts(req, deadline:)
-          buffer = prepare_stream_buffer(req) if streaming_buffer
+          next unless streaming_buffer
+
+          buffer = prepare_stream_buffer(req)
           req.options.on_data = on_data_callback(response_guard, buffer)
         end
       end
@@ -146,7 +152,7 @@ module Html2rss
         end
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def client
         @client ||= Faraday.new(url: request_url.to_s, headers: ctx.headers) do |faraday|
           faraday.use Faraday::FollowRedirects::Middleware, limit: ctx.policy.max_redirects, callback: redirect_callback
@@ -157,7 +163,6 @@ module Html2rss
           end
         end
       end
-      # rubocop:enable Metrics/AbcSize
 
       def apply_timeouts(request, deadline:)
         remaining_timeout = remaining_timeout_seconds(deadline)
@@ -224,6 +229,5 @@ module Html2rss
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/html2rss/request_service/policy.rb

@@ -84,11 +84,10 @@ module Html2rss
       # Returns the default request policy.
       #
       # @return [Policy] a default, frozen policy instance
-      # rubocop:disable Layout/ClassStructure
+      # rubocop:disable-next Layout/ClassStructure
       def self.default
         new
       end
-      # rubocop:enable Layout/ClassStructure
 
       ##
       # Validates whether a request target is permitted for the given context.