html2rss 0.32.4 → 0.34.0

data/lib/html2rss/config.rb

@@ -11,7 +11,7 @@ module Html2rss
   #
   # Configuration is validated during initialization.
   class Config # rubocop:disable Metrics/ClassLength
-    # Raised when a configuration hash fails runtime validation.
+    # Raised when a configuration cannot be loaded (YAML shape, file, feed name) or fails runtime validation.
     class InvalidConfig < Html2rss::Error; end
 
     class << self
@@ -25,7 +25,7 @@ module Html2rss
       # @return [Array(Hash, Html2rss::Config::ValidationReport)]
       def resolve_and_validate(config_input, feed_name: nil, params: {})
         raw = resolve_raw_hash(config_input, feed_name)
-      rescue Psych::Exception, ArgumentError => error
+      rescue InvalidConfig => error
         [{}, IssueMapper.parse_failure(error.message)]
       else
         working = HashUtil.deep_dup(raw)
@@ -66,14 +66,16 @@ module Html2rss
       #
       # @param string [String] YAML document
       # @return [Hash{Symbol => Object}] configuration hash
-      # @raise [ArgumentError] if +string+ is not a String or does not deserialize to a Hash
+      # @raise [InvalidConfig] if +string+ is not a String or does not deserialize to a Hash
       def from_yaml(string)
-        raise ArgumentError, 'YAML must be a String' unless string.is_a?(String)
+        raise InvalidConfig, 'YAML must be a String' unless string.is_a?(String)
 
         parsed = YAML.safe_load(string)
-        raise ArgumentError, 'YAML must deserialize to a Hash' unless parsed.is_a?(Hash)
+        raise InvalidConfig, 'YAML must deserialize to a Hash' unless parsed.is_a?(Hash)
 
-        HashUtil.deep_symbolize_keys(parsed, context: 'config')
+        symbolize_config(parsed)
+      rescue Psych::Exception => error
+        raise InvalidConfig, "YAML could not be parsed: #{error.message}"
       end
 
       ##
@@ -85,25 +87,16 @@ module Html2rss
       # @param feed_name [String, nil] the feed name when using multiple feeds.
       # @param multiple_feeds_key [Symbol] the key under which multiple feeds are defined.
       # @return [Hash{Symbol => Object}] the configuration hash.
-      # @raise [ArgumentError] if the file doesn't exist or feed is not found.
-      # rubocop:disable-next Metrics/MethodLength
+      # @raise [InvalidConfig] if the file doesn't exist or feed is not found.
       def load_yaml(file, feed_name = nil, multiple_feeds_key: MultipleFeedsConfig::CONFIG_KEY_FEEDS)
-        raise ArgumentError, "File '#{file}' does not exist" unless File.exist?(file)
-        raise ArgumentError, "`#{multiple_feeds_key}` is a reserved feed name" if feed_name == multiple_feeds_key
+        raise InvalidConfig, "File '#{file}' does not exist" unless File.exist?(file)
+        raise InvalidConfig, "`#{multiple_feeds_key}` is a reserved feed name" if feed_name == multiple_feeds_key
 
-        yaml = YAML.safe_load_file(file, symbolize_names: true)
+        yaml = read_yaml_mapping(file)
 
         return yaml unless yaml.key?(multiple_feeds_key)
 
-        unless feed_name
-          available_feeds = yaml.fetch(multiple_feeds_key).keys.join(', ')
-          raise ArgumentError,
-                "Feed name is required under `#{multiple_feeds_key}`. Available feeds: #{available_feeds}"
-        end
-
-        config = yaml.dig(multiple_feeds_key, feed_name.to_sym)
-        raise ArgumentError, "Feed '#{feed_name}' not found under `#{multiple_feeds_key}` key." unless config
-
+        config = select_feed(file, feed_name, yaml.fetch(multiple_feeds_key), multiple_feeds_key)
         MultipleFeedsConfig.to_single_feed(config, yaml, multiple_feeds_key:)
       end
 
@@ -126,17 +119,15 @@ module Html2rss
       # @param request_controls [Html2rss::Config::RequestControls, nil] explicit request controls to write
       # @param limit [Integer, nil] max articles to keep in the auto-sourced feed
       # @param keep_different_domain [Boolean, nil] when set, overrides cleanup.keep_different_domain
+      # @param keep_sponsored [Boolean, nil] when set, overrides cleanup.keep_sponsored
       # @return [Hash{Symbol => Object}] feed config hash ready for {from_hash}
-      # rubocop:disable-next Metrics/MethodLength -- keep_different_domain override stays co-located
+      # rubocop:disable-next Metrics/MethodLength, Metrics/ParameterLists -- cleanup overrides stay co-located
       def auto_source_config(url:, items_selector: nil, request_controls: nil, limit: nil,
-                             keep_different_domain: nil)
+                             keep_different_domain: nil, keep_sponsored: nil)
         auto_source = AutoSource::DEFAULT_CONFIG
-        auto_source = auto_source.merge(limit:) unless limit.nil?
-        unless keep_different_domain.nil?
-          auto_source = auto_source.merge(
-            cleanup: auto_source[:cleanup].merge(keep_different_domain:)
-          )
-        end
+        auto_source = auto_source.merge(limit: Option.integer(:limit, limit, min: 1)) unless limit.nil?
+        cleanup = { keep_different_domain:, keep_sponsored: }.compact
+        auto_source = auto_source.merge(cleanup: auto_source[:cleanup].merge(cleanup)) unless cleanup.empty?
 
         config = {
           channel: default_config[:channel].merge(url:),
@@ -228,6 +219,41 @@ module Html2rss
         end
       end
       private :resolve_raw_hash
+
+      def read_yaml_mapping(file)
+        yaml = YAML.safe_load_file(file)
+        return symbolize_config(yaml) if yaml.is_a?(Hash)
+
+        raise InvalidConfig, "File '#{file}' must contain a YAML mapping (a Hash)"
+      rescue Psych::Exception => error
+        raise InvalidConfig, "File '#{file}' could not be parsed: #{error.message}"
+      end
+      private :read_yaml_mapping
+
+      # @return [Hash{Symbol => Object}] the named feed's config from the +feeds+ mapping
+      def select_feed(file, feed_name, feeds, key)
+        unless feeds.is_a?(Hash)
+          raise InvalidConfig, "File '#{file}': `#{key}` must be a mapping of feed names to configs"
+        end
+        unless feed_name
+          raise InvalidConfig, "Feed name is required under `#{key}`. Available feeds: #{feeds.keys.join(', ')}"
+        end
+
+        config = feeds[feed_name.to_sym]
+        raise InvalidConfig, "Feed '#{feed_name}' not found under `#{key}` key." unless config
+        raise InvalidConfig, "File '#{file}': feed '#{feed_name}' must be a mapping" unless config.is_a?(Hash)
+
+        config
+      end
+      private :select_feed
+
+      # Loaded config keys that cannot be symbolized (non-string, non-symbol) are a config-load failure.
+      def symbolize_config(parsed)
+        HashUtil.deep_symbolize_keys(parsed, context: 'config')
+      rescue InvalidOption => error
+        raise InvalidConfig, error.message
+      end
+      private :symbolize_config
     end
 
     ##

data/lib/html2rss/contract_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ##
+  # Base for programmer errors: a value object built from wrong parts (each owner's +InvalidError+) or a
+  # component breaking its contract ({AutoSource::ScraperContractError}). It is an {Error}, but no
+  # operational rescue may swallow it: every broad +rescue Html2rss::Error+ in +lib/+ re-raises it first.
+  class ContractError < Error; end
+end

data/lib/html2rss/defaults.rb

@@ -55,9 +55,9 @@ module Html2rss
     #
     # @param logger [Logger]
     # @return [Logger] the logger
-    # @raise [ArgumentError] if logger is not a Logger
+    # @raise [InvalidOption] if logger is not a Logger
     def logger=(logger)
-      raise ArgumentError, 'logger must be a Logger' unless logger.is_a?(::Logger)
+      raise InvalidOption, 'logger must be a Logger' unless logger.is_a?(Logger)
 
       @logger = logger
       @logger.level = @log_level
@@ -69,7 +69,7 @@ module Html2rss
     #
     # @param level [Symbol, String, Integer] the new log level
     # @return [Integer] the normalized log level
-    # @raise [ArgumentError] if the log level is invalid
+    # @raise [InvalidOption] if the log level is invalid
     def log_level=(level)
       @log_level = normalize_log_level(level)
       @logger.level = @log_level
@@ -80,13 +80,13 @@ module Html2rss
     #
     # @param formatter [Proc, Logger::Formatter, nil] the new logger formatter
     # @return [Proc, Logger::Formatter, nil] the new logger formatter
-    # @raise [ArgumentError] if formatter is not a Proc, Logger::Formatter, or nil
+    # @raise [InvalidOption] if formatter is not a Proc, Logger::Formatter, or nil
     def logger_formatter=(formatter)
       @logger_formatter = case formatter
                           when nil, Proc, Logger::Formatter
                             formatter
                           else
-                            raise ArgumentError, 'formatter must be a Proc, Logger::Formatter, or nil'
+                            raise InvalidOption, 'formatter must be a Proc, Logger::Formatter, or nil'
                           end
       @logger.formatter = @logger_formatter
     end
@@ -96,14 +96,14 @@ module Html2rss
     #
     # @param headers [Hash, Proc, nil] the HTTP request headers to globally apply
     # @return [Hash, Proc, nil] the assigned headers
-    # @raise [ArgumentError] if headers is not a Hash, Proc, or nil
+    # @raise [InvalidOption] if headers is not a Hash, Proc, or nil
     def headers=(headers)
       @headers = case headers
                  when nil then nil
                  when Hash then headers.dup.freeze
                  when Proc then headers
                  else
-                   raise ArgumentError, 'headers must be a Hash or Proc'
+                   raise InvalidOption, 'headers must be a Hash or Proc'
                  end
     end
 
@@ -114,20 +114,9 @@ module Html2rss
     #
     # @param strategy [Symbol, String, nil] the strategy plan name
     # @return [Symbol, nil] the normalized strategy plan name
-    # @raise [ArgumentError] if the strategy plan is unknown
+    # @raise [InvalidOption] if the strategy plan is unknown
     def default_strategy=(strategy)
-      if strategy.nil?
-        @default_strategy = nil
-      else
-        unless strategy.is_a?(Symbol) || strategy.is_a?(String)
-          raise ArgumentError, 'strategy must be a Symbol or String'
-        end
-
-        normalized = strategy.to_sym
-        raise ArgumentError, "unknown strategy: #{strategy}" unless FeedPipeline::StrategyPlan.valid?(normalized)
-
-        @default_strategy = normalized
-      end
+      @default_strategy = (Option.strategy(strategy) unless strategy.nil?)
     end
 
     ##
@@ -135,18 +124,9 @@ module Html2rss
     #
     # @param ttl [Integer, String, nil] the minimum TTL
     # @return [Integer, nil] the normalized minimum TTL
-    # @raise [ArgumentError] if ttl is not a positive integer
+    # @raise [InvalidOption] if ttl is not a positive integer
     def min_ttl=(ttl)
-      if ttl.nil?
-        @min_ttl = nil
-      else
-        val = Integer(ttl)
-        raise ArgumentError unless val.positive?
-
-        @min_ttl = val
-      end
-    rescue ArgumentError, TypeError
-      raise ArgumentError, "min_ttl must be a positive integer, got #{ttl.inspect}"
+      @min_ttl = (positive_ttl(ttl) unless ttl.nil?)
     end
 
     ##
@@ -154,10 +134,10 @@ module Html2rss
     #
     # @param stylesheets [Array<Hash>] the XML stylesheet processing instructions to include in the generated feed
     # @return [Array<Hash>] the assigned stylesheets
-    # @raise [ArgumentError] if stylesheets is not an Array of hashes
+    # @raise [InvalidOption] if stylesheets is not an Array of hashes
     def stylesheets=(stylesheets)
-      raise ArgumentError, 'stylesheets must be an Array' unless stylesheets.is_a?(Array)
-      raise ArgumentError, 'stylesheets must be an Array of Hashes' unless stylesheets.all?(Hash)
+      raise InvalidOption, 'stylesheets must be an Array' unless stylesheets.is_a?(Array)
+      raise InvalidOption, 'stylesheets must be an Array of Hashes' unless stylesheets.all?(Hash)
 
       @stylesheets = stylesheets.map { |h| h.dup.freeze }.freeze
     end
@@ -171,19 +151,26 @@ module Html2rss
     # @return [void]
     def initialize_copy(other)
       super
-      @headers = @headers.dup if @headers.is_a?(Hash)
-      @stylesheets = @stylesheets.map(&:dup) if @stylesheets.is_a?(Array)
+      @headers = other.headers.dup if other.headers.is_a?(Hash)
+      @stylesheets = other.stylesheets.map(&:dup)
     end
 
     private
 
+    def positive_ttl(ttl)
+      val = Integer(ttl, exception: false)
+      return val if val&.positive?
+
+      raise InvalidOption, "min_ttl must be a positive integer, got #{ttl.inspect}"
+    end
+
     def normalize_log_level(level)
       if level.is_a?(Integer)
-        raise ArgumentError, "invalid log level: #{level}" unless LOG_LEVELS.value?(level)
+        raise InvalidOption, "invalid log level: #{level}" unless LOG_LEVELS.value?(level)
 
         level
       else
-        LOG_LEVELS.fetch(level.to_s.downcase.to_sym) { raise ArgumentError, "invalid log level: #{level}" }
+        LOG_LEVELS.fetch(level.to_s.downcase.to_sym) { raise InvalidOption, "invalid log level: #{level}" }
       end
     end
   end

data/lib/html2rss/doctor/botasaurus.rb

@@ -32,15 +32,13 @@ module Html2rss
         end
       end
 
-      module_function
-
       ENV_VAR = 'BOTASAURUS_SCRAPER_URL'
       private_constant :ENV_VAR
 
       ##
       # @param sample_url [String, nil] optional URL for a sample scrape smoke test
       # @return [Result]
-      def call(sample_url: nil) # rubocop:disable Metrics/AbcSize
+      def self.call(sample_url: nil) # rubocop:disable Metrics/AbcSize
         env = env_check
         checks = [env_check_record(env)]
         return missing_env_failure(checks) unless checks.first.ok
@@ -57,7 +55,7 @@ module Html2rss
 
       ##
       # @return [Hash{Symbol => Object}]
-      def env_check
+      def self.env_check
         base = ENV.fetch(ENV_VAR, '').strip
         {
           configured: MCP::Runtime.botasaurus_configured?,
@@ -69,71 +67,69 @@ module Html2rss
       ##
       # @param base_url [String]
       # @return [Hash{Symbol => Object}]
-      def health_check(base_url)
-        endpoint = "#{Url.for_channel(base_url).to_s.chomp('/')}/health"
-        response = health_session.get(endpoint)
+      def self.health_check(base_url)
+        response = health_session.get("#{Url.for_channel(base_url).to_s.chomp('/')}/health")
         raise response.error if response.is_a?(HTTPX::ErrorResponse)
 
         body = JSON.parse(response.body.to_s)
-        { ok: response.status == 200, status: response.status, version: body['version'] }
+        status = response.status
+        { ok: status == 200, status:, version: body['version'] }
+      rescue Html2rss::ContractError
+        raise
       rescue StandardError => error
         { ok: false, error: "#{error.class}: #{error.message}" }
       end
 
-      def health_session
+      def self.health_session
         HTTPX.with(timeout: { operation_timeout: 5, request_timeout: 5, total_request_timeout: 5 },
                    resolver_class: :system)
       end
-      module_function :health_session
       private_class_method :health_session
 
       ##
       # @param url [String]
       # @return [Hash{Symbol => Object}]
-      def sample_scrape(url)
+      def self.sample_scrape(url)
         wire = PageRecon::Diagnostics.call(url:, strategy: :botasaurus).to_wire_h
         {
           ok: wire[:status].to_i.between?(200, 399),
           status: wire[:status],
           articles_count: wire[:articles_count]
         }
-      rescue StandardError => error
+      rescue Html2rss::ContractError
+        raise
+      rescue Html2rss::Error => error
         { ok: false, error: "#{error.class}: #{error.message}" }
       end
 
-      def env_check_record(env = env_check)
+      def self.env_check_record(env = env_check)
         Check.new(name: :env, ok: env[:configured], detail: { var: env[:var], base_url_set: !env[:base_url].nil? })
       end
-      module_function :env_check_record
       private_class_method :env_check_record
 
-      def health_check_record(base_url)
+      def self.health_check_record(base_url)
         return Check.new(name: :health, ok: false, detail: { error: 'missing base URL' }) unless base_url
 
         health = health_check(base_url)
         Check.new(name: :health, ok: health[:ok], detail: health)
       end
-      module_function :health_check_record
       private_class_method :health_check_record
 
-      def sample_scrape_record(url)
+      def self.sample_scrape_record(url)
         sample = sample_scrape(url)
         Check.new(name: :sample_scrape, ok: sample[:ok], detail: sample)
       end
-      module_function :sample_scrape_record
       private_class_method :sample_scrape_record
 
-      def missing_env_failure(checks)
+      def self.missing_env_failure(checks)
         Log.info("doctor botasaurus: #{ENV_VAR} unset")
         failure(checks, "Set #{ENV_VAR} to the scrape-api base URL.")
       end
-      module_function :missing_env_failure
       private_class_method :missing_env_failure
 
-      def failure(checks, message)
+      def self.failure(checks, message)
         Result.new(ok: false, checks:, message:)
       end
-      module_function :failure
       private_class_method :failure
     end
   end

data/lib/html2rss/error.rb

@@ -39,11 +39,21 @@ module Html2rss
     # @return [Hash{String => Object}, nil] allowlisted upstream transport telemetry when attached
     attr_accessor :transport_meta
 
+    ##
+    # Stable failure classification, overridden per error class.
+    #
+    # @return [Symbol] one of +:timeout+, +:blocked+, +:connection+, +:invalid_url+, +:budget+, +:other+
+    def kind = :other
+
+    ##
+    # @return [Boolean] whether repeating the same request may succeed (derived from {#kind})
+    def retryable? = ErrorKind[kind].retryable?
+
     # @return [String, nil] scrape-api timeout stage when known (overridden by RequestTimedOut)
-    def timeout_phase = nil
+    def timeout_phase; end
 
     # @return [Symbol, nil] surface classification when known (overridden by NoFeedItemsExtracted)
-    def surface_category = nil
+    def surface_category; end
 
     ##
     # Sparse telemetry hash for observability consumers.
@@ -59,6 +69,9 @@ module Html2rss
     end
   end
 
+  # Raised when a caller-supplied option value is malformed or out of range.
+  class InvalidOption < Error; end
+
   # Raised when auto fallback exhausts all concrete tiers and extractors find no feed items.
   class NoFeedItemsExtracted < Error
     # Categories that append shared surface guidance to the empty-feed message.
@@ -87,7 +100,8 @@ module Html2rss
 
     def base_message
       summaries = attempts.map do |attempt|
-        details = attempt[:items_count].nil? ? "#{attempt[:error_class]} error" : "#{attempt[:items_count]} items"
+        count = attempt[:items_count]
+        details = count.nil? ? "#{attempt[:error_class]} error" : "#{count} items"
         "#{attempt[:strategy]} (#{details})"
       end.join(', ')
 

data/lib/html2rss/error_kind.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Html2rss
+  ErrorKind = Data.define(:name, :retryable)
+
+  ##
+  # Closed classification of {Html2rss::Error} failures, so consumers branch on a stable
+  # symbol instead of exception class names. Read it through {Html2rss::Error#kind}.
+  class ErrorKind
+    # Frozen name → instance table. Only transient transport failures are retryable.
+    ALL = {
+      timeout: true,
+      blocked: false,
+      connection: true,
+      invalid_url: false,
+      budget: false,
+      other: false
+    }.to_h { |name, retryable| [name, new(name:, retryable:)] }.freeze
+    private_class_method :new
+
+    ##
+    # @param name [Symbol, String] one of +ALL.keys+
+    # @return [ErrorKind]
+    # @raise [InvalidOption] when the name is not a known kind
+    def self.[](name) = ALL.fetch(name.to_sym) { raise InvalidOption, "unknown error kind: #{name.inspect}" }
+
+    ##
+    # @return [Boolean] whether repeating the same request may succeed
+    def retryable? = retryable
+
+    ##
+    # @return [Symbol]
+    def to_sym = name
+
+    ##
+    # @return [String]
+    def to_s = name.to_s
+  end
+end

data/lib/html2rss/feed_builder/item_presentation.rb

@@ -5,11 +5,15 @@ module Html2rss
     ##
     # Presentation rules for rendering an {Html2rss::Article} into feed wire formats.
     #
-    # Owns description enrichment ({Html::Rendering::DescriptionBuilder}) and RSS
-    # non-image enclosure selection. {Article} keeps raw extracted fields only.
+    # Owns description enrichment ({Html::Rendering::DescriptionBuilder}), RSS enclosure
+    # choice and the media-feed rule. {Article} keeps raw extracted fields only; media-file
+    # facts live on {Article::Enclosure}.
     module ItemPresentation
       class << self
         ##
+        # The item body: sanitized description text after at most one media element, the RSS enclosure
+        # ({.rss_enclosure_for}) when it is audio or video, else the item image ({Html::Rendering::DescriptionBuilder}).
+        #
         # @param article [Html2rss::Article]
         # @return [String, nil] sanitized description HTML/text for feed item bodies
         def description_for(article)
@@ -17,24 +21,33 @@ module Html2rss
             base: article.description,
             title: article.title,
             url: article.url,
-            enclosures: article.enclosures,
+            enclosure: rss_enclosure_for(article),
             image: article.image
           ).call
         end
 
         ##
-        # First non-image enclosure for RSS +enclosure+ (images stay on description / JSON Feed).
+        # The one RSS +enclosure+ of an item: its first audio or video file, else its first downloadable
+        # document or archive ({Article::Enclosure#document?}: PDF, ZIP). Images stay on the description /
+        # JSON Feed; stream playlists, Flash players and watch or player pages ({Article::Enclosure#player_page?})
+        # are never one.
         #
         # @param article [Html2rss::Article]
         # @return [Html2rss::Article::Enclosure, nil]
         def rss_enclosure_for(article)
-          article.enclosures.find { |enc| !image_mime_type?(enc.type) }
+          enclosures = article.enclosures
+          enclosures.find(&:media?) || enclosures.find(&:document?)
         end
 
-        private
-
-        def image_mime_type?(type)
-          type.to_s.downcase.start_with?('image/')
+        ##
+        # A media feed (podcast) is one where more than half of the items carry an audio or video
+        # RSS enclosure; only such a feed gets podcast (+itunes:+) tags.
+        #
+        # @param articles [Array<Html2rss::Article>]
+        # @return [Boolean]
+        def media_feed?(articles)
+          media_items = articles.count { |article| article.enclosures.any?(&:media?) }
+          media_items * 2 > articles.size
         end
       end
     end

data/lib/html2rss/feed_builder/json_feed/item.rb

@@ -103,7 +103,8 @@ module Html2rss
           {
             url: enclosure.url.to_s,
             mime_type: enclosure.type,
-            size_in_bytes: size&.positive? ? size : nil
+            size_in_bytes: (size if size.positive?),
+            duration_in_seconds: enclosure.duration
           }.compact
         end
       end

data/lib/html2rss/feed_builder/json_feed.rb

@@ -16,7 +16,7 @@ module Html2rss
       # @param user_comment [String] required generator comment (from {Status})
       # @param feed_url [String, nil] optional absolute self URL for the feed (JSON Feed feed_url)
       def initialize(channel:, articles:, user_comment:, feed_url: nil)
-        raise ArgumentError, 'user_comment must be a non-blank String' if blank_string?(user_comment)
+        raise InvalidOption, 'user_comment must be a non-blank String' if blank_string?(user_comment)
 
         @channel = channel
         @articles = articles
@@ -42,7 +42,7 @@ module Html2rss
 
       def normalize_feed_url(value)
         return if value.nil?
-        raise ArgumentError, 'feed_url must be a String or nil' unless value.is_a?(String)
+        raise InvalidOption, 'feed_url must be a String or nil' unless value.is_a?(String)
         return if value.strip.empty?
 
         Url.from_absolute(value).to_s

data/lib/html2rss/feed_builder/rss/stylesheet.rb

@@ -43,9 +43,9 @@ module Html2rss
         # @param type [String] MIME type (`text/css` or `text/xsl`)
         # @param media [String] media query hint for the stylesheet
         def initialize(href:, type:, media: 'all')
-          raise ArgumentError, 'stylesheet.href must be a String' unless href.is_a?(String)
-          raise ArgumentError, 'stylesheet.type invalid' unless TYPES.include?(type)
-          raise ArgumentError, 'stylesheet.media must be a String' unless media.is_a?(String)
+          raise InvalidOption, 'stylesheet.href must be a String' unless href.is_a?(String)
+          raise InvalidOption, 'stylesheet.type invalid' unless TYPES.include?(type)
+          raise InvalidOption, 'stylesheet.media must be a String' unless media.is_a?(String)
 
           @href = href
           @type = type