html2rss 0.32.3 → 0.33.0

data/lib/html2rss/test/enhance_audit.rb

@@ -6,8 +6,6 @@ module Html2rss
     # Probes list-card +enhance+ value on cached listing HTML.
     # Sole owner of enhance_gains metrics and enhance-specific warn-only warnings.
     module EnhanceAudit # rubocop:disable Metrics/ModuleLength -- probe + compare + heuristics stay co-located
-      module_function
-
       TRACKED_KEYS = %i[title url description published_at categories author image id enclosures].freeze
       CURATOR_KEYS = %i[title url description published_at].freeze
       private_constant :TRACKED_KEYS, :CURATOR_KEYS
@@ -28,7 +26,7 @@ module Html2rss
       # @param selectors [Hash{Symbol => Object}]
       # @param time_zone [String]
       # @return [AuditSlice, nil] nil when selectors are absent
-      def probe(response:, selectors:, time_zone:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- per-item probe loop
+      def self.probe(response:, selectors:, time_zone:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- per-item probe loop
         return nil unless selectors&.dig(:items, :selector)
 
         selector_engine = Selectors.new(response, selectors:, time_zone:)
@@ -64,7 +62,7 @@ module Html2rss
       # @param selectors [Hash{Symbol => Object}]
       # @param time_zone [String]
       # @return [Hash{Symbol => Object}, nil]
-      def compare(response:, selectors:, time_zone:) # rubocop:disable Metrics/MethodLength -- enhance off/on stats + delta
+      def self.compare(response:, selectors:, time_zone:) # rubocop:disable Metrics/MethodLength -- enhance off/on stats + delta
         return nil unless selectors&.dig(:items, :selector)
 
         off = extraction_stats(response, selectors, time_zone, enhance: false)
@@ -84,7 +82,7 @@ module Html2rss
 
       ##
       # @return [EnhanceGains] zeroed gains for compare fallback
-      def empty_gains
+      def self.empty_gains
         EnhanceGains.new(
           items_probed: 0,
           keys_added: zero_keys_added,
@@ -93,12 +91,12 @@ module Html2rss
         )
       end
 
-      def zero_keys_added
+      def self.zero_keys_added
         TRACKED_KEYS.to_h { |key| [key, 0] }.freeze
       end
       private_class_method :zero_keys_added
 
-      def extraction_stats(response, selectors, time_zone, enhance:)
+      def self.extraction_stats(response, selectors, time_zone, enhance:)
         merged = selectors_with_enhance(selectors, enhance:)
         articles = Selectors.new(response, selectors: merged, time_zone:).articles
         {
@@ -108,14 +106,14 @@ module Html2rss
       end
       private_class_method :extraction_stats
 
-      def selectors_with_enhance(selectors, enhance:)
+      def self.selectors_with_enhance(selectors, enhance:)
         merged = HashUtil.deep_dup(selectors)
         merged[:items] = merged.fetch(:items, {}).merge(enhance:)
         merged
       end
       private_class_method :selectors_with_enhance
 
-      def keys_added(baseline, enhanced)
+      def self.keys_added(baseline, enhanced)
         enhanced.each_with_object({}) do |(key, value), counts|
           next if value.nil?
 
@@ -127,7 +125,7 @@ module Html2rss
       end
       private_class_method :keys_added
 
-      def merge_keys_added!(gains, item_keys)
+      def self.merge_keys_added!(gains, item_keys)
         gains[:items_probed] += 1
         item_keys.each do |key, count|
           next unless TRACKED_KEYS.include?(key)
@@ -138,13 +136,13 @@ module Html2rss
       end
       private_class_method :merge_keys_added!
 
-      def finalize_gains!(gains)
+      def self.finalize_gains!(gains)
         curator_total = CURATOR_KEYS.sum { |key| gains[:keys_added][key] }
         gains[:no_op] = curator_total.zero?
       end
       private_class_method :finalize_gains!
 
-      def append_item_warnings!(warnings, item:, enhanced:, item_keys:)
+      def self.append_item_warnings!(warnings, item:, enhanced:, item_keys:)
         curator_added = item_keys.slice(*CURATOR_KEYS)
         return if curator_added.empty?
         return unless curator_added.key?(:description)
@@ -160,7 +158,7 @@ module Html2rss
       end
       private_class_method :append_item_warnings!
 
-      def category_only_description?(description, enhanced)
+      def self.category_only_description?(description, enhanced)
         normalized = description.downcase
         return true if Html2rss::Html::ArticleRules::Description::TYPE_CHIPS.include?(normalized)
 
@@ -169,7 +167,7 @@ module Html2rss
       end
       private_class_method :category_only_description?
 
-      def image_only_description?(description, item)
+      def self.image_only_description?(description, item)
         images = item.css('img')
         return description == images.first['alt'].to_s.strip if images.size == 1 && images.first['alt']
 
@@ -177,7 +175,7 @@ module Html2rss
       end
       private_class_method :image_only_description?
 
-      def prose_shaped?(text)
+      def self.prose_shaped?(text)
         return false if text.match?(IMAGE_FILENAME)
         return false if text.match?(%r{\Ahttps?://}i)
         return false if text.match?(%r{\A/[\w./-]+\z})

data/lib/html2rss/test/policy.rb

@@ -6,8 +6,6 @@ module Html2rss
     # Pass/fail classification for a configuration test after live extraction.
     # Owns min_items vs quality thresholds; {Test.call} orchestrates only.
     module Policy
-      module_function
-
       Outcome = Data.define(:passed, :failure_kind, :error_message)
 
       ##
@@ -28,7 +26,7 @@ module Html2rss
       # @param strict_quality [Boolean]
       # @param quality_report [QualityReport]
       # @return [Outcome]
-      def evaluate(item_count:, min_items:, strict_quality:, quality_report:)
+      def self.evaluate(item_count:, min_items:, strict_quality:, quality_report:)
         min_items_passed = item_count >= min_items
         quality_failed = strict_quality && min_items_passed && quality_failure?(quality_report)
         passed = min_items_passed && !quality_failed
@@ -39,7 +37,7 @@ module Html2rss
         Outcome.new(passed:, failure_kind:, error_message:)
       end
 
-      def log_strict_quality_failure(failure_kind, item_count)
+      def self.log_strict_quality_failure(failure_kind, item_count)
         Log.info("Test strict quality: failure_kind=#{failure_kind.to_sym} item_count=#{item_count}")
       end
       private_class_method :log_strict_quality_failure
@@ -47,7 +45,7 @@ module Html2rss
       ##
       # @param quality_report [QualityReport]
       # @return [Boolean]
-      def quality_failure?(quality_report)
+      def self.quality_failure?(quality_report)
         metrics = quality_report.metrics
         item_count = metrics[:item_count]
         return false if item_count.zero?
@@ -62,7 +60,7 @@ module Html2rss
       # @param min_items [Integer]
       # @param quality_report [QualityReport]
       # @return [Array(FailureKind, nil), Array(String, nil)]
-      def outcome_failure(min_items_passed:, quality_failed:, item_count:, min_items:, quality_report:)
+      def self.outcome_failure(min_items_passed:, quality_failed:, item_count:, min_items:, quality_report:)
         return [nil, nil] if min_items_passed && !quality_failed
         unless min_items_passed
           return [FailureKind[:min_items],
@@ -72,13 +70,13 @@ module Html2rss
         [FailureKind[:quality], quality_failure_message(quality_report)]
       end
 
-      def quality_failure_message(quality_report)
+      def self.quality_failure_message(quality_report)
         reasons = quality_failure_reasons(quality_report.metrics)
         "Feed quality check failed (#{reasons.join(', ')})"
       end
       private_class_method :quality_failure_message
 
-      def quality_failure_reasons(metrics)
+      def self.quality_failure_reasons(metrics)
         reasons = []
         reasons << 'duplicate_urls' if duplicate_urls_failure?(metrics)
         reasons << 'generic_titles' if junk_title_ratio_failure?(metrics)
@@ -87,17 +85,17 @@ module Html2rss
       end
       private_class_method :quality_failure_reasons
 
-      def duplicate_urls_failure?(metrics)
+      def self.duplicate_urls_failure?(metrics)
         metrics[:item_count] >= 2 && metrics[:unique_url_count] < 2
       end
       private_class_method :duplicate_urls_failure?
 
-      def junk_title_ratio_failure?(metrics)
+      def self.junk_title_ratio_failure?(metrics)
         metrics[:junk_title_count] > (metrics[:item_count] / 2.0)
       end
       private_class_method :junk_title_ratio_failure?
 
-      def short_title_failure?(metrics)
+      def self.short_title_failure?(metrics)
         metrics[:short_title_count].positive?
       end
       private_class_method :short_title_failure?

data/lib/html2rss/test.rb

@@ -5,8 +5,6 @@ module Html2rss
   # Service that runs schema validation and live feed extraction on a configuration,
   # enforcing minimum item thresholds and capturing sample output.
   module Test # rubocop:disable Metrics/ModuleLength -- Result + FailureKind nest with owner
-    module_function
-
     FailureKind = Data.define(:name)
 
     ##
@@ -163,27 +161,27 @@ module Html2rss
     # @param strict_quality [Boolean] when true, fail on ship-quality audit thresholds
     # @param compare_enhance [Boolean] diagnostic enhance off vs on comparison on cached HTML
     # @return [Html2rss::Test::Result]
-    def call(config_input, feed_name = nil, min_items: 1, params: {}, strategy: nil, # rubocop:disable Metrics/ParameterLists
-             strict_quality: false, compare_enhance: false)
+    def self.call(config_input, feed_name = nil, min_items: 1, params: {}, strategy: nil, # rubocop:disable Metrics/ParameterLists
+                  strict_quality: false, compare_enhance: false)
       raw_config, validation = Config.resolve_and_validate(config_input, feed_name:, params:)
       return validation_failure_result(validation, raw_config) unless validation.success?
 
       config = build_test_config(raw_config, strategy, params)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, compare_enhance:)
-    rescue StandardError => error
+    rescue Html2rss::Error => error
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
       execution_failure_result(error, raw_config, duration)
     end
 
-    def build_test_config(raw_config, strategy, params)
+    def self.build_test_config(raw_config, strategy, params)
       raw_config[:strategy] = strategy.to_sym if strategy
       raw_config[:params] = params if params&.any?
       Config.from_hash(raw_config)
     end
     private_class_method :build_test_config
 
-    def compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
+    def self.compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
       quality_report_for(
         feed_result.to_rss.items,
         channel_url: raw_config.dig(:channel, :url).to_s,
@@ -194,20 +192,20 @@ module Html2rss
     end
     private_class_method :compile_quality_report
 
-    def execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, # rubocop:disable Metrics/ParameterLists
-                               compare_enhance:)
+    def self.execute_timed_pipeline(raw_config, config, started, min_items:, strict_quality:, # rubocop:disable Metrics/ParameterLists
+                                    compare_enhance:)
       feed_result, pipeline_outcome = extract_feed(raw_config)
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
       quality_report = compile_quality_report(raw_config, config, feed_result, pipeline_outcome)
       enhance_compare = build_enhance_compare(config, pipeline_outcome) if compare_enhance
 
       build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare,
-                        min_items:, strict_quality:, response_body: pipeline_outcome&.response&.body)
+                        min_items:, strict_quality:, response_body: pipeline_outcome.response.body)
     end
     private_class_method :execute_timed_pipeline
 
-    def build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
-                          min_items:, strict_quality:, response_body:)
+    def self.build_test_result(raw_config, feed_result, duration, quality_report, enhance_compare, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
+                               min_items:, strict_quality:, response_body:)
       rss_doc = feed_result.to_rss
       outcome = Policy.evaluate(item_count: rss_doc.items.size, min_items:, strict_quality:, quality_report:)
       strategy_used = feed_result.status.selected_strategy || raw_config[:strategy] ||
@@ -232,27 +230,14 @@ module Html2rss
     end
     private_class_method :build_test_result
 
-    def extract_samples(items, limit: 3)
+    def self.extract_samples(items, limit: 3)
       items.first(limit).map do |item|
-        article = feed_item_as_article(item)
-        {
-          title: article.title.to_s.strip,
-          url: article.url.to_s,
-          published_at: article.published_at
-        }
+        article = Article.new(title: item.title, url: item.link, published_at: item.pubDate)
+        { title: article.title.to_s.strip, url: article.url.to_s, published_at: article.published_at }
       end
     end
     private_class_method :extract_samples
 
-    def feed_item_as_article(item)
-      case item
-      when Article then item
-      else
-        Article.new(title: item.title, url: item.link, published_at: item.pubDate)
-      end
-    end
-    private_class_method :feed_item_as_article
-
     ##
     # Builds a ship-quality report for RSS items (shared by test and MCP apply).
     #
@@ -263,8 +248,8 @@ module Html2rss
     # @param pipeline_outcome [Html2rss::FeedPipeline::PipelineOutcome]
     # @param probe_native_feed [Boolean] when false, skip syndication discovery (apply ship gate)
     # @return [QualityReport]
-    def quality_report_for(items, channel_url:, config:, feed_result:, pipeline_outcome:, # rubocop:disable Metrics/ParameterLists
-                           probe_native_feed: true)
+    def self.quality_report_for(items, channel_url:, config:, feed_result:, pipeline_outcome:, # rubocop:disable Metrics/ParameterLists
+                                probe_native_feed: true)
       audit = AutoSource::Cleanup.audit_feed_items(items)
       native_feed = probe_native_feed ? probe_native_feed_url(channel_url, config)&.to_s : nil
       report = QualityReport.from_audit(audit, native_feed:)
@@ -272,21 +257,20 @@ module Html2rss
       merge_enhance_audit(report, config, pipeline_outcome)
     end
 
-    def extract_feed(raw_config)
+    def self.extract_feed(raw_config)
       outcome, feed_result = FeedPipeline.new(raw_config).to_outcome_and_result
       [feed_result, outcome]
     end
     private_class_method :extract_feed
 
-    def enhance_enabled?(config)
+    def self.enhance_enabled?(config)
       return false unless config.selectors
 
       !!config.selectors.dig(:items, :enhance)
     end
     private_class_method :enhance_enabled?
 
-    def build_enhance_compare(config, pipeline_outcome)
-      return nil unless pipeline_outcome
+    def self.build_enhance_compare(config, pipeline_outcome)
       return nil unless config.selectors
 
       EnhanceAudit.compare(
@@ -297,9 +281,8 @@ module Html2rss
     end
     private_class_method :build_enhance_compare
 
-    def merge_enhance_audit(report, config, pipeline_outcome) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- warning merge + metrics
-      return report unless pipeline_outcome && enhance_enabled?(config)
-      return report unless config.selectors
+    def self.merge_enhance_audit(report, config, pipeline_outcome) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- warning merge + metrics
+      return report unless enhance_enabled?(config)
 
       slice = EnhanceAudit.probe(
         response: pipeline_outcome.response,
@@ -320,7 +303,7 @@ module Html2rss
     end
     private_class_method :merge_enhance_audit
 
-    def enhance_gains_to_h(enhance_gains)
+    def self.enhance_gains_to_h(enhance_gains)
       {
         items_probed: enhance_gains.items_probed,
         keys_added: enhance_gains.keys_added,
@@ -330,7 +313,7 @@ module Html2rss
     end
     private_class_method :enhance_gains_to_h
 
-    def append_url_mismatch_warning(report, channel_url, feed_result)
+    def self.append_url_mismatch_warning(report, channel_url, feed_result)
       return report unless url_mismatch?(channel_url, feed_result)
 
       warnings = report.warnings.dup
@@ -344,22 +327,20 @@ module Html2rss
     end
     private_class_method :append_url_mismatch_warning
 
-    def url_mismatch?(channel_url, feed_result)
-      status = feed_result&.status
-      return false unless status
-
+    def self.url_mismatch?(channel_url, feed_result)
+      status = feed_result.status
       configured = channel_url.to_s
       final = status.scrape_url.to_s
       final = status.entry_url.to_s if final.empty?
       return false if configured.empty? || final.empty?
 
       !Url.from_absolute(configured).same_document?(Url.from_absolute(final))
-    rescue ArgumentError
+    rescue Html2rss::Url::InvalidUrlError
       false
     end
     private_class_method :url_mismatch?
 
-    def probe_native_feed_url(channel_url, config)
+    def self.probe_native_feed_url(channel_url, config)
       return nil if channel_url.to_s.empty?
 
       resources = FeedPipeline::RuntimePolicy.resources_for(config)
@@ -368,12 +349,12 @@ module Html2rss
         config:, strategy:, budget: resources.budget, policy: resources.policy
       )
       Syndication::Discovery.best_feed_url(page_url: channel_url, request_session: session)
-    rescue StandardError
+    rescue Html2rss::Error
       nil
     end
     private_class_method :probe_native_feed_url
 
-    def validation_failure_result(report, raw_config) # rubocop:disable Metrics/MethodLength
+    def self.validation_failure_result(report, raw_config) # rubocop:disable Metrics/MethodLength
       Result.new(
         success: false,
         item_count: 0,
@@ -391,7 +372,7 @@ module Html2rss
     end
     private_class_method :validation_failure_result
 
-    def execution_failure_result(error, raw_config, duration) # rubocop:disable Metrics/MethodLength
+    def self.execution_failure_result(error, raw_config, duration) # rubocop:disable Metrics/MethodLength
       Result.new(
         success: false,
         item_count: 0,

data/lib/html2rss/url.rb

@@ -26,6 +26,9 @@ module Html2rss
   class Url
     include Comparable
 
+    # Raised when a string cannot be parsed or resolved to a valid URL.
+    class InvalidUrlError < Html2rss::Error; end
+
     # Regular expression for basic URI format validation
     URI_REGEXP = Addressable::URI::URIREGEX
     # Schemes accepted by channel URL validation.
@@ -37,22 +40,21 @@ module Html2rss
     # @param relative_url [String, Html2rss::Url] the relative URL to resolve
     # @param base_url [String, Html2rss::Url] the base URL to resolve against
     # @return [Url] the resolved absolute URL
-    # @raise [ArgumentError] if the URL cannot be parsed
+    # @raise [InvalidUrlError] if the URL cannot be parsed
     def self.from_relative(relative_url, base_url)
       url = Addressable::URI.parse(relative_url.to_s.strip)
       return new(url) if url.absolute?
 
-      base_url.is_a?(self) ? base_url.join_uri(url) : join_parsed_base(base_url, url)
+      join_parsed_base(base_url, url)
     rescue Addressable::URI::InvalidURIError
-      raise ArgumentError, 'URL could not be parsed'
+      raise InvalidUrlError, 'URL could not be parsed'
     end
 
-    # @param base_url [String]
+    # @param base_url [String, Url]
     # @param url [Addressable::URI]
     # @return [Url]
     def self.join_parsed_base(base_url, url)
       uri = Addressable::URI.parse(base_url.to_s)
-      uri.path = '/' if uri.path.empty?
       new(uri.join(url).normalize)
     end
     private_class_method :join_parsed_base
@@ -64,10 +66,10 @@ module Html2rss
     # @param raw_url [String] the raw URL string to sanitize
     # @return [Url, nil] the sanitized URL, or nil if no valid URL found
     def self.sanitize(raw_url)
-      match = raw_url.to_s.match(%r{(?:(?:https?|ftp|mailto)://|mailto:)[^\s<>"]+})
+      match = raw_url.to_s.match(%r{(?:(?:https?|ftp)://|mailto:)[^\s<>"]+})
       return unless match
 
-      new(Addressable::URI.parse(match[0].strip).normalize)
+      new(Addressable::URI.parse(match[0]).normalize)
     end
 
     ##
@@ -75,15 +77,15 @@ module Html2rss
     #
     # @param url_string [String, Html2rss::Url] the absolute URL to parse
     # @return [Url] the parsed and normalized URL
-    # @raise [ArgumentError] if the URL is not absolute or cannot be parsed
+    # @raise [InvalidUrlError] if the URL is not absolute or cannot be parsed
     def self.from_absolute(url_string)
       return url_string if url_string.is_a?(self)
 
-      new(Addressable::URI.parse(url_string.to_s.strip).normalize).tap do |url|
-        raise ArgumentError, 'URL must be absolute' unless url.absolute?
+      new(Addressable::URI.parse(url_string.to_s.lstrip).normalize).tap do |url|
+        raise InvalidUrlError, 'URL must be absolute' unless url.absolute?
       end
     rescue Addressable::URI::InvalidURIError
-      raise ArgumentError, 'URL must be absolute'
+      raise InvalidUrlError, 'URL must be absolute'
     end
 
     ##
@@ -92,20 +94,30 @@ module Html2rss
     #
     # @param url_string [String] the URL string to validate and parse
     # @return [Url] the validated and parsed URL
-    # @raise [ArgumentError] if the URL doesn't meet channel requirements
+    # @raise [InvalidUrlError] if the URL doesn't meet channel requirements
     # @example Creating a channel URL
     #   Url.for_channel('https://example.com')
     #   # => #<Html2rss::Url:... @uri=#<Addressable::URI:... URI:https://example.com>>
     # @example Invalid channel URL
     #   Url.for_channel('/relative/path')
-    #   # => raises ArgumentError: "URL must be absolute"
+    #   # => raises InvalidUrlError: "URL must be absolute"
     def self.for_channel(url_string)
-      stripped = url_string.to_s.strip
+      stripped = url_string.to_s.lstrip
       return nil if stripped.empty?
 
       from_absolute(stripped).tap { validate_channel_url(_1) }
     end
 
+    ##
+    # Creates an absolute http(s) URL, for example for a channel image.
+    #
+    # @param url_string [String, Html2rss::Url] the URL to validate and parse
+    # @return [Url] the validated and parsed URL
+    # @raise [InvalidUrlError] if the URL is not absolute or not http(s)
+    def self.from_absolute_web(url_string)
+      from_absolute(url_string).tap { validate_scheme(_1) }
+    end
+
     ##
     # Extracts a base URL from HTML metadata tags.
     #
@@ -116,10 +128,10 @@ module Html2rss
       tags = { 'link[rel="canonical"]' => 'href', 'meta[property="og:url"]' => 'content',
                'meta[name="twitter:url"]' => 'content', 'base[href]' => 'href' }
       tags.each do |sel, attr|
-        val = doc.at_css(sel)&.[](attr).to_s.strip
-        return from_absolute(val) unless val.empty?
-      rescue ArgumentError
-        next
+        val = doc.at_css(sel)&.[](attr)
+        return from_absolute(val)
+      rescue InvalidUrlError
+        nil
       end
       nil
     end
@@ -128,31 +140,32 @@ module Html2rss
     # Validates that a URL meets channel requirements.
     #
     # @param url [Url] the URL to validate
-    # @raise [ArgumentError] if the URL doesn't meet channel requirements
+    # @raise [InvalidUrlError] if the URL doesn't meet channel requirements
     def self.validate_channel_url(url)
-      raise ArgumentError, 'URL must be absolute' unless url.absolute?
+      has_forbidden_at = url.user
+      has_forbidden_at ||= [url.query, url.fragment].compact.any? { |value| value.include?('@') }
+      raise InvalidUrlError, 'URL must not contain an @ character' if has_forbidden_at
 
-      uri = Addressable::URI.parse(url.to_s)
-      has_forbidden_at = uri.user || uri.password
-      has_forbidden_at ||= [uri.query, uri.fragment].compact.any? { |value| value.include?('@') }
-      raise ArgumentError, 'URL must not contain an @ character' if has_forbidden_at
+      validate_scheme(url)
+    end
 
+    def self.validate_scheme(url)
       scheme = url.scheme
-      raise ArgumentError, "URL scheme '#{scheme}' is not supported" unless SUPPORTED_SCHEMES.include?(scheme)
+      raise InvalidUrlError, "URL scheme '#{scheme}' is not supported" unless SUPPORTED_SCHEMES.include?(scheme)
     end
 
-    private_class_method :validate_channel_url
+    private_class_method :validate_channel_url, :validate_scheme
 
     ##
     # @param uri [Addressable::URI] the underlying Addressable::URI object (internal use only)
     def initialize(uri)
       @uri = uri.freeze
-      @path_segments = @uri.path.to_s.split('/').reject(&:empty?).freeze
+      @path_segments = path.split('/').reject(&:empty?).freeze
       freeze
     end
 
     # @return [String] normalized URL string
-    def to_s = @uri.to_s
+    def to_s = @uri.to_str
 
     # @return [String, nil] URI scheme, for example `http` or `https`
     def scheme = @uri.scheme
@@ -160,6 +173,9 @@ module Html2rss
     # @return [String, nil] URI host component
     def host = @uri.host
 
+    # @return [String, nil] userinfo user, without the password
+    def user = @uri.user
+
     # Registrable domain (eTLD+1). Same-site hosts like www.wp.pl and wiadomosci.wp.pl
     # share `wp.pl`. IP literals stay the host so 1.2.3.4 is not treated as `3.4`.
     #
@@ -189,7 +205,7 @@ module Html2rss
     # Returns the URL query string as a hash of string keys and values.
     #
     # @return [Hash{String => String}] normalized query parameters
-    def query_values = @uri.query_values(Hash) || {}
+    def query_values = @uri.query_values || {}
 
     ##
     # Returns the URL path split into non-empty segments.
@@ -205,7 +221,7 @@ module Html2rss
     def with_path(path)
       uri = @uri.dup
       uri.path = path
-      self.class.from_absolute(uri.normalize.to_s)
+      self.class.from_absolute(uri)
     end
 
     ##
@@ -213,7 +229,7 @@ module Html2rss
     #
     # @return [Url] this URL when already fragment-free; otherwise a new URL
     def without_fragment
-      @uri.fragment ? self.class.from_absolute(@uri.omit(:fragment).normalize.to_s) : self
+      fragment ? self.class.from_absolute(@uri.omit(:fragment)) : self
     end
 
     ##
@@ -224,7 +240,7 @@ module Html2rss
     def with_query_values(values)
       uri = @uri.dup
       uri.query_values = values.transform_keys(&:to_s).transform_values(&:to_s)
-      self.class.from_absolute(uri.normalize.to_s)
+      self.class.from_absolute(uri)
     end
 
     ##
@@ -240,15 +256,7 @@ module Html2rss
     #   url = Url.from_absolute('https://example.com/hello%20world/article.html')
     #   url.titleized # => "Hello World Article"
     def titleized
-      path = @uri.path
-      return '' if path.empty?
-
-      nicer_path = CGI.unescapeURIComponent(path)
-                      .split('/')
-                      .flat_map do |part|
-                        part.gsub(/[^a-zA-Z0-9.]/, ' ').gsub(/\s+/, ' ').split
-                      end
-
+      nicer_path = CGI.unescapeURIComponent(path).gsub(/[^a-zA-Z0-9.]/, ' ').split
       nicer_path.map!(&:capitalize)
       File.basename(nicer_path.join(' '), '.*')
     end
@@ -266,8 +274,7 @@ module Html2rss
     #   url = Url.from_absolute('https://example.com')
     #   url.channel_titleized # => "example.com"
     def channel_titleized
-      nicer_path = CGI.unescapeURIComponent(@uri.path).split('/').reject(&:empty?)
-      host = @uri.host
+      nicer_path = CGI.unescapeURIComponent(path).split('/').reject(&:empty?)
 
       nicer_path.any? ? "#{host}: #{nicer_path.map(&:capitalize).join(' ')}" : host
     end
@@ -318,12 +325,7 @@ module Html2rss
     # @param relative_uri [Addressable::URI]
     # @return [Url]
     def join_uri(relative_uri)
-      base = @uri
-      if base.path.empty?
-        base = base.dup
-        base.path = '/'
-      end
-      self.class.new(base.join(relative_uri).normalize)
+      self.class.new(@uri.join(relative_uri).normalize)
     end
 
     protected
@@ -332,15 +334,13 @@ module Html2rss
     #
     # @return [String]
     def document_identity
-      uri = @uri.omit(:fragment)
-      "#{uri.scheme}\0#{uri.authority}\0#{uri.path.to_s.chomp('/')}\0#{uri.query}"
+      "#{scheme}\0#{@uri.authority}\0#{path.chomp('/')}\0#{query}"
     end
 
     private
 
     def ip_address_host?
-      IPAddr.new(host.to_s)
-      true
+      !IPAddr.new(host).nil?
     rescue IPAddr::Error
       false
     end

data/lib/html2rss/version.rb

@@ -2,6 +2,6 @@
 
 module Html2rss
   # Current application version.
-  VERSION = '0.32.3'
+  VERSION = '0.33.0'
   public_constant :VERSION
 end