html2rss 0.23.0 → 0.25.0

data/lib/html2rss/html/sst_article_extractor.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Html2rss
+  module Html
+    ##
+    # Builds an {Html2rss::Article} from an SST segment / ranked segment.
+    # Port of Html::ArticleExtractor field logic onto SST::Node.
+    # rubocop:disable 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 = %i[strong b].freeze
+
+      class << self
+        ##
+        # @param ranked_or_segment [Scoring::RankedSegment, AutoSource::Segment]
+        # @param base_url [String, Html2rss::Url]
+        # @param scraper [Class, nil]
+        # @param fallback_anchorless [Boolean]
+        # @return [Html2rss::Article, nil]
+        def call(ranked_or_segment, base_url:, scraper: nil, fallback_anchorless: false)
+          new(ranked_or_segment, base_url:, scraper:, fallback_anchorless:).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]
+      def initialize(ranked_or_segment, base_url:, scraper: nil, fallback_anchorless: false)
+        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)
+
+        @segment = segment
+        @root = segment.root_node
+        @selected_anchor = segment.primary_link
+        @base_url = base_url
+        @scraper = scraper
+        @fallback_anchorless = fallback_anchorless
+      end
+
+      ##
+      # @return [Html2rss::Article, nil]
+      def call # rubocop:disable Metrics/MethodLength
+        attrs = {
+          title: extract_title,
+          url: extract_url,
+          image: extract_image,
+          description: extract_description,
+          id: generate_id,
+          published_at: extract_published_at,
+          enclosures: extract_enclosures,
+          categories: extract_categories,
+          scraper: @scraper
+        }
+        article = Article.new(**attrs)
+        article.valid? ? article : nil
+      end
+
+      private
+
+      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
+        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 # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        source = heading || @selected_anchor
+        title_text = if source
+                       source.visible_text
+                     elsif @fallback_anchorless && @selected_anchor.nil?
+                       first_nonempty_own_text
+                     end
+        return unless title_text
+
+        kicker = kicker_node&.visible_text.to_s.strip
+        kicker && !kicker.empty? && !title_text.include?(kicker) ? "#{kicker}: #{title_text}" : title_text
+      end
+
+      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
+        end
+      end
+
+      def select_best_heading(tags)
+        min_name = tags.map { |t| t.name.to_s }.min
+        best = nil
+        max_size = -1
+        tags.each do |tag|
+          next unless tag.name.to_s == min_name
+
+          size = tag.visible_text.to_s.size
+          (best = tag) && (max_size = size) if size > max_size
+        end
+        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)
+        # Walk via root children since Extractor may not hold Index; use tag walk on tree.
+        return true if child.equal?(ancestor)
+
+        ancestor.descendants.any? { |d| d.equal?(child) }
+      end
+
+      def extract_description
+        exclude = [heading, @selected_anchor, kicker_node].compact
+        description = @root.visible_text(exclude:)
+        return if description.nil?
+
+        desc = description.strip
+        desc.empty? ? nil : desc
+      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
+
+      def parse_id_from_dom
+        candidates = [@root.attrs.id]
+        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
+      end
+
+      def extract_image
+        img_src = image_from_srcset || image_from_img || image_from_style
+        Url.from_relative(img_src, @base_url) if img_src
+      end
+
+      def image_from_img
+        @root.find { |n| n.image? && n.attrs.src && !n.attrs.src.start_with?('data:') }&.attrs&.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)
+      end
+
+      def image_from_style
+        styles = @root.find_all { |n| n.attrs.style&.include?('url') }.map { |n| n.attrs.style }
+        ArticleRules::Image.best_from_styles(styles)
+      end
+
+      def extract_published_at
+        datetimes = @root.find_all { |n| n.attrs.datetime }.map { |n| n.attrs.datetime }
+        ArticleRules::Date.earliest(datetimes)
+      end
+
+      def extract_enclosures
+        @root.find_all { |n| enclosure_node?(n) }.filter_map { |element| enclosure_from(element) }
+      end
+
+      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
+      end
+
+      def extract_categories
+        Set.new.tap do |categories|
+          @root.find_all { |n| category_candidate?(n) }.each do |element|
+            add_category_text!(categories, element) if ArticleRules::Category.class_match?(element.attrs.class_attr)
+            element.attrs.raw.each do |name, value|
+              next unless ArticleRules::Category.attr_name_match?(name)
+
+              ArticleRules::Category.add_text!(categories, value)
+            end
+          end
+        end.to_a
+      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) }
+      end
+
+      def add_category_text!(categories, element)
+        if element.link?
+          ArticleRules::Category.add_text!(categories, element.visible_text)
+          return
+        end
+
+        anchors = element.find_all(&:link?)
+        if anchors.any?
+          anchors.each { |a| ArticleRules::Category.add_text!(categories, a.visible_text) }
+        else
+          ArticleRules::Category.add_split_text!(categories, element.visible_text)
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/html2rss/link_destination/destination_facts.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module LinkDestination
+    # Normalized URL plus reusable route-classification facts for one link.
+    DestinationFacts = Data.define(
+      :url,
+      :destination,
+      :segments,
+      :content_path,
+      :utility_path,
+      :taxonomy_path,
+      :vanity_path,
+      :shallow,
+      :strong_post_suffix,
+      :high_confidence_junk_path,
+      :high_confidence_utility_destination
+    ) do
+      # @param url [Html2rss::Url] normalized destination URL
+      # @return [DestinationFacts] route facts for downstream link scoring
+      def self.build(url) # rubocop:disable Metrics/MethodLength
+        classifier = PathClassifier.new(url.path_segments)
+
+        new(
+          url:,
+          destination: url.to_s,
+          segments: classifier.segments,
+          strong_post_suffix: classifier.strong_post_suffix?,
+          content_path: classifier.content_path?,
+          utility_path: classifier.utility_path?,
+          taxonomy_path: classifier.taxonomy_path?,
+          vanity_path: classifier.vanity_path?,
+          shallow: classifier.shallow?,
+          high_confidence_junk_path: classifier.junk_path?,
+          high_confidence_utility_destination: classifier.utility_destination?
+        )
+      end
+    end
+  end
+end

data/lib/html2rss/link_destination/noise_policy.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module LinkDestination
+    ##
+    # Noise / junk chrome eligibility for SST anchors (port of LinkHeuristics#noise_anchor?).
+    class NoisePolicy
+      # Child tag names that mark icon-only anchors as noise.
+      ICON_NAMES = %i[img svg].freeze
+
+      # @param link_resolver [LinkResolver]
+      # @param index [SST::Index]
+      def initialize(link_resolver:, index:)
+        @link_resolver = link_resolver
+        @index = index
+      end
+
+      ##
+      # @param text [String]
+      # @param destination_facts [LinkDestination::DestinationFacts, nil]
+      # @param anchor [SST::Node, nil]
+      # @param container [SST::Node, nil]
+      # @param heading_anchor [Boolean]
+      # @return [Boolean]
+      def noise_anchor?(text:, destination_facts:, anchor: nil, container: nil, heading_anchor: false) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return true unless destination_facts
+
+        destination_facts.taxonomy_path ||
+          short_utility_label?(text, destination_facts) ||
+          recommended_chrome?(text, destination_facts, heading_anchor:) ||
+          (@link_resolver.utility_prefix_text?(text) && destination_facts.high_confidence_utility_destination) ||
+          (@link_resolver.utility_text?(text) && destination_facts.vanity_path) ||
+          utility_text_chrome?(text, destination_facts, heading_anchor:) ||
+          icon_only_anchor?(anchor, text) ||
+          utility_landmark_ancestor?(anchor, container)
+      end
+
+      private
+
+      def short_utility_label?(text, destination_facts)
+        destination_facts.utility_path &&
+          !destination_facts.content_path &&
+          !destination_facts.strong_post_suffix &&
+          text.to_s.scan(/\p{Alnum}+/).size <= 3
+      end
+
+      def recommended_chrome?(text, destination_facts, heading_anchor:)
+        !heading_anchor && @link_resolver.recommended_text?(text) && destination_facts.shallow
+      end
+
+      def utility_text_chrome?(text, destination_facts, heading_anchor:)
+        return false if destination_facts.content_path
+        return false unless @link_resolver.utility_text?(text)
+
+        !heading_anchor && !destination_facts.strong_post_suffix
+      end
+
+      def icon_only_anchor?(anchor, text)
+        return false unless anchor
+        return false if text.to_s.match?(/\p{Alnum}/)
+
+        !!anchor.find { |n| ICON_NAMES.include?(n.name) }
+      end
+
+      def utility_landmark_ancestor?(anchor, container) # rubocop:disable Metrics/CyclomaticComplexity
+        return false unless anchor && container
+
+        curr = @index.parent_of(anchor)
+        while curr && curr.name != :html
+          return true if curr != container && curr.utility_landmark?
+          return false if curr.equal?(container)
+
+          curr = @index.parent_of(curr)
+        end
+        false
+      end
+    end
+  end
+end

data/lib/html2rss/link_destination/path_classifier.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module LinkDestination
+    # Classifies normalized destination path segments for scoring.
+    class PathClassifier # rubocop:disable Metrics/ClassLength
+      attr_reader :segments
+
+      # Soft utility segments excluded from high-confidence junk (still utility_path).
+      SOFT_UTILITY = %w[
+        for-you join member members membership newsletter newsletters
+        plans plus premium pricing recommended
+      ].to_set.freeze
+
+      # Segment groups used to classify article, taxonomy, utility, and vanity routes.
+      SEGMENT_SETS = begin
+        content = %w[
+          article articles blog blogs changelog changelogs insight insights
+          launch launches news post posts release releases story stories update updates
+          artikel beitrag beitraege nachrichten neuigkeiten aktuelles
+          articulo articulos noticia noticias entrada entradas publicacion publicaciones
+          actualite actualites nouvelle nouvelles teaser teasers card cards
+        ].to_set.freeze
+        taxonomy = %w[
+          category categories tag tags topic topics
+          kategorie kategorien schlagwort schlagworte thema themen
+          categoria categorias etiqueta etiquetas tema temas
+          categorie etiquette etiquettes sujet sujets theme themes
+        ].to_set.freeze
+        vanity = %w[
+          join membership plus premium pricing plans subscribe signup
+          abonnieren abo suscribirse boletin s-abonner saboner
+        ].to_set.freeze
+        utility = (
+          taxonomy.to_a + %w[
+            about account archive archives author authors comment comments
+            contact feedback help login logout notification notifications
+            preference preferences profile register search settings share signup subscribe
+            feed feeds comment-feed comments-feed privacy terms cookie cookies user users
+            kategorie kategorien schlagwort schlagworte thema themen autor autoren archiv
+            ueber-uns ueber ueberuns profil kontakt impressum suche hilfe anmelden registrieren
+            konto registrierung anmeldung abonnieren abo datenschutz nutzungsbedingungen agb
+            categoria categorias etiqueta etiquetas tema temas autores archivos
+            sobre-nosotros sobre quienes-somos buscar busqueda ayuda entrar ingresar
+            registrarse registro cuenta suscribirse boletin privacidad condiciones
+            categorie etiquette etiquettes sujet sujets theme themes auteur auteurs
+            a-propos apropos recherche rechercher aide connexion s-inscrire
+            sinscrire inscription compte s-abonner saboner lettre-information confidentialite
+            mentions-legales cgu menu sidebar widget social modal popup banner promo ad ads
+            related recommendation recommendations pagination pager
+          ] + SOFT_UTILITY.to_a
+        ).to_set.freeze
+        {
+          content:,
+          utility:,
+          high_confidence_junk: (utility - SOFT_UTILITY).freeze,
+          taxonomy:,
+          vanity:,
+          deep_post_context: %w[press newsroom presse pressemitteilungen prensa].to_set.freeze
+        }.freeze
+      end
+      # Path segment that begins with a year-like publishing marker.
+      YEARISH_SEGMENT = /\A\d{4,}[\w-]*\z/
+      # Hyphenated slug shape common to article permalinks.
+      POST_SLUG_SEGMENT = /\A[a-z0-9]+(?:-[a-z0-9]+){2,}\z/i
+
+      # @param segments [Array<String>] normalized URL path segments
+      def initialize(segments)
+        @segments = segments
+      end
+
+      # @return [Boolean] true when the route has article-like path evidence
+      def content_path?
+        @content_path ||= SEGMENT_SETS[:content].intersect?(segments) ||
+                          yearish_content_context?
+      end
+
+      # @return [Boolean] true when the route includes utility/navigation evidence
+      def utility_path?
+        @utility_path ||= SEGMENT_SETS[:utility].intersect?(segments)
+      end
+
+      # @return [Boolean] true when the route points at conversion or account chrome
+      def vanity_path?
+        @vanity_path ||= SEGMENT_SETS[:vanity].intersect?(segments)
+      end
+
+      # @return [Boolean] true when the route points at taxonomy/listing chrome
+      def taxonomy_path?
+        @taxonomy_path ||= SEGMENT_SETS[:taxonomy].intersect?(segments)
+      end
+
+      # @return [Boolean] true when the route is too shallow to strongly indicate an article
+      def shallow?
+        segment_count = segments.size
+        junk_segments = SEGMENT_SETS.fetch(:high_confidence_junk)
+
+        segment_count <= 1 || (segment_count == 2 && junk_segments.include?(segments.last))
+      end
+
+      # @return [Boolean] true when the final path segment looks like a post slug
+      def strong_post_suffix?
+        @strong_post_suffix ||= segments.any? &&
+                                included_last_segment? &&
+                                trusted_post_context?(segments.size - 1)
+      end
+
+      # @return [Boolean] true when every path segment is utility chrome
+      def utility_only_route?
+        junk_segments = SEGMENT_SETS.fetch(:high_confidence_junk)
+
+        segments.all? { |segment| junk_segments.include?(segment) }
+      end
+
+      # @return [Boolean] true when the route is shallow and contains high-confidence noise
+      def shallow_high_confidence_route?
+        junk_segments = SEGMENT_SETS.fetch(:high_confidence_junk)
+        vanity_segments = SEGMENT_SETS.fetch(:vanity)
+
+        shallow? && segments.any? do |segment|
+          junk_segments.include?(segment) || vanity_segments.include?(segment)
+        end
+      end
+
+      # @return [Boolean] true when the leading segments are all utility chrome
+      def deep_utility_context_route?
+        all_junk?(segments.size - 1)
+      end
+
+      # @return [Boolean] true when the route is shallow and contains high-confidence noise
+      def junk_path?
+        return false if excluded_content_route?
+
+        taxonomy_path? ||
+          utility_only_route? ||
+          deep_utility_context_route? ||
+          shallow_high_confidence_route?
+      end
+
+      # @return [Boolean] true when the route points at conversion or account chrome
+      def utility_destination?
+        return false if excluded_content_route?
+
+        vanity_path? || utility_route?
+      end
+
+      private
+
+      def yearish_content_context?
+        segments.any? { |segment| segment.match?(YEARISH_SEGMENT) } &&
+          (strong_post_suffix? || trusted_post_context?(segments.size - 1))
+      end
+
+      def excluded_content_route?
+        segments.empty? || content_path? || strong_post_suffix?
+      end
+
+      def utility_route?
+        taxonomy_path? ||
+          utility_only_route? ||
+          deep_utility_context_route? ||
+          shallow_utility_route?
+      end
+
+      def shallow_utility_route?
+        shallow? && utility_path?
+      end
+
+      def all_junk?(limit)
+        return false if limit <= 0
+
+        junk_segments = SEGMENT_SETS.fetch(:high_confidence_junk)
+        (0...limit).all? { |i| junk_segments.include?(segments[i]) }
+      end
+
+      def trusted_post_context?(limit)
+        return false if limit <= 0
+
+        content_segments = SEGMENT_SETS.fetch(:content)
+        context_segments = SEGMENT_SETS.fetch(:deep_post_context)
+
+        (0...limit).any? do |i|
+          segment = segments[i]
+          content_segments.include?(segment) ||
+            segment.match?(PathClassifier::YEARISH_SEGMENT) ||
+            context_segments.include?(segment)
+        end
+      end
+
+      def included_last_segment?
+        !excluded_last_segment? && slug_last_segment?
+      end
+
+      def excluded_last_segment?
+        last = segments.last
+        [SEGMENT_SETS[:high_confidence_junk], SEGMENT_SETS[:vanity]].any? { |set| set.include?(last) }
+      end
+
+      def slug_last_segment?
+        last = segments.last
+        last.match?(YEARISH_SEGMENT) || last.match?(POST_SLUG_SEGMENT)
+      end
+    end
+  end
+end

data/lib/html2rss/link_destination/text_classifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Html2rss
+  module LinkDestination
+    # Classifies visible anchor text for utility and recommendation chrome.
+    class TextClassifier
+      # Prefix labels that usually identify navigation or subscription links.
+      UTILITY_PREFIX_PATTERN = /
+        \A\s*(
+          # English
+          view\s+all|see\s+all|all\s+news|subscribe|newsletter|comment\s+feed|comments\s+feed|join|premium|plus|
+          # German
+          alle\s+anzeigen|alle\s+news|abonnieren|newsletter|kommentar\s+feed|mitmachen|
+          # Spanish
+          ver\s+todos|ver\s+todo|todas\s+las\s+noticias|suscribirse|bolet(i|í)n|comentarios\s+feed|unirse|
+          # French
+          voir\s+tout|voir\s+tous|toutes\s+les\s+nouvelles|s['’]abonner|flux\s+de\s+commentaires|rejoindre
+        )\b
+      /ix
+      # Short labels that usually identify non-article navigation links.
+      UTILITY_PATTERN = /
+        \A\s*(
+          # English
+          about|contact|comments?|join|log\s+in|login|member(ship)?|
+          plus|premium|pricing|recommended(\s+for\s+you)?|
+          see\s+all|share|sign\s+up|signup|subscribe|view\s+all|
+          # German
+          (ue|ü)ber(\s+uns)?|kontakt|kommentare?|mitmachen|anmelden|login|
+          mitglied(schaft)?|empfohlen(\s+f(ue|ü)r\s+dich)?|alle\s+anzeigen|
+          teilen|registrieren|abonnieren|newsletter|
+          # Spanish
+          sobre(\s+nosotros)?|contacto|comentarios?|unirse|iniciar\s+sesion|
+          login|miembro|membres(i|í)a|recomendado(\s+para\s+ti)?|ver\s+todo|
+          compartir|registrarse|suscribirse|bolet(i|í)n|
+          # French
+          (a|à)\s+propos|(a|à)propos|contact|commentaires?|rejoindre|
+          se\s+connecter|login|membre|abonnement|recommand(e|é)(\s+pour\s+vous)?|
+          voir\s+tout|partager|s['’]inscrire|s['’]abonner|newsletter
+        )\b
+      /ix
+      # Labels for recommendation chrome rather than source articles.
+      RECOMMENDED_PATTERN = /
+        \A\s*(
+          recommended(\s+for\s+you)?|
+          empfohlen(\s+f(ue|ü)r\s+dich)?|
+          recomendado(\s+para\s+ti)?|
+          recommand(e|é)(\s+pour\s+vous)?
+        )\b
+      /ix
+
+      # @param text [String, #to_s] visible anchor text
+      # @return [Boolean] true when text matches a utility label
+      def utility?(text) = text.to_s.match?(UTILITY_PATTERN)
+
+      # @param text [String, #to_s] visible anchor text
+      # @return [Boolean] true when text begins with a utility label
+      def utility_prefix?(text) = text.to_s.match?(UTILITY_PREFIX_PATTERN)
+
+      # @param text [String, #to_s] visible anchor text
+      # @return [Boolean] true when text identifies recommendation chrome
+      def recommended?(text) = text.to_s.match?(RECOMMENDED_PATTERN)
+    end
+  end
+end

data/lib/html2rss/link_destination.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ##
+  # Destination URL / anchor-text classification shared by Scoring.
+  module LinkDestination
+  end
+end