html2rss 0.32.4 → 0.34.0

data/lib/html2rss/selectors/option_spec.rb

@@ -11,6 +11,9 @@ module Html2rss
     # introspection SoT (+for+ / +expectation_for+); {SchemaExport} maps Ruby
     # types to JSON Schema only.
     class OptionSpec
+      # Raised when an extractor/post-processor +OPTIONS+ declares a type with no JSON Schema mapping.
+      class InvalidError < Html2rss::ContractError; end
+
       # Maps Ruby option types to JSON Schema +type+ strings.
       RUBY_TO_JSON_TYPE = {
         String => 'string',
@@ -83,7 +86,7 @@ module Html2rss
           when Array then ruby_type.map { |t| json_type_for(t) }
           else
             RUBY_TO_JSON_TYPE.fetch(ruby_type) do
-              raise ArgumentError, "unsupported OPTIONS type mapping for #{ruby_type}"
+              raise InvalidError, "unsupported OPTIONS type mapping for #{ruby_type}"
             end
           end
         end

data/lib/html2rss/selectors/post_processors/base.rb

@@ -114,14 +114,6 @@ module Html2rss
         end
 
         attr_reader :value, :context
-
-        # Abstract method to be implemented by subclasses
-        #
-        # @return [Object] transformed value
-        # @raise [NotImplementedError] if not implemented in subclass
-        def call
-          raise NotImplementedError, 'You must implement the `call` method in the post processor'
-        end
       end
     end
   end

data/lib/html2rss/selectors/post_processors/gsub.rb

@@ -70,7 +70,7 @@ module Html2rss
         #
         # @param string [String]
         # @return [Regexp]
-        # @raise [ArgumentError] when +string+ is not a String, exceeds the character cap,
+        # @raise [InvalidOption] when +string+ is not a String, exceeds the character cap,
         #   contains nested quantifiers, or does not parse
         def self.compiled_pattern(string)
           compiled_patterns[string] ||= compile_regexp_string(string)
@@ -88,25 +88,25 @@ module Html2rss
         # to maintain backwards compatibility before building the Regexp.
         # Length is the character count of the authored string (the JSON Schema
         # +maxLength+ unit), then the AST is walked for nested quantifiers,
-        # then +to_re+. Parser errors are re-raised as ArgumentError so
+        # then +to_re+. Parser errors are re-raised as InvalidOption so
         # validation and execution share one path.
         #
         # @param string [String]
         # @return [Regexp]
-        # @raise [ArgumentError] when +string+ is not a String, exceeds {MAX_PATTERN_LENGTH},
+        # @raise [InvalidOption] when +string+ is not a String, exceeds {MAX_PATTERN_LENGTH},
         #   contains nested quantifiers, or does not parse
         def self.compile_regexp_string(string)
-          raise ArgumentError, 'must be a string!' unless string.is_a?(String)
-          raise ArgumentError, "pattern exceeds #{MAX_PATTERN_LENGTH} characters" if string.length > MAX_PATTERN_LENGTH
+          raise InvalidOption, 'must be a string!' unless string.is_a?(String)
+          raise InvalidOption, "pattern exceeds #{MAX_PATTERN_LENGTH} characters" if string.length > MAX_PATTERN_LENGTH
 
           source = regexp_source(string)
 
-          expression = Regexp::Parser.parse(source, options: ::Regexp::EXTENDED | ::Regexp::IGNORECASE)
-          raise ArgumentError, 'pattern contains nested quantifiers' if nested_quantifiers?(expression)
+          expression = Regexp::Parser.parse(source)
+          raise InvalidOption, 'pattern contains nested quantifiers' if nested_quantifiers?(expression)
 
           expression.to_re
         rescue Regexp::Parser::Error => error
-          raise ArgumentError, error.message, [], cause: nil
+          raise InvalidOption, error.message, [], cause: nil
         end
         private_class_method :compile_regexp_string
 
@@ -161,8 +161,7 @@ module Html2rss
         ##
         # @return [Regexp]
         def pattern
-          raw = @pattern
-          raw.is_a?(String) ? self.class.compiled_pattern(raw) : raw
+          self.class.compiled_pattern(@pattern)
         end
       end
     end

data/lib/html2rss/selectors/post_processors/html_transformers/keep_playable_media.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Html2rss
+  class Selectors
+    module PostProcessors
+      module HtmlTransformers
+        ##
+        # Transformer that keeps only media a reader can play: an +http(s)+ +src+ on +<audio>+, +<video>+
+        # and +<source>+, made absolute; any other +src+ (missing, blank, +javascript:+, +data:+, unparsable)
+        # is removed. A +<source>+ left without one is dropped, and so is an +<audio>+ or +<video>+ with no
+        # playable +src+ of its own or on a child +<source>+ (no empty player shell).
+        class KeepPlayableMedia
+          # Elements that play a file named by +src+ (theirs or a child +<source>+).
+          PLAYERS = %w[audio video].freeze
+
+          # @param base_url [String, Html2rss::Url] base URL used to resolve relative sources
+          def initialize(base_url)
+            @base_url = base_url
+          end
+
+          ##
+          # @param node_name [String] node name currently being transformed
+          # @param node [Nokogiri::XML::Node] node currently being transformed
+          # @param _env [Hash] transformer context
+          # @option _env [Object] :_reserved reserved for transformer pipeline context
+          # @return [void]
+          def call(node_name:, node:, **_env)
+            if node_name == 'source'
+              node.unlink unless absolutize_src(node)
+            elsif PLAYERS.include?(node_name)
+              # Children are transformed after their parent, so child sources are only checked here.
+              playable = absolutize_src(node) || node.css('source').any? { Url.resolve_web(_1['src'], @base_url) }
+              node.unlink unless playable
+            end
+          end
+
+          private
+
+          # Rewrites +src+ to its absolute playable URL (Nokogiri stores its +to_s+) or removes it;
+          # returns the URL kept, if any.
+          def absolutize_src(node)
+            url = Url.resolve_web(node['src'], @base_url)
+            url ? node['src'] = url : node.remove_attribute('src')
+            url
+          end
+        end
+      end
+    end
+  end
+end

data/lib/html2rss/selectors/post_processors/html_transformers/transform_urls_to_absolute_ones.rb

@@ -12,9 +12,7 @@ module Html2rss
           URL_ELEMENTS_WITH_URL_ATTRIBUTE = {
             'a' => :href, # Visible link
             'img' => :src, # Visible image
-            'iframe' => :src, # Embedded frame (visible content)
-            'audio' => :src, # Can show controls, so potentially visible
-            'video' => :src # Video player is visible
+            'iframe' => :src # Embedded frame (visible content)
           }.freeze
 
           # @param base_url [String, Html2rss::Url] base URL used to resolve relative links

data/lib/html2rss/selectors/post_processors/parse_time.rb

@@ -63,15 +63,14 @@ module Html2rss
         # @param _value [String] extracted time string (unused; type-checked via VALUE_TYPE)
         # @param context [Selectors::StepEnv] must carry a usable +time_zone+
         # @return [void]
-        # @raise [ArgumentError] when time_zone is nil or empty
+        # @raise [MissingOption] when time_zone is nil or empty
         def self.validate_args!(_value, context)
           time_zone_value = context.time_zone
 
-          if time_zone_value.nil? || time_zone_value.empty?
-            raise ArgumentError, 'time_zone cannot be nil or empty', [], cause: nil
-          end
+          raise MissingOption, 'time_zone cannot be nil or empty', [], cause: nil if time_zone_value.nil?
 
           assert_type(time_zone_value, String, :time_zone, context:)
+          raise MissingOption, 'time_zone cannot be nil or empty', [], cause: nil if time_zone_value.empty?
         end
 
         ##
@@ -89,7 +88,7 @@ module Html2rss
         private
 
         def parse_time(string, time_zone)
-          components = Date._parse(string, false)
+          components = Date._parse(string)
           if components[:zone] || components.key?(:offset)
             Time.parse(string)
           else
@@ -104,7 +103,7 @@ module Html2rss
             components[:mday],
             components[:hour] || 0,
             components[:min] || 0,
-            (components[:sec] || 0) + (components[:sec_fraction] || 0)
+            components[:sec] || 0
           )
         end
       end

data/lib/html2rss/selectors/post_processors/parse_uri.rb

@@ -44,7 +44,7 @@ module Html2rss
         # @param _context [Selectors::StepEnv] post-processor context
         # @return [void]
         def self.validate_args!(value, _context)
-          raise ArgumentError, 'The `value` option is missing or empty.' if value.to_s.empty?
+          raise MissingOption, 'The `value` option is missing or empty.' if value.to_s.empty?
         end
 
         ##

data/lib/html2rss/selectors/post_processors/sanitize_html.rb

@@ -17,12 +17,14 @@ module Html2rss
       # - `referrer-policy='no-referrer'` to <img> tags
       # - wraps all <img> tags, whose direct parent is not an <a>, into an <a>
       #   linking to the <img>'s `src`.
+      # - keeps <audio>, <video> and <source> with an absolute http(s) `src`; a player
+      #   without a playable `src` (its own or a <source>'s) is removed.
       #
       # Imagine this HTML structure:
       #
       #     <section>
       #       Lorem <b>ipsum</b> dolor...
-      #       <iframe src="https://evil.corp/miner"></iframe>
+      #       <iframe src="https://evil.example/miner"></iframe>
       #       <script>alert();</script>
       #     </section>
       #
@@ -93,10 +95,20 @@ module Html2rss
           'audio' => {
             'referrerpolicy' => 'no-referrer',
             'crossorigin' => 'anonymous',
-            'preload' => 'none'
+            'preload' => 'none',
+            'controls' => 'true'
           }
         }.freeze
 
+        # Media elements kept in descriptions and the attributes they keep besides the html2rss defaults
+        # ({TAG_ATTRIBUTES}); {HtmlTransformers::KeepPlayableMedia} keeps +src+ only as an absolute
+        # +http(s)+ URL and drops a player left without one.
+        MEDIA_ATTRIBUTES = {
+          'audio' => %w[src],
+          'video' => %w[src],
+          'source' => %w[src type]
+        }.freeze
+
         # @return [Hash{Symbol => Object}] JSON Schema fragment for this post-processor
         def self.schema_export = SchemaExport.for_post_processor(name: :sanitize_html, klass: self)
 
@@ -145,24 +157,25 @@ module Html2rss
         ##
         # @param base_url [String, Html2rss::Url]
         # @return [Hash] the memoized sanitize configuration
-        # rubocop:disable-next Metrics/MethodLength, ThreadSafety/ClassInstanceVariable
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize, ThreadSafety/ClassInstanceVariable
         def self.sanitize_config(base_url)
           @sanitize_configs ||= {}
           @sanitize_configs[base_url] ||= begin
             config = Sanitize::Config.merge(
               Sanitize::Config::RELAXED,
-              attributes: { all: %w[dir lang alt title translate] },
+              attributes: { all: %w[dir lang alt title translate], **MEDIA_ATTRIBUTES },
               add_attributes: TAG_ATTRIBUTES,
               transformers: [
                 lambda { |env|
                   HtmlTransformers::TransformUrlsToAbsoluteOnes.new(base_url).call(**env)
                 },
+                ->(env) { HtmlTransformers::KeepPlayableMedia.new(base_url).call(**env) },
                 ->(env) { HtmlTransformers::WrapImgInA.new.call(**env) }
               ]
             )
             config[:elements].delete('style')
             config.delete(:css)
-            config[:elements].push('audio', 'video', 'source')
+            config[:elements].push(*MEDIA_ATTRIBUTES.keys)
             config.freeze
           end
         end

data/lib/html2rss/selectors/post_processors/substring.rb

@@ -70,7 +70,7 @@ module Html2rss
           return (start..) unless step_config.key?(:end)
 
           finish = step_config[:end]
-          raise ArgumentError, 'The `start` value must be unequal to the `end` value.' if start == finish
+          raise InvalidOption, 'The `start` value must be unequal to the `end` value.' if start == finish
 
           (start..finish)
         end

data/lib/html2rss/selectors/schema_export.rb

@@ -8,72 +8,72 @@ module Html2rss
     # Each registry class owns +DESCRIPTION+, +EXAMPLES+, and optional +OPTIONS+;
     # this module is the export adapter only.
     module SchemaExport
-      module_function
-
-      ##
-      # @param name [Symbol, String] registry key
-      # @param klass [Class] post-processor class
-      # @return [Hash{Symbol => Object}] JSON Schema object for one post-processor
-      def for_post_processor(name:, klass:)
-        name = name.to_s
-        {
-          type: 'object',
-          title: name,
-          description: klass::DESCRIPTION,
-          examples: klass::EXAMPLES,
-          properties: post_processor_properties(name, klass),
-          required: post_processor_required(klass),
-          additionalProperties: true
-        }
-      end
+      class << self
+        ##
+        # @param name [Symbol, String] registry key
+        # @param klass [Class] post-processor class
+        # @return [Hash{Symbol => Object}] JSON Schema object for one post-processor
+        def for_post_processor(name:, klass:)
+          name = name.to_s
+          {
+            type: 'object',
+            title: name,
+            description: klass::DESCRIPTION,
+            examples: klass::EXAMPLES,
+            properties: post_processor_properties(name, klass),
+            required: post_processor_required(klass),
+            additionalProperties: true
+          }
+        end
 
-      ##
-      # @param name [Symbol, String] registry key
-      # @param klass [Class] extractor class
-      # @return [Hash{Symbol => Object}] JSON Schema for one extractor name
-      def for_extractor(name:, klass:)
-        name = name.to_s
-        {
-          type: 'string',
-          const: name,
-          title: name,
-          description: klass::DESCRIPTION,
-          examples: klass::EXAMPLES
-        }
-      end
+        ##
+        # @param name [Symbol, String] registry key
+        # @param klass [Class] extractor class
+        # @return [Hash{Symbol => Object}] JSON Schema for one extractor name
+        def for_extractor(name:, klass:)
+          name = name.to_s
+          {
+            type: 'string',
+            const: name,
+            title: name,
+            description: klass::DESCRIPTION,
+            examples: klass::EXAMPLES
+          }
+        end
 
-      ##
-      # @param name [String] registry key
-      # @param klass [Class]
-      # @return [Hash{Symbol => Hash}]
-      def post_processor_properties(name, klass)
-        properties = { name: { type: 'string', const: name } }
-        OptionSpec.for(klass).each do |spec|
-          properties[spec.name] = property_schema_for(spec.type)
+        ##
+        # @param name [String] registry key
+        # @param klass [Class]
+        # @return [Hash{Symbol => Hash}]
+        def post_processor_properties(name, klass)
+          properties = { name: { type: 'string', const: name } }
+          OptionSpec.for(klass).each do |spec|
+            properties[spec.name] = property_schema_for(spec.type)
+          end
+          properties
         end
-        properties
-      end
 
-      ##
-      # @param klass [Class]
-      # @return [Array<String>]
-      def post_processor_required(klass)
-        required = ['name']
-        required + OptionSpec.for(klass).select(&:required).map { |spec| spec.name.to_s }
-      end
+        ##
+        # @param klass [Class]
+        # @return [Array<String>]
+        def post_processor_required(klass)
+          required = ['name']
+          required + OptionSpec.for(klass).select(&:required).map { |spec| spec.name.to_s }
+        end
 
-      ##
-      # @param ruby_type [Class, Array<Class>]
-      # @return [Hash{Symbol => String, Array<String>}]
-      def property_schema_for(ruby_type)
-        { type: json_type_for(ruby_type) }
-      end
+        ##
+        # @param ruby_type [Class, Array<Class>]
+        # @return [Hash{Symbol => String, Array<String>}]
+        def property_schema_for(ruby_type)
+          { type: json_type_for(ruby_type) }
+        end
 
-      ##
-      # @param ruby_type [Class, Array<Class>]
-      # @return [String, Array<String>]
-      def json_type_for(ruby_type)
-        OptionSpec.json_type_for(ruby_type)
+        ##
+        # @param ruby_type [Class, Array<Class>]
+        # @return [String, Array<String>]
+        def json_type_for(ruby_type)
+          OptionSpec.json_type_for(ruby_type)
+        end
       end
     end
   end

data/lib/html2rss/selectors.rb

@@ -35,6 +35,10 @@ module Html2rss
     # Config selector keys that map onto a different {Article} attribute.
     # +:enclosure+ stays singular in YAML; Article stores +:enclosures+.
     SELECTOR_TO_ARTICLE_KEY = { enclosure: :enclosures }.freeze
+    # Admission-drop reason tallied for selector items that carry no URL (same shape as
+    # {AutoSource#admission_drops}).
+    MISSING_URL_REASON = 'missing_url'
+
     # Selector keys that may be copied onto an Article (PROVIDED_KEYS + mapped aliases).
     SELECTABLE_SELECTOR_KEYS = Set[*(Html2rss::Article::PROVIDED_KEYS + SELECTOR_TO_ARTICLE_KEY.keys)].freeze
     # ArticleExtractor keys that enhance can fill. Skip the extractor when all are already present.
@@ -56,6 +60,7 @@ module Html2rss
       @time_zone = time_zone
       @rss_item_attributes = @selectors.keys.select { SELECTABLE_SELECTOR_KEYS.include?(_1) }
       @parsed_body = nil
+      @unlinked_count = 0
       @compiled_fields = compile_selector_fields
       @compiled_item_fields = @rss_item_attributes.filter_map { @compiled_fields[_1] }
     end
@@ -70,39 +75,52 @@ module Html2rss
     end
 
     ##
-    # Iterates over each scraped article.
+    # Drop tallies for the last iteration: items skipped for having no URL, as {AutoSource#admission_drops}.
+    #
+    # @return [Hash{String => Integer}] empty when every item was linked
+    def admission_drops
+      @unlinked_count.positive? ? { MISSING_URL_REASON => @unlinked_count }.freeze : {}.freeze
+    end
+
+    ##
+    # Iterates over each scraped article. An item without a URL is skipped and tallied in {#admission_drops},
+    # as in auto-source ({Html2rss::Article#linked?}).
     #
     # @yield [article] Gives each article as an Html2rss::Article.
     # @return [Enumerator] An enumerator if no block is given.
     def each(&)
-      return enum_for(:each) unless block_given?
+      return enum_for unless block_given?
 
       enhance = enhance?
+      @unlinked_count = 0
 
       parsed_body.css(items_selector).each do |item|
         article_hash = extract_article(item)
 
         enhance_article_hash(article_hash, item) if enhance
 
-        yield Html2rss::Article.new(**article_hash, scraper: self.class)
+        article = build_article(article_hash)
+        article.linked? ? yield(article) : @unlinked_count += 1
       end
     end
 
     ##
     # Yields +baseline+, +enhanced+, and the item node per list entry for enhance diagnostics.
+    #
+    # @param linked_only [Boolean] skip items {#each} would drop for having no URL
     # Consumed by {Test::EnhanceAudit} so the extraction loop has one owner.
     #
     # @yieldparam baseline [Hash]
     # @yieldparam enhanced [Hash]
     # @yieldparam item [Nokogiri::XML::Element]
     # @return [Enumerator] if no block is given
-    def each_enhance_pair
-      return enum_for(:each_enhance_pair) unless block_given?
+    def each_enhance_pair(linked_only: false)
+      return enum_for(:each_enhance_pair, linked_only:) unless block_given?
 
       parsed_body.css(items_selector).each do |item|
         baseline = extract_article(item)
         enhanced = enhance_article_hash(baseline.dup, item)
-        yield baseline, enhanced, item
+        yield baseline, enhanced, item unless linked_only && !build_article(enhanced).linked?
       end
     end
 
@@ -132,7 +150,7 @@ module Html2rss
 
       field = @compiled_fields[name]
       return select_compiled(field, scope) if field
-      return select_field(name, scope:, config: nil) if name == :url
+      return select_field(name, scope:) if name == :url
 
       raise InvalidSelectorName, "Selector for '#{name}' is not defined."
     end
@@ -168,6 +186,12 @@ module Html2rss
       text.empty? || text == DEFAULT_ITEMS_SELECTOR
     end
 
+    ##
+    # Whether +selectors.items.enhance+ is on: each matched item node fills fields that explicit
+    # selectors left empty (see {ENHANCEABLE_KEYS}) via {Html::ArticleExtractor}, using only the
+    # item's own markup and making no extra requests.
+    #
+    # @return [Boolean]
     def enhance? = !!@selectors.dig(ITEMS_SELECTOR_KEY, :enhance)
 
     def parsed_body
@@ -183,6 +207,8 @@ module Html2rss
       end
     end
 
+    def build_article(article_hash) = Article.new(**article_hash, scraper: self.class)
+
     def extract_article(item)
       scope = item_env_for(item, @url)
       hash = @compiled_item_fields.each_with_object({}) do |field, h|
@@ -190,13 +216,30 @@ module Html2rss
         next if value.nil?
 
         article_key = field.article_key
-        h[article_key] = article_key == :enclosures ? wrap_enclosure_value(value) : value
+        h[article_key] = article_value(article_key, value, scope)
       end
 
       hash[:url] ||= default_item_url(item) if anchor_element?(item)
       hash
     end
 
+    def article_value(article_key, value, scope)
+      case article_key
+      when :enclosures then wrap_enclosure_value(value)
+      when :url then resolve_url_value(value, scope.base_url)
+      else value
+      end
+    end
+
+    # A +url+ selector value that is a single whitespace-free string token (a +static+ value or a post-processor
+    # result) resolves against the page URL like an +href+; a value that is no http(s) reference stays as given.
+    # Text with surrounding words is left to +Article#url+'s sanitizer, which extracts the embedded URL.
+    def resolve_url_value(value, base_url)
+      return value unless value.is_a?(String) && value.match?(/\A\S+\z/)
+
+      Url.resolve_web(value, base_url) || value
+    end
+
     def enhance_article_hash(article_hash, article_tag) # rubocop:disable Metrics/MethodLength -- merge extracted keys
       return article_hash if enhanceable_fields_present?(article_hash)
 
@@ -205,7 +248,6 @@ module Html2rss
         article_tag,
         base_url: @url,
         selected_anchor:,
-        fallback_anchorless: true,
         time_zone: @time_zone
       )
       return article_hash unless extracted
@@ -225,15 +267,11 @@ module Html2rss
       value.is_a?(Array) ? value : [value]
     end
 
-    def select_field(selector_key, scope:, config:)
-      return default_item_url(scope.item, scope.base_url) if fallback_url_selector?(selector_key, config, scope.item)
-      raise InvalidSelectorName, "Selector for '#{selector_key}' is not defined." if config.nil?
+    # Only reached for +:url+ without a configured selector, so the item must be an anchor.
+    def select_field(selector_key, scope:)
+      return default_item_url(scope.item, scope.base_url) if anchor_element?(scope.item)
 
-      if SPECIAL_ATTRIBUTES.member?(selector_key)
-        select_special(selector_key, scope:, config:)
-      else
-        select_regular(selector_key, scope:, config:)
-      end
+      raise InvalidSelectorName, "Selector for '#{selector_key}' is not defined."
     end
 
     def select_compiled(field, scope)
@@ -327,6 +365,7 @@ module Html2rss
     end
 
     def post_process(scope, value, post_process_steps)
+      value = step_input(value)
       post_process_steps.each do |step_config|
         value = PostProcessors.call(step_config[:name], value, scope.context_for(step_config:))
       end
@@ -334,9 +373,15 @@ module Html2rss
       value
     end
 
+    # Post-processors work on text, so a URL value (from the href extractor) enters them as a String.
+    def step_input(value)
+      value.is_a?(Url) ? value.to_s : value
+    end
+
     def apply_compiled_post_process(scope, value, steps)
       return value unless value && steps
 
+      value = step_input(value)
       steps.each do |klass, step_config|
         value = klass.new(value, scope.context_for(step_config:)).call
       end
@@ -375,15 +420,8 @@ module Html2rss
     end
 
     def extract_category_text(category)
-      text = case category
-             when Nokogiri::XML::Node, Nokogiri::XML::NodeSet
-               Html2rss::Html::Navigator.extract_visible_text(category)
-             else
-               category&.to_s
-             end
-
-      stripped = text&.strip
-      stripped unless stripped.nil? || stripped.empty?
+      stripped = category.to_s.strip
+      stripped unless stripped.empty?
     end
 
     def node_set_with_multiple_elements?(nodes)
@@ -396,12 +434,11 @@ module Html2rss
       Extractors.element(item, config[:selector])
     end
 
-    # @return [Hash, nil] enclosure details, or nil when the selector yields nothing.
+    # @return [Hash, nil] enclosure details, or nil when the selector yields nothing or no http(s) URL
+    #   ({Url.resolve_web})
     def enclosure(scope:, config:)
       selected = select_regular(:enclosure, scope:, config:)
-      return if selected.nil? || selected.to_s.strip.empty?
-
-      url = Url.from_relative(selected, scope.base_url)
+      return unless (url = Url.resolve_web(selected, scope.base_url))
 
       { url:, type: config[:content_type] }
     end

data/lib/html2rss/sst/attrs.rb

@@ -65,7 +65,7 @@ module Html2rss
           case class_names
           when nil then AttrDefaults::EMPTY_CLASS_NAMES
           when Array then class_names.map { |token| token.to_s.freeze }.freeze
-          else raise ArgumentError, "class_names must be an Array, got #{class_names.class}"
+          else raise InvalidError, "class_names must be an Array, got #{class_names.class}"
           end
         end
 
@@ -73,7 +73,7 @@ module Html2rss
           case raw
           when nil then AttrDefaults::EMPTY_RAW
           when Hash then raw.transform_values { |v| v.to_s.freeze }.freeze
-          else raise ArgumentError, "raw must be a Hash, got #{raw.class}"
+          else raise InvalidError, "raw must be a Hash, got #{raw.class}"
           end
         end
       end

data/lib/html2rss/sst/document.rb

@@ -13,10 +13,10 @@ module Html2rss
       # @param degraded [Boolean] true when MAX_NODES forced semantic-tag-only mode
       # @param node_count [Integer]
       # @return [Document]
-      # @raise [ArgumentError] when root/index missing
+      # @raise [InvalidError] when root/index missing
       def self.build(root:, index:, degraded: false, node_count: 0)
-        raise ArgumentError, 'root is required' unless root.is_a?(Node)
-        raise ArgumentError, 'index is required' unless index.is_a?(Index)
+        raise InvalidError, 'root is required' unless root.is_a?(Node)
+        raise InvalidError, 'index is required' unless index.is_a?(Index)
 
         new(root:, index:, degraded: !!degraded, node_count: Integer(node_count))
       end