html2rss 0.33.0 → 0.34.0

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

@@ -4,44 +4,25 @@ module Html2rss
   module Html
     class ArticleExtractor
       ##
-      # Extracts enclosures from HTML tags using various strategies.
+      # Adapts Nokogiri elements to {ArticleRules::Enclosure}, which owns which elements become enclosures.
       class EnclosureExtractor
-        # CSS union query covering images, media, PDFs, iframes, and archives.
-        SELECTOR = [
-          'img[src]:not([src^="data"])',
-          'video source[src]',
-          'audio source[src]',
-          'audio[src]',
-          'a[href$=".pdf"]',
-          'iframe[src]',
-          'a[href$=".zip"]',
-          'a[href$=".tar.gz"]',
-          'a[href$=".tgz"]'
-        ].join(',').freeze
+        # CSS union of the element names {ArticleRules::Enclosure} may turn into an enclosure.
+        SELECTOR = ArticleRules::Enclosure::ELEMENT_NAMES.join(',').freeze
+        # CSS union of the players a +source+ element must sit inside.
+        PLAYERS = ArticleRules::Enclosure::MEDIA_ELEMENTS.join(',').freeze
 
         # @param article_tag [Nokogiri::XML::Element] article container node
         # @param base_url [String, Html2rss::Url] base URL for relative enclosure links
-        # @return [Array<Hash{Symbol => Object}>] normalized enclosure hashes
+        # @return [Array<Hash{Symbol => Object}>] normalized enclosure hashes in document order, one per URL
         def self.call(article_tag, base_url)
-          article_tag.css(SELECTOR).filter_map do |element|
-            extract_from_element(element, base_url)
+          found = article_tag.css(SELECTOR).filter_map do |element|
+            attrs = { src: element['src'], href: element['href'], type: element['type'] }
+            ArticleRules::Enclosure.from_element(element.name, base_url, **attrs) do
+              element.ancestors(PLAYERS).first&.name
+            end
           end
+          ArticleRules::Enclosure.unique(found)
         end
-
-        def self.extract_from_element(element, base_url)
-          case element.name
-          when 'img'
-            ArticleRules::Enclosure.from_image(element['src'], base_url)
-          when 'audio', 'source'
-            ArticleRules::Enclosure.from_media(element['src'], element['type'], base_url)
-          when 'iframe'
-            ArticleRules::Enclosure.from_iframe(element['src'], base_url)
-          when 'a'
-            ArticleRules::Enclosure.from_anchor(element['href'], base_url)
-          end
-        end
-
-        private_class_method :extract_from_element
       end
     end
   end

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

@@ -12,10 +12,9 @@ module Html2rss
         class << self
           ##
           # @param article_tag [Nokogiri::XML::Element] container node
-          # @param fallback_anchorless [Boolean] whether to use fallback search
           # @param selected_anchor [Nokogiri::XML::Node, nil] anchor element
           # @return [Nokogiri::XML::Node, nil] the heading node, if found
-          def call(article_tag, fallback_anchorless:, selected_anchor:)
+          def call(article_tag, selected_anchor:)
             tags = article_tag.css(HEADING_TAGS.join(','))
             if tags.any?
               select_best_heading(tags)
@@ -23,7 +22,7 @@ module Html2rss
               labeled = heading_from_aria_or_title(article_tag)
               return labeled if labeled
 
-              fallback_heading(article_tag) if fallback_anchorless && selected_anchor.nil?
+              fallback_heading(article_tag) if selected_anchor.nil?
             end
           end
 

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

@@ -14,16 +14,15 @@ module Html2rss
           # @param heading [Nokogiri::XML::Node, nil] heading node
           # @param url [Html2rss::Url, nil] absolute article URL
           # @param selected_anchor [Nokogiri::XML::Node, nil] anchor element
-          # @param fallback_anchorless [Boolean] whether to use fallback hashing
           # @return [String, nil] the generated ID, if any
-          def call(article_tag, heading:, url:, selected_anchor:, fallback_anchorless:)
+          def call(article_tag, heading:, url:, selected_anchor:)
             id_from_dom = parse_id_from_dom(article_tag, url, selected_anchor)
             return id_from_dom if id_from_dom
 
-            heading_text = resolve_heading_text(article_tag, heading, fallback_anchorless)
+            heading_text = resolve_heading_text(article_tag, heading)
             if heading_text && !heading_text.strip.empty?
               generate_slug(heading_text)
-            elsif fallback_anchorless
+            else
               generate_content_hash(article_tag)
             end
           end
@@ -36,18 +35,16 @@ module Html2rss
             candidates.compact.reject(&:empty?).first
           end
 
-          def resolve_heading_text(article_tag, heading, fallback_anchorless)
+          def resolve_heading_text(article_tag, heading)
             text = heading ? Navigator::TextExtractor.call(heading) : nil
             if text.nil? || text.strip.empty?
-              fallback_text_node_content(article_tag, fallback_anchorless)
+              fallback_text_node_content(article_tag)
             else
               text
             end
           end
 
-          def fallback_text_node_content(article_tag, fallback_anchorless)
-            return unless fallback_anchorless
-
+          def fallback_text_node_content(article_tag)
             article_tag.xpath('.//text()').find { |t| !t.text.strip.empty? }&.text&.strip
           end
 

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

@@ -12,7 +12,8 @@ module Html2rss
         def self.call(article_tag, base_url:)
           img_src = from_source(article_tag) ||
                     from_img(article_tag) ||
-                    from_style(article_tag)
+                    from_style(article_tag) ||
+                    from_poster(article_tag)
 
           Url.from_relative(img_src, base_url) if img_src
         end
@@ -43,6 +44,13 @@ module Html2rss
           styles = article_tag.css('[style*="url"]').map { |tag| tag['style'] }
           ArticleRules::Image.best_from_styles(styles)
         end
+
+        # @param article_tag [Nokogiri::XML::Element] article container node
+        # @return [String, nil] first usable video poster frame: the last resort, when the card has no other image
+        def self.from_poster(article_tag)
+          posters = article_tag.css('video[poster]').map { |video| video['poster'] }
+          posters.find { |src| ArticleRules::Image.remote_src?(src) }
+        end
       end
     end
   end

data/lib/html2rss/html/article_extractor.rb

@@ -14,11 +14,10 @@ module Html2rss
         # @param article_tag [Nokogiri::XML::Node] article-like container to extract from
         # @param base_url [String, Html2rss::Url] base url used to resolve relative links
         # @param selected_anchor [Nokogiri::XML::Node, nil] explicit primary anchor for the container
-        # @param fallback_anchorless [Boolean] whether to fall back to anchorless extraction
         # @param time_zone [String] channel time zone for naive leftover dates
         # @return [Hash{Symbol => Object}] extracted article attributes
-        def call(article_tag, base_url:, selected_anchor: nil, fallback_anchorless: false, time_zone: 'UTC')
-          new(article_tag, base_url:, selected_anchor:, fallback_anchorless:, time_zone:).call
+        def call(article_tag, base_url:, selected_anchor: nil, time_zone: 'UTC')
+          new(article_tag, base_url:, selected_anchor:, time_zone:).call
         end
       end
 
@@ -26,26 +25,26 @@ module Html2rss
       # @param article_tag [Nokogiri::XML::Node] article-like container to extract from
       # @param base_url [String, Html2rss::Url] base url used to resolve relative links
       # @param selected_anchor [Nokogiri::XML::Node, nil] explicit primary anchor for the container
-      # @param fallback_anchorless [Boolean] whether to fall back to anchorless extraction
       # @param time_zone [String] channel time zone for naive leftover dates
-      def initialize(article_tag, base_url:, selected_anchor: nil, fallback_anchorless: false, time_zone: 'UTC')
-        raise ArgumentError, 'article_tag is required' unless article_tag
+      def initialize(article_tag, base_url:, selected_anchor: nil, time_zone: 'UTC')
+        raise InvalidError, 'article_tag is required' unless article_tag
 
         @article_tag = article_tag
         @base_url = base_url
         @selected_anchor = selected_anchor
-        @fallback_anchorless = fallback_anchorless
         @time_zone = time_zone
       end
 
       # @return [Hash{Symbol => Object}] extracted article attributes
       def call # rubocop:disable Metrics/MethodLength
-        title = extract_title
+        title = extract_headline
         lines = leftover_lines
         published_at = extract_published_at(lines)
         source, lines, published_at = parent_card_fields(title, lines, published_at)
         {
-          title:,
+          # Composed here, not passed as a +kicker:+ key: Selectors' enhance merges keys one by one,
+          # so a separate kicker would prefix an explicitly selected title.
+          title: Article::Title.compose(title, kicker: title_pieces.kicker_text),
           url: extract_url,
           image: extract_image,
           description: ArticleRules::Description.from_lines(lines, title:),
@@ -63,55 +62,29 @@ module Html2rss
       def extract_url
         @extract_url ||= begin
           href = selected_anchor&.[]('href').to_s
-
-          if href.empty?
-            anchorless_url_fallback
-          else
-            Url.from_relative(href.split('#').first.strip, base_url)
-          end
+          Url.from_relative(href.split('#').first, base_url) unless href.empty?
         end
       end
 
-      def anchorless_url_fallback
-        return unless @fallback_anchorless
+      def extract_headline
+        return first_text_title unless headline_source
 
-        id = generate_id
-        Url.from_relative("##{id}", base_url) if id
+        title_pieces.headline_text(headline_source)
       end
 
-      # rubocop:disable-next Metrics/CyclomaticComplexity
-      def extract_title
-        source = heading || selected_anchor
-        title_text = source ? Navigator.extract_visible_text(source) : fallback_anchorless_title
-        return unless title_text
-
-        kicker = kicker_node ? Navigator.extract_visible_text(kicker_node).to_s.strip : nil
-        kicker && !kicker.empty? && !title_text.include?(kicker) ? "#{kicker}: #{title_text}" : title_text
-      end
-
-      def fallback_anchorless_title
-        return unless @fallback_anchorless && selected_anchor.nil?
+      # Kicker and headline text ({TitlePieces}) of this card.
+      def title_pieces = @title_pieces ||= TitlePieces.new(article_tag, headline_source, anchor: selected_anchor)
 
+      def first_text_title
         text_node = article_tag.xpath('.//text()').find { |t| !t.text.strip.empty? }
         text_node&.text&.strip
       end
 
       def heading
-        @heading ||= HeadingExtractor.call(
-          article_tag,
-          fallback_anchorless: @fallback_anchorless,
-          selected_anchor:
-        )
+        @heading ||= HeadingExtractor.call(article_tag, selected_anchor:)
       end
 
-      def kicker_node
-        @kicker_node ||= begin
-          selector = '[data-tb-kicker], [class*="kicker"], [class*="eyebrow"], ' \
-                     '[class*="pre-title"], [class*="pretitle"], [class*="overline"]'
-          node = article_tag.at_css(selector)
-          node && heading && (node == heading || Navigator.descendant_of?(node, heading)) ? nil : node
-        end
-      end
+      def headline_source = heading || selected_anchor
 
       def leftover_lines
         leftover_lines_from(article_tag)
@@ -124,7 +97,7 @@ module Html2rss
       end
 
       def leftover_exclude_nodes_for(node)
-        [heading, selected_anchor, kicker_node, *node.css('time')].compact
+        [heading, selected_anchor, title_pieces.kicker, *node.css('time')].compact
       end
 
       def heading_or_anchor_item?
@@ -186,8 +159,7 @@ module Html2rss
           article_tag,
           heading:,
           url: (selected_anchor ? extract_url : nil),
-          selected_anchor:,
-          fallback_anchorless: @fallback_anchorless
+          selected_anchor:
         )
       end
 

data/lib/html2rss/html/article_rules/category.rb

@@ -27,10 +27,10 @@ module Html2rss
           end
 
           ##
-          # @param class_attr [String, nil]
+          # @param class_names [Array<String>] individual class tokens
           # @return [Boolean]
-          def class_match?(class_attr)
-            class_attr.to_s.split(/\s+/).any? { |token| class_token_match?(token) }
+          def class_match?(class_names)
+            class_names.any? { |token| class_token_match?(token) }
           end
 
           ##

data/lib/html2rss/html/article_rules/description.rb

@@ -7,24 +7,15 @@ module Html2rss
       # Leftover visible-text keep/drop for article descriptions.
       # Split once on block newlines; Date and Category consume the same keepers.
       module Description
-        # CTA lines dropped by whole-line equality (case-insensitive).
-        CTA = Set['read more', 'learn more'].freeze
-        # Type-chip lines dropped when the whole leftover line is one of these.
-        TYPE_CHIPS = Set['news article', 'press release', 'news'].freeze
+        # Owner of the read-more vocabulary; a whole line that is one is chrome, not a dek.
+        TEXT_CLASSIFIER = LinkDestination::TextClassifier.new
+        private_constant :TEXT_CLASSIFIER
         # Listing section names that are chrome, not a dek.
         SECTION_NAMES = Set['press releases'].freeze
         # Skip date detection / DateTime.parse above this length.
         MAX_DATE_CHARS = 128
         # Optional type-chip / clock separators (ASCII/en/em dash, pipe, bullet).
         CHIP_SEPARATORS = [' - ', ' – ', ' — ', ' | ', ' • '].freeze
-        # Trailing clock plus optional AM/PM and one timezone/offset token (IANA, GMT/UTC offset, or abbrev).
-        CLOCK_ZONE = %r{
-          \A
-          \d{1,2}:\d{2}(?::\d{2})?
-          (?:\s*(?:AM|PM))?
-          (?:\s+(?:[A-Za-z]+(?:/[A-Za-z_]+)+|(?:GMT|UTC)[+-]\d{1,2}(?::\d{2})?|[A-Za-z]{2,5}))?
-          \z
-        }ix
         # Whole-line date shapes after normalize (ISO, numeric, day-month, month-day).
         DATE_SHAPES = [
           /\A\d{4}-\d{1,2}-\d{1,2}(?:[T ]\d{1,2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?\z/i,
@@ -100,13 +91,13 @@ module Html2rss
             nil
           end
 
-          def type_chip?(text) = TYPE_CHIPS.include?(text.downcase)
+          def type_chip?(text) = Article::Title::TYPE_MARKERS.include?(text.downcase)
 
-          def clock_zone?(text) = text.match?(CLOCK_ZONE)
+          def clock_zone?(text) = Article::Title.clock_piece?(text)
 
           def chrome?(normalized, title:, type_chips:)
             key = normalized.downcase
-            CTA.include?(key) || (type_chips && TYPE_CHIPS.include?(key)) ||
+            TEXT_CLASSIFIER.read_more?(normalized) || (type_chips && Article::Title::TYPE_MARKERS.include?(key)) ||
               SECTION_NAMES.include?(key) || normalized.end_with?(':') ||
               date_shaped?(normalized) || title_echo?(key, title)
           end

data/lib/html2rss/html/article_rules/enclosure.rb

@@ -4,66 +4,94 @@ module Html2rss
   module Html
     module ArticleRules
       ##
-      # DOM-agnostic enclosure URL/type normalization.
+      # The one rule for which HTML elements become enclosures, and their URL/type normalization.
+      #
+      # DOM-agnostic: {ArticleExtractor::EnclosureExtractor} (Nokogiri) and {SstArticleExtractor} (SST)
+      # only visit {ELEMENT_NAMES}, adapt their node API to {.from_element} and pass the result through
+      # {.unique}. Images (+img[src]+), players (+audio[src]+, +video[src]+), a player's +source[src]+ with
+      # its +type+, and file links ({FILE_LINK}) qualify; an +iframe+ (embed player page) never does,
+      # and only an http(s) URL is one (no +data:+, +blob:+, +javascript:+ or +mailto:+).
       module Enclosure
-        # Href path suffixes treated as download/archive enclosure links.
-        ARCHIVE_HREF_SUFFIXES = %w[.pdf .zip .tar.gz .tgz].freeze
+        # A link to a file: its path (before any query or fragment) ends, in any case, in a downloadable
+        # document or archive extension (+.pdf+, +.zip+, +.tar.gz+, +.tgz+) or an audio or video one
+        # ({Article::Enclosure::MEDIA_TYPES}, which also types it), such as an episode's download link.
+        FILE_LINK = /
+          \A[^?\#]*\.
+          (?:pdf|zip|tar\.gz|tgz|#{Regexp.union(Article::Enclosure::MEDIA_TYPES.keys).source})
+          (?:[?\#]|\z)
+        /ix
+        # Element names that may carry an enclosure.
+        ELEMENT_NAMES = %w[img audio video source a].freeze
+        # Players whose own +src+ and inner +source+ elements name a media file.
+        MEDIA_ELEMENTS = %w[audio video].freeze
 
         class << self
           ##
-          # @param href [String]
-          # @return [Boolean]
-          def archive_href?(href)
-            ARCHIVE_HREF_SUFFIXES.any? { |suffix| href.to_s.end_with?(suffix) }
-          end
-
-          ##
-          # @param src [String]
+          # The enclosure an HTML element stands for, if any. A player's file carries the player as its
+          # kind, so an untyped file without a media extension is still audio or video
+          # ({Article::Enclosure::KIND_TYPES}).
+          #
+          # @param name [String] element name (lower case)
           # @param base_url [String, Html2rss::Url]
+          # @param src [String, nil] the element's +src+ attribute
+          # @param href [String, nil] the element's +href+ attribute
+          # @param type [String, nil] the element's +type+ attribute
+          # @yieldreturn [String, nil] the name of the nearest {MEDIA_ELEMENTS} player around the element (an
+          #   ancestor, not only the parent: the HTML4 parser nests sibling +source+ elements), or nil; asked
+          #   only for a +source+
           # @return [Hash{Symbol => Object}, nil]
-          def from_image(src, base_url)
-            return if src.to_s.empty?
-
-            abs = Url.from_relative(src, base_url)
-            { url: abs, type: Article::Enclosure.guess_content_type_from_url(abs, default: 'image/jpeg') }
+          def from_element(name, base_url, src:, href:, type:)
+            case name
+            when 'img' then from_image(src, base_url)
+            when 'audio', 'video' then from_media(src, type, base_url, kind: name.to_sym)
+            when 'source' then from_source(src, type, base_url, yield)
+            when 'a' then from_anchor(href, base_url)
+            end
           end
 
           ##
-          # @param src [String]
-          # @param type [String, nil]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
-          def from_media(src, type, base_url)
-            return if src.to_s.empty?
+          # @param href [String, nil] an anchor's +href+
+          # @return [Boolean] whether it names a file {.from_element} turns into an enclosure ({FILE_LINK})
+          def file_link?(href) = href.to_s.match?(FILE_LINK)
 
-            { url: Url.from_relative(src, base_url), type: }
+          ##
+          # @param src [String, nil]
+          # @param type [String, nil] declared MIME type; nil lets {Article::Enclosure#type} guess it
+          # @param base_url [String, Html2rss::Url, nil]
+          # @param kind [Symbol, nil] +:audio+ or +:video+ when the source proves the file's kind
+          # @return [Hash{Symbol => Object}, nil] nil unless +src+ resolves to an http(s) URL ({Url.resolve_web})
+          def from_media(src, type, base_url, kind: nil)
+            return unless (url = Url.resolve_web(src, base_url))
+
+            { url:, type:, kind: }.compact
           end
 
           ##
-          # @param src [String]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
-          def from_iframe(src, base_url)
-            return if src.to_s.empty?
+          # One enclosure per URL, at its first position in document order; a duplicate declaring a type
+          # wins over an untyped one (+<video src=x><source src=x type=video/webm>+).
+          #
+          # @param enclosures [Array<Hash{Symbol => Object}>] {.from_element} results in document order
+          # @return [Array<Hash{Symbol => Object}>]
+          def unique(enclosures)
+            enclosures.group_by { _1[:url] }.map { |_url, same| same.find { _1[:type] } || same.first }
+          end
+
+          private
+
+          def from_image(src, base_url)
+            return unless (url = Url.resolve_web(src, base_url))
 
-            abs = Url.from_relative(src, base_url)
-            { url: abs, type: Article::Enclosure.guess_content_type_from_url(abs, default: 'text/html') }
+            { url:, type: Article::Enclosure.guess_content_type_from_url(url, default: 'image/jpeg') }
+          end
+
+          def from_source(src, type, base_url, player)
+            from_media(src, type, base_url, kind: player.to_sym) if player
           end
 
-          ##
-          # @param href [String]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
           def from_anchor(href, base_url)
-            return if href.to_s.empty?
+            return unless file_link?(href) && (url = Url.resolve_web(href, base_url))
 
-            abs = Url.from_relative(href, base_url)
-            type = if href.end_with?('.pdf')
-                     Article::Enclosure.guess_content_type_from_url(abs)
-                   else
-                     'application/zip'
-                   end
-            { url: abs, type: }
+            { url: }
           end
         end
       end

data/lib/html2rss/html/article_rules/image.rb

@@ -14,10 +14,16 @@ module Html2rss
         MAX_ATTR_CHARS = 4_096
         # Optional quoting around a CSS `url(...)` value.
         QUOTES = ['"', "'"].freeze
-        # Srcset width/height descriptor suffixes.
-        UNITS = %w[w h].freeze
-        # HTML/CSS whitespace treated as srcset token separators.
-        WS = [' ', "\t", "\n", "\r", "\f"].freeze
+        # Srcset width/height descriptor suffix bytes (`w`, `h`).
+        UNIT_BYTES = [119, 104].freeze
+        # HTML/CSS whitespace bytes (space, tab, LF, CR, FF) treated as srcset token separators.
+        WS_BYTES = [32, 9, 10, 13, 12].freeze
+        # ASCII `,`.
+        COMMA = 44
+        # ASCII `0`.
+        ZERO = 48
+        # ASCII `9`.
+        NINE = 57
 
         class << self
           ##
@@ -29,6 +35,11 @@ module Html2rss
             by_size[by_size.keys.max]
           end
 
+          ##
+          # @param src [String, nil] an image URL attribute, e.g. a video +poster+
+          # @return [Boolean] whether it names a fetchable image: not blank, not an inline +data:+ URI
+          def remote_src?(src) = src.to_s.match?(/\S/) && !src.start_with?('data:')
+
           ##
           # @param style_strings [Array<String>] CSS style attribute values
           # @return [String, nil] longest non-data background url
@@ -54,23 +65,24 @@ module Html2rss
 
           # URL token + `Nw`/`Nh` pairs. Commas may appear inside URLs; a candidate
           # boundary is whitespace before a width/height descriptor.
+          # Scans bytes: every separator, digit and unit is ASCII, and UTF-8
+          # continuation bytes (0x80+) never equal an ASCII byte, so byte offsets are safe.
+          # `getbyte` returns nil past the end, which every predicate treats as no match.
           def each_srcset_pair(string) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             i = 0
-            len = string.length
+            len = string.bytesize
             while i < len
-              i += 1 while i < len && sep?(string[i])
-              break if i >= len
-
+              i += 1 while sep?(string.getbyte(i))
               start = i
-              i += 1 while i < len && !ws?(string[i])
-              url = string[start, i - start]
+              i += 1 until ws?(string.getbyte(i)) || i >= len
+              url = string.byteslice(start, i - start)
 
-              i += 1 while i < len && ws?(string[i])
+              i += 1 while ws?(string.getbyte(i))
               size_start = i
-              i += 1 while i < len && string[i].between?('0', '9')
-              next unless i > size_start && i < len && UNITS.include?(string[i])
+              i += 1 while digit?(string.getbyte(i))
+              next unless i > size_start && UNIT_BYTES.include?(string.getbyte(i))
 
-              yield url, string[size_start, i - size_start].to_i
+              yield url, string.byteslice(size_start, i - size_start).to_i
               i += 1
             end
           end
@@ -99,9 +111,11 @@ module Html2rss
             string[start, close - start] if close
           end
 
-          def sep?(char) = ws?(char) || char == ','
+          def sep?(byte) = ws?(byte) || byte == COMMA
+
+          def ws?(byte) = WS_BYTES.include?(byte)
 
-          def ws?(char) = WS.include?(char)
+          def digit?(byte) = byte&.between?(ZERO, NINE)
         end
       end
     end

data/lib/html2rss/html/feed_link.rb

@@ -2,15 +2,16 @@
 
 module Html2rss
   module Html
-    FeedLink = Data.define(:href, :mime_type)
+    FeedLink = Data.define(:href, :mime_type, :title)
 
-    # A native RSS/Atom hint from a document head +link[rel=alternate]+.
+    # A native RSS/Atom/RDF hint from a document head +link[rel=alternate]+.
     #
     # Does not guess +/feed+ or +/rss.xml+ paths — that stays in configs +probe_rss+.
+    # +title+ is the link's stripped +title+ attribute (empty when absent).
     class FeedLink
       class << self
         ##
-        # Collects RSS/Atom +rel=alternate+ links from +doc+'s +head+.
+        # Collects RSS/Atom/RDF +rel=alternate+ links from +doc+'s +head+.
         #
         # @param doc [Nokogiri::XML::Node] parsed HTML document
         # @return [Array<FeedLink>] native feed hints, omitting blanks and non-feed types
@@ -21,16 +22,13 @@ module Html2rss
         private
 
         def from_node(node)
-          href = node['href']&.strip
+          href = node['href'].strip # the head selector guarantees an href attribute
           mime_type = feed_mime_type(node['type'])
-          new(href:, mime_type:) unless href.nil? || href.empty? || mime_type.nil?
+          new(href:, mime_type:, title: node['title'].to_s.strip) unless href.empty? || mime_type.nil?
         end
 
         def feed_mime_type(type)
-          return Probe::APPLICATION_RSS_XML if Probe.mime_match?(type, Probe::APPLICATION_RSS_XML)
-          return Probe::APPLICATION_ATOM_XML if Probe.mime_match?(type, Probe::APPLICATION_ATOM_XML)
-
-          nil
+          Probe::FEED_MIME_TYPES.find { |mime| Probe.mime_match?(type, mime) }
         end
       end
     end