html2rss 0.23.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53482ae1084593193664ab8301bd451f53f68b4afabc8f0a336d9ae6dcd357c
-  data.tar.gz: 65ef2c8261a216040484134f71de9b8579378d6f7aa20100d0c79cf684efcd65
+  metadata.gz: 1b6b0ddc57b5cf372cc9bc6405bb21f7dc6d00aa526e234132974ccc6ef609f7
+  data.tar.gz: 59a60ef044a99686838b5498f0712a455a6c5a832c27619db0c99ba21742f6a8
 SHA512:
-  metadata.gz: 18c6b5dfb6f23753b1c4885339b16505800b91235e65f397d7195d2301b7c32974c12be0087c35c2e63a5bd08185518ea49c6bd252cc68f22521814c6f6e74f8
-  data.tar.gz: 458fff5c3579ea95190e458a9cf5814418467fdfc37cedc1244faf4d7c7eb6582640b9d8465329f68eac3624c33c1691514da25c1ce1a7cb6ddb2c7999c38638
+  metadata.gz: 8994aa3b90d791ea8cf75df9b576669fffe505fe0895e207745ab0e591f187ab490382d00a95d49fc1073570f886d6940f27f1c1ca80ba7c57817740f48c4bc4
+  data.tar.gz: dc62483a0ade2b582fb3839778a3a518a7f1a08e781d2105c0e93c70aaa26313e153a4e30121170b8a59e8472517e6cb8d9958b9c06fa3a862358631f469c18a

data/README.md

@@ -13,7 +13,7 @@ Most people looking for a first working feed should start with `html2rss-web`, r
 Detailed usage guides, reference docs, and the feed directory live on the project website:
 
 - [Ruby gem documentation](https://html2rss.github.io/ruby-gem)
-- [Request strategies](https://html2rss.github.io/ruby-gem/reference/strategy) (`auto`, `faraday`, `botasaurus`, `browserless`)
+- [Request strategies](https://html2rss.github.io/ruby-gem/reference/strategy) (`auto` = `faraday` → `botasaurus`; pin `browserless` explicitly)
 - [Selectors & pagination](https://html2rss.github.io/ruby-gem/reference/selectors#paginated-feeds)
 - [Web application](https://html2rss.github.io/web-application)
 - [Feed directory](https://html2rss.github.io/feed-directory)
@@ -26,7 +26,7 @@ Cloud development: [Open in GitHub Codespaces](https://github.com/codespaces/new
 ## Architecture
 
 1. **Config** — loads and validates configuration (YAML/hash); schema via `html2rss schema` / `schema/html2rss-config.schema.json`
-2. **RequestService** — fetches pages (`faraday`, `botasaurus`, or `browserless`)
+2. **RequestService** — fetches pages (`faraday`, `botasaurus`, or explicit `browserless`)
 3. **Selectors** — extracts content via CSS selectors with extractors/post-processors
 4. **AutoSource** — auto-detects content (Schema.org, JSON state, semantic HTML, structural patterns)
 5. **FeedBuilder** — assembles Article objects and renders feeds (RSS 2.0 / JSON Feed 1.1)

data/lib/html2rss/article.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'sanitize'
-require 'nokogiri'
 
 module Html2rss
   ##
   # Article is a simple data object representing an article extracted from a page.
   # It is enumerable and responds to all keys specified in PROVIDED_KEYS.
-  # rubocop:disable Metrics/ClassLength
+  #
+  # Description and enclosure wire presentation live in {FeedBuilder::ItemPresentation}.
+  # rubocop:disable Metrics/ClassLength -- value object retains Marshal + defensive freeze helpers
   class Article
     include Enumerable
     include Comparable
@@ -26,9 +26,9 @@ module Html2rss
     # @param options [Hash{Symbol => String}]
     # @option options [String] :id stable article identifier
     # @option options [String] :title article title
-    # @option options [String] :description article description/content
+    # @option options [String] :description raw extracted description/content (not feed-rendered HTML)
     # @option options [String, Html2rss::Url] :url canonical article URL
-    # @option options [String, Html2rss::Url] :image image URL for fallback enclosure rendering
+    # @option options [String, Html2rss::Url] :image image URL for description / JSON Feed +image+
     # @option options [String] :author author name
     # @option options [String] :guid explicit GUID override
     # @option options [String, Time, DateTime] :published_at publication timestamp
@@ -36,9 +36,9 @@ module Html2rss
     # @option options [Array<String>] :categories category labels
     # @option options [Class] :scraper scraper class that produced the article
     def initialize(**options)
-      @to_h = options.each_with_object({}) { |(k, v), h| h[k] = v.freeze if v }.freeze
+      @to_h = options.each_with_object({}) { |(key, value), hash| hash[key] = freeze_option(value) }.freeze
 
-      @description = @url = @image = @guid = @enclosures = @enclosure = @categories = @published_at = NOT_SET
+      @url = @image = @guid = @enclosures = @categories = @published_at = NOT_SET
 
       return unless (unknown_keys = options.keys - PROVIDED_KEYS).any?
 
@@ -65,18 +65,10 @@ module Html2rss
     # @return [String, nil] article title
     def title = blank_string_to_nil(@to_h[:title])
 
-    # @return [String] rendered article description
-    def description
-      return @description unless @description == NOT_SET
-
-      @description = Html::Rendering::DescriptionBuilder.new(
-        base: @to_h[:description],
-        title:,
-        url:,
-        enclosures:,
-        image:
-      ).call
-    end
+    # Raw extracted description — feed HTML enrichment is {FeedBuilder::ItemPresentation.description_for}.
+    #
+    # @return [String, nil]
+    def description = blank_string_to_nil(@to_h[:description])
 
     # @return [Url, nil]
     def url
@@ -117,21 +109,7 @@ module Html2rss
 
       @enclosures = Array(@to_h[:enclosures])
                     .map { |enclosure| Enclosure.new(**enclosure) }
-    end
-
-    # @return [Html2rss::Article::Enclosure, nil]
-    def enclosure
-      return @enclosure unless @enclosure == NOT_SET
-
-      @enclosure = case (object = @to_h[:enclosures]&.first)
-                   when Hash
-                     Enclosure.new(**object)
-                   when nil
-                     Enclosure.new(url: image) if image
-                   else
-                     Log.warn "Article: unknown enclosure type: #{object.class}"
-                     nil
-                   end
+                    .freeze
     end
 
     # @return [Array<String>] normalized, unique category names
@@ -142,7 +120,7 @@ module Html2rss
         categories.map! { |category| category.to_s.strip }
         categories.reject!(&:empty?)
         categories.uniq!
-      end
+      end.freeze
     end
 
     # Parses and returns the published_at time.
@@ -171,6 +149,35 @@ module Html2rss
 
     private
 
+    ##
+    # Marshal only the constructor payload so lazy +NOT_SET+ sentinels do not break
+    # {FeedResult} cache round-trips.
+    #
+    # @return [Hash{Symbol => Object}]
+    def marshal_dump = @to_h
+
+    ##
+    # @param payload [Hash{Symbol => Object}] constructor options from {#marshal_dump}
+    # @return [void]
+    def marshal_load(payload)
+      initialize(**payload)
+    end
+
+    def freeze_option(value)
+      case value
+      when String then value.dup.freeze
+      when Array then freeze_array_option(value)
+      when Hash then value.transform_values { freeze_option(_1) }.freeze
+      else value
+      end
+    end
+
+    def freeze_array_option(value)
+      value.map do |entry|
+        entry.is_a?(Hash) ? entry.transform_values { freeze_option(_1) }.freeze : freeze_option(entry)
+      end.freeze
+    end
+
     def dedup_from_url
       return unless (value = url)
 

data/lib/html2rss/auto_source/scraper/html.rb

@@ -1,21 +1,11 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
-
 module Html2rss
   class AutoSource
     module Scraper
       ##
-      # Scrapes article-like blocks from plain HTML by looking for repeated link
-      # structures when richer structured data is unavailable.
-      #
-      # The approach is intentionally heuristic:
-      # 1. collect repeated anchor paths
-      # 2. walk upward to a shared container shape
-      # 3. extract the best anchor found inside each container
-      #
-      # This scraper is broader and noisier than `SemanticHtml`, so it acts as a
-      # fallback for pages without stronger semantic signals.
+      # Fallback HTML list/cluster scraper via SST pipeline
+      # (Normalizer → Segmenter → Scoring::Engine → Html::SstArticleExtractor).
       class Html
         include Enumerable
 
@@ -25,53 +15,44 @@ module Html2rss
         DEFAULT_MINIMUM_SELECTOR_FREQUENCY = 2
         # Number of most frequent selectors kept for container extraction.
         DEFAULT_USE_TOP_SELECTORS = 5
+        # Maximum articles materialized after eligibility filtering.
+        TOP_K = Scoring::Engine::TOP_K
 
         ##
-        # @return [Symbol] config key used to enable or configure this scraper
+        # @return [Symbol]
         def self.options_key = :html
 
         ##
-        # Probes whether the document appears to contain repeated anchor
-        # structures that this fallback scraper can cluster into article-like
-        # containers.
-        #
-        # @param parsed_body [Nokogiri::HTML::Document] parsed HTML document
-        # @return [Boolean] true when the scraper can likely extract articles
+        # @param parsed_body [Nokogiri::HTML::Document]
+        # @return [Boolean]
         def self.articles?(parsed_body)
-          new(parsed_body, url: DETECTION_BASE_URL).any?
-        end
+          return false unless parsed_body
 
-        ##
-        # Simplify an XPath selector by removing the index notation.
-        # This keeps repeated anchor paths comparable across sibling blocks.
-        #
-        # @param xpath [String] original XPath
-        # @return [String] XPath without positional indexes
-        def self.simplify_xpath(xpath)
-          Discovery::ListCandidates.simplify_xpath(xpath)
+          new(parsed_body, url: DETECTION_BASE_URL).extractable?
+        rescue ArgumentError
+          false
         end
 
-        # @param parsed_body [Nokogiri::HTML::Document] The parsed HTML document.
-        # @param url [String] The base URL.
-        # @param extractor [Class] The extractor class to handle article extraction.
-        # @param opts [Hash] Additional options.
-        # @option opts [Integer] :minimum_selector_frequency minimum count before a selector is considered stable
-        # @option opts [Integer] :use_top_selectors number of top selectors to keep
-        def initialize(parsed_body, url:, extractor: Html2rss::Html::ArticleExtractor, **opts)
+        # @param parsed_body [Nokogiri::HTML::Document, nil] parsed HTML (when +document:+ omitted)
+        # @param url [String, Html2rss::Url]
+        # @param document [SST::Document, nil] memoized SST document from AutoSource
+        # @param link_resolver [Scoring::LinkResolver, nil] shared page-scoped resolver
+        # @param opts [Hash]
+        # @option opts [Boolean] :fallback_anchorless keep anchorless cluster cards
+        # @option opts [Integer] :minimum_selector_frequency list frequency floor
+        # @option opts [Integer] :use_top_selectors list selector budget
+        def initialize(parsed_body = nil, url:, document: nil, link_resolver: nil, **opts)
           @parsed_body = parsed_body
+          @provided_document = document
+          @provided_link_resolver = link_resolver
           @url = url
-          @extractor = extractor
           @opts = opts
           @fallback_anchorless = opts.fetch(:fallback_anchorless, false)
-          @link_heuristics = LinkHeuristics.new(url)
-          @ignored_cache = {}.compare_by_identity
         end
 
-        attr_reader :parsed_body
-
         ##
-        # @yieldparam [Hash] The scraped article hash
-        # @return [Enumerator] Enumerator for the scraped articles
+        # @yieldparam article [Html2rss::Article]
+        # @return [Enumerator]
         def each
           return enum_for(:each) unless block_given?
 
@@ -79,135 +60,77 @@ module Html2rss
         end
 
         ##
-        # @return [Boolean] true when the scraper can likely extract articles
+        # @return [Boolean]
         def extractable?
-          articles.any?
-        end
-
-        ##
-        # Decides whether a traversed node has reached a useful article-like
-        # boundary for the generic HTML scraper.
-        #
-        # The predicate prefers containers that add surrounding link context,
-        # which helps the scraper move from a leaf anchor toward a repeated
-        # teaser/card wrapper.
-        #
-        # @param node [Nokogiri::XML::Node] candidate boundary node
-        # @return [Boolean] true when the node is a good extraction boundary
-        def article_tag_condition?(node)
-          # Ignore tags that are below ignored DOM chrome.
-          return false if Html2rss::Html::Navigator.ignored_container_path?(node, @ignored_cache)
-          return true if %w[body html].include?(node.name)
-          return false unless (parent = node.parent)
-
-          anchor_count(parent) > anchor_count(node)
+          ranked_segments.any?
+        rescue ArgumentError
+          false
         end
 
         private
 
         def articles
           @articles ||= begin
-            extracted = each_article_tag.filter_map do |article_tag, selected_anchor|
-              extract_article(article_tag, selected_anchor:)
+            ranked = list_ranked
+            if ranked.empty? && @fallback_anchorless
+              materialize(cluster_ranked, fallback_anchorless: true)
+            else
+              materialize(ranked)
             end
-
-            extracted += find_anchorless_articles if @fallback_anchorless
-            extracted
           end
+        rescue ArgumentError
+          []
         end
 
-        def find_anchorless_articles
-          Discovery::DomClustering.call(
-            parsed_body,
-            minimum_selector_frequency:
-          ).map do |node|
-            @extractor.new(node, base_url: @url, selected_anchor: nil, fallback_anchorless: true).call
+        def ranked_segments
+          @ranked_segments ||= begin
+            ranked = list_ranked
+            ranked = cluster_ranked if @fallback_anchorless && ranked.empty?
+            ranked
           end
         end
 
-        ##
-        # @return [Integer]
-        def minimum_selector_frequency = @opts[:minimum_selector_frequency] || DEFAULT_MINIMUM_SELECTOR_FREQUENCY
-
-        ##
-        # @return [Boolean]
-        def use_top_selectors = @opts[:use_top_selectors] || DEFAULT_USE_TOP_SELECTORS
-
-        ##
-        # @param node [Nokogiri::XML::Node]
-        # @return [Integer]
-        def anchor_count(node)
-          (@anchor_counts ||= {}.compare_by_identity)[node] ||= node.name == 'a' ? 1 : node.css('a').size
-        end
-
-        ##
-        # @param node [Nokogiri::XML::Node]
-        # @return [Boolean]
-        def relevant_anchor?(node)
-          destination_facts = @link_heuristics.destination_facts(node)
-          return false unless destination_facts
-
-          !noise_anchor?(node, destination_facts:)
+        def list_ranked
+          @list_ranked ||= rank_strategy(:list, permit_unanchored: false)
         end
 
-        ##
-        # @yield [article_tag, selected_anchor]
-        # @yieldparam article_tag [Nokogiri::XML::Node]
-        # @yieldparam selected_anchor [Nokogiri::XML::Node]
-        # @return [Enumerator, nil]
-        def each_article_tag(&block)
-          return enum_for(:each_article_tag) unless block
-
-          anchor_filter = ->(node) { relevant_anchor?(node) }
-          boundary_condition = ->(node) { article_tag_condition?(node) }
-
-          list_candidates.each_article_tag(anchor_filter:, boundary_condition:, &block)
+        def cluster_ranked
+          @cluster_ranked ||= rank_strategy(:cluster, permit_unanchored: true)
         end
 
-        ##
-        # @param article_tag [Nokogiri::XML::Node]
-        # @param selected_anchor [Nokogiri::XML::Node, nil]
-        # @return [Hash, nil]
-        def extract_article(article_tag, selected_anchor: nil)
-          selected_anchor ||= preferred_anchor_for(article_tag)
-          return unless selected_anchor
-          return if noise_anchor?(
-            selected_anchor,
-            destination_facts: @link_heuristics.destination_facts(selected_anchor),
-            container: article_tag
+        def rank_strategy(strategy, permit_unanchored:)
+          segments = Segmenter.call(
+            document,
+            base_url: @url,
+            strategy:,
+            permit_unanchored:,
+            minimum_selector_frequency:,
+            use_top_selectors:,
+            link_resolver:
           )
-
-          @extractor.call(article_tag, base_url: @url, selected_anchor:)
+          engine.select_eligible(segments, limit: TOP_K)
         end
 
-        ##
-        # @param anchor [Nokogiri::XML::Node]
-        # @param destination_facts [LinkHeuristics::DestinationFacts, nil]
-        # @return [Boolean]
-        def noise_anchor?(anchor, destination_facts:, container: nil)
-          (@noise_anchors ||= {}.compare_by_identity)[anchor] ||= begin
-            text = Html2rss::Html::Navigator.extract_visible_text(anchor).to_s.strip
-            @link_heuristics.noise_anchor?(text:, destination_facts:, anchor:, container:)
+        def materialize(ranked, fallback_anchorless: false)
+          ranked.filter_map do |entry|
+            ::Html2rss::Html::SstArticleExtractor.call(entry, base_url: @url, scraper: self.class, fallback_anchorless:)
           end
         end
 
-        ##
-        # @param article_tag [Nokogiri::XML::Node]
-        # @return [Nokogiri::XML::Node, nil]
-        def preferred_anchor_for(article_tag)
-          article_tag.css(Html2rss::Html::Navigator::MAIN_ANCHOR_SELECTOR).find { relevant_anchor?(_1) } ||
-            Html2rss::Html::Navigator.main_anchor_for(article_tag)
+        def engine
+          @engine ||= Scoring::Engine.new(link_resolver:)
         end
 
-        ##
-        # @return [Discovery::ListCandidates]
-        def list_candidates
-          Discovery::ListCandidates.new(
-            parsed_body,
-            minimum_selector_frequency:,
-            use_top_selectors:
-          )
+        def link_resolver
+          @link_resolver ||= @provided_link_resolver || Scoring::LinkResolver.new(@url)
         end
+
+        def document
+          @document ||= @provided_document || SST::Normalizer.call(@parsed_body)
+        end
+
+        def minimum_selector_frequency = @opts[:minimum_selector_frequency] || DEFAULT_MINIMUM_SELECTOR_FREQUENCY
+        def use_top_selectors = @opts[:use_top_selectors] || DEFAULT_USE_TOP_SELECTORS
       end
     end
   end

data/lib/html2rss/auto_source/scraper/json_state/article_normalizer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Html2rss
+  class AutoSource
+    module Scraper
+      class JsonState
+        # Shapes raw entries into the structure required downstream.
+        module ArticleNormalizer
+          # Preferred keys when extracting title-like values from state payloads.
+          TITLE_KEYS = %i[title headline name text].freeze
+          # Preferred keys when extracting URL-like values from state payloads.
+          URL_KEYS = %i[url link href permalink slug path canonicalUrl shortUrl].freeze
+          # Preferred keys when extracting description-like values from state payloads.
+          DESCRIPTION_KEYS = %i[description summary excerpt dek subheading].freeze
+          # Preferred keys when extracting image-like values from state payloads.
+          IMAGE_KEYS = %i[image imageUrl thumbnailUrl thumbnail src featuredImage coverImage heroImage].freeze
+          # Preferred keys when extracting publication timestamps from state payloads.
+          PUBLISHED_AT_KEYS = %i[published_at publishedAt datePublished date publicationDate pubDate updatedAt
+                                 updated_at createdAt created_at].freeze
+          # Preferred keys when extracting category-like values from state payloads.
+          CATEGORY_KEYS = %i[categories tags section sections topic topics channel].freeze
+          # Preferred keys when extracting identifier-like values from state payloads.
+          ID_KEYS = %i[id guid uuid slug key].freeze
+
+          module_function
+
+          # rubocop:disable Metrics/MethodLength
+          # @param entry [Hash] raw article entry candidate
+          # @param base_url [String, Html2rss::Url] base URL for relative link resolution
+          # @return [Hash{Symbol => Object, nil}] normalized article hash for downstream extraction
+          def normalise(entry, base_url:)
+            return unless entry.is_a?(Hash)
+
+            title = string(ValueFinder.fetch(entry, TITLE_KEYS))
+            description = string(ValueFinder.fetch(entry, DESCRIPTION_KEYS))
+            article_url = resolve_link(entry, keys: URL_KEYS, base_url:,
+                                              log_key: 'JsonState: invalid URL encountered')
+            return unless article_url
+            return if title.nil? && description.nil?
+
+            {
+              title:,
+              description:,
+              url: article_url,
+              image: resolve_link(entry, keys: IMAGE_KEYS, base_url:,
+                                         log_key: 'JsonState: invalid image URL encountered'),
+              published_at: string(ValueFinder.fetch(entry, PUBLISHED_AT_KEYS)),
+              categories: categories(entry),
+              id: identifier(entry, article_url)
+            }.compact
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          # @param value [Object] candidate scalar value
+          # @return [String, nil] normalized non-empty string value
+          def string(value)
+            trimmed = value.to_s.strip
+            trimmed unless trimmed.empty?
+          end
+
+          # @param entry [Hash] raw article entry candidate
+          # @param keys [Array<String>] preferred link keys
+          # @param base_url [String, Html2rss::Url] base URL for relative link resolution
+          # @param log_key [String] structured log message key
+          # @return [Html2rss::Url, nil] resolved absolute URL
+          def resolve_link(entry, keys:, base_url:, log_key:)
+            value = ValueFinder.fetch(entry, keys)
+            value = ValueFinder.fetch(value, keys) if value.is_a?(Hash)
+            string = string(value)
+            return unless string
+
+            Url.from_relative(string, base_url)
+          rescue ArgumentError
+            Log.debug(log_key, url: string)
+            nil
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          # @param entry [Hash] raw article entry candidate
+          # @return [Array<String>, nil] normalized unique categories
+          def categories(entry)
+            raw = ValueFinder.fetch(entry, CATEGORY_KEYS)
+            names = case raw
+                    when Array then raw
+                    when Hash then raw.values
+                    when String then [raw]
+                    else []
+                    end
+
+            result = names.flat_map do |value|
+              case value
+              when Hash
+                string(ValueFinder.fetch(value, %i[name title label]))
+              else
+                string(value)
+              end
+            end.compact
+
+            result.uniq!
+            result unless result.empty?
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          # @param entry [Hash] raw article entry candidate
+          # @param article_url [Html2rss::Url] resolved article URL
+          # @return [String] stable article identifier fallbacking to resolved URL
+          def identifier(entry, article_url)
+            value = ValueFinder.fetch(entry, ID_KEYS)
+            value = ValueFinder.fetch(value, ID_KEYS) if value.is_a?(Hash)
+            string(value) || article_url.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/html2rss/auto_source/scraper/json_state/candidate_detector.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Html2rss
+  class AutoSource
+    module Scraper
+      class JsonState
+        # Identifies arrays that look like collections of article hashes.
+        module CandidateDetector
+          # Preferred keys when extracting title-like values from state payloads.
+          TITLE_KEYS = %i[title headline name text].freeze
+          # Preferred keys when extracting URL-like values from state payloads.
+          URL_KEYS = %i[url link href permalink slug path canonicalUrl shortUrl].freeze
+
+          module_function
+
+          # @param document [Hash, Array, Object] candidate document node
+          # @return [Boolean] whether the node contains article-like arrays
+          def candidate_array?(document)
+            case document
+            when Array
+              return true if array_of_articles?(document)
+
+              document.any? { traversable_candidate?(_1) }
+            when Hash then document.each_value.any? { candidate_array?(_1) }
+            else false
+            end
+          end
+
+          # @param value [Hash, Array, Object] candidate nested value
+          # @return [Boolean] whether nested value should be traversed for article candidates
+          def traversable_candidate?(value)
+            case value
+            when Array, Hash then candidate_array?(value)
+            else false
+            end
+          end
+
+          # @param array [Array<Object>] candidate list of entries
+          # @return [Boolean] whether array includes hash entries with title and URL fields
+          def array_of_articles?(array)
+            array.any? do |element|
+              next unless element.is_a?(Hash)
+
+              title_from(element) && url_from(element)
+            end
+          end
+
+          # @param object [Hash] article candidate object
+          # @return [Object, nil] detected title-like value
+          def title_from(object)
+            ValueFinder.fetch(object, TITLE_KEYS)
+          end
+
+          # @param object [Hash] article candidate object
+          # @return [Object, nil] detected URL-like value
+          def url_from(object)
+            ValueFinder.fetch(object, URL_KEYS)
+          end
+        end
+      end
+    end
+  end
+end