html2rss 0.23.0 → 0.25.0

data/lib/html2rss/feed_builder.rb

@@ -1,23 +1,15 @@
 # frozen_string_literal: true
 
 module Html2rss
-  # Entrypoint and namespace for feed building and formatting (RSS 2.0 / JSON Feed 1.1).
+  # Namespace for feed format adapters (RSS 2.0 / JSON Feed 1.1).
+  #
+  # {FeedResult} constructs {Rss} / {JsonFeed} directly — there is no dispatcher
+  # entrypoint on this module. Stylesheets are a scrape-time artifact carried on
+  # FeedResult; +feed_url+ is a render-time JSON Feed-only option.
+  #
+  # Channel field projection:
+  # - Rss: language, title, description, ttl, link, updated
+  # - JsonFeed: title, home_page_url, description, language, icon, authors (+ feed_url)
   module FeedBuilder
-    # Builds the requested feed type from the channel and article list.
-    #
-    # @param type [Symbol] :rss or :json_feed
-    # @param channel [Html2rss::Channel]
-    # @param articles [Array<Html2rss::Article>]
-    # @return [RSS::Rss, Hash] format-compliant representation of the feed
-    def self.build(type, channel:, articles:, **)
-      case type
-      when :rss
-        Rss.new(channel:, articles:, **).call
-      when :json_feed
-        JsonFeed.new(channel:, articles:).call
-      else
-        raise ArgumentError, "Unknown feed type: #{type}"
-      end
-    end
   end
 end

data/lib/html2rss/feed_pipeline/auto_fallback.rb

@@ -5,9 +5,10 @@ module Html2rss
     # Retries feed extraction across concrete request strategies for the :auto plan.
     #
     # Owned by {FeedPipeline}; invoked only after {StrategyPlan} resolves +:auto+.
+    # Hosted by the pipeline instance: session + extract call back into FeedPipeline.
     class AutoFallback
       # Ordered list of concrete request strategies attempted by the :auto plan.
-      CHAIN = %i[faraday botasaurus browserless].freeze
+      CHAIN = %i[faraday botasaurus].freeze
 
       # Error classes that should abort auto fallback immediately.
       NON_FALLBACK_ERRORS = [
@@ -44,34 +45,49 @@ module Html2rss
 
         # @param strategy [Symbol] strategy that returned a response
         # @param items_count [Integer] extracted article count
+        # @param transport_meta [Hash, nil] optional allowlisted upstream telemetry
         # @return [void]
-        def record_items(strategy:, items_count:)
-          @attempts << { strategy:, items_count:, error_class: nil }
+        def record_items(strategy:, items_count:, transport_meta: nil)
+          attempt = { strategy:, items_count:, error_class: nil }
+          attempt[:transport_meta] = transport_meta if transport_meta && !transport_meta.empty?
+          @attempts << attempt
         end
 
         # @param response [RequestService::Response] successful response
         # @param articles [Array] extracted articles
+        # @param dedup_dropped [Integer] articles removed by deduplication
+        # @param selected_strategy [Symbol] concrete strategy that produced items
+        # @param attempt_count [Integer] number of attempts recorded for this chain
         # @return [void]
-        def succeed!(response:, articles:)
-          @result = { response:, articles: }
+        def succeed!(response:, articles:, dedup_dropped:, selected_strategy:, attempt_count:)
+          @result = PipelineOutcome.new(
+            response:,
+            articles:,
+            dedup_dropped:,
+            selected_strategy:,
+            attempt_count:,
+            strategy_attempts: attempts
+          )
         end
       end
 
       ##
       # @param strategies [Array<Symbol>] ordered concrete strategies for fallback
       # @param budget [RequestService::Budget] shared request budget across retries
-      # @param session_for [Proc] request session factory proc
-      # @param articles_for [Proc] article extraction proc
+      # @param pipeline [Html2rss::FeedPipeline] host for session + article extraction
+      # @param config [Html2rss::Config] validated feed config
+      # @param resources [Html2rss::FeedPipeline::RuntimePolicy::Resources] budget + policy
       # @return [void]
-      def initialize(strategies:, budget:, session_for:, articles_for:)
+      def initialize(strategies:, budget:, pipeline:, config:, resources:)
         @strategies = strategies
         @budget = budget
-        @session_for = session_for
-        @articles_for = articles_for
+        @pipeline = pipeline
+        @config = config
+        @resources = resources
       end
 
       ##
-      # @return [Hash{Symbol => Object}] pipeline state containing :response and :articles
+      # @return [Html2rss::FeedPipeline::PipelineOutcome] scrape-finished state for materialization
       def call
         state = run_attempts
         return state.result if state.succeeded?
@@ -81,7 +97,7 @@ module Html2rss
 
       private
 
-      attr_reader :strategies, :budget, :session_for, :articles_for
+      attr_reader :strategies, :budget, :pipeline, :config, :resources
 
       def run_attempts
         AttemptState.new.tap do |state|
@@ -93,7 +109,7 @@ module Html2rss
       end
 
       def attempt(strategy:, next_strategy:, state:)
-        request_session = session_for.call(strategy:, budget:)
+        request_session = pipeline.request_session_for(config, strategy:, resources:)
         response = fetch_response(request_session:, strategy:, next_strategy:, state:)
         return unless response
 
@@ -106,38 +122,65 @@ module Html2rss
         raise
       rescue StandardError => error
         state.record_error(strategy:, error:)
-        log_warn_fallback_error(strategy:, next_strategy:, error:) if next_strategy
-        Log.debug("#{self.class}: strategy=#{strategy} error=#{error.class}: #{error.message}")
+        log_fallback_error(strategy:, next_strategy:, error:, request_session:) if next_strategy
         nil
       end
 
       def process_response(response:, strategy:, next_strategy:, request_session:, state:)
-        articles = articles_for.call(response:, request_session:)
+        articles, dedup_dropped = articles_for(response:, request_session:)
         items_count = articles.size
-        state.record_items(strategy:, items_count:)
-        Log.debug("#{self.class}: strategy=#{strategy} items=#{items_count}")
-        return record_success(response:, strategy:, articles:, state:) if items_count.positive?
+        state.record_items(strategy:, items_count:, transport_meta: response.transport_meta)
+        Log.debug("#{self.class}: strategy=#{strategy} items=#{items_count} " \
+                  "host=#{response.url.host} elapsed=#{format('%.3f', budget.elapsed_seconds)}s " \
+                  "budget_remaining=#{budget_remaining_label}")
+        return record_success(response:, strategy:, articles:, dedup_dropped:, state:) if items_count.positive?
 
-        log_info_fallback_zero_items(strategy:, next_strategy:) if next_strategy
+        log_info_fallback_zero_items(strategy:, next_strategy:, response:) if next_strategy
       end
 
-      def record_success(response:, strategy:, articles:, state:)
-        state.succeed!(response:, articles:)
-        return unless state.attempts.size > 1
+      def articles_for(response:, request_session:)
+        pipeline.deduplicated_articles(config:, response:, request_session:)
+      end
+
+      def record_success(response:, strategy:, articles:, dedup_dropped:, state:)
+        attempt_count = state.attempts.size
+        state.succeed!(response:, articles:, dedup_dropped:, selected_strategy: strategy, attempt_count:)
+        return unless attempt_count > 1
 
-        Log.info("#{self.class}: auto selected strategy=#{strategy} after attempts=#{state.attempts.size}")
+        Log.info("#{self.class}: auto selected strategy=#{strategy} after attempts=#{attempt_count} " \
+                 "host=#{response.url.host} elapsed=#{format('%.3f', budget.elapsed_seconds)}s " \
+                 "budget_remaining=#{budget_remaining_label}")
       end
 
       def finalize_failure(attempts:)
         raise NoFeedItemsExtracted.new(attempts:)
       end
 
-      def log_warn_fallback_error(strategy:, next_strategy:, error:)
-        Log.warn("#{self.class}: auto fallback #{strategy} -> #{next_strategy} after error=#{error.class}")
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def log_fallback_error(strategy:, next_strategy:, error:, request_session:)
+        host = request_session.url.host
+        detail = "host=#{host} elapsed=#{format('%.3f', budget.elapsed_seconds)}s " \
+                 "budget_remaining=#{budget_remaining_label}"
+        if error.is_a?(RequestService::RequestTimedOut)
+          Log.info("#{self.class}: auto fallback #{strategy} -> #{next_strategy} " \
+                   "after timeout=#{error.class} #{detail}")
+        else
+          Log.warn("#{self.class}: auto fallback #{strategy} -> #{next_strategy} " \
+                   "after error=#{error.class} #{detail}")
+        end
+        Log.debug("#{self.class}: strategy=#{strategy} error=#{error.class}: #{error.message} #{detail}")
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def log_info_fallback_zero_items(strategy:, next_strategy:, response:)
+        Log.info("#{self.class}: auto fallback #{strategy} -> #{next_strategy} after zero extracted items " \
+                 "host=#{response.url.host} elapsed=#{format('%.3f', budget.elapsed_seconds)}s " \
+                 "budget_remaining=#{budget_remaining_label}")
       end
 
-      def log_info_fallback_zero_items(strategy:, next_strategy:)
-        Log.info("#{self.class}: auto fallback #{strategy} -> #{next_strategy} after zero extracted items")
+      def budget_remaining_label
+        remaining = budget.remaining_timeout_seconds
+        remaining.nil? ? 'untracked' : format('%.3f', remaining)
       end
     end
   end

data/lib/html2rss/feed_pipeline.rb

@@ -4,8 +4,13 @@ module Html2rss
   ##
   # Builds feeds from validated config through request, extraction, and rendering stages.
   class FeedPipeline
-    # Bundle of inputs shared by selector and auto-source article collection.
-    ExtractionContext = Data.define(:config, :response, :request_session)
+    # Scrape-finished facts after request + extraction + dedup (before Channel/Status materialize).
+    # 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.
+    PipelineOutcome = Data.define(
+      :response, :articles, :dedup_dropped, :selected_strategy, :attempt_count, :strategy_attempts
+    )
 
     ##
     # @param raw_config [Hash{Symbol => Object}] user-provided feed config
@@ -14,34 +19,55 @@ module Html2rss
     end
 
     ##
-    # @return [RSS::Rss] generated RSS feed
-    def to_rss
-      run do |response:, config:, articles:|
-        channel = Html2rss::Channel.new(response, overrides: config.channel)
-        FeedBuilder.build(:rss, channel:, articles:, stylesheets: config.stylesheets)
-      end
+    # Runs the pipeline once and returns an opaque, Marshal-cacheable result.
+    #
+    # @return [Html2rss::FeedResult]
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- Status kwargs stay co-located with Channel
+    def to_result
+      config = Config.from_hash(raw_config, params: raw_config[:params])
+      outcome = pipeline_outcome_for(config)
+      channel = Channel.from_response(outcome.response, overrides: config.channel)
+      status = Status.build(
+        articles: outcome.articles,
+        dedup_dropped: outcome.dedup_dropped,
+        selected_strategy: outcome.selected_strategy,
+        attempt_count: outcome.attempt_count,
+        strategy_attempts: outcome.strategy_attempts
+      )
+      FeedResult.new(channel:, articles: outcome.articles, status:, stylesheets: config.stylesheets)
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    ##
-    # @return [Hash] generated JSONFeed 1.1 payload
-    def to_json_feed
-      run do |response:, config:, articles:|
-        channel = Html2rss::Channel.new(response, overrides: config.channel)
-        FeedBuilder.build(:json_feed, channel:, articles:)
-      end
+    # @api private Host seam for {AutoFallback} (and single-strategy path).
+    # @param config [Html2rss::Config]
+    # @param strategy [Symbol]
+    # @param resources [Html2rss::FeedPipeline::RuntimePolicy::Resources]
+    # @return [Html2rss::RequestSession]
+    def request_session_for(config, strategy:, resources:)
+      RequestSession.build(
+        config:,
+        strategy:,
+        budget: resources.budget,
+        policy: resources.policy
+      )
+    end
+
+    # @api private Host seam for {AutoFallback} (and single-strategy path).
+    # @param config [Html2rss::Config]
+    # @param response [Html2rss::RequestService::Response]
+    # @param request_session [Html2rss::RequestSession]
+    # @return [Array(Array<Html2rss::Article>, Integer)] unique articles and drop count
+    def deduplicated_articles(config:, response:, request_session:)
+      collected = collect_articles(config:, response:, request_session:)
+      unique = Article::Deduplicator.new(collected).call
+      [unique, collected.size - unique.size]
     end
 
     private
 
     attr_reader :raw_config
 
-    def run
-      config = Config.from_hash(raw_config, params: raw_config[:params])
-      state = pipeline_state_for(config)
-      yield response: state.fetch(:response), config:, articles: state.fetch(:articles)
-    end
-
-    def pipeline_state_for(config)
+    def pipeline_outcome_for(config)
       plan = StrategyPlan.resolve(config.strategy)
       resources = RuntimePolicy.resources_for(config)
       if plan.is_a?(StrategyPlan::Auto)
@@ -54,52 +80,37 @@ 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 = deduplicated_articles(
-        ExtractionContext.new(config:, response:, request_session:)
-      )
-      { response:, articles: }
-    end
+      articles, dedup_dropped = deduplicated_articles(config:, response:, request_session:)
+      if config.auto_source && articles.empty?
+        raise NoFeedItemsExtracted.new(attempts: [{ strategy:, items_count: 0, error_class: nil }])
+      end
 
-    def request_session_for(config, strategy:, resources:)
-      RequestSession.build(
-        config:,
-        strategy:,
-        budget: resources.budget,
-        policy: resources.policy
+      PipelineOutcome.new(
+        response:, articles:, dedup_dropped:, selected_strategy: nil, attempt_count: 0, strategy_attempts: []
       )
     end
 
-    def deduplicated_articles(extraction)
-      Article::Deduplicator.new(collect_articles(extraction)).call
-    end
-
-    # rubocop:disable Metrics/MethodLength
     def run_auto_pipeline(config, resources:)
       AutoFallback.new(
         strategies: AutoFallback::CHAIN,
         budget: resources.budget,
-        session_for: lambda do |strategy:, budget:|
-          budget.effective_timeout_seconds(fallback: resources.policy.total_timeout_seconds)
-          request_session_for(config, strategy:, resources:)
-        end,
-        articles_for: lambda do |response:, request_session:|
-          deduplicated_articles(ExtractionContext.new(config:, response:, request_session:))
-        end
+        pipeline: self,
+        config:,
+        resources:
       ).call
     end
-    # rubocop:enable Metrics/MethodLength
 
-    def collect_articles(extraction)
-      selector_articles(extraction) + auto_source_articles(extraction)
+    def collect_articles(config:, response:, request_session:)
+      selector_articles(config:, response:, request_session:) +
+        auto_source_articles(config:, response:, request_session:)
     end
 
     # rubocop:disable Metrics/MethodLength
-    def selector_articles(extraction)
-      config = extraction.config
+    def selector_articles(config:, response:, request_session:)
       return [] unless (selectors = config.selectors)
 
-      page_responses = extraction.request_session.page_responses(
-        extraction.response,
+      page_responses = request_session.page_responses(
+        response,
         pagination_config: selectors.dig(:items, :pagination)
       )
 
@@ -114,10 +125,10 @@ module Html2rss
     end
     # rubocop:enable Metrics/MethodLength
 
-    def auto_source_articles(extraction)
-      return [] unless (auto_source = extraction.config.auto_source)
+    def auto_source_articles(config:, response:, request_session:)
+      return [] unless (auto_source = config.auto_source)
 
-      AutoSource.new(extraction.response, auto_source, request_session: extraction.request_session).articles
+      AutoSource.new(response, auto_source, request_session:).articles
     end
   end
 end

data/lib/html2rss/feed_result.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ##
+  # Closed Marshal-cacheable handle for one scrape.
+  #
+  # Frozen consumer query/render set (do not grow without an explicit contract change):
+  # {#empty?}, {#channel_title}, {#to_rss}, {#to_json_feed}, and {#status}.
+  #
+  # Non-goals: no Channel reader, no Articles reader, no peephole into scrape internals.
+  # html2rss-web and other consumers must use only this surface.
+  #
+  # @note Gem contract: instances must round-trip through +Marshal.dump+ / +Marshal.load+
+  #   so web can cache one scrape and render RSS or JSON Feed on read. Loaded results
+  #   are re-frozen via private {#marshal_load}. For trusted cache reads only,
+  #   +Marshal.load(payload, freeze: true)+ is also safe.
+  class FeedResult
+    ##
+    # @param channel [Html2rss::Channel] channel metadata (internal; not exposed on the public API)
+    # @param articles [Array<Html2rss::Article>] extracted articles (deduplicated; not exposed)
+    # @param status [Html2rss::Status] pipeline telemetry
+    # @param stylesheets [Array<Hash>] optional RSS stylesheet configs
+    def initialize(channel:, articles:, status:, stylesheets: [])
+      raise ArgumentError, 'channel must be a Html2rss::Channel' unless channel.is_a?(Channel)
+      raise ArgumentError, 'status must be a Html2rss::Status' unless status.is_a?(Status)
+
+      articles = Array(articles)
+      raise ArgumentError, 'articles must all be Html2rss::Article' unless articles.all?(Article)
+
+      @channel = channel
+      @articles = articles.dup.freeze
+      @status = status
+      @stylesheets = freeze_stylesheets(stylesheets)
+      freeze
+    end
+
+    ##
+    # @return [Boolean] true when the scrape produced no items
+    def empty? = @articles.empty?
+
+    ##
+    # Channel title string only — does not expose the channel object.
+    #
+    # @return [String] title from the materialized channel
+    def channel_title = @channel.title
+
+    ##
+    # @return [RSS::Rss] RSS 2.0 document
+    def to_rss
+      FeedBuilder::Rss.new(
+        channel: @channel,
+        articles: @articles,
+        stylesheets: @stylesheets,
+        generator: status.to_generator_comment
+      ).call
+    end
+
+    ##
+    # @param feed_url [String, nil] optional self URL for JSON Feed (+feed_url+)
+    # @return [Hash] JSON Feed 1.1 hash
+    def to_json_feed(feed_url: nil)
+      FeedBuilder::JsonFeed.new(
+        channel: @channel,
+        articles: @articles,
+        feed_url:,
+        user_comment: status.to_generator_comment
+      ).call
+    end
+
+    ##
+    # @return [Html2rss::Status] frozen scraper tallies, dedup count, and generator formatter.
+    #   {Status#to_h} on +status+ is a stable consumer contract for observability payloads.
+    attr_reader :status
+
+    private
+
+    # Constructor payload for Marshal (avoids default ivar thaw). Rebuilds via {#initialize}.
+    def marshal_dump = [@channel, @articles, @status, @stylesheets]
+
+    def marshal_load((channel, articles, status, stylesheets))
+      initialize(channel:, articles:, status:, stylesheets:)
+    end
+
+    def freeze_stylesheets(stylesheets)
+      Array(stylesheets).map do |sheet|
+        sheet.to_h.transform_keys(&:to_sym).transform_values do |value|
+          value.is_a?(String) ? value.dup.freeze : value
+        end.freeze
+      end.freeze
+    end
+  end
+end

data/lib/html2rss/html/article_extractor/category_extractor.rb

@@ -7,20 +7,16 @@ module Html2rss
       # CategoryExtractor is responsible for extracting categories from HTML elements
       # by looking for CSS class names containing common category-related terms.
       class CategoryExtractor
-        # Common category-related terms to look for in class names
-        CATEGORY_TERMS = %w[
-          category categories tag tags topic topics section sections
-          label labels theme themes subject subjects
-        ].freeze
+        # Shared category vocabulary (owned by {ArticleRules::Category}).
+        CATEGORY_TERMS = ArticleRules::Category::CATEGORY_TERMS
+        # Shared category attribute/class pattern (owned by {ArticleRules::Category}).
+        CATEGORY_ATTR_PATTERN = ArticleRules::Category::CATEGORY_ATTR_PATTERN
 
         # CSS selectors to find elements with category-related class names or data attributes
         CATEGORY_SELECTORS = CATEGORY_TERMS.flat_map do |term|
           ["[class*=\"#{term}\"]", "[data-#{term}]", "[#{term}]"]
         end.freeze
 
-        # Regex pattern for matching category-related attribute names
-        CATEGORY_ATTR_PATTERN = /#{CATEGORY_TERMS.join('|')}/i
-
         ##
         # Extracts categories from the given article tag by looking for elements
         # with class names containing common category-related terms.
@@ -30,7 +26,6 @@ module Html2rss
         def self.call(article_tag)
           return [] unless article_tag
 
-          # Single optimized traversal that extracts all category types
           extract_all_categories(article_tag)
             .map(&:strip)
             .reject(&:empty?)
@@ -44,10 +39,7 @@ module Html2rss
         def self.extract_all_categories(article_tag)
           Set.new.tap do |categories|
             article_tag.css(CATEGORY_SELECTORS.join(',')).each do |element|
-              # Extract text categories from elements with category-related class names
-              extract_text_categories!(categories, element) if element['class']&.match?(CATEGORY_ATTR_PATTERN)
-
-              # Extract data categories from all elements
+              extract_text_categories!(categories, element) if ArticleRules::Category.class_match?(element['class'])
               extract_element_data_categories!(categories, element)
             end
           end
@@ -61,10 +53,9 @@ module Html2rss
         # @return [void]
         def self.extract_element_data_categories!(categories, element)
           element.attributes.each_value do |attr|
-            next unless attr.name.match?(CATEGORY_ATTR_PATTERN)
+            next unless ArticleRules::Category.attr_name_match?(attr.name)
 
-            value = attr.value&.strip
-            categories.add(value) if value && !value.empty?
+            ArticleRules::Category.add_text!(categories, attr.value)
           end
         end
 
@@ -85,7 +76,7 @@ module Html2rss
           if anchors.any?
             anchors.each { |node| add_text_to_categories!(categories, node) }
           else
-            extract_split_text_categories!(categories, element)
+            ArticleRules::Category.add_split_text!(categories, element.text)
           end
         end
 
@@ -96,27 +87,10 @@ module Html2rss
         # @param element [Nokogiri::XML::Element] The element to extract text from
         # @return [void]
         def self.add_text_to_categories!(categories, element)
-          text = Navigator.extract_visible_text(element)
-          categories.add(text) if text && !text.empty?
-        end
-
-        ##
-        # Extracts categories from the element's text by splitting on newlines.
-        #
-        # @param categories [Set<String>] Accumulator set
-        # @param element [Nokogiri::XML::Element] The element to extract text from
-        # @return [void]
-        def self.extract_split_text_categories!(categories, element)
-          text = element.text
-          return unless text
-
-          text.split(/\n+/).each do |line|
-            line = line.strip
-            categories.add(line) unless line.empty?
-          end
+          ArticleRules::Category.add_text!(categories, Navigator.extract_visible_text(element))
         end
 
-        private_class_method :add_text_to_categories!, :extract_split_text_categories!
+        private_class_method :add_text_to_categories!
       end
     end
   end

data/lib/html2rss/html/article_extractor/date_extractor.rb

@@ -8,13 +8,8 @@ module Html2rss
         # @param article_tag [Nokogiri::XML::Element] article container node
         # @return [DateTime, nil]
         def self.call(article_tag)
-          times = article_tag.css('[datetime]').filter_map do |tag|
-            DateTime.parse(tag['datetime'])
-          rescue ArgumentError, TypeError
-            nil
-          end
-
-          times.min
+          datetimes = article_tag.css('[datetime]').map { |tag| tag['datetime'] }
+          ArticleRules::Date.earliest(datetimes)
         end
       end
     end

data/lib/html2rss/html/article_extractor/enclosure_extractor.rb

@@ -33,62 +33,17 @@ module Html2rss
         def self.extract_from_element(element, base_url)
           case element.name
           when 'img'
-            extract_image(element, base_url)
+            ArticleRules::Enclosure.from_image(element['src'], base_url)
           when 'video', 'audio', 'source'
-            extract_media(element, base_url)
+            ArticleRules::Enclosure.from_media(element['src'], element['type'], base_url)
           when 'iframe'
-            extract_iframe(element, base_url)
+            ArticleRules::Enclosure.from_iframe(element['src'], base_url)
           when 'a'
-            extract_a(element, base_url)
+            ArticleRules::Enclosure.from_anchor(element['href'], base_url)
           end
         end
 
-        def self.extract_image(img, base_url)
-          src = img['src'].to_s
-          return if src.empty?
-
-          abs_url = Url.from_relative(src, base_url)
-          {
-            url: abs_url,
-            type: Article::Enclosure.guess_content_type_from_url(abs_url, default: 'image/jpeg')
-          }
-        end
-
-        def self.extract_media(element, base_url)
-          src = element['src'].to_s
-          return if src.empty?
-
-          {
-            url: Url.from_relative(src, base_url),
-            type: element['type']
-          }
-        end
-
-        def self.extract_iframe(iframe, base_url)
-          src = iframe['src'].to_s
-          return if src.empty?
-
-          abs_url = Url.from_relative(src, base_url)
-          {
-            url: abs_url,
-            type: Article::Enclosure.guess_content_type_from_url(abs_url, default: 'text/html')
-          }
-        end
-
-        def self.extract_a(link, base_url)
-          href = link['href'].to_s
-          return if href.empty?
-
-          abs_url = Url.from_relative(href, base_url)
-
-          if href.end_with?('.pdf')
-            { url: abs_url, type: Article::Enclosure.guess_content_type_from_url(abs_url) }
-          else
-            { url: abs_url, type: 'application/zip' }
-          end
-        end
-
-        private_class_method :extract_from_element, :extract_image, :extract_media, :extract_iframe, :extract_a
+        private_class_method :extract_from_element
       end
     end
   end