html2rss 0.32.4 → 0.34.0

data/lib/html2rss/html/probe.rb

@@ -15,67 +15,71 @@ 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
 
-      module_function
+      class << self
+        ##
+        # @param string [String, Symbol, #to_s] wire value
+        # @return [String] folded comparison key
+        def fold(string)
+          string.to_s.downcase
+        end
 
-      ##
-      # @param string [String, Symbol, #to_s] wire value
-      # @return [String] folded comparison key
-      def fold(string)
-        string.to_s.downcase
-      end
+        ##
+        # @param node [Nokogiri::XML::Node]
+        # @return [String] folded element name
+        def tag(node)
+          name = node.name
+          return fold(name) unless name.is_a?(String)
+          return name if name.ascii_only? && !name.match?(/[A-Z]/)
 
-      ##
-      # @param node [Nokogiri::XML::Node]
-      # @return [String] folded element name
-      def tag(node)
-        name = node.name
-        return fold(name) unless name.is_a?(String)
-        return name if name.ascii_only? && !name.match?(/[A-Z]/)
+          fold(name)
+        end
 
-        fold(name)
-      end
+        ##
+        # @param type [String, Symbol, #to_s, nil] MIME type attribute value
+        # @return [String] media type without parameters, folded
+        def mime_base(type)
+          raw = type.to_s
+          return fold(raw) unless raw.include?(';') || raw.match?(/\A\s|\s\z/)
 
-      ##
-      # @param type [String, Symbol, #to_s, nil] MIME type attribute value
-      # @return [String] media type without parameters, folded
-      def mime_base(type)
-        raw = type.to_s
-        return fold(raw) unless raw.include?(';') || raw.match?(/\A\s|\s\z/)
+          fold(raw.split(';', 2).first.to_s.strip)
+        end
 
-        fold(raw.split(';', 2).first.to_s.strip)
-      end
+        ##
+        # @param actual [String, Symbol, #to_s, nil] observed MIME type
+        # @param expected [Array<String>] canonical MIME types to match
+        # @return [Boolean]
+        def mime_match?(actual, *expected)
+          base = mime_base(actual)
+          expected.any? { |candidate| base == candidate || base == mime_base(candidate) }
+        end
 
-      ##
-      # @param actual [String, Symbol, #to_s, nil] observed MIME type
-      # @param expected [Array<String>] canonical MIME types to match
-      # @return [Boolean]
-      def mime_match?(actual, *expected)
-        base = mime_base(actual)
-        expected.any? { |candidate| base == candidate || base == mime_base(candidate) }
-      end
-
-      ##
-      # @param doc [Nokogiri::XML::Node]
-      # @param mime_types [Array<String>] optional MIME filters (folded once per call)
-      # @return [Array<Nokogiri::XML::Element>]
-      def scripts(doc, *mime_types)
-        return doc.css('script') if mime_types.empty?
+        ##
+        # @param doc [Nokogiri::XML::Node]
+        # @param mime_types [Array<String>] optional MIME filters (folded once per call)
+        # @return [Array<Nokogiri::XML::Element>]
+        def scripts(doc, *mime_types)
+          return doc.css('script') if mime_types.empty?
 
-        allowed = mime_types.to_set { |mime| mime_base(mime) }
-        doc.css('script').select { |script| allowed.include?(mime_base(script['type'])) }
-      end
+          allowed = mime_types.to_set { |mime| mime_base(mime) }
+          doc.css('script').select { |script| allowed.include?(mime_base(script['type'])) }
+        end
 
-      ##
-      # @param doc [Nokogiri::XML::Node]
-      # @param rel [String] link rel token
-      # @param mime [String, nil] optional MIME filter
-      # @return [Array<Nokogiri::XML::Element>]
-      def alternate_links(doc, rel:, mime: nil)
-        nodes = doc.css(%(link[rel~="#{rel}"][href]))
-        return nodes if mime.nil?
+        ##
+        # @param doc [Nokogiri::XML::Node]
+        # @param rel [String] link rel token
+        # @param mime [String, nil] optional MIME filter
+        # @return [Array<Nokogiri::XML::Element>]
+        def alternate_links(doc, rel:, mime: nil)
+          nodes = doc.css(%(link[rel~="#{rel}"][href]))
+          return nodes if mime.nil?
 
-        nodes.select { |node| mime_match?(node['type'], mime) }
+          nodes.select { |node| mime_match?(node['type'], mime) }
+        end
       end
     end
   end

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:)