html2rss 0.32.4 → 0.34.0

data/lib/html2rss/syndication/discovery.rb

@@ -3,217 +3,201 @@
 module Html2rss
   module Syndication
     ##
-    # Finds a same-origin RSS/Atom URL for a page via head alternates and path guesses.
+    # Finds an RSS/Atom URL for a page via head alternates and same-origin path guesses.
     #
     # Ports configs +probe_rss+ path/alternate logic onto {RequestSession#follow_up}.
-    module Discovery # rubocop:disable Metrics/ModuleLength -- discovery + path probes stay co-located
+    # Head alternates keep document order within two groups: those whose title or URL
+    # hints audio ({AUDIO_HINT}) and the rest. On a page that shows podcast signals
+    # ({PODCAST_PAGE_HINT} in its URL host, path or +<title>+, an +og:type+ matching {MEDIA_OG_TYPE},
+    # or a {PODCAST_SCHEMA_TYPE} in its JSON-LD) the order is audio-hinted alternates, other
+    # alternates, path guesses. On any other page it is other alternates, path guesses, then the
+    # audio-hinted alternates, so a news page that advertises only a podcast feed does not become
+    # a media feed. This is the one ordering owner: {.best_feed_url}, {.candidate_urls} and the
+    # feed-resolution feed slot all read it. Alternates are fetched as +:advertised_feed+ with the
+    # page's {RequestService::FeedAdvertisement}, so a feed the page advertises on another host
+    # is followed (see {RequestService::Policy}). Path guesses stay same-origin.
+    module Discovery # rubocop:disable Metrics/ModuleLength -- discovery ordering + probe stay on one owner
       # Common feed path suffixes probed after head +rel=alternate+ hints.
       DEFAULT_PATHS = CandidateCatalog::FEED_PATHS
-
-      LINK_TAG_RE = /<link\b[^>]*>/i
-      HREF_RE = /\bhref\s*=\s*["']([^"']+)["']/i
-      TYPE_RE = /\btype\s*=\s*["']([^"']+)["']/i
-      REL_RE = /\brel\s*=\s*["']([^"']+)["']/i
-      private_constant :LINK_TAG_RE, :HREF_RE, :TYPE_RE, :REL_RE
-
-      module_function
-
-      ##
-      # Probes candidates lazily and returns the first feedish URL.
-      #
-      # @param page_url [String, Html2rss::Url] page or origin URL
-      # @param request_session [Html2rss::RequestSession] shared session for follow-ups
-      # @param parsed_body [Nokogiri::HTML::Document, nil] parsed HTML when available
-      # @param html [String, nil] raw HTML when a document is unavailable
-      # @param extra_paths [Array<String>] additional path guesses
-      # @param max_probes [Integer, nil] max candidate GETs (nil = uncapped)
-      # @return [Html2rss::Url, nil]
-      # rubocop:disable-next Metrics/ParameterLists -- discovery kwargs stay co-located
-      def best_feed_url(page_url:, request_session:, parsed_body: nil, html: nil, extra_paths: [],
-                        max_probes: nil)
-        best_feed_response(
-          page_url:, request_session:, parsed_body:, html:, extra_paths:, max_probes:
-        )&.url
-      end
-
-      ##
-      # Like {#best_feed_url} but returns the validated syndication response for parsing.
-      #
-      # @param page_url [String, Html2rss::Url]
-      # @param request_session [Html2rss::RequestSession]
-      # @param parsed_body [Nokogiri::HTML::Document, nil]
-      # @param html [String, nil]
-      # @param extra_paths [Array<String>]
-      # @param max_probes [Integer, nil] max candidate GETs (nil = uncapped)
-      # @return [Html2rss::RequestService::Response, nil]
-      # rubocop:disable-next Metrics/ParameterLists, Metrics/MethodLength -- discovery kwargs stay co-located
-      def best_feed_response(page_url:, request_session:, parsed_body: nil, html: nil, extra_paths: [],
-                             max_probes: nil)
-        page = Html2rss::Url.from_absolute(page_url)
-        candidates = candidate_urls(page_url: page, parsed_body:, html:, extra_paths:)
-        Log.debug(
-          "Syndication::Discovery: host=#{page.host} candidate_count=#{candidates.size}"
-        )
-
-        first_feedish_response(
-          candidates, request_session:, origin_url: page, max_probes:
-        ).tap do |response|
-          next unless response
-
-          Log.info({
-            event_name: 'syndication.discovery.selected',
-            host: page.host,
-            message: "Syndication::Discovery: host=#{page.host} selected_feed_url=#{response.url}"
-          }.to_json)
+      # Words marking a podcast page in its URL host, path or title; {AUDIO_HINT} adds audio file formats.
+      PODCAST_WORDS = %w[podcast episode audio].freeze
+      # Word-ish podcast hint in a page's URL host, path or +<title>+ (plural allowed, case-insensitive).
+      PODCAST_PAGE_HINT = /(?<![[:alpha:]])(?:#{PODCAST_WORDS.join('|')})s?(?![[:alpha:]])/i
+      # Word-ish audio hint in an alternate's title or URL (Podlove-style per-format podcast feeds).
+      AUDIO_HINT = /(?<![[:alpha:]])(?:#{(PODCAST_WORDS + %w[mp3 m4a aac opus]).join('|')})s?(?![[:alpha:]])/i
+      # +og:type+ values (+music.song+, +video.episode+, ...) marking a podcast or media page.
+      MEDIA_OG_TYPE = /\A\s*(?:music|video)\./i
+      # A JSON-LD +@type+ naming podcast content (short name or schema.org URL, alone or in an
+      # array), matched on the script text anywhere in the page without parsing the JSON.
+      PODCAST_SCHEMA_TYPE = %r{"@type"\s*:\s*(?:\[\s*(?:"[^"]*"\s*,\s*)*)?
+                               "(?:https?://schema\.org/)?(?:PodcastSeries|PodcastEpisode|AudioObject)"}ix
+
+      class << self
+        ##
+        # Probes candidates lazily and returns the first feedish URL.
+        #
+        # @param page_url [String, Html2rss::Url] page or origin URL
+        # @param request_session [Html2rss::RequestSession] shared session for follow-ups
+        # @param parsed_body [Nokogiri::HTML::Document, nil] parsed HTML when available
+        # @param html [String, nil] raw HTML when a document is unavailable
+        # @param extra_paths [Array<String>] additional path guesses
+        # @param max_probes [Integer, nil] max candidate GETs (nil = uncapped)
+        # @return [Html2rss::Url, nil]
+        # rubocop:disable-next Metrics/ParameterLists -- discovery kwargs stay co-located
+        def best_feed_url(page_url:, request_session:, parsed_body: nil, html: nil, extra_paths: [],
+                          max_probes: nil)
+          best_feed_response(page_url:, request_session:, parsed_body:, html:, extra_paths:, max_probes:)&.url
         end
-      end
-
-      ##
-      # Ordered candidate feed URLs (head alternates first, then path guesses).
-      #
-      # @param page_url [String, Html2rss::Url]
-      # @param parsed_body [Nokogiri::HTML::Document, nil]
-      # @param html [String, nil]
-      # @param extra_paths [Array<String>]
-      # @return [Array<Html2rss::Url>]
-      def candidate_urls(page_url:, parsed_body: nil, html: nil, extra_paths: [])
-        page = Html2rss::Url.from_absolute(page_url)
-        (alternate_feed_urls(page, parsed_body:, html:) +
-          path_guess_urls(page, extra_paths:)).uniq
-      end
-
-      ##
-      # @param response [Html2rss::RequestService::Response, nil]
-      # @return [Boolean]
-      def feedish?(response)
-        return false unless response
-        return false unless successful_status?(response)
-
-        response.feed_response?
-      end
 
-      def successful_status?(response)
-        status = response.status
-        status.nil? || status.between?(200, 299)
-      end
-      module_function :successful_status?
-      private_class_method :successful_status?
-
-      ##
-      # Directory-relative feed path guesses for a page URL.
-      #
-      # @param page_url [String, Html2rss::Url]
-      # @return [Array<String>] relative paths
-      def page_dir_paths(page_url)
-        path = Html2rss::Url.from_absolute(page_url).path
-        return [] if path.nil? || path.empty? || path == '/'
-
-        dir = path.sub(%r{/[^/]*$}, '/')
-        ["#{dir}feed", "#{dir}rss.xml", "#{dir}atom.xml"]
-      end
+        ##
+        # The native feed of a page already fetched: the one entry point for the curation gates
+        # (Recon, Capture, Test), so each reads the page's head alternates (cross-origin only
+        # through its {RequestService::FeedAdvertisement}) before same-origin path guesses. The page
+        # is the response's own URL, where a redirect landed, so relative alternates and the origin of
+        # the follow-ups are the fetched page's, never the entry URL's.
+        #
+        # @param response [Html2rss::RequestService::Response] the fetched page; a non-HTML
+        #   response contributes its raw body only
+        # @param request_session [Html2rss::RequestSession] session for the probes
+        # @return [Html2rss::Url, nil]
+        def native_feed_url(response:, request_session:)
+          parsed_body = response.parsed_body if response.html_response?
+          best_feed_url(page_url: response.url, request_session:, parsed_body:, html: response.body)
+        end
 
-      def first_feedish_response(urls, request_session:, origin_url:, max_probes: nil)
-        scoped = max_probes.nil? ? urls.lazy : urls.lazy.take(max_probes)
-        scoped.filter_map do |url|
-          response = probe(url, request_session:, origin_url:)
-          response if feedish?(response)
-        end.first
-      end
-      module_function :first_feedish_response
-      private_class_method :first_feedish_response
+        ##
+        # Like {#best_feed_url} but returns the validated syndication response for parsing.
+        #
+        # @param page_url [String, Html2rss::Url]
+        # @param request_session [Html2rss::RequestSession]
+        # @param parsed_body [Nokogiri::HTML::Document, nil]
+        # @param html [String, nil]
+        # @param extra_paths [Array<String>]
+        # @param max_probes [Integer, nil] max candidate GETs (nil = uncapped)
+        # @return [Html2rss::RequestService::Response, nil]
+        # rubocop:disable-next Metrics/ParameterLists, Metrics/MethodLength -- discovery kwargs stay co-located
+        def best_feed_response(page_url:, request_session:, parsed_body: nil, html: nil, extra_paths: [],
+                               max_probes: nil)
+          page = Html2rss::Url.from_absolute(page_url)
+          doc = document(parsed_body)
+          advertisement = RequestService::FeedAdvertisement.from_document(doc, page_url: page)
+          candidates = candidates(page, advertisement, doc:, html:, extra_paths:)
+          Log.debug("Syndication::Discovery: host=#{page.host} candidate_count=#{candidates.size}")
+
+          first_feedish_response(
+            candidates, request_session:, origin_url: page, advertisement:, max_probes:
+          ).tap do |response|
+            next unless response
+
+            Log.info({
+              event_name: 'syndication.discovery.selected',
+              host: page.host,
+              message: "Syndication::Discovery: host=#{page.host} selected_feed_url=#{response.url}"
+            }.to_json)
+          end
+        end
 
-      def first_feedish_url(urls, request_session:, origin_url:, max_probes: nil)
-        first_feedish_response(urls, request_session:, origin_url:, max_probes:)&.url
-      end
-      module_function :first_feedish_url
-      private_class_method :first_feedish_url
-
-      def probe(url, request_session:, origin_url:)
-        request_session.follow_up(url:, relation: :auto_source, origin_url:)
-      rescue Html2rss::Error => error
-        Log.debug(
-          "Syndication::Discovery: probe skipped host=#{origin_url.host} " \
-          "(#{error.class})"
-        )
-        nil
-      end
-      module_function :probe
-      private_class_method :probe
+        ##
+        # Ordered candidate feed URLs (head alternates, then path guesses; on a page without podcast
+        # signals the audio-hinted alternates come after the guesses).
+        #
+        # @param page_url [String, Html2rss::Url]
+        # @param parsed_body [Nokogiri::HTML::Document, nil]
+        # @param html [String, nil]
+        # @param extra_paths [Array<String>]
+        # @return [Array<Html2rss::Url>]
+        def candidate_urls(page_url:, parsed_body: nil, html: nil, extra_paths: [])
+          page = Html2rss::Url.from_absolute(page_url)
+          doc = document(parsed_body)
+          advertisement = RequestService::FeedAdvertisement.from_document(doc, page_url: page)
+          candidates(page, advertisement, doc:, html:, extra_paths:)
+        end
 
-      def alternate_feed_urls(page, parsed_body:, html:)
-        from_document = feed_links_from_document(parsed_body, page)
-        return from_document if from_document.any?
+        ##
+        # @param response [Html2rss::RequestService::Response, nil]
+        # @return [Boolean]
+        def feedish?(response)
+          return false unless response
+          return false unless successful_status?(response)
 
-        alternate_feed_hrefs(html.to_s, page)
-      end
-      module_function :alternate_feed_urls
-      private_class_method :alternate_feed_urls
-
-      def feed_links_from_document(parsed_body, page)
-        return [] unless parsed_body.is_a?(Nokogiri::HTML::Document)
+          response.feed_response?
+        end
 
-        Html::FeedLink.from_document(parsed_body).filter_map do |link|
-          absolute_url(page, link.href)
+        ##
+        # Directory-relative feed path guesses for a page URL.
+        #
+        # @param page_url [String, Html2rss::Url]
+        # @return [Array<String>] relative paths
+        def page_dir_paths(page_url)
+          path = Html2rss::Url.from_absolute(page_url).path
+          return [] if path == '/'
+
+          dir = path.sub(%r{/[^/]*$}, '/')
+          ["#{dir}feed", "#{dir}rss.xml", "#{dir}atom.xml"]
         end
-      end
-      module_function :feed_links_from_document
-      private_class_method :feed_links_from_document
 
-      def path_guess_urls(page, extra_paths:)
-        paths = (page_dir_paths(page) + DEFAULT_PATHS + Array(extra_paths)).uniq
-        paths.filter_map { |path| absolute_url(page, path) }
-      end
-      module_function :path_guess_urls
-      private_class_method :path_guess_urls
+        private
 
-      def alternate_feed_hrefs(html, page)
-        return [] if html.nil? || html.empty?
+        def successful_status?(response) = response.status.nil? || response.status.between?(200, 299)
 
-        html.scan(LINK_TAG_RE).filter_map { |tag| href_from_alternate_link(tag, page) }.uniq
-      end
-      module_function :alternate_feed_hrefs
-      private_class_method :alternate_feed_hrefs
+        def first_feedish_response(urls, request_session:, origin_url:, advertisement:, max_probes: nil)
+          scoped = max_probes.nil? ? urls.lazy : urls.lazy.take(max_probes)
+          scoped.filter_map do |url|
+            response = probe(url, request_session:, origin_url:, advertisement:)
+            response if feedish?(response)
+          end.first
+        end
 
-      def href_from_alternate_link(tag, page)
-        return unless alternate_rel?(tag)
+        def probe(url, request_session:, origin_url:, advertisement:)
+          if advertisement.advertises?(url)
+            request_session.follow_up(url:, relation: :advertised_feed, origin_url:, advertisement:)
+          else
+            request_session.follow_up(url:, relation: :auto_source, origin_url:)
+          end
+        rescue Html2rss::ContractError
+          raise
+        rescue Html2rss::Error => error
+          Log.debug("Syndication::Discovery: probe skipped host=#{origin_url.host} (#{error.class})")
+          nil
+        end
 
-        href = tag[HREF_RE, 1]
-        return if href.nil? || href.empty?
-        return unless syndication_type?(tag[TYPE_RE, 1]) || feed_like_href?(href)
+        def candidates(page, advertisement, doc:, html:, extra_paths:)
+          leading, trailing = alternate_feed_urls(page, advertisement, doc:, html:)
+          (leading + path_guess_urls(page, extra_paths:) + trailing).uniq
+        end
 
-        absolute_url(page, href.strip)
-      end
-      module_function :href_from_alternate_link
-      private_class_method :href_from_alternate_link
+        # An HTML page without a parsed document still gets an (empty) advertisement.
+        def document(parsed_body)
+          parsed_body.is_a?(Nokogiri::HTML::Document) ? parsed_body : Nokogiri::HTML::Document.new
+        end
 
-      def alternate_rel?(tag)
-        tag[REL_RE, 1].to_s.downcase.split(/\s+/).include?('alternate')
-      end
-      module_function :alternate_rel?
-      private_class_method :alternate_rel?
+        # @return [Array(Array, Array)] alternates ranked before the path guesses, and those after them
+        def alternate_feed_urls(page, advertisement, doc:, html:)
+          feeds = advertisement.feeds
+          return [AlternateLinks.hrefs(html.to_s).filter_map { |href| absolute_url(page, href) }, []] if feeds.empty?
 
-      def syndication_type?(type)
-        return false if type.nil? || type.empty?
+          audio, other = feeds.keys.partition { |url| AUDIO_HINT.match?("#{feeds.fetch(url)} #{url}") }
+          podcast_page?(doc, page) ? [audio + other, []] : [other, audio]
+        end
 
-        t = type.downcase
-        t.include?('rss+xml') || t.include?('atom+xml') || t.include?('rss') || t.include?('atom')
-      end
-      module_function :syndication_type?
-      private_class_method :syndication_type?
+        # The page itself looks like a podcast page: cheap signals only (no request, no JSON parse).
+        def podcast_page?(doc, page)
+          PODCAST_PAGE_HINT.match?("#{page.host}#{page.path}") || PODCAST_PAGE_HINT.match?(doc.title) ||
+            MEDIA_OG_TYPE.match?(doc.at_css('meta[property="og:type"]')&.[]('content')) ||
+            Html::Probe.scripts(doc, Html::Probe::APPLICATION_LD_JSON).any? { PODCAST_SCHEMA_TYPE.match?(_1.text) }
+        end
 
-      def feed_like_href?(href)
-        href.match?(/rss|atom|feed|\.xml/i)
-      end
-      module_function :feed_like_href?
-      private_class_method :feed_like_href?
+        def path_guess_urls(page, extra_paths:)
+          paths = (page_dir_paths(page) + DEFAULT_PATHS + Array(extra_paths)).uniq
+          paths.filter_map { |path| absolute_url(page, path) }
+        end
 
-      def absolute_url(base, path)
-        Html2rss::Url.from_relative(path, base)
-      rescue ArgumentError
-        nil
+        def absolute_url(base, path)
+          Html2rss::Url.from_relative(path, base)
+        rescue Html2rss::Url::InvalidUrlError
+          nil
+        end
       end
-      module_function :absolute_url
-      private_class_method :absolute_url
     end
   end
 end

data/lib/html2rss/syndication/feed.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module Syndication
+    Feed = Data.define(:articles, :channel)
+
+    ##
+    # One parsed native feed ({Parser.parse}): its items as AutoSource article hashes and what it
+    # states about its channel ({ChannelFacts}).
+    #
+    # @!attribute [r] articles
+    #   @return [Array<Hash{Symbol => Object}>] article hashes (may be empty)
+    # @!attribute [r] channel
+    #   @return [ChannelFacts, nil] nil when the document is no RSS 2.0 or Atom feed or failed to parse
+    class Feed
+      # No feed read: no articles, no channel facts.
+      NONE = new(articles: [].freeze, channel: nil)
+    end
+  end
+end

data/lib/html2rss/syndication/item_media.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module Syndication
+    ##
+    # Reads the media files and image a feed item declares, for {Parser}: the +rss+ library parses the
+    # item text but drops Media RSS, so this module reads the same document's item elements.
+    #
+    # Enclosures, in document order and once per URL: RSS 2.0 +enclosure+ (+url+, +type+, +length+),
+    # Atom +link rel="enclosure"+ (+href+, +type+, +length+) and Media RSS +media:content+, also inside
+    # +media:group+ (+url+, +type+, +fileSize+, +duration+). A Media RSS +medium+ (+audio+, +video+, +image+)
+    # is the file's kind, typing an untyped file ({Article::Enclosure::KIND_TYPES}); it never makes a watch or
+    # player page ({Article::Enclosure#player_page?}, judged without it) a file, except that +image+ keeps one.
+    # An item +itunes:duration+ is the duration of every file that declares none ({Article::Enclosure} keeps it
+    # only on audio and video). The item image is its +itunes:image+ (+href+, or the URL as its text), else its
+    # first +media:thumbnail+ (also inside +media:group+); without either, {Article} makes its first image file
+    # the item image. Every declared URL resolves against the feed URL through {Url.resolve_web}, so a
+    # +javascript:+, +data:+ or +ftp:+ file or image is dropped, never shipped nor made an item URL ({Parser}).
+    # Sizes, durations and kinds come from {Article::Enclosure}. Items match by namespace
+    # ({ITEMS}); a document without any media marker ({MEDIA_MARKERS}) is not parsed a second time.
+    module ItemMedia
+      # Namespace prefixes the item queries bind.
+      NAMESPACES = {
+        'rss1' => 'http://purl.org/rss/1.0/',
+        'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+        'atom' => 'http://www.w3.org/2005/Atom',
+        'media' => 'http://search.yahoo.com/mrss/',
+        'itunes' => 'http://www.itunes.com/dtds/podcast-1.0.dtd'
+      }.freeze
+      # Item elements in document order, by format: RSS 2.0 +item+ (no namespace) under +rss/channel+,
+      # RSS 1.0 +item+ under +rdf:RDF+, Atom +entry+ under +feed+. Extension elements named +item+ never count.
+      ITEMS = '/rss/channel/item | /rdf:RDF/rss1:item | /atom:feed/atom:entry'
+      # Text only a document declaring item media contains: an RSS 2.0 enclosure, an Atom enclosure link,
+      # or the Media RSS or iTunes namespace. Any other document is not parsed a second time.
+      MEDIA_MARKERS = Regexp.union('<enclosure', /rel=["']enclosure["']/, NAMESPACES['media'], NAMESPACES['itunes'])
+      # Enclosure elements of one item, in document order.
+      ENCLOSURES = "enclosure | atom:link[@rel='enclosure'] | media:content | media:group/media:content"
+      # Thumbnail URLs of one item, in document order (blank ones skipped, like a blank iTunes image).
+      THUMBNAILS = 'media:thumbnail/@url[normalize-space()] | media:group/media:thumbnail/@url[normalize-space()]'
+      # The item's iTunes image URL: its +href+, else the URL written as the element text.
+      ITUNES_IMAGE = 'itunes:image/@href[normalize-space()] | ' \
+                     'itunes:image[not(normalize-space(@href))][normalize-space()]'
+
+      class << self
+        ##
+        # @param body [String] the feed document
+        # @param count [Integer] items the +rss+ library read from +body+
+        # @param url [String, Html2rss::Url, nil] the feed URL (nil when unknown): the base of relative file and
+        #   image URLs, and named in the log when items cannot be matched
+        # @return [Array<Hash{Symbol => Object}>] per item, in document order, its +enclosures+ and +image+
+        #   when present; all empty when the document declares no media or its item elements do not
+        #   number +count+ (logged)
+        def for_items(body, count:, url:)
+          return Array.new(count) { {} } unless MEDIA_MARKERS.match?(body)
+
+          nodes = Nokogiri::XML(body).xpath(ITEMS, NAMESPACES)
+          return nodes.map { |node| item_media(node, url) } if nodes.size == count
+
+          warn_mismatch(nodes.size, count, url)
+          Array.new(count) { {} }
+        end
+
+        private
+
+        def item_media(node, feed_url)
+          duration = Article::Enclosure.parse_duration(node.at_xpath('itunes:duration', NAMESPACES)&.text)
+          files = node.xpath(ENCLOSURES, NAMESPACES).filter_map { file(_1, duration, feed_url) }
+          declared = node.at_xpath(ITUNES_IMAGE, NAMESPACES) || node.at_xpath(THUMBNAILS, NAMESPACES)
+          { enclosures: files.uniq { _1[:url].to_s }, image: declared && Url.resolve_web(declared.content, feed_url) }
+            .reject { |_, value| value.nil? || value == [] }
+        end
+
+        # The file's facts: its declared type, its +medium+ as kind, its byte length and its own duration, else
+        # the item's.
+        #
+        # @return [Hash{Symbol => Object}, nil] nil without an http(s) URL or for a watch or player page not marked
+        #   an image
+        def file(element, item_duration, feed_url)
+          return unless (url = Url.resolve_web(attribute(element, 'url', 'href'), feed_url))
+
+          type = attribute(element, 'type')
+          bytes_length = Article::Enclosure.parse_size(attribute(element, 'length', 'fileSize'))
+          kind = Article::Enclosure::KIND_TYPES.each_key.find { _1.name == element['medium'] }
+          return if kind != :image && Article::Enclosure.new(url:, type:, bytes_length:).player_page?
+
+          duration = Article::Enclosure.parse_duration(attribute(element, 'duration')) || item_duration
+          { url:, type:, kind:, bytes_length:, duration: }.compact
+        end
+
+        def attribute(element, *names)
+          names.filter_map { element[_1]&.strip }.find { !_1.empty? }
+        end
+
+        def warn_mismatch(elements, count, url)
+          Log.warn({
+            event_name: 'syndication.item_media_mismatch', feed_url: url,
+            message: "Syndication::ItemMedia: #{elements} item elements for #{count} parsed items; no item media read"
+          }.to_json)
+        end
+      end
+    end
+  end
+end