html2rss 0.32.4 → 0.33.0

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

@@ -25,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

data/lib/html2rss/request_service/policy.rb

@@ -47,13 +47,13 @@ module Html2rss
                      allow_private_networks: DEFAULTS[:allow_private_networks],
                      allow_cross_origin_followups: DEFAULTS[:allow_cross_origin_followups],
                      resolver: Socket)
-        @connect_timeout_seconds = validate_positive_integer!(:connect_timeout_seconds, connect_timeout_seconds)
-        @read_timeout_seconds = validate_positive_integer!(:read_timeout_seconds, read_timeout_seconds)
-        @total_timeout_seconds = validate_positive_integer!(:total_timeout_seconds, total_timeout_seconds)
-        @max_redirects = validate_non_negative_integer!(:max_redirects, max_redirects)
-        @max_response_bytes = validate_positive_integer!(:max_response_bytes, max_response_bytes)
-        @max_decompressed_bytes = validate_positive_integer!(:max_decompressed_bytes, max_decompressed_bytes)
-        @max_requests = [validate_positive_integer!(:max_requests, max_requests), MAX_REQUESTS_CEILING].min
+        @connect_timeout_seconds = Option.integer(:connect_timeout_seconds, connect_timeout_seconds, min: 1)
+        @read_timeout_seconds = Option.integer(:read_timeout_seconds, read_timeout_seconds, min: 1)
+        @total_timeout_seconds = Option.integer(:total_timeout_seconds, total_timeout_seconds, min: 1)
+        @max_redirects = Option.integer(:max_redirects, max_redirects, min: 0)
+        @max_response_bytes = Option.integer(:max_response_bytes, max_response_bytes, min: 1)
+        @max_decompressed_bytes = Option.integer(:max_decompressed_bytes, max_decompressed_bytes, min: 1)
+        @max_requests = [Option.integer(:max_requests, max_requests, min: 1), MAX_REQUESTS_CEILING].min
         @allow_private_networks = allow_private_networks ? true : false
         @allow_cross_origin_followups = allow_cross_origin_followups ? true : false
         @network_guard = NetworkGuard.new(allow_private_networks: @allow_private_networks, resolver:)
@@ -135,18 +135,6 @@ module Html2rss
 
       attr_reader :network_guard
 
-      def validate_positive_integer!(name, value)
-        raise ArgumentError, "#{name} must be positive" unless value.is_a?(Integer) && value.positive?
-
-        value
-      end
-
-      def validate_non_negative_integer!(name, value)
-        raise ArgumentError, "#{name} must be non-negative" unless value.is_a?(Integer) && !value.negative?
-
-        value
-      end
-
       def enforce_same_origin!(url, origin_url, relation)
         return if relation == :initial || allow_cross_origin_followups?
 
@@ -163,13 +151,7 @@ module Html2rss
       end
 
       def comparable_origin(url)
-        [url.host, normalized_port(url)]
-      end
-
-      def normalized_port(url)
-        return url.port if url.port
-
-        url.scheme == 'https' ? 443 : 80
+        [url.scheme, url.host, url.port]
       end
     end
 

data/lib/html2rss/request_service/response.rb

@@ -31,15 +31,12 @@ module Html2rss
       # @param status [Integer, nil] the HTTP status code when available
       # @param transport_meta [Hash] allowlisted upstream telemetry (frozen when present)
       # @param captured_responses [Array<Hash>] JSON XHR/fetch bodies captured during browser scrapes
-      # rubocop:disable-next Metrics/MethodLength, Metrics/ParameterLists -- transport + capture fields stay co-located
+      # rubocop:disable-next Metrics/ParameterLists -- transport + capture fields stay co-located
       def initialize(body:, url:, headers: {}, status: nil, transport_meta: EMPTY_TRANSPORT_META,
                      captured_responses: EMPTY_CAPTURED_RESPONSES)
         @body = body
 
-        headers = (headers || {}).transform_keys(&:to_s)
-        HashUtil.assert_string_keys!(headers, context: 'response headers', deep: false)
-
-        @headers = headers
+        @headers = (headers || {}).transform_keys(&:to_s)
         @status = status
         @url = url
         @transport_meta = transport_meta.nil? || transport_meta.empty? ? EMPTY_TRANSPORT_META : transport_meta.freeze
@@ -165,7 +162,7 @@ module Html2rss
       end
 
       def feed_looking_body?
-        snippet = body.to_s[0, 800].downcase
+        snippet = body.to_s.b[0, 800].downcase
         FEED_BODY_MARKERS.any? { |marker| snippet.include?(marker) }
       end
     end

data/lib/html2rss/request_session/pager/base.rb

@@ -26,7 +26,7 @@ module Html2rss
         # @yield [RequestService::Response] each page response
         # @return [Enumerator] enumerator when no block is given
         def each
-          return enum_for(:each) unless block_given?
+          return enum_for unless block_given?
 
           yield initial_response
 
@@ -48,14 +48,14 @@ module Html2rss
 
         # @return [Integer] configured maximum pages (always a positive Integer)
         def max_pages
-          value = config.fetch(:max_pages, DEFAULT_MAX_PAGES)
+          value = config[:max_pages]
           value.is_a?(Integer) && value.positive? ? value : DEFAULT_MAX_PAGES
         end
 
         # @param next_url [Html2rss::Url, String, nil]
         # @return [Boolean]
         def follow_up_allowed?(next_url)
-          !next_url.nil? && !next_url.to_s.empty? && !session.visited?(next_url)
+          !next_url.to_s.empty? && !session.visited?(next_url)
         end
 
         # @param next_url [Html2rss::Url, String]

data/lib/html2rss/request_session/pager/custom_selector.rb

@@ -11,7 +11,7 @@ module Html2rss
         # @param page_response [RequestService::Response]
         # @param page_number [Integer]
         # @return [String, nil]
-        def next_page_url(page_response, page_number: nil) # rubocop:disable Lint/UnusedMethodArgument
+        def next_page_url(page_response, page_number:) # rubocop:disable Lint/UnusedMethodArgument
           selector = config[:selector]
           return nil if selector.nil? || selector.empty?
 
@@ -19,16 +19,16 @@ module Html2rss
           return nil unless node
 
           href = node['href'] || node.text
-          return nil if href.nil? || href.strip.empty?
+          return nil if href.strip.empty?
 
-          Html2rss::Url.from_relative(href.strip, page_response.url)
+          Html2rss::Url.from_relative(href, page_response.url)
         end
 
         # @param parsed_body [Nokogiri::HTML::Document]
         # @param selector [String]
         # @return [Nokogiri::XML::Node, nil]
         def extract_node(parsed_body, selector)
-          parsed_body.at_css(selector) || parsed_body.at_xpath(selector)
+          parsed_body.at_css(selector)
         rescue Nokogiri::CSS::SyntaxError, Nokogiri::XML::XPath::SyntaxError
           # Pure XPath like `descendant::a` fails LOOKS_LIKE_XPATH / at_css; fall back explicitly.
           parsed_body.at_xpath(selector)

data/lib/html2rss/request_session/pager/offset.rb

@@ -25,14 +25,8 @@ module Html2rss
         # @return [Html2rss::Url]
         def next_page_url(page_response, page_number:)
           param = config.fetch(:param, DEFAULT_PARAM)
-          target_offset_val = target_offset_for(page_number)
           url = Html2rss::Url.from_absolute(page_response.url)
-
-          if url.to_s.include?('{offset}')
-            Html2rss::Url.from_absolute(url.to_s.gsub('{offset}', target_offset_val.to_s))
-          else
-            url.with_query_values(url.query_values.merge(param.to_s => target_offset_val.to_s))
-          end
+          url.with_query_values(url.query_values.merge(param.to_s => target_offset_for(page_number).to_s))
         end
 
         # @param page_number [Integer]

data/lib/html2rss/request_session/pager/rel_next.rb

@@ -11,7 +11,7 @@ module Html2rss
         # @param page_response [RequestService::Response]
         # @param page_number [Integer]
         # @return [String, nil]
-        def next_page_url(page_response, page_number: nil) # rubocop:disable Lint/UnusedMethodArgument
+        def next_page_url(page_response, page_number:) # rubocop:disable Lint/UnusedMethodArgument
           href = page_response.parsed_body.at_css('link[rel~="next"][href], a[rel~="next"][href]')&.[]('href')
           return nil if href.nil? || href.empty?
 

data/lib/html2rss/request_session/pager/url_template.rb

@@ -25,14 +25,8 @@ module Html2rss
         # @return [Html2rss::Url]
         def next_page_url(page_response, page_number:)
           param = config.fetch(:param, DEFAULT_PARAM)
-          target_page_val = target_page_for(page_number)
           url = Html2rss::Url.from_absolute(page_response.url)
-
-          if url.to_s.include?('{page}')
-            Html2rss::Url.from_absolute(url.to_s.gsub('{page}', target_page_val.to_s))
-          else
-            url.with_query_values(url.query_values.merge(param.to_s => target_page_val.to_s))
-          end
+          url.with_query_values(url.query_values.merge(param.to_s => target_page_for(page_number).to_s))
         end
 
         # @param page_number [Integer]

data/lib/html2rss/scoring/engine.rb

@@ -91,21 +91,17 @@ module Html2rss
 
       private
 
-      def rank_one(segment, hard_junk_mode: :strict) # rubocop:disable Metrics/MethodLength
+      def rank_one(segment, hard_junk_mode: :strict) # rubocop:disable Metrics/AbcSize
         facts = segment.primary_link ? @link_resolver.destination_facts(segment.primary_link) : nil
         obs = @assessor.call(segment.root_node, segment.primary_link, destination_facts: facts)
         return if obs.hard_junk?(mode: hard_junk_mode)
 
         quality, quality_parts = apply_rules(QUALITY_RULES, obs)
         junk, junk_parts = apply_rules(JUNK_RULES, obs)
-        ranked(
+        RankedSegment.new(
           segment:,
-          score: build_score(
-            composite: quality - junk,
-            quality:,
-            junk:,
-            breakdown: quality_parts.merge(junk_parts)
-          )
+          score: Score.new(composite: (quality - junk).to_f, quality: quality.to_f, junk: junk.to_f,
+                           breakdown: quality_parts.merge(junk_parts).freeze)
         )
       end
 
@@ -116,30 +112,6 @@ module Html2rss
         end
         [parts.values.sum, parts]
       end
-
-      def build_score(composite:, quality: nil, junk: nil, breakdown: nil)
-        raise ArgumentError, 'composite must be Numeric' unless composite.is_a?(Numeric)
-
-        Score.new(
-          composite: composite.to_f,
-          quality: (quality.nil? ? composite : quality).to_f,
-          junk: (junk || 0).to_f,
-          breakdown: normalize_breakdown(breakdown)
-        )
-      end
-
-      def normalize_breakdown(breakdown)
-        return Score::EMPTY_BREAKDOWN if breakdown.nil?
-
-        breakdown.transform_keys { |id| self.class.assert_feature_id!(id) }.freeze
-      end
-
-      def ranked(segment:, score:)
-        raise ArgumentError, 'segment must be AutoSource::Segment' unless segment.is_a?(Html2rss::AutoSource::Segment)
-        raise ArgumentError, 'score must be Scoring::Score' unless score.is_a?(Score)
-
-        RankedSegment.new(segment:, score:)
-      end
     end
   end
 end

data/lib/html2rss/scoring/link_resolver.rb

@@ -24,7 +24,6 @@ module Html2rss
       def initialize(base_url)
         @base_url = base_url
         @by_href = {}
-        @by_node = {}.compare_by_identity
         @text_classifier = LinkDestination::TextClassifier.new
       end
 
@@ -35,15 +34,11 @@ module Html2rss
       # @param node_or_href [SST::Node, String, #to_s]
       # @return [LinkDestination::DestinationFacts, nil]
       def destination_facts(node_or_href)
-        return @by_node[node_or_href] if node_or_href.is_a?(SST::Node) && @by_node.key?(node_or_href)
-
         href = extract_href(node_or_href)
         return unless href
 
-        facts = (@by_href[href] ||= build_facts(href))
-        @by_node[node_or_href] = facts if node_or_href.is_a?(SST::Node)
-        facts
-      rescue ArgumentError
+        @by_href[href] ||= build_facts(href)
+      rescue Html2rss::Url::InvalidUrlError
         nil
       end
 

data/lib/html2rss/selectors/extractors/href.rb

@@ -54,11 +54,9 @@ module Html2rss
         ##
         # Retrieves and returns the normalized absolute URL.
         #
-        # @return [Html2rss::Url, nil] The absolute URL.
+        # @return [Html2rss::Url, nil] The absolute URL, or nil when nothing matched or the +href+ is blank.
         def call
-          return nil unless @href
-
-          Url.from_relative(@href, @base_url)
+          Url.from_relative(@href, @base_url) unless @href.strip.empty?
         end
       end
     end