html2rss 0.33.0 → 0.34.0

data/lib/html2rss/html/navigator/text_extractor.rb

@@ -5,7 +5,9 @@ module Html2rss
     class Navigator
       ##
       # TextExtractor extracts visible text from DOM elements, preserving lists
-      # and block spacing while sanitizing white spaces.
+      # and block spacing while sanitizing white spaces. Same joining rule as {SST::Text}: an inline element
+      # embedded in direct text and touching it stays in its word (+Straßenbah<span>n</span> für+), while two
+      # adjacent elements and an element opening or closing its parent's text always separate.
       class TextExtractor
         # HTML block elements that trigger line breaks or special formatting.
         BLOCK_TAGS = %w[p div li ul ol h1 h2 h3 h4 h5 h6 tr br].to_set.freeze
@@ -29,19 +31,21 @@ module Html2rss
 
           private
 
+          # +last+ is [node, block?] of the previous piece with text.
           def iterate_children(tag, separator, exclude_nodes)
-            last = false
-            tag.children.each_with_object([]) do |c, p|
-              next if exclude_nodes&.include?(c) || !visible_child?(c)
+            last = nil
+            tag.children.each_with_object([]) do |c, parts|
+              text, block = process_child_node(c, separator, exclude_nodes) if shown?(c, exclude_nodes)
+              next if text.to_s.empty?
 
-              text, block = process_child_node(c, separator, exclude_nodes)
-              next if text.empty?
-
-              append_separator!(p, separator, block, last)
-              (p << text) && (last = block)
+              parts << gap(separator, block, last, c) if last
+              parts << text
+              last = [c, block]
             end
           end
 
+          def shown?(child, exclude_nodes) = !exclude_nodes&.include?(child) && visible_child?(child)
+
           def process_child_node(child, separator, exclude_nodes)
             child_text = get_child_text(child, separator, exclude_nodes)
             return ['', false] if child_text.empty?
@@ -58,16 +62,22 @@ module Html2rss
             end
           end
 
-          def append_separator!(parts, separator, is_block, last_was_block)
-            return if parts.empty?
+          def gap(separator, is_block, last, child)
+            return (separator == ' ' ? "\n" : separator) if is_block || last.last
 
-            parts << if is_block || last_was_block
-                       (separator == ' ' ? "\n" : separator)
-                     else
-                       ' '
-                     end
+            touching?(last.first, child) ? '' : ' '
           end
 
+          # Whether direct text and an inline element meet as adjacent siblings with no whitespace between
+          # them. Only an element embedded in direct text (a text sibling on both sides) touches it.
+          def touching?(before, after)
+            element = before.element? ? before : after
+            before.next_sibling == after && embedded?(element) &&
+              !before.text.match?(/\s\z/) && !after.text.match?(/\A\s/)
+          end
+
+          def embedded?(element) = element.previous_sibling&.text? && element.next_sibling&.text?
+
           def visible_child?(node)
             !INVISIBLE_CONTENT_TAGS.include?(node.name) &&
               !(node.name == 'a' && node['href']&.start_with?('#'))

data/lib/html2rss/html/navigator.rb

@@ -5,17 +5,17 @@ module Html2rss
     ##
     # Navigator owns DOM chrome recognition and node traversal helpers.
     class Navigator
+      # String forms of {SST::Tags} (the vocabulary owner); no delta today.
       # Heading tags used to prioritize title extraction and container assessment.
-      HEADING_TAGS = Set['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].freeze
+      HEADING_TAGS = SST::Tags::HEADING_NAMES.to_set(&:to_s).freeze
 
       # Element tags that indicate ignored DOM chrome when found in a container path.
-      IGNORED_CONTAINER_TAGS = Set['nav', 'footer', 'header', 'svg', 'script', 'style'].freeze
+      IGNORED_CONTAINER_TAGS = SST::Tags::IGNORED_CONTAINER_NAMES.to_set(&:to_s).freeze
 
-      # Ancestor tags that usually indicate navigation/utility regions inside a content container.
-      UTILITY_LANDMARK_TAGS = Set['nav', 'aside', 'footer', 'menu'].freeze
-
-      # Immediate parent walk stops here — not a usable article card.
-      CARD_WALK_STOP_TAGS = (UTILITY_LANDMARK_TAGS | IGNORED_CONTAINER_TAGS | Set['html', 'body']).freeze
+      # Immediate parent walk stops here — not a usable article card. Utility landmarks
+      # (tags and roles, {SST::Tags.utility_landmark?}) stop too, and page-level header/footer
+      # (or banner/contentinfo roles), via {usable_card_parent?}.
+      CARD_WALK_STOP_TAGS = (IGNORED_CONTAINER_TAGS | Set['html', 'body']).freeze
 
       # Inner tags that mean a wrapping <a> is a card, not a span-styled list link.
       WRAPPING_ANCHOR_CHILD_TAGS = (HEADING_TAGS + %w[p]).freeze
@@ -23,7 +23,7 @@ module Html2rss
       # Anchor selector used to identify the canonical article link element.
       MAIN_ANCHOR_SELECTOR = begin
         buf = +'a[href]:not([href=""])'
-        %w[# javascript: mailto: tel: file:// sms: data:].each do |prefix|
+        SST::Tags::SKIP_HREF_PREFIXES.each do |prefix|
           buf << %[:not([href^="#{prefix}"])]
         end
         buf.freeze
@@ -67,6 +67,7 @@ module Html2rss
 
         ##
         # Immediate parent is a usable article card (not html/body/landmark chrome).
+        # A header/footer inside article/section/aside/main belongs to its card.
         #
         # @param node [Nokogiri::XML::Node, SST::Node, nil]
         # @return [Boolean]
@@ -74,7 +75,11 @@ module Html2rss
           return false unless node
           return false if node.is_a?(Nokogiri::XML::Document)
 
-          !CARD_WALK_STOP_TAGS.include?(Probe.tag(node))
+          tag = Probe.tag(node)
+          role = node.is_a?(SST::Node) ? node.attrs.raw['role'] : node['role']
+          return !page_chrome?(node) if SST::Tags.page_level_chrome?(tag, role)
+
+          !CARD_WALK_STOP_TAGS.include?(tag) && !SST::Tags.utility_landmark?(tag, role)
         end
 
         ##
@@ -123,6 +128,31 @@ module Html2rss
           end
           false
         end
+
+        private
+
+        # Whether a header/footer is page-level chrome. SST nodes defer to the
+        # Normalizer's chrome index (unindexed nodes stay chrome); Nokogiri nodes
+        # check for a sectioning ancestor.
+        #
+        # @param node [Nokogiri::XML::Node, SST::Node]
+        # @return [Boolean]
+        def page_chrome?(node)
+          if node.is_a?(SST::Node)
+            index = SST::Index.for_node(node)
+            return index.nil? || index.ignored_chrome?(node)
+          end
+
+          nokogiri_chrome_scope(node) == :chrome
+        end
+
+        # Folds {SST::Tags.chrome_scope} over a Nokogiri node's ancestors, root first.
+        #
+        # @param node [Nokogiri::XML::Node]
+        # @return [Symbol] +:page+, +:sectioned+, or +:chrome+
+        def nokogiri_chrome_scope(node)
+          (node.ancestors.reverse << node).reduce(:page) { |scope, el| el.element? ? SST::Tags.chrome_scope(el, scope) : scope }
+        end
       end
     end
   end

data/lib/html2rss/html/probe.rb

@@ -15,6 +15,10 @@ module Html2rss
       APPLICATION_RSS_XML = 'application/rss+xml'
       # @see #mime_match?
       APPLICATION_ATOM_XML = 'application/atom+xml'
+      # @see #mime_match?
+      APPLICATION_RDF_XML = 'application/rdf+xml'
+      # Every syndication format advertised by +link[rel=alternate]+ (RSS 2.0, Atom, RSS 1.0 / RDF).
+      FEED_MIME_TYPES = [APPLICATION_RSS_XML, APPLICATION_ATOM_XML, APPLICATION_RDF_XML].freeze
 
       class << self
         ##

data/lib/html2rss/html/rendering/description_builder.rb

@@ -3,32 +3,38 @@
 module Html2rss
   module Html
     module Rendering
-      # Builds a sanitized article description from the base text, title, and optional media.
+      # Builds a sanitized article description from the base text, title, and at most one media element.
       #
-      # Combines media elements (images, audio, video, PDFs) with sanitized text content
-      # to create rich RSS descriptions that reveal more scraped information.
+      # The media element is the item's RSS enclosure when it is an audio or video file (a player), else the item
+      # image; a downloadable document (PDF, ZIP) falls back to the image. Nothing is rendered when the sanitized
+      # description already references that file: an +src+, +href+ or +srcset+ URL resolving to the same normalized
+      # absolute URL. Those attributes are parsed only when the description contains the file name (+File.basename+
+      # of its path).
       #
       # @example Basic usage
       #   builder = DescriptionBuilder.new(
       #     base: "Article content",
       #     title: "Article Title",
       #     url: "https://example.com",
-      #     enclosures: [enclosure_object],
+      #     enclosure: enclosure_object,
       #     image: "https://example.com/image.jpg"
       #   )
       #   description = builder.call
       class DescriptionBuilder
-        # Removes the specified pattern from the beginning of the text
-        # within a given range if the pattern occurs before the range's end.
+        # XPath of the attributes whose URLs count as the description already showing a file.
+        URL_ATTRIBUTES = './/@src|.//@href|.//@srcset'
+
+        # Removes the first occurrence of the pattern in the text content (never inside a tag or attribute)
+        # if it starts before the range's end. Text after a stray +<+ that opens no tag is left alone.
         #
         # @param text [String]
-        # @param pattern [String]
+        # @param pattern [String, nil] nothing is removed without one
         # @param end_of_range [Integer] Optional, defaults to half the text length
         # @return [String]
-        def self.remove_pattern_from_start(text, pattern, end_of_range: (text.size * 0.5).to_i)
-          return text unless text.is_a?(String) && pattern.is_a?(String) && !pattern.empty?
+        def self.remove_pattern_from_start(text, pattern, end_of_range: text.size / 2)
+          return text unless pattern
 
-          index = text.index(pattern)
+          index = text.index(/\A(?:<[^>]*>|[^<])*?\K#{Regexp.escape(pattern)}/)
           return text if index.nil? || index > end_of_range
 
           "#{text[0, index]}#{text[(index + pattern.size)..]}"
@@ -36,52 +42,60 @@ module Html2rss
 
         # @param base [String] The base text content for the description
         # @param title [String] The article title (used for alt text and title removal)
-        # @param url [String, Html2rss::Url] The article URL (used for sanitization)
-        # @param enclosures [Array<Html2rss::Article::Enclosure>, nil] Media enclosures
-        # @param image [String, Html2rss::Url, nil] Fallback image URL
-        def initialize(base:, title:, url:, enclosures:, image:)
+        # @param url [String, Html2rss::Url] The article URL (used for sanitization and URL resolution)
+        # @param enclosure [Html2rss::Article::Enclosure, nil] the item's RSS enclosure
+        #   ({FeedBuilder::ItemPresentation.rss_enclosure_for}); rendered only when audio or video
+        # @param image [String, Html2rss::Url, nil] item image URL, rendered when the enclosure is no player
+        def initialize(base:, title:, url:, enclosure:, image:)
           @base = base.to_s
           @title = title
           @url = url
-          @enclosures = Array(enclosures)
+          @player = enclosure if enclosure&.media?
           @image = image
         end
 
-        # Generates the complete description with media and sanitized text.
+        # Generates the description: the media element (unless the text already shows it) and the sanitized text.
         #
         # @return [String, nil] The complete description or nil if empty
         def call
-          fragments = []
-          fragments.concat(Array(rendered_media))
-          fragments << processed_base_description
+          text = processed_base_description
+          file = @player&.url || @image
+          media = media_html if file && !(text && shown?(text, Url.from_absolute(file)))
 
-          result = fragments.compact.join("\n\n").strip
-          result.empty? ? nil : result
+          parts = [media, text].compact
+          parts.join("\n\n") unless parts.empty?
         end
 
         private
 
-        def rendered_media
-          rendered = render_enclosures
-          return rendered if rendered.any?
-          return render_fallback_image if @image
+        def media_html
+          if @player&.video? then VideoRenderer.new(url: @player.url, type: @player.type).to_html
+          elsif @player then AudioRenderer.new(url: @player.url, type: @player.type).to_html
+          else ImageRenderer.new(url: @image, title: @title).to_html
+          end
+        end
 
-          []
+        def shown?(text, file)
+          text.include?(File.basename(file.path)) && referenced_urls(text).include?(file.to_s)
         end
 
-        def render_enclosures
-          @enclosures.filter_map do |enclosure|
-            MediaRenderer.for(enclosure:, image: @image, title: @title)&.to_html
+        def referenced_urls(text)
+          Nokogiri::HTML.fragment(text).xpath(URL_ATTRIBUTES).flat_map do |attribute|
+            value = attribute.value
+            values = attribute.name == 'srcset' ? value.split(',').map { _1[/\S+/] } : [value]
+            values.map { resolve(_1) }
           end
         end
 
-        def render_fallback_image
-          [MediaRenderer.for(enclosure: nil, image: @image, title: @title)&.to_html]
+        def resolve(value)
+          Url.from_relative(value, @url).to_s
+        rescue Url::InvalidUrlError
+          nil
         end
 
         def processed_base_description
           text = self.class.remove_pattern_from_start(@base, @title)
-          Html2rss::Selectors::PostProcessors::SanitizeHtml.call(text, @url)
+          Selectors::PostProcessors::SanitizeHtml.call(text, @url)
         end
       end
     end

data/lib/html2rss/html/rendering.rb

@@ -2,8 +2,8 @@
 
 module Html2rss
   module Html
-    # Namespace for HTML rendering logic, used to generate rich content such as
-    # images, audio, video, or embedded documents for feed descriptions.
+    # Namespace for HTML rendering logic: the feed item description and its one media element
+    # (an image, audio or video player).
     #
     # @see Html2rss::Html::Rendering::DescriptionBuilder
     #
@@ -12,13 +12,6 @@ module Html2rss
     #     url: "https://example.com/image.jpg",
     #     title: "Example"
     #   ).to_html
-    #
-    # @example
-    #   Html2rss::Html::Rendering::MediaRenderer.for(
-    #     enclosure: nil,
-    #     image: "https://example.com/image.jpg",
-    #     title: "Example"
-    #   )
     module Rendering
     end
   end

data/lib/html2rss/html/sst_article_extractor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'zlib'
-
 module Html2rss
   module Html
     ##
@@ -9,10 +7,9 @@ module Html2rss
     # Port of Html::ArticleExtractor field logic onto SST::Node.
     # rubocop:disable-next Metrics/ClassLength -- SST field extractors colocated for parity with ArticleExtractor
     class SstArticleExtractor
-      # CSS class tokens that mark kicker / eyebrow text (excluded from titles).
-      KICKER_CLASS_PATTERN = /kicker|eyebrow|pre-title|pretitle|overline/i
-      # Inline emphasis tags used as title fallbacks when no heading exists.
-      FALLBACK_HEADING_NAMES = Set[:strong, :b].freeze
+      # CSS class tokens that mark title-like nodes. Broad on purpose: also shared with
+      # {Html2rss::SelectorCandidates}, which owns no copy of it.
+      TITLE_CLASS_PATTERN = /title|font-bold|font-semibold/
       # Nested blocks that mean a category node is actually a content container.
       CATEGORY_CONTAINER_NAMES = Set[:p, :article, :section].freeze
 
@@ -21,49 +18,50 @@ module Html2rss
         # @param ranked_or_segment [Scoring::RankedSegment, AutoSource::Segment]
         # @param base_url [String, Html2rss::Url]
         # @param scraper [Class, nil]
-        # @param fallback_anchorless [Boolean]
         # @param time_zone [String] channel time zone for naive leftover dates
-        # @return [Html2rss::Article, nil]
-        def call(ranked_or_segment, base_url:, scraper: nil, fallback_anchorless: false, time_zone: 'UTC')
-          new(ranked_or_segment, base_url:, scraper:, fallback_anchorless:, time_zone:).call
+        # @return [Html2rss::Article, nil] nil when the segment has no primary link (no URL of its own)
+        def call(ranked_or_segment, base_url:, scraper: nil, time_zone: 'UTC')
+          new(ranked_or_segment, base_url:, scraper:, time_zone:).call
         end
       end
 
       # @param ranked_or_segment [Scoring::RankedSegment, AutoSource::Segment]
       # @param base_url [String, Html2rss::Url]
       # @param scraper [Class, nil]
-      # @param fallback_anchorless [Boolean]
       # @param time_zone [String] channel time zone for naive leftover dates
-      def initialize(ranked_or_segment, base_url:, scraper: nil, fallback_anchorless: false, time_zone: 'UTC')
+      def initialize(ranked_or_segment, base_url:, scraper: nil, time_zone: 'UTC')
         segment = ranked_or_segment.is_a?(Scoring::RankedSegment) ? ranked_or_segment.segment : ranked_or_segment
-        raise ArgumentError, 'segment is required' unless segment.is_a?(AutoSource::Segment)
+        raise InvalidError, 'segment is required' unless segment.is_a?(AutoSource::Segment)
 
         @segment = segment
         @root = segment.root_node
         @selected_anchor = segment.primary_link
         @base_url = base_url
         @scraper = scraper
-        @fallback_anchorless = fallback_anchorless
         @time_zone = time_zone
       end
 
       ##
       # @return [Html2rss::Article, nil]
       def call # rubocop:disable Metrics/MethodLength
-        title = extract_title
+        return unless @selected_anchor
+
+        title = title_from_in_card_sources
         lines = leftover_lines
         published_at = extract_published_at(lines)
         root, lines, published_at = parent_card_fields(title, lines, published_at)
         attrs = {
           title:,
+          kicker: title_pieces.kicker_text,
           url: extract_url,
           image: extract_image,
           description: ArticleRules::Description.from_lines(lines, title:),
-          id: generate_id,
+          id: parse_id_from_dom,
           published_at:,
           enclosures: extract_enclosures,
           categories: extract_categories(title, root:),
-          scraper: @scraper
+          scraper: @scraper,
+          compose_title: true
         }
         article = Article.new(**attrs)
         article.valid? ? article : nil
@@ -73,33 +71,17 @@ module Html2rss
 
       def extract_url
         @extract_url ||= begin
-          href = @selected_anchor&.attrs&.href.to_s
-          if href.empty?
-            anchorless_url_fallback
-          else
-            Url.from_relative(href.split('#').first.strip, @base_url)
-          end
+          href = @selected_anchor.attrs.href.to_s
+          Url.from_relative(href.split('#').first.strip, @base_url) unless href.empty?
         end
       end
 
-      def anchorless_url_fallback
-        return unless @fallback_anchorless
-
-        id = generate_id
-        Url.from_relative("##{id}", @base_url) if id
-      end
-
-      def extract_title
-        title_text = title_from_in_card_sources
-        return unless title_text
+      # Kicker and headline text ({TitlePieces}) of this card.
+      def title_pieces = @title_pieces ||= TitlePieces.new(@root, heading || @selected_anchor, anchor: @selected_anchor)
 
-        kicker = kicker_node&.visible_text.to_s.strip
-        kicker && !kicker.empty? && !title_text.include?(kicker) ? "#{kicker}: #{title_text}" : title_text
-      end
-
-      # Prefer a non-junk title. Credit-only cards may blank to nil (description can carry
-      # the item). Other junk shapes must stay present so Cleanup can hard-reject them —
-      # blanking slug/CMS/template text would admit titleless cards.
+      # Prefer a non-junk headline ({Article} composes it with {#kicker_text}). A credit-only card
+      # blanks to nil, and Cleanup drops the untitled item as +blank_title+. Other junk shapes stay
+      # present so Cleanup rejects them under their own reason (slug, CMS, template).
       #
       # @return [String, nil]
       def title_from_in_card_sources
@@ -110,14 +92,11 @@ module Html2rss
         candidates.find { |text| AutoSource::Cleanup.junk_reason(text) != :credit }
       end
 
-      # @return [Array<String>] ordered in-card title candidates (heading → anchor → fallback)
+      # @return [Array<String>] ordered in-card title candidates (heading → anchor)
       def title_candidates
         [].tap do |candidates|
-          add_title_candidate!(candidates, heading&.visible_text)
-          add_title_candidate!(candidates, @selected_anchor&.visible_text)
-          next unless candidates.empty? && @fallback_anchorless && @selected_anchor.nil?
-
-          add_title_candidate!(candidates, first_nonempty_own_text)
+          add_title_candidate!(candidates, heading_title_text)
+          add_title_candidate!(candidates, title_pieces.headline_text(@selected_anchor))
         end
       end
 
@@ -131,14 +110,13 @@ module Html2rss
         candidates << stripped
       end
 
+      # @return [String, nil] the heading's headline text ({TitlePieces#headline_text})
+      def heading_title_text = title_pieces.headline_text(heading)
+
       def heading
         @heading ||= begin
           tags = @root.find_all(&:heading?)
-          if tags.any?
-            select_best_heading(tags)
-          elsif @fallback_anchorless && @selected_anchor.nil?
-            fallback_heading
-          end
+          select_best_heading(tags) if tags.any?
         end
       end
 
@@ -155,42 +133,13 @@ module Html2rss
         best
       end
 
-      def fallback_heading
-        @root.find do |n|
-          next true if FALLBACK_HEADING_NAMES.include?(n.name)
-
-          n.attrs.class_names.any? { |c| c.match?(/title|font-bold|font-semibold/) } &&
-            !n.visible_text.to_s.strip.empty?
-        end
-      end
-
-      def kicker_node # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        @kicker_node ||= begin
-          node = @root.find do |n|
-            n.attrs.raw.key?('data-tb-kicker') ||
-              n.attrs.class_names.any? { |c| c.match?(KICKER_CLASS_PATTERN) }
-          end
-          node && heading && (node.equal?(heading) || descendant_of?(node, heading)) ? nil : node
-        end
-      end
-
-      def descendant_of?(child, ancestor)
-        return true if child.equal?(ancestor)
-
-        if (index = SST::Index.for_node(child))
-          return index.descendant_of?(child, ancestor)
-        end
-
-        !ancestor.find { |d| d.equal?(child) }.nil?
-      end
-
       def leftover_lines
         leftover_lines_from(@root)
       end
 
       def leftover_lines_from(node)
         times = node.find_all { |n| n.name == :time }
-        exclude = [heading, @selected_anchor, kicker_node, *times].compact
+        exclude = [heading, @selected_anchor, title_pieces.kicker, *times].compact
         ArticleRules::Description.lines_from(node.visible_text(exclude:))
       end
 
@@ -234,7 +183,7 @@ module Html2rss
         CardWalk.thin_wrapper?(
           children: node.children,
           item: @root,
-          descendant_of: ->(item, child) { descendant_of?(item, child) }
+          descendant_of: ->(item, child) { SST::Index.descendant_or_self?(item, child) }
         )
       end
 
@@ -253,48 +202,15 @@ module Html2rss
         SST::Index.for_node(@root)&.parent_of(@root)
       end
 
-      def generate_id # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        @generate_id ||= begin
-          id_from_dom = parse_id_from_dom
-          if id_from_dom
-            id_from_dom
-          else
-            heading_text = heading&.visible_text
-            heading_text = first_nonempty_own_text if heading_text.to_s.strip.empty? && @fallback_anchorless
-            if heading_text && !heading_text.strip.empty?
-              generate_slug(heading_text)
-            elsif @fallback_anchorless
-              text = @root.visible_text.to_s.strip
-              Zlib.crc32(text).to_s(36) unless text.empty?
-            end
-          end
-        end
-      end
-
+      # DOM id of the card, else the link's path or query.
       def parse_id_from_dom
-        candidates = [@root.attrs.id]
+        url = extract_url
         nested = @root.find { |n| n.attrs.id }
-        candidates << nested.attrs.id if nested
-        if @selected_anchor
-          url = extract_url
-          candidates += [url&.path, url&.query]
-        end
-        candidates.compact.reject(&:empty?).first
-      end
-
-      def generate_slug(text)
-        slug = text.downcase.gsub(/[^a-z0-9]+/, '-')
-        slug = slug[1..] if slug.start_with?('-')
-        slug = slug[0..-2] if slug.end_with?('-')
-        slug unless slug.empty?
-      end
-
-      def first_nonempty_own_text
-        @root.find { |n| !n.own_text.to_s.strip.empty? }&.own_text&.strip
+        [@root.attrs.id, nested&.attrs&.id, url&.path, url&.query].compact.reject(&:empty?).first
       end
 
       def extract_image
-        img_src = image_from_srcset || image_from_img || image_from_style
+        img_src = image_from_srcset || image_from_img || image_from_style || image_from_poster
         Url.from_relative(img_src, @base_url) if img_src
       end
 
@@ -302,6 +218,12 @@ module Html2rss
         @root.find { |n| n.image? && n.attrs.src && !n.attrs.src.start_with?('data:') }&.attrs&.src
       end
 
+      # A video's poster frame: the last resort, when the card has no other image.
+      def image_from_poster
+        posters = @root.find_all { |n| n.name == :video }.map { |n| n.attrs.raw['poster'] }
+        posters.find { |src| ArticleRules::Image.remote_src?(src) }
+      end
+
       def image_from_srcset
         srcsets = @root.find_all { |n| n.attrs.srcset }.map { |n| n.attrs.srcset }
         ArticleRules::Image.largest_from_srcsets(srcsets)
@@ -317,30 +239,18 @@ module Html2rss
         ArticleRules::Date.earliest(datetimes, leftover_lines: lines, time_zone: @time_zone)
       end
 
-      def extract_enclosures
-        @root.find_all { |n| enclosure_node?(n) }.filter_map { |element| enclosure_from(element) }
-      end
+      def extract_enclosures = ArticleRules::Enclosure.unique(collect_enclosures(@root, nil, []))
 
-      def enclosure_node?(node)
-        case node.name
-        when :img then node.attrs.src && !node.attrs.src.start_with?('data:')
-        when :source, :audio, :video, :iframe then node.attrs.src
-        when :a then ArticleRules::Enclosure.archive_href?(node.attrs.href)
-        else false
-        end
-      end
-
-      def enclosure_from(element)
-        case element.name
-        when :img
-          ArticleRules::Enclosure.from_image(element.attrs.src, @base_url)
-        when :video, :audio, :source
-          ArticleRules::Enclosure.from_media(element.attrs.src, element.attrs.type, @base_url)
-        when :iframe
-          ArticleRules::Enclosure.from_iframe(element.attrs.src, @base_url)
-        when :a
-          ArticleRules::Enclosure.from_anchor(element.attrs.href, @base_url)
-        end
+      # Depth-first in document order, carrying the nearest player ancestor's name for +source+ elements.
+      def collect_enclosures(node, player, found)
+        name = node.name.name
+        attrs = node.attrs
+        enclosure = ArticleRules::Enclosure.from_element(name, @base_url, src: attrs.src, href: attrs.href,
+                                                                          type: attrs.type) { player }
+        found << enclosure if enclosure
+        player = name if ArticleRules::Enclosure::MEDIA_ELEMENTS.include?(name)
+        node.children.each { |child| collect_enclosures(child, player, found) }
+        found
       end
 
       def extract_categories(title, root: @root)
@@ -357,12 +267,12 @@ module Html2rss
       end
 
       def category_candidate?(node)
-        ArticleRules::Category.class_match?(node.attrs.class_attr) ||
-          node.attrs.raw.keys.any? { |k| ArticleRules::Category.attr_name_match?(k) }
+        ArticleRules::Category.class_match?(node.attrs.class_names) ||
+          node.attrs.raw.any? { |k, _| ArticleRules::Category.attr_name_match?(k) }
       end
 
       def category_text_node?(element, root)
-        !element.equal?(root) && ArticleRules::Category.class_match?(element.attrs.class_attr)
+        !element.equal?(root) && ArticleRules::Category.class_match?(element.attrs.class_names)
       end
 
       def add_category_text!(categories, element, title:)