html2rss 0.32.4 → 0.34.0

data/lib/html2rss/feed_builder/rss.rb

@@ -6,7 +6,20 @@ module Html2rss
   module FeedBuilder
     ##
     # Builds an RSS Feed by providing channel, articles and stylesheets.
-    class Rss
+    #
+    # A media feed ({ItemPresentation.media_feed?}) also gets the podcast tags clients play from:
+    # channel +itunes:image+, +itunes:author+, +itunes:category+ (nesting its subcategories) and
+    # +itunes:explicit+ (+true+ or +false+), item +itunes:duration+ (+HH:MM:SS+) and +itunes:image+, each
+    # only when known; categories and the explicit flag only when the followed native feed states them.
+    #
+    # +managingEditor+ carries the channel author only when it is an RSS 2.0 email address
+    # (+editor@example.com+ or +editor@example.com (Name)+); a plain name is no managing editor.
+    class Rss # rubocop:disable Metrics/ClassLength -- channel, item and podcast projections stay co-located
+      # First duration in seconds that +itunes:duration+ cannot spell as +HH:MM:SS+ (100 hours).
+      MAX_CLOCK_DURATION = 100 * 3600
+      # An RSS 2.0 person: an email address, optionally followed by the name in parentheses.
+      EMAIL_PERSON = /\A[^\s@()]+@[^\s@()]+(?: \(.+\))?\z/
+
       class << self
         # @param article [Html2rss::Article] source article
         # @param item_maker [RSS::Maker::RSS20::ItemsBase::ItemBase] RSS item builder
@@ -37,7 +50,7 @@ module Html2rss
           item_maker.title = article.title
           item_maker.author = article.author
           description = ItemPresentation.description_for(article)
-          item_maker.description = description if description && !description.empty?
+          item_maker.description = description if description
           item_maker.link = article.url.to_s if article.url
           item_maker.pubDate = article.published_at&.rfc2822
         end
@@ -60,12 +73,13 @@ module Html2rss
       # @param stylesheets [Array<Hash>] An optional array of stylesheet configurations.
       # @param generator [String] required preformatted generator comment (from {Status})
       def initialize(channel:, articles:, generator:, stylesheets: [])
-        raise ArgumentError, 'generator must be a non-blank String' if blank_string?(generator)
+        raise InvalidOption, 'generator must be a non-blank String' if blank_string?(generator)
 
         @channel = channel
         @articles = articles
         @stylesheets = stylesheets
         @generator = generator
+        @media_feed = ItemPresentation.media_feed?(articles)
       end
 
       # @return [RSS::Rss] RSS 2.0 document instance
@@ -80,7 +94,7 @@ module Html2rss
 
       private
 
-      attr_reader :channel, :articles, :generator
+      attr_reader :channel, :articles, :generator, :media_feed
 
       def blank_string?(value)
         !value.is_a?(String) || value.strip.empty?
@@ -98,13 +112,25 @@ module Html2rss
         channel_maker.description = channel.description
         channel_maker.ttl = channel.ttl
 
-        channel_maker.managingEditor = channel.author if channel.author
-        channel_maker.author = channel.author if channel.author
+        channel_maker.managingEditor = channel.author if EMAIL_PERSON.match?(channel.author)
         channel_maker.link = channel.url.to_s
         channel_maker.generator = generator
         channel_maker.updated = channel.last_build_date
 
         make_image(maker.image) if channel.image
+        make_podcast_channel(channel_maker) if media_feed
+      end
+
+      def make_podcast_channel(channel_maker)
+        channel_maker.itunes_image = channel.image
+        channel_maker.itunes_author = channel.author
+        channel_maker.itunes_explicit = channel.explicit&.to_s
+        channel.categories.each { add_itunes_category(channel_maker, *_1) }
+      end
+
+      def add_itunes_category(channel_maker, name, *subcategories)
+        category = channel_maker.new_itunes_category(name)
+        subcategories.each { category.new_category.text = _1 }
       end
 
       def make_image(image_maker)
@@ -114,9 +140,26 @@ module Html2rss
 
       def make_items(maker)
         articles.each do |article|
-          maker.items.new_item { |item_maker| self.class.add_item(article, item_maker) }
+          maker.items.new_item do |item_maker|
+            self.class.add_item(article, item_maker)
+            make_podcast_item(article, item_maker) if media_feed
+          end
         end
       end
+
+      def make_podcast_item(article, item_maker)
+        duration = ItemPresentation.rss_enclosure_for(article)&.duration
+        item_maker.itunes_duration = format_duration(duration) if duration
+        item_maker.itunes_image = article.image
+      end
+
+      # +HH:MM:SS+; plain seconds from 100 hours on, which +HH+ cannot spell.
+      def format_duration(seconds)
+        return seconds.to_s if seconds >= MAX_CLOCK_DURATION
+
+        format('%<hours>02d:%<minutes>02d:%<seconds>02d',
+               hours: seconds / 3600, minutes: seconds % 3600 / 60, seconds: seconds % 60)
+      end
     end
   end
 end

data/lib/html2rss/feed_builder.rb

@@ -8,7 +8,8 @@ module Html2rss
   # FeedResult; +feed_url+ is a render-time JSON Feed-only option.
   #
   # Channel field projection:
-  # - Rss: language, title, description, ttl, link, updated
+  # - Rss: language, title, description, ttl, link, updated, managingEditor (author in email form only)
+  #   (+ itunes:image, itunes:author, itunes:category, itunes:explicit on a media feed)
   # - JsonFeed: title, home_page_url, description, language, icon, authors (+ feed_url)
   module FeedBuilder
   end

data/lib/html2rss/feed_pipeline/README.md

@@ -11,7 +11,7 @@ Use `:auto` when you want `default` (HTTPX) first and a browser-backed hop only
 1. **Default (HTTPX)** — plain HTTP (faster, cheaper).
 2. **Botasaurus** — attempted when default raises a fallback-eligible error (for example `BlockedSurfaceDetected` or timeout) or extracts zero feed items.
 
-Before escalating default → Botasaurus on a **weak** auto-source extract (empty / below floor / high-entropy / app-shell / unsupported — not blocked), `FeedResolution` may probe up to five same-origin listing or native-feed candidates and rewrite the effective scrape URL via {ScrapeTarget}. Botasaurus then uses the resolved URL. Direct RSS/Atom entry URLs are parsed via `Syndication::Parser` without HTML AutoSource.
+Before escalating default → Botasaurus on a **weak** auto-source extract (empty / below floor / high-entropy / app-shell / unsupported — not blocked), `FeedResolution` may probe up to five same-origin listing or native-feed candidates and rewrite the effective scrape URL via {ScrapeTarget}. Botasaurus then uses the resolved URL. Direct RSS/Atom/RDF entry URLs are parsed via `Syndication::Parser` without HTML AutoSource.
 
 There is no Browserless / Puppeteer-in-gem tier. Pin `botasaurus` when you want browser rendering without default first. Botasaurus needs `BOTASAURUS_SCRAPER_URL`.
 

data/lib/html2rss/feed_pipeline/auto_fallback.rb

@@ -83,7 +83,7 @@ module Html2rss
         # @param elapsed_ms [Integer, nil] monotonic hop duration in milliseconds
         # @return [void]
         def record_error(strategy:, error:, elapsed_ms: nil)
-          meta = error.is_a?(Html2rss::Error) ? error.transport_meta : nil
+          meta = error.transport_meta if error.is_a?(Error)
           append_attempt(strategy:, error_class: error.class.name, transport_meta: meta, elapsed_ms:)
           @last_error = error
           return unless TERMINAL_TRANSPORT_ERRORS.any? { |klass| error.is_a?(klass) }
@@ -108,26 +108,15 @@ module Html2rss
         end
 
         # @param response [RequestService::Response] successful response
-        # @param articles [Array] extracted articles
-        # @param dedup_dropped [Integer] articles removed by deduplication
+        # @param extraction [Html2rss::FeedPipeline::Extraction] its articles, drops and feed channel facts
         # @param selected_strategy [Symbol] concrete strategy that produced items
         # @param attempt_count [Integer] number of attempts recorded for this chain
-        # @param admission_drops [Hash{String => Integer}] Cleanup drop tallies
         # @param scrape_target [Html2rss::ScrapeTarget]
         # @return [void]
-        # rubocop:disable-next Metrics/ParameterLists, Metrics/MethodLength -- PipelineOutcome kwargs stay co-located
-        def succeed!(response:, articles:, dedup_dropped:, selected_strategy:, attempt_count:,
-                     scrape_target:, admission_drops: {})
+        def succeed!(response:, extraction:, selected_strategy:, attempt_count:, scrape_target:)
           @result = PipelineOutcome.new(
-            response:,
-            articles:,
-            dedup_dropped:,
-            selected_strategy:,
-            attempt_count:,
-            strategy_attempts: attempts,
-            admission_drops:,
-            scrape_target:,
-            entry_resolution:
+            response:, selected_strategy:, attempt_count:, strategy_attempts: attempts,
+            scrape_target:, entry_resolution:, **extraction.to_h
           )
         end
 
@@ -137,7 +126,7 @@ module Html2rss
         # @raise [Html2rss::Error, StandardError]
         def raise_failure!
           if (error = failure_error)
-            error.attempts = attempts if error.is_a?(Html2rss::Error)
+            error.attempts = attempts if error.is_a?(Error)
             raise error
           end
 
@@ -215,18 +204,18 @@ module Html2rss
       rescue *NON_FALLBACK_ERRORS => error
         state.record_error(strategy:, error:, elapsed_ms: monotonic_ms - started_ms)
         state.abort!
-      rescue StandardError => error
+      rescue Html2rss::ContractError
+        raise
+      rescue Html2rss::Error => error
         state.record_error(strategy:, error:, elapsed_ms: monotonic_ms - started_ms)
         log_fallback_error(strategy:, next_strategy:, error:, request_session:) if next_strategy && request_session
       end
 
       # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize, Metrics/ParameterLists -- extract + resolution delegate
       def process_response(response:, strategy:, next_strategy:, request_session:, state:, elapsed_ms: nil)
-        articles, dedup_dropped, admission_drops = pipeline.deduplicated_articles(
-          config:, response:, request_session:
-        )
+        extraction = pipeline.extract(config:, response:, request_session:)
         state.remember_response(response)
-        items_count = articles.size
+        items_count = extraction.articles.size
         state.record_items(strategy:, items_count:, transport_meta: response.transport_meta, elapsed_ms:)
         Log.debug("#{self.class}: strategy=#{strategy} items=#{items_count} " \
                   "host=#{response.url.host} elapsed=#{format('%.3f', budget.elapsed_seconds)}s " \
@@ -234,16 +223,13 @@ module Html2rss
 
         if (outcome = FeedResolution.try_apply!(
           pipeline:, config:, response:, session: request_session, strategy:, resources:,
-          articles:, scrape_target:, state:, budget:
+          articles: extraction.articles, scrape_target:, state:, budget:
         ))
           @scrape_target = outcome.scrape_target
           return
         end
 
-        if items_count.positive?
-          return record_success(response:, strategy:, articles:, dedup_dropped:, admission_drops:,
-                                state:)
-        end
+        return record_success(response:, strategy:, extraction:, state:) if items_count.positive?
 
         if DETERMINISTIC_HTTP_STATUSES.member?(response&.status)
           state.abort!
@@ -254,14 +240,10 @@ module Html2rss
         log_info_fallback_zero_items(strategy:, next_strategy:, response:) if next_strategy
       end
 
-      # rubocop:disable-next Metrics/ParameterLists, Metrics/MethodLength -- success kwargs + structured selected log
-      def record_success(response:, strategy:, articles:, dedup_dropped:, admission_drops:, state:)
+      # rubocop:disable-next Metrics/MethodLength -- success + structured selected log
+      def record_success(response:, strategy:, extraction:, state:)
         attempt_count = state.attempts.size
-        state.succeed!(
-          response:, articles:, dedup_dropped:, selected_strategy: strategy,
-          attempt_count:, admission_drops:,
-          scrape_target:
-        )
+        state.succeed!(response:, extraction:, selected_strategy: strategy, attempt_count:, scrape_target:)
         return unless attempt_count > 1
 
         Log.info({

data/lib/html2rss/feed_pipeline/strategy_plan.rb

@@ -33,13 +33,13 @@ module Html2rss
         ##
         # @param name [Symbol, String] config or configure strategy value
         # @return [Auto, Concrete] resolved feed-level plan
-        # @raise [ArgumentError] when +name+ is neither +:auto+ nor a registered strategy
+        # @raise [InvalidOption] when +name+ is neither +:auto+ nor a registered strategy
         def resolve(name)
           normalized = name.to_sym
           return Auto.new if normalized == AUTO_NAME
 
           unless RequestService.strategy_registered?(normalized)
-            raise ArgumentError, "unknown strategy plan: #{name.inspect}"
+            raise InvalidOption, "unknown strategy plan: #{name.inspect}"
           end
 
           Concrete.new(strategy: normalized)
@@ -64,7 +64,7 @@ module Html2rss
 
           resolve(name)
           true
-        rescue ArgumentError
+        rescue InvalidOption
           false
         end
 

data/lib/html2rss/feed_pipeline.rb

@@ -10,11 +10,19 @@ module Html2rss
     # selected_strategy: set on :auto success; nil otherwise.
     # attempt_count: auto attempts attempted; 0 outside :auto.
     # strategy_attempts: auto attempt hashes (with optional transport_meta); empty outside :auto.
+    # feed_channel: channel facts of the native feed followed ({Syndication::ChannelFacts}); nil without one.
     PipelineOutcome = Data.define(
       :response, :articles, :dedup_dropped, :selected_strategy, :attempt_count, :strategy_attempts,
-      :admission_drops, :scrape_target, :entry_resolution
+      :admission_drops, :scrape_target, :entry_resolution, :feed_channel
     )
 
+    # What one response yields after extraction and dedup ({#extract}); its fields are the
+    # {PipelineOutcome} fields of the same names.
+    # articles: unique articles. dedup_dropped: articles removed by deduplication.
+    # admission_drops: Cleanup drop tallies. feed_channel: the followed native feed's channel facts
+    # ({Syndication::ChannelFacts}); nil without one.
+    Extraction = Data.define(:articles, :dedup_dropped, :admission_drops, :feed_channel)
+
     ##
     # @param raw_config [Hash{Symbol => Object}] user-provided feed config
     def initialize(raw_config)
@@ -71,11 +79,11 @@ module Html2rss
     # @param config [Html2rss::Config]
     # @param response [Html2rss::RequestService::Response]
     # @param request_session [Html2rss::RequestSession]
-    # @return [Array(Array<Html2rss::Article>, Integer, Hash)] unique articles, dedup drops, admission drops
-    def deduplicated_articles(config:, response:, request_session:)
-      collected, admission_drops = collect_articles(config:, response:, request_session:)
+    # @return [Extraction] unique articles with their dedup and admission drops and feed channel facts
+    def extract(config:, response:, request_session:)
+      collected, admission_drops, feed_channel = collect_articles(config:, response:, request_session:)
       unique = Article::Deduplicator.new(collected).call
-      [unique, collected.size - unique.size, admission_drops]
+      Extraction.new(articles: unique, dedup_dropped: collected.size - unique.size, admission_drops:, feed_channel:)
     end
 
     private
@@ -95,13 +103,12 @@ module Html2rss
     def run_pipeline_for_strategy(config, strategy:, resources:)
       request_session = request_session_for(config, strategy:, resources:)
       response = request_session.fetch_initial_response
-      articles, dedup_dropped, admission_drops = deduplicated_articles(config:, response:, request_session:)
-      raise_empty_auto_source!(strategy:, response:) if config.auto_source && articles.empty?
+      extraction = extract(config:, response:, request_session:)
+      raise_empty_auto_source!(strategy:, response:) if config.auto_source && extraction.articles.empty?
 
       PipelineOutcome.new(
-        response:, articles:, dedup_dropped:, selected_strategy: nil, attempt_count: 0,
-        strategy_attempts: [], admission_drops:,
-        scrape_target: ScrapeTarget.from_config(config), entry_resolution: nil
+        response:, selected_strategy: nil, attempt_count: 0, strategy_attempts: [],
+        scrape_target: ScrapeTarget.from_config(config), entry_resolution: nil, **extraction.to_h
       )
     end
 
@@ -127,49 +134,55 @@ module Html2rss
     end
 
     def collect_articles(config:, response:, request_session:)
-      selector = selector_articles(config:, response:, request_session:)
-      auto, admission_drops = auto_source_articles(config:, response:, request_session:)
-      [selector + auto, admission_drops]
+      selector, selector_drops = selector_articles(config:, response:, request_session:)
+      auto, auto_drops, feed_channel = auto_source_articles(config:, response:, request_session:)
+      [selector + auto, selector_drops.merge(auto_drops) { |_reason, left, right| left + right }, feed_channel]
     end
 
-    # rubocop:disable-next Metrics/MethodLength
+    # @return [Array(Array<Html2rss::Article>, Hash{String => Integer})] articles and unlinked-item drop tallies
     def selector_articles(config:, response:, request_session:)
-      return [] unless (selectors = config.selectors)
-      return [] if response.feed_response?
+      return [[], {}] unless (selectors = config.selectors)
+      return [[], {}] if response.feed_response?
 
       page_responses = request_session.page_responses(
         response,
         pagination_config: selectors.dig(:items, :pagination)
       )
+      engines = page_responses.lazy.map { |page| Selectors.new(page, selectors:, time_zone: config.time_zone) }
+      collect_selector_pages(engines)
+    end
 
+    # Stops at the first empty page after articles were found; drop tallies sum over the pages read.
+    def collect_selector_pages(engines)
       articles = []
-      page_responses.each do |page_response|
-        page_articles = Selectors.new(page_response, selectors:, time_zone: config.time_zone).articles
+      drops = Hash.new(0)
+      engines.each do |engine|
+        page_articles = engine.articles
+        engine.admission_drops.each { |reason, count| drops[reason] += count }
         break if page_articles.empty? && articles.any?
 
         articles.concat(page_articles)
       end
-      articles
+      [articles, drops]
     end
 
-    # @return [Array(Array<Html2rss::Article>, Hash{String => Integer})]
+    # @return [Array(Array<Html2rss::Article>, Hash{String => Integer}, Html2rss::Syndication::ChannelFacts)]
     def auto_source_articles(config:, response:, request_session:)
-      return [[], {}] unless (auto_source = config.auto_source)
+      return [[], {}, nil] unless (auto_source = config.auto_source)
       return syndication_articles(response) if response.feed_response?
 
       source = AutoSource.new(response, auto_source, request_session:)
-      [source.articles, source.admission_drops]
+      [source.articles, source.admission_drops, source.feed_channel]
     end
 
     def syndication_articles(response)
-      articles = Syndication::Parser.parse_response(response).map do |hash|
-        Article.new(**hash, scraper: AutoSource::Scraper::NativeFeed)
-      end
-      [articles, {}]
+      feed = Syndication::Parser.parse_response(response)
+      articles = feed.articles.map { |hash| Article.new(**hash, scraper: AutoSource::Scraper::NativeFeed) }
+      [articles, {}, feed.channel]
     end
 
     def feed_result_for(config, outcome) # rubocop:disable Metrics/MethodLength
-      channel = Channel.from_response(outcome.response, overrides: config.channel)
+      channel = Channel.from_response(outcome.response, overrides: config.channel, feed: outcome.feed_channel)
       status = Status.build(
         articles: outcome.articles,
         dedup_dropped: outcome.dedup_dropped,

data/lib/html2rss/feed_resolution/README.md

@@ -24,7 +24,7 @@ tournament on item count (feed-as-means) — intentional.
 
 ### CandidateGenerator mix
 
-- **Feed slot:** first `Syndication::Discovery.candidate_urls` only (alternates precede path guesses).
+- **Feed slot:** first same-domain `Syndication::Discovery.candidate_urls` entry. Alternates precede path guesses, except audio-hinted ones on a page without podcast signals. An alternate on another domain is skipped.
 - **Listing fill** (cap = `max - 1` when `max > 1`; `max == 1` → feed only): nav (`taxonomy_path +3`, `content_path +1`) → segment first-wins (`:list` → `:cluster` → `:semantic`, ≥2 same-origin primary links) → `LISTING_PATHS`.
 - Same-page / same-registrable-domain filters; feed never pads into listing slots.
 

data/lib/html2rss/feed_resolution/candidate_generator.rb

@@ -46,14 +46,12 @@ module Html2rss
 
       def listing_cap = max > 1 ? max - 1 : 0
 
+      # First eligible Discovery candidate: an alternate on another domain (Discovery ranks
+      # audio-hinted ones first on a podcast page) must not displace a same-domain feed or path guess.
       def feed_slot
         return unless parsed_html
 
-        url = Syndication::Discovery.candidate_urls(page_url: entry_url, parsed_body: parsed_html).first
-        return unless url
-        return unless eligible_url?(url)
-
-        url
+        Syndication::Discovery.candidate_urls(page_url: entry_url, parsed_body: parsed_html).find { eligible_url?(_1) }
       end
 
       def listing_urls
@@ -86,6 +84,8 @@ module Html2rss
         return [] unless parsed_html
 
         sst = SST::Normalizer.call(parsed_html)
+        return [] unless sst
+
         link_resolver = Scoring::LinkResolver.new(entry_url)
 
         SEGMENT_STRATEGIES.each do |strategy|
@@ -93,8 +93,6 @@ module Html2rss
           return urls if urls.size >= 2
         end
         []
-      rescue StandardError
-        []
       end
 
       def segment_urls_for(sst, strategy, link_resolver)
@@ -120,7 +118,7 @@ module Html2rss
         return if href.nil? || href.empty? || href.start_with?('#', 'mailto:', 'javascript:')
 
         Html2rss::Url.from_relative(href, entry_url)
-      rescue ArgumentError
+      rescue Html2rss::Url::InvalidUrlError
         nil
       end
 

data/lib/html2rss/feed_resolution/options.rb

@@ -8,15 +8,11 @@ module Html2rss
     # Typed +auto_source.entry_resolution+ options (one expansion from config Hash).
     class Options
       ##
-      # @param auto_source [Hash, nil]
+      # @param auto_source [Hash, nil] validated +auto_source+ config
       # @return [Options]
       def self.from_auto_source(auto_source)
-        raw = auto_source.is_a?(Hash) ? auto_source[:entry_resolution] : nil
-        raw = {} unless raw.is_a?(Hash)
-        new(
-          enabled: raw.fetch(:enabled, FeedResolution::DEFAULT_CONFIG[:enabled]) != false,
-          max_probes: Integer(raw.fetch(:max_probes, FeedResolution::DEFAULT_CONFIG[:max_probes]))
-        )
+        raw = auto_source&.dig(:entry_resolution) || {}
+        new(enabled: raw.fetch(:enabled, true), max_probes: raw.fetch(:max_probes, DEFAULT_CONFIG[:max_probes]))
       end
 
       ##

data/lib/html2rss/feed_resolution/policy.rb

@@ -8,40 +8,36 @@ module Html2rss
       # Minimum admitted articles before the entry URL is considered strong enough.
       ARTICLE_FLOOR = 3
 
-      module_function
-
-      ##
-      # @param config [Html2rss::Config]
-      # @param articles [Array<Html2rss::Article>] typed extract results (count derived)
-      # @param surface_category [Html2rss::SurfaceCategory, Symbol]
-      # @return [Boolean]
-      def resolve?(config:, articles:, surface_category:)
-        raise ArgumentError, 'articles must be an Array' unless articles.is_a?(Array)
-        return false unless eligible_config?(config)
-
-        category = SurfaceCategory[surface_category]
-        return false if category.blocked?
-
-        articles.size < ARTICLE_FLOOR || category.weak? || native_feed_majority?(articles)
-      end
-
-      def eligible_config?(config)
-        return false unless config.auto_source
-        return false if config.selectors
-
-        Options.from_auto_source(config.auto_source).enabled?
-      end
-      module_function :eligible_config?
-      private_class_method :eligible_config?
-
-      def native_feed_majority?(articles)
-        return false if articles.empty?
-
-        native = articles.count { |article| article.scraper == AutoSource::Scraper::NativeFeed }
-        native * 2 >= articles.size
+      class << self
+        ##
+        # @param config [Html2rss::Config]
+        # @param articles [Array<Html2rss::Article>] typed extract results (count derived)
+        # @param surface_category [Html2rss::SurfaceCategory, Symbol]
+        # @return [Boolean]
+        def resolve?(config:, articles:, surface_category:)
+          raise InvalidError, 'articles must be an Array' unless articles.is_a?(Array)
+          return false unless eligible_config?(config)
+
+          category = SurfaceCategory[surface_category]
+          return false if category.blocked?
+
+          articles.size < ARTICLE_FLOOR || category.weak? || native_feed_majority?(articles)
+        end
+
+        private
+
+        def eligible_config?(config)
+          return false unless config.auto_source
+          return false if config.selectors
+
+          Options.from_auto_source(config.auto_source).enabled?
+        end
+
+        def native_feed_majority?(articles)
+          native = articles.count { |article| article.scraper == AutoSource::Scraper::NativeFeed }
+          native * 2 >= articles.size
+        end
       end
-      module_function :native_feed_majority?
-      private_class_method :native_feed_majority?
     end
   end
 end

data/lib/html2rss/feed_resolution/probe.rb

@@ -16,7 +16,7 @@ module Html2rss
       # @param origin_url [String, Html2rss::Url]
       def initialize(request_session:, origin_url:)
         @request_session = request_session
-        @origin_url = Html2rss::Url.from_absolute(origin_url)
+        @origin_url = Url.from_absolute(origin_url)
       end
 
       ##
@@ -28,7 +28,9 @@ module Html2rss
           relation: :entry_resolution,
           origin_url:
         )
-        score_response(url, response)
+        score_response(response)
+      rescue Html2rss::ContractError
+        raise
       rescue Html2rss::Error
         nil
       end
@@ -37,9 +39,9 @@ module Html2rss
 
       attr_reader :request_session, :origin_url
 
-      def score_response(_url, response) # rubocop:disable Metrics/MethodLength -- feed vs HTML branches
+      def score_response(response) # rubocop:disable Metrics/MethodLength -- feed vs HTML branches
         if response.feed_response?
-          count = Syndication::Parser.parse_response(response).size
+          count = Syndication::Parser.parse_response(response).articles.size
           return Scored.new(
             url: response.url,
             score: Scorer.score_feed(articles_count: count),

data/lib/html2rss/feed_resolution/scorer.rb

@@ -11,38 +11,38 @@ module Html2rss
       # Bonus when the surface looks like a listing rather than a hub/shell.
       LISTING_SURFACE_BONUS = 5
 
-      module_function
+      class << self
+        ##
+        # @param articles_count [Integer]
+        # @return [Integer]
+        def score_feed(articles_count:)
+          articles_count * ARTICLE_WEIGHT
+        end
 
-      ##
-      # @param articles_count [Integer]
-      # @return [Integer]
-      def score_feed(articles_count:)
-        articles_count.to_i * ARTICLE_WEIGHT
-      end
-
-      ##
-      # @param assessment [Html2rss::PageRecon::Assessment]
-      # @return [Integer]
-      def score_assessment(assessment)
-        score = assessment.articles_count * ARTICLE_WEIGHT
-        score += LISTING_SURFACE_BONUS if assessment.listing_bonus?
-        drops = assessment.admission_drops.values.sum
-        total = assessment.articles_count + drops
-        score -= ((drops.to_f / total) * ARTICLE_WEIGHT).round if total.positive?
-        score
-      end
+        ##
+        # @param assessment [Html2rss::PageRecon::Assessment]
+        # @return [Integer]
+        def score_assessment(assessment)
+          score = assessment.articles_count * ARTICLE_WEIGHT
+          score += LISTING_SURFACE_BONUS if assessment.listing_bonus?
+          drops = assessment.admission_drops.values.sum
+          total = assessment.articles_count + drops
+          score -= ((drops.to_f / total) * ARTICLE_WEIGHT).round if total.positive?
+          score
+        end
 
-      ##
-      # @param scored [Array<Probe::Scored>]
-      # @param entry_articles_count [Integer]
-      # @return [Probe::Scored, nil]
-      def pick_winner(scored:, entry_articles_count:)
-        winner = scored.max_by(&:score)
-        return unless winner
-        return if winner.articles_count <= entry_articles_count.to_i
-        return if winner.score <= 0
+        ##
+        # @param scored [Array<Probe::Scored>]
+        # @param entry_articles_count [Integer]
+        # @return [Probe::Scored, nil]
+        def pick_winner(scored:, entry_articles_count:)
+          winner = scored.max_by(&:score)
+          return unless winner
+          return if winner.articles_count <= entry_articles_count.to_i
+          return if winner.score <= 0
 
-        winner
+          winner
+        end
       end
     end
   end