simple-rss 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7e2a8e829ef0776194df8fd028266dbcecaeb0a5b7b1025aa75b739acbd6ad9
-  data.tar.gz: 664c6319db58dab8bf81e9f540afb6f1251997fa669b3e433a30748eb599ac16
+  metadata.gz: 0b914acfc63bfc4e787b6a0373e6c4fbbcec1b953a6517a2709a70b96e5993a6
+  data.tar.gz: 26e9dddcca6e05b34e8ef6da52a3654fadb6932ac9558f9ee8e70117e99f1e9f
 SHA512:
-  metadata.gz: 3885af60f0b54553af1e3545a781f6f1179825386cc3edcf1575ed75bb79240eefc83998295d21e842287f1c949a0554918d39d1df1df924701d27f20b26c192
-  data.tar.gz: 81394817f11b09d433eb7b07031120661a7de18d678deff66fdbf4f331f8ec6483a155069f36539e4ba6122210ec3c58cf08b67f3a44d9afc582c0952861d073
+  metadata.gz: 0bbb1967e261cec7c2fdb1bb00fd511562a4647043c40f5b7b6e56aedc5d8d8f003727988ffd2fb77fb7291b397d41008e40eb3a14d156889168423d90f934c5
+  data.tar.gz: c1428ee431c4bfd718a573d2d89e5121e9cef46cbd1ce5ade80b21b9bc98b939f35dcdd133287fb70de83c3a00b7a5099d97a2f12699c6224a194c874a42e215

data/lib/simple-rss.rb

@@ -3,14 +3,14 @@
 require "cgi"
 require "time"
 
-class SimpleRSS
+class SimpleRSS # rubocop:disable Metrics/ClassLength
   # @rbs skip
   include Enumerable
 
   # @rbs!
   #   include Enumerable[Hash[Symbol, untyped]]
 
-  VERSION = "2.1.0".freeze
+  VERSION = "2.2.0".freeze
 
   # @rbs @items: Array[Hash[Symbol, untyped]]
   # @rbs @source: String
@@ -52,6 +52,9 @@ class SimpleRSS
     media:title media:thumbnail#url media:thumbnail#height media:thumbnail#width
     media:credit media:credit#role
     media:category media:category#scheme
+    media:description
+    enclosure#url enclosure#type enclosure#length
+    itunes:duration itunes:image#href
   ]
 
   # @rbs (untyped, ?Hash[Symbol, untyped]) -> void
@@ -95,6 +98,100 @@ class SimpleRSS
     items.sort_by { |item| item[:pubDate] || item[:updated] || Time.at(0) }.reverse.first(count)
   end
 
+  # @rbs () -> Symbol
+  def feed_type
+    atom_namespaced_feed = source.match?(/<(atom:)?feed\b[^>]*xmlns(:\w+)?=['"][^'"]*atom/i)
+    return :atom if atom_namespaced_feed
+    return :rss2 if source.match?(/<rss[^>]*version=['"]2/i)
+    return :rss1 if source.match?(/<rdf:RDF/i)
+    return :rss09 if source.match?(/<rss[^>]*version=['"]0\.9/i)
+
+    :unknown
+  end
+
+  # @rbs () -> bool
+  def valid?
+    return false if items.empty?
+
+    title_value = instance_variable_get(:@title)
+    link_value = instance_variable_get(:@link)
+    return true if title_value || link_value
+
+    false
+  end
+
+  # @rbs (Time) -> Array[Hash[Symbol, untyped]]
+  def items_since(time)
+    items.select do |item|
+      item_date = item[:pubDate] || item[:updated] || item[:published]
+      item_date.is_a?(Time) && item_date > time
+    end
+  end
+
+  # @rbs (String) -> Array[Hash[Symbol, untyped]]
+  def items_by_category(name)
+    query = name.to_s.downcase
+
+    items.select do |item|
+      category = item[:category]
+      next false if category.nil?
+
+      category_matches_query?(category, query)
+    end
+  end
+
+  # @rbs (String) -> Array[Hash[Symbol, untyped]]
+  def search(query)
+    pattern = Regexp.new(Regexp.escape(query.to_s), Regexp::IGNORECASE)
+
+    items.select do |item|
+      searchable_fields(item).any? { |field| field.to_s.match?(pattern) }
+    end
+  end
+
+  # @rbs (*SimpleRSS) -> Array[Hash[Symbol, untyped]]
+  def merge(*feeds)
+    all_items = [items, *feeds.map(&:items)].flatten
+    dedupe_items(sorted_items_by_date(all_items))
+  end
+
+  # @rbs (SimpleRSS) -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+  def diff(other)
+    other_keys = keyed_item_set(other.items)
+    current_keys = keyed_item_set(items)
+
+    {
+      added: select_new_keyed_items(other.items, current_keys),
+      removed: select_new_keyed_items(items, other_keys)
+    }
+  end
+
+  # @rbs () -> self
+  def dedupe
+    @items = dedupe_items(items)
+    self
+  end
+
+  # @rbs () -> Array[Hash[Symbol, untyped]]
+  def enclosures
+    items.filter_map do |item|
+      enclosure_url = item[:enclosure_url]
+      next if blank_value?(enclosure_url)
+
+      {
+        url: enclosure_url,
+        type: item[:enclosure_type],
+        length: item[:enclosure_length],
+        item: item
+      }
+    end
+  end
+
+  # @rbs () -> Array[String]
+  def images
+    items.flat_map { |item| item_image_urls(item) }.uniq
+  end
+
   # @rbs (?Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
   def as_json(_options = {})
     hash = {} #: Hash[Symbol, untyped]
@@ -157,6 +254,22 @@ class SimpleRSS
       new source, options
     end
 
+    # @rbs (untyped, ?Hash[Symbol, untyped]) -> bool
+    def valid?(source, options = {})
+      parse(source, options)
+      true
+    rescue StandardError
+      false
+    end
+
+    # @rbs (*SimpleRSS) -> Array[Hash[Symbol, untyped]]
+    def merge(*feeds)
+      first_feed = feeds.first
+      return [] if first_feed.nil?
+
+      first_feed.merge(*feeds.drop(1))
+    end
+
     # Fetch and parse a feed from a URL
     # Returns nil if conditional GET returns 304 Not Modified
     #
@@ -290,11 +403,33 @@ class SimpleRSS
 
         parse_item_tag(item, tag, match[3], match[2])
       end
-      item.define_singleton_method(:method_missing) { |name, *| self[name] }
+      item.define_singleton_method(:method_missing) { |name, *_args| self[name] }
+      add_item_media_helpers(item)
       @items << item
     end
   end
 
+  # @rbs (Hash[Symbol, untyped]) -> void
+  def add_item_media_helpers(item)
+    item.define_singleton_method(:has_media?) do
+      [
+        self[:media_content_url],
+        self[:media_thumbnail_url],
+        self[:enclosure_url],
+        self[:itunes_image_href]
+      ].any? { |value| !value.nil? && !value.to_s.strip.empty? }
+    end
+
+    item.define_singleton_method(:media_url) do
+      [
+        self[:media_content_url],
+        self[:media_thumbnail_url],
+        self[:enclosure_url],
+        self[:itunes_image_href]
+      ].find { |value| !value.nil? && !value.to_s.strip.empty? }
+    end
+  end
+
   # @rbs (Hash[Symbol, untyped], Symbol, String?, String?) -> void
   def parse_item_tag(item, tag, content, item_attrs = nil)
     return if content.nil?
@@ -412,6 +547,89 @@ class SimpleRSS
     tag.to_s.tr(":", "_").intern
   end
 
+  # @rbs (untyped, String) -> bool
+  def category_matches_query?(category, query)
+    return category.any? { |value| value.to_s.downcase.include?(query) } if category.is_a?(Array)
+
+    category.to_s.downcase.include?(query)
+  end
+
+  # @rbs (Hash[Symbol, untyped]) -> Array[untyped]
+  def searchable_fields(item)
+    [item[:title], item[:description], item[:summary], item[:content]]
+  end
+
+  # @rbs (Array[Hash[Symbol, untyped]]) -> Set[String]
+  def keyed_item_set(item_list)
+    item_list.each_with_object(Set.new) do |item, keys|
+      key = item_key(item)
+      next if key.nil?
+
+      keys.add(key)
+    end
+  end
+
+  # @rbs (Array[Hash[Symbol, untyped]], Set[String]) -> Array[Hash[Symbol, untyped]]
+  def select_new_keyed_items(item_list, known_keys)
+    item_list.select do |item|
+      key = item_key(item)
+      !key.nil? && !known_keys.include?(key)
+    end
+  end
+
+  # @rbs (Array[Hash[Symbol, untyped]]) -> Array[Hash[Symbol, untyped]]
+  def sorted_items_by_date(item_list)
+    keyed_items, unkeyed_items = item_list.partition { |item| !item_key(item).nil? }
+    keyed_items.sort_by { |item| item_date(item) || Time.at(0) }.reverse + unkeyed_items
+  end
+
+  # @rbs (Array[Hash[Symbol, untyped]]) -> Array[Hash[Symbol, untyped]]
+  def dedupe_items(item_list)
+    seen_keys = Set.new
+
+    item_list.each_with_object([]) do |item, unique_items|
+      key = item_key(item)
+
+      if key.nil?
+        unique_items << item
+        next
+      end
+
+      next if seen_keys.include?(key)
+
+      seen_keys.add(key)
+      unique_items << item
+    end
+  end
+
+  # @rbs (Hash[Symbol, untyped]) -> String?
+  def item_key(item)
+    key = item[:guid] || item[:id] || item[:link]
+    return nil if key.nil?
+
+    key.to_s
+  end
+
+  # @rbs (Hash[Symbol, untyped]) -> Time?
+  def item_date(item)
+    date = item[:pubDate] || item[:updated] || item[:published]
+    return date if date.is_a?(Time)
+
+    nil
+  end
+
+  # @rbs (Hash[Symbol, untyped]) -> Array[String]
+  def item_image_urls(item)
+    [item[:media_thumbnail_url], item[:media_content_url], item[:itunes_image_href]]
+      .compact
+      .reject { |url| blank_value?(url) }
+  end
+
+  # @rbs (untyped) -> bool
+  def blank_value?(value)
+    value.to_s.strip.empty?
+  end
+
   # @rbs (untyped) -> untyped
   def serialize_value(value)
     case value
@@ -545,5 +763,5 @@ class SimpleRSS
   end
 end
 
-class SimpleRSSError < StandardError
+class SimpleRSSError < StandardError # rubocop:disable Style/OneClassPerFile
 end

data/simple-rss.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "simple-rss"
-  s.version = "2.1.0"
-  s.date = "2025-12-29"
+  s.version = "2.2.0"
+  s.date = "2025-12-28"
   s.summary = "A simple, flexible, extensible, and liberal RSS and Atom reader for Ruby. It is designed to be backwards compatible with the standard RSS parser, but will never do RSS generation."
   s.email = "lucas@rufy.com"
   s.homepage = "https://github.com/cardmagic/simple-rss"

data/test/base/feed_merging_and_diffing_test.rb

@@ -0,0 +1,140 @@
+require "test_helper"
+
+class FeedMergingAndDiffingTest < Test::Unit::TestCase
+  def setup
+    @feed_one = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Feed One</title>
+          <item>
+            <guid>shared-guid</guid>
+            <title>Shared (older)</title>
+            <pubDate>Mon, 01 Jan 2024 10:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <guid>one-guid</guid>
+            <title>Only One</title>
+            <pubDate>Mon, 01 Jan 2024 11:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <title>Unidentified One</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    @feed_two = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Feed Two</title>
+          <item>
+            <guid>shared-guid</guid>
+            <title>Shared (newer)</title>
+            <pubDate>Mon, 01 Jan 2024 12:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <link>https://example.com/two-only</link>
+            <title>Only Two</title>
+            <pubDate>Mon, 01 Jan 2024 13:00:00 UTC</pubDate>
+          </item>
+          <item>
+            <title>Unidentified Two</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+  end
+
+  def test_merge_dedupes_and_sorts_newest_first
+    merged = @feed_one.merge(@feed_two)
+    titles = merged.map { |item| item[:title] }
+
+    assert_equal [
+      "Only Two",
+      "Shared (newer)",
+      "Only One",
+      "Unidentified One",
+      "Unidentified Two"
+    ], titles
+  end
+
+  def test_class_merge_combines_multiple_feeds
+    merged = SimpleRSS.merge(@feed_one, @feed_two)
+
+    assert_equal 5, merged.size
+    assert_equal "Only Two", merged.first[:title]
+  end
+
+  def test_diff_reports_added_and_removed_items
+    old_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Old Feed</title>
+          <item>
+            <guid>stay</guid>
+            <title>Stay</title>
+          </item>
+          <item>
+            <guid>remove</guid>
+            <title>Remove</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    new_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>New Feed</title>
+          <item>
+            <guid>stay</guid>
+            <title>Stay</title>
+          </item>
+          <item>
+            <guid>add</guid>
+            <title>Add</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    diff = old_feed.diff(new_feed)
+
+    assert_equal(["Add"], diff[:added].map { |item| item[:title] })
+    assert_equal(["Remove"], diff[:removed].map { |item| item[:title] })
+  end
+
+  def test_dedupe_mutates_items_and_keeps_unidentified_entries
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Dedupe Feed</title>
+          <item>
+            <guid>duplicate</guid>
+            <title>First duplicate</title>
+          </item>
+          <item>
+            <guid>duplicate</guid>
+            <title>Second duplicate</title>
+          </item>
+          <item>
+            <title>Unidentified One</title>
+          </item>
+          <item>
+            <title>Unidentified Two</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    result = feed.dedupe
+
+    assert_same feed, result
+    assert_equal(["First duplicate", "Unidentified One", "Unidentified Two"], feed.items.map { |item| item[:title] })
+  end
+end

data/test/base/fetch_integration_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+# Integration tests that require network access
+# These are skipped by default, run with NETWORK_TESTS=1
+class FetchIntegrationTest < Test::Unit::TestCase
+  def test_fetch_real_feed
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
+    assert_kind_of SimpleRSS, rss
+    assert rss.title
+    assert rss.items.any?
+  end
+
+  def test_fetch_stores_caching_headers
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
+    assert(rss.etag || rss.last_modified, "Expected ETag or Last-Modified header")
+  end
+
+  def test_fetch_follows_redirect
+    omit unless ENV["NETWORK_TESTS"]
+    rss = SimpleRSS.fetch("https://github.com/cardmagic/simple-rss/commits/master.atom", timeout: 10)
+    assert_kind_of SimpleRSS, rss
+  end
+end

data/test/base/fetch_test.rb

@@ -88,30 +88,3 @@ class FetchTest < Test::Unit::TestCase
     end
   end
 end
-
-# Integration tests that require network access
-# These are skipped by default, run with NETWORK_TESTS=1
-class FetchIntegrationTest < Test::Unit::TestCase
-  def test_fetch_real_feed
-    omit unless ENV["NETWORK_TESTS"]
-    # Use a reliable, long-lived RSS feed
-    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
-    assert_kind_of SimpleRSS, rss
-    assert rss.title
-    assert rss.items.any?
-  end
-
-  def test_fetch_stores_caching_headers
-    omit unless ENV["NETWORK_TESTS"]
-    rss = SimpleRSS.fetch("https://feeds.bbci.co.uk/news/rss.xml", timeout: 10)
-    # At least one of these should be present for most feeds
-    assert(rss.etag || rss.last_modified, "Expected ETag or Last-Modified header")
-  end
-
-  def test_fetch_follows_redirect
-    omit unless ENV["NETWORK_TESTS"]
-    # GitHub raw URLs often redirect
-    rss = SimpleRSS.fetch("https://github.com/cardmagic/simple-rss/commits/master.atom", timeout: 10)
-    assert_kind_of SimpleRSS, rss
-  end
-end

data/test/base/filtering_and_validation_test.rb

@@ -0,0 +1,187 @@
+require "test_helper"
+
+class FilteringAndValidationTest < Test::Unit::TestCase
+  def setup
+    @rss09 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss09.rdf")
+    @rss20 = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/rss20.xml")
+    @atom = SimpleRSS.parse open(File.dirname(__FILE__) + "/../data/atom.xml")
+  end
+
+  def test_feed_type_for_known_formats
+    assert_equal :rss1, @rss09.feed_type
+    assert_equal :rss2, @rss20.feed_type
+    assert_equal :atom, @atom.feed_type
+  end
+
+  def test_feed_type_unknown_for_non_standard_feed
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <feed>
+        <title>Unknown Feed</title>
+        <entry>
+          <title>Post</title>
+        </entry>
+      </feed>
+    XML
+
+    assert_equal :unknown, feed.feed_type
+  end
+
+  def test_class_valid_returns_true_for_well_formed_feed
+    xml = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Valid Feed</title>
+          <link>http://example.com</link>
+          <item>
+            <title>Post</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    assert_equal true, SimpleRSS.valid?(xml)
+  end
+
+  def test_class_valid_returns_false_for_invalid_feed
+    invalid_xml = open(File.dirname(__FILE__) + "/../data/not-rss.xml").read
+
+    assert_equal false, SimpleRSS.valid?(invalid_xml)
+  end
+
+  def test_class_valid_returns_false_when_source_read_fails
+    unreadable_source = Object.new
+    unreadable_source.define_singleton_method(:read) do
+      raise IOError, "stream closed"
+    end
+
+    assert_equal false, SimpleRSS.valid?(unreadable_source)
+  end
+
+  def test_instance_valid_requires_metadata_and_items
+    valid_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Valid Feed</title>
+          <item>
+            <title>Post</title>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    invalid_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <description>No title and no link</description>
+          <item>
+            <description>Body only</description>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    empty_feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>No Items</title>
+        </channel>
+      </rss>
+    XML
+
+    assert_equal true, valid_feed.valid?
+    assert_equal false, invalid_feed.valid?
+    assert_equal false, empty_feed.valid?
+  end
+
+  def test_items_since_filters_by_date
+    threshold = Time.parse("Wed Aug 24 13:30:00 UTC 2005")
+
+    filtered = @rss20.items_since(threshold)
+
+    assert_equal 1, filtered.size
+    assert_operator filtered.first[:pubDate], :>, threshold
+  end
+
+  def test_items_by_category_matches_strings_and_arrays
+    feed_with_string_category = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>String Category Feed</title>
+          <item>
+            <title>Ruby News</title>
+            <category>Technology</category>
+          </item>
+          <item>
+            <title>Sports News</title>
+            <category>Sports</category>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    feed_with_array_category = SimpleRSS.parse(
+      <<~XML,
+        <?xml version="1.0" encoding="UTF-8"?>
+        <rss version="2.0">
+          <channel>
+            <title>Array Category Feed</title>
+            <item>
+              <title>Dev Update</title>
+              <category>Technology</category>
+              <category>Ruby</category>
+            </item>
+          </channel>
+        </rss>
+      XML
+      array_tags: [:category]
+    )
+
+    string_results = feed_with_string_category.items_by_category("tech")
+    array_results = feed_with_array_category.items_by_category("ruby")
+
+    assert_equal 1, string_results.size
+    assert_equal "Ruby News", string_results.first[:title]
+    assert_equal 1, array_results.size
+    assert_equal "Dev Update", array_results.first[:title]
+  end
+
+  def test_search_matches_title_description_summary_and_content
+    feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0">
+        <channel>
+          <title>Search Feed</title>
+          <item>
+            <title>Ruby Patterns</title>
+            <description>Language design</description>
+          </item>
+          <item>
+            <title>Other Topic</title>
+            <description>Talks about BREAKING updates</description>
+          </item>
+          <item>
+            <title>Third Topic</title>
+            <summary>A quick ruby summary</summary>
+          </item>
+          <item>
+            <title>Fourth Topic</title>
+            <content>Deep dive into Ruby internals</content>
+          </item>
+        </channel>
+      </rss>
+    XML
+
+    ruby_results = feed.search("ruby")
+    breaking_results = feed.search("breaking")
+
+    assert_equal 3, ruby_results.size
+    assert_equal 1, breaking_results.size
+    assert_equal "Other Topic", breaking_results.first[:title]
+  end
+end

data/test/base/media_and_enclosure_helpers_test.rb

@@ -0,0 +1,84 @@
+require "test_helper"
+
+class MediaAndEnclosureHelpersTest < Test::Unit::TestCase
+  def setup
+    @feed = SimpleRSS.parse <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd">
+        <channel>
+          <title>Podcast Feed</title>
+          <item>
+            <title>Episode 1</title>
+            <enclosure url="https://example.com/audio-1.mp3" type="audio/mpeg" length="12345" />
+            <media:content url="https://example.com/image-1.jpg" type="image/jpeg" />
+            <media:description>Episode image</media:description>
+            <media:thumbnail url="https://example.com/thumb-1.jpg" />
+            <itunes:duration>00:42:00</itunes:duration>
+            <itunes:image href="https://example.com/itunes-1.jpg" />
+          </item>
+          <item>
+            <title>Episode 2</title>
+            <media:thumbnail url="https://example.com/thumb-2.jpg" />
+          </item>
+          <item>
+            <title>Episode 3</title>
+            <enclosure url="https://example.com/audio-3.mp3" type="audio/mpeg" length="999" />
+          </item>
+          <item>
+            <title>Episode 4</title>
+            <enclosure url="" type="audio/mpeg" length="111" />
+            <media:thumbnail url="" />
+            <itunes:image href="" />
+          </item>
+        </channel>
+      </rss>
+    XML
+  end
+
+  def test_enclosures_extracts_podcast_enclosures
+    enclosures = @feed.enclosures
+
+    assert_equal 2, enclosures.size
+    assert_equal "https://example.com/audio-1.mp3", enclosures.first[:url]
+    assert_equal "audio/mpeg", enclosures.first[:type]
+    assert_equal "12345", enclosures.first[:length]
+    assert_equal "Episode 1", enclosures.first[:item][:title]
+  end
+
+  def test_images_collects_unique_media_urls
+    images = @feed.images
+
+    assert_equal [
+      "https://example.com/thumb-1.jpg",
+      "https://example.com/image-1.jpg",
+      "https://example.com/itunes-1.jpg",
+      "https://example.com/thumb-2.jpg"
+    ], images
+  end
+
+  def test_item_media_helpers
+    first_item = @feed.items.first
+    second_item = @feed.items[1]
+    third_item = @feed.items[2]
+    fourth_item = @feed.items.last
+
+    assert_equal true, first_item.has_media?
+    assert_equal "https://example.com/image-1.jpg", first_item.media_url
+
+    assert_equal true, second_item.has_media?
+    assert_equal "https://example.com/thumb-2.jpg", second_item.media_url
+
+    assert_equal true, third_item.has_media?
+    assert_equal "https://example.com/audio-3.mp3", third_item.media_url
+
+    assert_equal false, fourth_item.has_media?
+    assert_nil fourth_item.media_url
+  end
+
+  def test_media_description_and_itunes_duration_are_parsed
+    first_item = @feed.items.first
+
+    assert_equal "Episode image", first_item[:media_description]
+    assert_equal "00:42:00", first_item[:itunes_duration]
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: simple-rss
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Lucas Carlson
 bindir: bin
 cert_chain: []
-date: 2025-12-29 00:00:00.000000000 Z
+date: 2025-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -70,10 +70,14 @@ files:
 - test/base/encoding_test.rb
 - test/base/enumerable_test.rb
 - test/base/feed_attributes_test.rb
+- test/base/feed_merging_and_diffing_test.rb
+- test/base/fetch_integration_test.rb
 - test/base/fetch_test.rb
+- test/base/filtering_and_validation_test.rb
 - test/base/hash_xml_serialization_test.rb
 - test/base/item_attributes_test.rb
 - test/base/json_serialization_test.rb
+- test/base/media_and_enclosure_helpers_test.rb
 - test/data/atom.xml
 - test/data/atom_with_entry_attrs.xml
 - test/data/atom_with_feed_attrs.xml
@@ -102,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A simple, flexible, extensible, and liberal RSS and Atom reader for Ruby.
   It is designed to be backwards compatible with the standard RSS parser, but will