html2rss 0.32.3 → 0.33.0

data/lib/html2rss/mcp/runtime.rb

@@ -14,31 +14,24 @@ module Html2rss
         :botasaurus_configured
       )
 
-      module_function
+      class << self
+        ##
+        # @return [Boolean] whether Botasaurus transport is configured in this process
+        def botasaurus_configured?
+          !ENV['BOTASAURUS_SCRAPER_URL'].to_s.strip.empty?
+        end
 
-      ##
-      # @return [Boolean] whether Botasaurus transport is configured in this process
-      def botasaurus_configured?
-        !ENV['BOTASAURUS_SCRAPER_URL'].to_s.strip.empty?
-      end
-
-      ##
-      # @return [Snapshot] runtime capabilities and catalog identity for MCP clients
-      def snapshot
-        Snapshot.new(
-          version: Html2rss::VERSION,
-          mcp_contract_version: Contract::MCP_CONTRACT_VERSION,
-          catalog_fingerprint: Contract.catalog_fingerprint,
-          tools: Contract.catalog_tools,
-          botasaurus_configured: botasaurus_configured?
-        )
-      end
-
-      ##
-      # @param strategy [String, Symbol, nil]
-      # @return [Symbol]
-      def coerce_strategy(strategy)
-        (strategy || :auto).to_sym
+        ##
+        # @return [Snapshot] runtime capabilities and catalog identity for MCP clients
+        def snapshot
+          Snapshot.new(
+            version: Html2rss::VERSION,
+            mcp_contract_version: Contract::MCP_CONTRACT_VERSION,
+            catalog_fingerprint: Contract.catalog_fingerprint,
+            tools: Contract.catalog_tools,
+            botasaurus_configured: botasaurus_configured?
+          )
+        end
       end
     end
   end

data/lib/html2rss/mcp/server/tools.rb

@@ -36,9 +36,9 @@ module Html2rss
             input_schema: Contract::INSPECT_INPUT_SCHEMA,
             annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
-              Outcome.inspect(
+              Outcome.inspect_report(
                 report: PageRecon::Diagnostics.call(
-                  url:, strategy: Runtime.coerce_strategy(strategy), deep: false
+                  url:, strategy: Option.strategy(strategy), deep: false
                 )
               )
             }
@@ -51,7 +51,7 @@ module Html2rss
             input_schema: Contract::RECON_INPUT_SCHEMA,
             annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
-              Outcome.recon(result: Html2rss.recon(url, strategy: Runtime.coerce_strategy(strategy)))
+              Outcome.recon(result: Html2rss.recon(url, strategy: Option.strategy(strategy)))
             }
           ),
           Tool.new(
@@ -63,7 +63,7 @@ module Html2rss
             annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, limit: 10, **|
               Outcome.batch_scrape(
-                Batch.batch_scrape(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:, limit:)
+                Batch.batch_scrape(urls:, strategy: Option.strategy(strategy), concurrency:, limit:)
               )
             }
           ),
@@ -76,7 +76,7 @@ module Html2rss
             annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
               Outcome.batch_inspect(
-                Batch.batch_inspect(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+                Batch.batch_inspect(urls:, strategy: Option.strategy(strategy), concurrency:)
               )
             }
           ),
@@ -89,7 +89,7 @@ module Html2rss
             annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
               Outcome.batch_recon(
-                Batch.batch_recon(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+                Batch.batch_recon(urls:, strategy: Option.strategy(strategy), concurrency:)
               )
             }
           ),
@@ -136,7 +136,7 @@ module Html2rss
                               compare_enhance: false, **kwargs|
               feed_config = ConfigArgument.parse(config:, yaml:).config
               test_args = { min_items:, strict_quality:, compare_enhance: }
-              test_args[:strategy] = Runtime.coerce_strategy(kwargs[:strategy]) if kwargs.key?(:strategy)
+              test_args[:strategy] = Option.strategy(kwargs[:strategy]) if kwargs.key?(:strategy)
               Outcome.test(Html2rss.test(feed_config, **test_args))
             }
           ),
@@ -163,7 +163,7 @@ module Html2rss
           # @param items_selector [String, nil]
           # @return [Outcome]
           def scrape_outcome(url:, strategy: 'auto', limit: 25, items_selector: nil)
-            wire = Batch.scrape_wire(url:, strategy: Runtime.coerce_strategy(strategy), limit:, items_selector:)
+            wire = Batch.scrape_wire(url:, strategy: Option.strategy(strategy), limit:, items_selector:)
             Outcome.scrape(
               items: wire[:items],
               requested_strategy: wire[:strategy],
@@ -189,7 +189,7 @@ module Html2rss
           # @return [Outcome]
           def capture_outcome(url:, strategy: 'auto', items_selector: nil, force: false, topics: nil, title: nil, # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
                               summary: nil, enhance: nil, limit: nil, max_redirects: nil, max_requests: nil)
-            plan = Runtime.coerce_strategy(strategy)
+            plan = Option.strategy(strategy)
             result = Html2rss::Capture.build(
               url,
               strategy: plan,

data/lib/html2rss/option.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ##
+  # Edge validation for caller-supplied option values (public API, CLI, MCP).
+  # Everything past these checks may trust its types.
+  module Option
+    class << self
+      ##
+      # @param name [Symbol] option name used in the error message
+      # @param value [Object] candidate value
+      # @param min [Integer] inclusive lower bound
+      # @param max [Integer, nil] inclusive upper bound
+      # @param optional [Boolean] whether +nil+ passes through
+      # @return [Integer, nil] +value+ when valid
+      # @raise [InvalidOption] when +value+ is not an Integer within bounds
+      def integer(name, value, min:, max: nil, optional: false)
+        return value if value.nil? && optional
+        return value if value.is_a?(Integer) && (min..max).cover?(value)
+
+        raise InvalidOption, "#{name} must be an Integer in #{min}..#{max}, got #{value.inspect}"
+      end
+
+      ##
+      # @param value [Symbol, String, nil] strategy plan name (+nil+ means +:auto+)
+      # @return [Symbol] the plan name
+      # @raise [InvalidOption] when +value+ is not a registered plan
+      def strategy(value)
+        name = value.nil? ? FeedPipeline::StrategyPlan::AUTO_NAME : value
+        return name.to_sym if FeedPipeline::StrategyPlan.valid?(name)
+
+        accepted = FeedPipeline::StrategyPlan.accepted_names.join(', ')
+        raise InvalidOption, "strategy must be one of #{accepted}, got #{value.inspect}"
+      end
+
+      ##
+      # @param name [Symbol] option name used in the error message
+      # @param value [Object] candidate list
+      # @return [Array] +value+ when it is a non-empty Array
+      # @raise [InvalidOption] otherwise
+      def list(name, value)
+        return value if value.is_a?(Array) && value.any?
+
+        raise InvalidOption, "#{name} must be a non-empty Array, got #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/html2rss/page_recon/diagnostics.rb

@@ -34,14 +34,12 @@ module Html2rss
       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)
+      def self.call(url:, strategy: :auto, deep: false)
         probe = PageRecon.probe(url, strategy: resolve_inspect_strategy(strategy, deep:))
         recon = probe.result
         response = probe.response
@@ -56,10 +54,10 @@ module Html2rss
       # @param strategy [Symbol, String]
       # @param concurrency [Integer]
       # @return [Array<Report>]
-      def batch(urls:, strategy: :auto, concurrency: Batch::DEFAULT_CONCURRENCY)
+      def self.batch(urls:, strategy: :auto, concurrency: Batch::DEFAULT_CONCURRENCY)
         Batch.map(Array(urls), concurrency:) do |url|
           call(url:, strategy:)
-        rescue StandardError => error
+        rescue Html2rss::Error => error
           error_report(url, error)
         end
       end
@@ -67,7 +65,7 @@ module Html2rss
       ##
       # @param response [Html2rss::RequestService::Response]
       # @return [Hash] redacted XHR capture diagnostics (no query strings)
-      def xhr_capture_info(response)
+      def self.xhr_capture_info(response)
         captured = response.captured_responses
         {
           count: captured.size,
@@ -79,7 +77,7 @@ module Html2rss
       ##
       # @param entry [Hash] captured response hash
       # @return [String, nil] scheme+host+path only
-      def redacted_endpoint(entry)
+      def self.redacted_endpoint(entry)
         raw = entry['url'] || entry[:url]
         return unless raw
 
@@ -94,7 +92,7 @@ module Html2rss
       ##
       # @param entry [Hash] captured response hash
       # @return [Boolean]
-      def xhr_candidate_articles?(entry)
+      def self.xhr_candidate_articles?(entry)
         body = entry['body'] || entry[:body]
         return false unless body.is_a?(String)
 
@@ -107,7 +105,7 @@ module Html2rss
       ##
       # @param parsed [Object] parsed response body
       # @return [Array<String>, Hash]
-      def scraper_info(parsed)
+      def self.scraper_info(parsed)
         return { error: 'Response is not HTML' } unless parsed.is_a?(Nokogiri::HTML::Document)
 
         begin

data/lib/html2rss/page_recon.rb

@@ -158,8 +158,6 @@ module Html2rss
     def self.discover_segments(sst, url)
       link_resolver = Scoring::LinkResolver.new(url)
       AutoSource::Segmenter.call(sst, base_url: url, strategy: :list, link_resolver:)
-    rescue StandardError
-      []
     end
 
     ##
@@ -268,8 +266,6 @@ module Html2rss
 
     def sst_document
       Html2rss::SST::Normalizer.call(response.body)
-    rescue ArgumentError
-      nil
     end
 
     def segment_stats(sst, page_url)

data/lib/html2rss/recon.rb

@@ -9,8 +9,6 @@ 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)
 
     ##
@@ -106,12 +104,12 @@ module Html2rss
     # @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
+    def self.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
+      rescue Html2rss::Error => error
         return error_result(url_obj, error)
       end
 
@@ -149,7 +147,7 @@ module Html2rss
     # @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)
+    def self.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?
 
@@ -166,7 +164,7 @@ module Html2rss
     # @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)
+    def self.find_native_feed(url_obj, session, response)
       feed = Syndication::Discovery.best_feed_url(
         page_url: url_obj,
         request_session: session,
@@ -174,12 +172,12 @@ module Html2rss
         html: response.body
       )
       [feed, nil]
-    rescue StandardError => error
+    rescue Html2rss::Error => error
       [nil, "discovery_error=#{error.class}: #{error.message}"]
     end
     private_class_method :find_native_feed
 
-    def build_notes(recon, native_feed, response)
+    def self.build_notes(recon, native_feed, response)
       notes = []
       notes << "native_rss=#{native_feed}" if native_feed
       if recon.scheme_downgrade
@@ -192,7 +190,7 @@ module Html2rss
     end
     private_class_method :build_notes
 
-    def determine_verdict(recon, native_feed)
+    def self.determine_verdict(recon, native_feed)
       return Verdict[:drop] if recon.status.nil? || recon.status >= 400 || recon.scheme_downgrade
       return Verdict[:defer] if native_feed
 
@@ -203,7 +201,7 @@ module Html2rss
     end
     private_class_method :determine_verdict
 
-    def error_result(url_obj, error) # rubocop:disable Metrics/MethodLength
+    def self.error_result(url_obj, error) # rubocop:disable Metrics/MethodLength
       Result.new(
         requested_url: url_obj,
         final_url: url_obj,
@@ -226,14 +224,14 @@ module Html2rss
     # @param cache_dir [String]
     # @param cache_mutex [Mutex, nil]
     # @return [void]
-    def cache_html_body(body, url_obj, cache_dir, cache_mutex)
+    def self.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
+    rescue SystemCallError, IOError => error
       Log.debug("Recon cache failed: #{error.message}")
     end
     private_class_method :cache_html_body

data/lib/html2rss/request_service/blocked_surface.rb

@@ -79,10 +79,10 @@ module Html2rss
       end
 
       def self.interstitial_signature_match?(body, signature)
-        min_matches = signature.fetch(:min_matches, 1)
+        min_matches = signature[:min_matches]
         matches = 0
 
-        signature.fetch(:patterns).each do |pattern|
+        signature[:patterns].each do |pattern|
           matches += 1 if pattern.match?(body)
           return true if matches >= min_matches
         end
@@ -91,11 +91,7 @@ module Html2rss
       end
       private_class_method :interstitial_signature_match?
 
-      def self.normalize_body(body)
-        body.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '')
-      rescue Encoding::CompatibilityError, Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-        body.to_s.force_encoding(Encoding::UTF_8).scrub
-      end
+      def self.normalize_body(body) = body.to_s.scrub
       private_class_method :normalize_body
     end
   end

data/lib/html2rss/request_service/botasaurus_strategy.rb

@@ -65,7 +65,7 @@ module Html2rss
         return ctx.url if final_url.nil?
 
         Html2rss::Url.from_absolute(final_url)
-      rescue ArgumentError
+      rescue Html2rss::Url::InvalidUrlError
         ctx.url
       end
 
@@ -117,7 +117,7 @@ module Html2rss
             raise BotasaurusConfigurationError, 'BOTASAURUS_SCRAPER_URL is required for strategy=botasaurus.'
           end
           Html2rss::Url.for_channel(configured)
-        rescue ArgumentError => error
+        rescue Html2rss::Url::InvalidUrlError => error
           raise BotasaurusConfigurationError, "BOTASAURUS_SCRAPER_URL is invalid: #{error.message}"
         end
       end

data/lib/html2rss/request_service/budget.rb

@@ -11,7 +11,7 @@ module Html2rss
       # @param max_requests [Integer] maximum HTTP request slots
       # @param total_timeout_seconds [Integer, nil] wall-clock timeout for the feed build
       def initialize(max_requests:, total_timeout_seconds: nil)
-        validate_slot_limits!(max_requests:)
+        Option.integer(:max_requests, max_requests, min: 1)
 
         @remaining_requests = max_requests
         @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -25,33 +25,20 @@ module Html2rss
       # @return [Integer] remaining request slots after consumption
       # @raise [RequestBudgetExceeded] if no request slots remain
       def consume!
-        consume_request!
-      end
-
-      ##
-      # Consumes one HTTP request slot.
-      #
-      # @return [Integer] remaining request slots after consumption
-      # @raise [RequestBudgetExceeded] if no request slots remain
-      def consume_request!
         @mutex.synchronize do
           raise RequestBudgetExceeded, 'Request budget exhausted' if @remaining_requests.zero?
 
           @remaining_requests -= 1
         end
       end
-
-      ##
-      # @return [Integer] HTTP request slots still available
-      def remaining
-        remaining_requests
-      end
+      alias consume_request! consume!
 
       ##
       # @return [Integer] HTTP request slots still available
       def remaining_requests
         @mutex.synchronize { @remaining_requests }
       end
+      alias remaining remaining_requests
 
       ##
       # @return [Float, nil] the remaining timeout in seconds, or nil if not tracked
@@ -91,14 +78,6 @@ module Html2rss
       def effective_timeout_ms(fallback:)
         (effective_timeout_seconds(fallback:) * 1000).to_i
       end
-
-      private
-
-      def validate_slot_limits!(max_requests:)
-        return if max_requests.is_a?(Integer) && max_requests.positive?
-
-        raise ArgumentError, 'max_requests must be positive'
-      end
     end
   end
 end

data/lib/html2rss/request_service/compressed_body.rb

@@ -7,56 +7,58 @@ require 'zlib'
 module Html2rss
   class RequestService
     # Decodes gzip/brotli bodies when Content-Encoding is missing or the type is octet-stream.
-    module CompressedBody
+    class CompressedBody
       # Gzip stream magic (RFC 1952).
       GZIP_MAGIC = "\x1F\x8B".b.freeze
       # HTML prefix for unlabeled brotli trial decode. Same object as {Response::HTML_BODY_SNIFF}.
       HTML_BODY_SNIFF = Response::HTML_BODY_SNIFF
 
-      module_function
-
       # @param body [String, nil] raw response body
       # @param headers [Hash] response headers (Content-Encoding / Content-Type)
       # @return [String, nil] decoded body when compressed; otherwise the original body
-      def decode(body, headers: {})
-        return body if body.nil? || body.empty?
-
+      def self.decode(body, headers: {})
         raw = body.to_s.b
-        decode_labeled(raw, headers) || decode_unlabeled(raw, headers) || body
+        new(raw, headers).decoded_body || body
+      end
+
+      # @param raw [String] binary response body
+      # @param headers [Hash] response headers (Content-Encoding / Content-Type)
+      def initialize(raw, headers)
+        @raw = raw
+        @headers = headers
       end
+      private_class_method :new
 
-      def decode_labeled(raw, headers)
-        encodings = content_encodings(headers)
+      # @return [String, nil] inflated body, or nil when the bytes are not a recognized stream
+      def decoded_body
+        decode_labeled || decode_unlabeled
+      end
+
+      private
+
+      def decode_labeled
+        encodings = content_encodings
         return if encodings.empty?
 
-        encodings.reverse.reduce(raw) { |buffer, encoding| inflate(buffer, encoding) || buffer }
+        encodings.reverse.reduce(@raw) { |buffer, encoding| inflate(buffer, encoding) || buffer }
       end
-      module_function :decode_labeled
-      private_class_method :decode_labeled
 
-      def decode_unlabeled(raw, headers)
-        return uncompress_gzip(raw) if raw.start_with?(GZIP_MAGIC)
-        return unless octet_stream?(headers)
+      def decode_unlabeled
+        return uncompress_gzip(@raw) if @raw.start_with?(GZIP_MAGIC)
+        return unless octet_stream?
 
-        try_brotli(raw)
+        try_brotli(@raw)
       end
-      module_function :decode_unlabeled
-      private_class_method :decode_unlabeled
 
       def inflate(raw, encoding)
         case encoding
-        when 'gzip'
-          return raw unless raw.start_with?(GZIP_MAGIC)
-
-          uncompress_gzip(raw)
+        when 'gzip' then uncompress_gzip(raw)
         when 'br' then try_brotli(raw, require_html: false)
         when 'deflate' then inflate_deflate(raw)
         end
       rescue Zlib::Error, Brotli::Error, ArgumentError
         nil
       end
-      module_function :inflate
-      private_class_method :inflate
 
       def inflate_deflate(raw)
         inflater = nil
@@ -67,51 +69,37 @@ module Html2rss
       ensure
         inflater&.close
       end
-      module_function :inflate_deflate
-      private_class_method :inflate_deflate
 
       def uncompress_gzip(raw)
-        Zlib::GzipReader.wrap(StringIO.new(raw), encoding: 'ASCII-8BIT', &:read)
+        Zlib::GzipReader.wrap(StringIO.new(raw), &:read).b
       rescue Zlib::Error
         nil
       end
-      module_function :uncompress_gzip
-      private_class_method :uncompress_gzip
 
       def try_brotli(raw, require_html: true)
         inflated = Brotli.inflate(raw)
         return inflated unless require_html
-        return inflated if inflated.b.match?(HTML_BODY_SNIFF)
 
-        nil
+        inflated.b.match?(HTML_BODY_SNIFF) ? inflated : nil
       rescue Brotli::Error, ArgumentError
         nil
       end
-      module_function :try_brotli
-      private_class_method :try_brotli
 
-      def content_encodings(headers)
-        header(headers, 'content-encoding')
+      def content_encodings
+        header('content-encoding')
           .to_s
           .split(',')
-          .filter_map { |val| (s = val.strip.downcase).empty? ? nil : s }
+          .map { |val| val.strip.downcase }
+          .reject(&:empty?)
       end
-      module_function :content_encodings
-      private_class_method :content_encodings
 
-      def octet_stream?(headers)
-        header(headers, 'content-type').to_s.downcase.include?('application/octet-stream')
+      def octet_stream?
+        header('content-type').to_s.downcase.include?('application/octet-stream')
       end
-      module_function :octet_stream?
-      private_class_method :octet_stream?
 
-      def header(headers, name)
-        headers.fetch(name) do
-          headers.find { |key, _value| key.to_s.casecmp?(name) }&.last
-        end
+      def header(name)
+        @headers.find { |key, _value| key.to_s.casecmp?(name) }&.last
       end
-      module_function :header
-      private_class_method :header
     end
   end
 end

data/lib/html2rss/request_service/context.rb

@@ -87,9 +87,7 @@ module Html2rss
       end
 
       def normalize_request(request)
-        normalized = HashUtil.deep_symbolize_keys(request, context: 'request')
-        HashUtil.assert_symbol_keys!(normalized, context: 'request')
-        normalized
+        HashUtil.deep_symbolize_keys(request, context: 'request')
       end
     end
   end

data/lib/html2rss/request_service/local_file_strategy.rb

@@ -15,6 +15,9 @@ module Html2rss
 
       def skip_postflight? = true
 
+      # Local files never open a socket; keep filesystem errors as wire classes.
+      def connection_error?(_error) = false
+
       ##
       # @return [Response] the mock response wrapped around the file contents
       # @raise [ArgumentError] if the local file path is missing
@@ -22,7 +25,6 @@ module Html2rss
       def fetch
         file_path = ctx.request[:local_file_path]
         raise ArgumentError, 'Local file path is required for local_file strategy' unless file_path
-        raise Errno::ENOENT, "File not found: #{file_path}" unless File.exist?(file_path)
 
         body = File.read(file_path)
         Response.new(

data/lib/html2rss/request_service/network_guard.rb

@@ -68,7 +68,7 @@ module Html2rss
       def validate_remote_ip!(ip:, url:)
         return if allow_private_networks?
 
-        parsed_ip = ip && !ip.to_s.empty? ? parse_ip(ip) : nil
+        parsed_ip = parse_ip(ip.to_s)
         raise PrivateNetworkDenied, "Remote IP could not be validated for #{url}" unless parsed_ip
         return unless blocked_ip?(parsed_ip)
 
@@ -122,7 +122,8 @@ module Html2rss
       end
 
       def blocked_ip?(address)
-        BLOCKED_IP_RANGES.any? { |range| range.include?(address) }
+        native = address.native
+        BLOCKED_IP_RANGES.any? { |range| range.include?(native) }
       end
     end
   end