podcast_index 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b65c6fe11a9ccf6a3747e6c3c5cd862686978ee63cfcf7b1fd88ad79dc46367
-  data.tar.gz: 9695467e8f4bcfe6507ef16d8a91e6745de89fc0601d0cc63899886766b96e88
+  metadata.gz: fc3ddf4428c6108e1b2e5c3e5a9886283d34234cd85ccb8c6d927129d73d09fc
+  data.tar.gz: ebe518a53c0aeed362d57922464c13caae545b7535c7ea8622442286a55e2bd2
 SHA512:
-  metadata.gz: 6a24dfe1841426f4b8aede0afa6470060e6dcbcbaca97312b249d7918b0c45d19bcf26cb201ffb0f38a40285e71ecea42613b42424d58f67968bc0c91b0e9da0
-  data.tar.gz: 4bd0f8edc4931a7b8c54a46fa56c80ae12247903ae546bde090051cd7fb61efc44da3b2884675fe211247f90f04ce2e94abdcedf610329a3d029ef32f0338227
+  metadata.gz: 83fe55e0065975fe9c6ee193247dacf1ba710cbf41660065ca81b1bdf7964f626f2540f7d2f63b6ef74b8937e6c5a3161e4d401777e23e0bee7bcdd74cfa4f55
+  data.tar.gz: 69a5aef31c4658c5934029522dd66f8e5e9b7d8c4040978302e03457b6ba181c6a70ddad786a12c8dab0d7d5de74fbb770d54daef08f197b4aada0a6e7818351

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.2.1] - 2023-07-06
+
+* Raise exception when `Podcast.find` returns no result ([#6](https://github.com/jasonyork/podcast-index/issues/6))
+
+## [0.2.0] - 2023-04-24
+
+* BREAKING: Switching to be more consistent with ActiveRecord conventions, using `find_by` and `where` methods for all models
+* Add support for all "Search", "Podcasts", "Episodes", "Recent" and "Value" sections of the API.  This introduces the `Soundbite` and `Value` domain models.
+* Update README.md
+
 ## [0.1.0] - 2023-01-06
 
 - Initial release

data/Gemfile.lock

@@ -1,25 +1,24 @@
 PATH
   remote: .
   specs:
-    podcast_index (0.1.0)
+    podcast_index (0.2.1)
       activesupport (>= 6.0, < 8)
       addressable (~> 2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.7)
+    activesupport (7.0.3.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
     addressable (2.8.1)
       public_suffix (>= 2.0.2, < 6.0)
     ast (2.4.2)
     codecov (0.6.0)
       simplecov (>= 0.15, < 0.22)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     crack (0.4.5)
       rexml
     debug (1.7.1)
@@ -94,7 +93,6 @@ GEM
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
-    zeitwerk (2.6.6)
 
 PLATFORMS
   x86_64-darwin-20

data/README.md

@@ -32,6 +32,21 @@ In a Rails app, this configuration would typically be placed in an initializer f
 
 ## Usage
 
+This client currently implements the following sections of the API:
+* [Search](https://podcastindex-org.github.io/docs-api/#tag--Search)
+* [Podcasts](https://podcastindex-org.github.io/docs-api/#tag--Podcasts)
+* [Episodes](https://podcastindex-org.github.io/docs-api/#tag--Episodes)
+* [Recent](https://podcastindex-org.github.io/docs-api/#tag--Recent)
+* [Value](https://podcastindex-org.github.io/docs-api/#tag--Value)
+
+These are exposed through the following domain models:
+* [Episode](lib/podcast_index/episode.rb)
+* [Podcast](lib/podcast_index/podcast.rb)
+* [Soundbite](lib/podcast_index/soundbite.rb)
+* [Value](lib/podcast_index/value.rb)
+
+The intent is to follow ActiveRecord conventions as reasonably possible.  Therefore, most of the requests are accessed through the model's `.find_by` and `.where` methods.
+
 ### Examples
 
 Find a podcast by podcastindex id:
@@ -41,26 +56,86 @@ podcast = PodcastIndex::Podcast.find(920666)
 podcast.title # => "Podcasting 2.0"
 ```
 
+When the podcast cannot be found:
+
+```ruby
+begin
+  podcast = PodcastIndex::Podcast.find("invalid")
+rescue PodcastIndex::PodcastNotFound
+  puts "Podcast not found"
+end
+```
+
 Find an episode by guid:
 
 ```ruby
-episode = PodcastIndex::Episode.find_by_guid("PC2084", feedurl: "http://mp3s.nashownotes.com/pc20rss.xml")
+episode = PodcastIndex::Episode.find_by(guid: "PC2084", feedurl: "http://mp3s.nashownotes.com/pc20rss.xml")
 episode.title # => "Episode 84: All Aboard to On-Board!"
 ```
 
+Find a Value block by feed_id:
+
+```ruby
+value = PodcastIndex::Value.find_by(feed_id: 920666)
+value.model.type # => "lightning"
+```
+
 Methods that return multiple results are represented as an array of objects:
 
 ```ruby
-episodes = PodcastIndex::Episode.find_by_person("Adam Curry")
+episodes = PodcastIndex::Episode.where(person: "Adam Curry")
 episodes.count # => 57
 episodes.first.title # => "Episode #2: A conversation with Adam Curry"
 ```
 
+```ruby
+soundbite = PodcastIndex::Soundbite.where(recent: true)
+soundbite.first.episode_id # => 15082076307
+```
+
+
+
 ### Supported Methods
 
-This client currently implements most of the API, focusing on searching for Podcasts and Episodes.  For the list of supported methods, see the [Podcast](lib/podcast_index/podcast.rb) and [Episode](lib/podcast_index/episode.rb) models.
+```ruby
+# Episode
+Episode.find(id, fulltext: nil)
+Episode.find_by(guid, feedurl: nil, feedid: nil, fulltext: nil)
+Episode.where(feed_id:, since: nil, max: nil, fulltext: nil)
+Episode.where(feed_url:, since: nil, max: nil, fulltext: nil)
+Episode.where(podcast_guid:, since: nil, max: nil, fulltext: nil)
+Episode.where(live: true, max: nil)
+Episode.where(itunes_id:, since: nil, max: nil, fulltext: nil)
+Episode.where(person:, fulltext: nil)
+Episode.where(recent: true, max: nil, exclude_string: nil, before: nil, fulltext: nil)
+Episode.sample(max: nil, lang: nil, categories: [], exclude_categories: [], fulltext: nil) # Find a random episode
+
+# Podcast
+Podcast.find(id)
+Podcast.find_by(feed_url)
+Podcast.find_by(guid)
+Podcast.find_by(itunes_id)
+Podcast.where(tag:)
+Podcast.where(medium:)
+# Additional parameters only for searching with "music" medium
+Podcast.where(medium: "music", term:, val: nil, aponly: nil, clean: nil, fulltext: nil) 
+Podcast.where(term:, val: nil, aponly: nil, clean: nil, fulltext: nil)
+Podcast.where(title:, val: nil, clean: nil, fulltext: nil)
+Podcast.where(trending: true, max: nil, since: nil, lang: nil, categories: [], exclude_categories: [])
+Podcast.where(dead: true)
+Podcast.where(recent: true, max: nil, since: nil, lang: nil, categories: [], exclude_categories: [])
+Podcast.where(new: true, max: nil, since: nil, feedid: nil, desc: nil)
+Podcast.where(newly_found: true, max: nil, since: nil)
+
+# Soundbite
+Soundbite.where(recent: true, max: nil)
+
+# Value
+Value.find_by(feed_id)
+Value.find_by(feed_url)
+```
 
-The attributes of the response object mirror the names in the API, but have been translated to "underscore" format more closely follow Ruby conventions.  For example, the `lastUpdateTime` attribute for a `Podcast` is renamed to `last_update_time`.
+The attributes of the models mirror the names in the API, but have been translated to "underscore" format to more closely follow Ruby conventions.  For example, the `lastUpdateTime` attribute for a `Podcast` is exposed as `last_update_time`.
 
 ### Exception Handling
 

data/lib/podcast_index/api/episodes.rb

@@ -4,30 +4,53 @@ module PodcastIndex
       extend Request
 
       class << self
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/byid
         def by_id(id:, fulltext: nil)
           response = get("/episodes/byid", id: id, fulltext: fulltext)
           JSON.parse(response.body)
         end
 
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/byfeedid
         def by_feed_id(id:, since: nil, max: nil, fulltext: nil)
           response = get("/episodes/byfeedid", id: id, since: since, max: max, fulltext: fulltext)
           JSON.parse(response.body)
         end
 
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/byfeedurl
         def by_feed_url(url:, since: nil, max: nil, fulltext: nil)
           response = get("/episodes/byfeedurl", url: url, since: since, max: max, fulltext: fulltext)
           JSON.parse(response.body)
         end
 
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/bypodcastguid
+        def by_podcast_guid(podcast_guid:, since: nil, max: nil, fulltext: nil)
+          response = get("/episodes/bypodcastguid", guid: podcast_guid, since: since, max: max, fulltext: fulltext)
+          JSON.parse(response.body)
+        end
+
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/byguid
         def by_guid(guid:, feedurl: nil, feedid: nil, fulltext: nil)
           response = get("/episodes/byguid", guid: guid, feedurl: feedurl, feedid: feedid, fulltext: fulltext)
           JSON.parse(response.body)
         end
 
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/byitunesid
         def by_itunes_id(id:, since: nil, max: nil, fulltext: nil)
           response = get("/episodes/byitunesid", id: id, since: since, max: max, fulltext: fulltext)
           JSON.parse(response.body)
         end
+
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/live
+        def live(max: nil)
+          response = get("/episodes/live", max: max)
+          JSON.parse(response.body)
+        end
+
+        # https://podcastindex-org.github.io/docs-api/#get-/episodes/random
+        def random(max: nil, lang: nil, cat: nil, notcat: nil, fulltext: nil)
+          response = get("/episodes/random", max: max, lang: lang, cat: cat, notcat: notcat, fulltext: fulltext)
+          JSON.parse(response.body)
+        end
       end
     end
   end

data/lib/podcast_index/api/podcasts.rb

@@ -23,6 +23,27 @@ module PodcastIndex
           response = get("/podcasts/byguid", guid: guid)
           JSON.parse(response.body)
         end
+
+        def by_tag(tag:)
+          params = {}.tap { |p| p[tag] = true }
+          response = get("/podcasts/bytag", params)
+          JSON.parse(response.body)
+        end
+
+        def by_medium(medium:)
+          response = get("/podcasts/bymedium", medium: medium)
+          JSON.parse(response.body)
+        end
+
+        def trending(max: nil, since: nil, lang: nil, cat: nil, notcat: nil)
+          response = get("/podcasts/trending", max: max, since: since, lang: lang, cat: cat, notcat: notcat)
+          JSON.parse(response.body)
+        end
+
+        def dead
+          response = get("/podcasts/dead", {})
+          JSON.parse(response.body)
+        end
       end
     end
   end

data/lib/podcast_index/api/recent.rb

@@ -0,0 +1,35 @@
+module PodcastIndex
+  module Api
+    class Recent
+      extend Request
+
+      class << self
+        def episodes(max: nil, exclude_string: nil, before: nil, fulltext: nil)
+          response = get("/recent/episodes", max: max, exclude_string: exclude_string, before: before,
+                                             fulltext: fulltext)
+          JSON.parse(response.body)
+        end
+
+        def feeds(max: nil, since: nil, lang: nil, cat: nil, notcat: nil)
+          response = get("/recent/feeds", max: max, since: since, lang: lang, cat: cat, notcat: notcat)
+          JSON.parse(response.body)
+        end
+
+        def new_feeds(max: nil, since: nil, feedid: nil, desc: nil)
+          response = get("/recent/newfeeds", max: max, since: since, feedid: feedid, desc: desc)
+          JSON.parse(response.body)
+        end
+
+        def data(max: nil, since: nil)
+          response = get("/recent/data", max: max, since: since)
+          JSON.parse(response.body)
+        end
+
+        def soundbites(max: nil)
+          response = get("/recent/soundbites", max: max)
+          JSON.parse(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/podcast_index/api/search.rb

@@ -19,10 +19,10 @@ module PodcastIndex
           JSON.parse(response.body)
         end
 
-        # def music_by_term(term, val: nil, aponly: nil, clean: nil, fulltext: nil)
-        #   response = get("/search/music/byterm", q: term, val:, aponly:, clean:, fulltext:)
-        #   JSON.parse(response.body)
-        # end
+        def music_by_term(term:, val: nil, aponly: nil, clean: nil, fulltext: nil)
+          response = get("/search/music/byterm", q: term, val: val, aponly: aponly, clean: clean, fulltext: fulltext)
+          JSON.parse(response.body)
+        end
       end
     end
   end

data/lib/podcast_index/api/value.rb

@@ -0,0 +1,19 @@
+module PodcastIndex
+  module Api
+    class Value
+      extend Request
+
+      class << self
+        def by_feed_id(id:)
+          response = get("/value/byfeedid", id: id)
+          JSON.parse(response.body)
+        end
+
+        def by_feed_url(url:)
+          response = get("/value/byfeedurl", url: url)
+          JSON.parse(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/podcast_index/episode.rb

@@ -4,18 +4,50 @@ require "delegate"
 module PodcastIndex
   class Episode < SimpleDelegator
     class << self
+      FIND_ONE_ATTRIBUTES = %i[guid].freeze
+      FIND_MANY_ATTRIBUTES = %i[feed_id feed_url podcast_guid live itunes_id person recent].freeze
+
       def find(id, fulltext: nil)
         response = Api::Episodes.by_id(id: id, fulltext: fulltext)
         from_response(response)
       end
 
-      def find_by_feed_id(feed_id, since: nil, max: nil, fulltext: nil)
+      def find_by(attributes)
+        match = (attributes.keys & FIND_ONE_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_ONE_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_ONE_ATTRIBUTES}" if match.length > 1
+
+        send("find_by_#{match.first}", attributes[match.first])
+      end
+
+      def where(attributes)
+        match = (attributes.keys & FIND_MANY_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_MANY_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_MANY_ATTRIBUTES}" if match.length > 1
+
+        send("find_all_by_#{match.first}", **attributes)
+      end
+
+      def sample(max: nil, lang: nil, categories: [], exclude_categories: [], fulltext: nil)
+        response = Api::Episodes.random(max: max, lang: lang, cat: categories.join(","),
+                                        notcat: exclude_categories.join(","), fulltext: fulltext)
+        from_response_collection(response, "episodes")
+      end
+
+    private
+
+      def find_all_by_feed_id(feed_id:, since: nil, max: nil, fulltext: nil)
         response = Api::Episodes.by_feed_id(id: feed_id, since: since, max: max, fulltext: fulltext)
         from_response_collection(response)
       end
 
-      def find_by_feed_url(url, since: nil, max: nil, fulltext: nil)
-        response = Api::Episodes.by_feed_url(url: url, since: since, max: max, fulltext: fulltext)
+      def find_all_by_feed_url(feed_url:, since: nil, max: nil, fulltext: nil)
+        response = Api::Episodes.by_feed_url(url: feed_url, since: since, max: max, fulltext: fulltext)
+        from_response_collection(response)
+      end
+
+      def find_all_by_podcast_guid(podcast_guid:, since: nil, max: nil, fulltext: nil)
+        response = Api::Episodes.by_podcast_guid(podcast_guid: podcast_guid, since: since, max: max, fulltext: fulltext)
         from_response_collection(response)
       end
 
@@ -24,25 +56,33 @@ module PodcastIndex
         from_response(response)
       end
 
-      def find_by_itunes_id(itunes_id, since: nil, max: nil, fulltext: nil)
+      def find_all_by_live(live:, max: nil) # rubocop:disable Lint/UnusedMethodArgument
+        response = Api::Episodes.live(max: max)
+        from_response_collection(response)
+      end
+
+      def find_all_by_itunes_id(itunes_id:, since: nil, max: nil, fulltext: nil)
         response = Api::Episodes.by_itunes_id(id: itunes_id, since: since, max: max, fulltext: fulltext)
         from_response_collection(response)
       end
 
-      def find_by_person(person, fulltext: nil)
+      def find_all_by_person(person:, fulltext: nil)
         response = Api::Search.by_person(person: person, fulltext: fulltext)
         from_response_collection(response)
       end
 
-    private
+      def find_all_by_recent(recent:, max: nil, exclude_string: nil, before: nil, fulltext: nil) # rubocop:disable Lint/UnusedMethodArgument
+        response = Api::Recent.episodes(max: max, exclude_string: exclude_string, before: before, fulltext: fulltext)
+        from_response_collection(response)
+      end
 
       def from_response(response)
         feed = response["episode"].transform_keys(&:underscore)
         new(JSON.parse(feed.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
       end
 
-      def from_response_collection(response)
-        response["items"].map do |item|
+      def from_response_collection(response, collection_key = "items")
+        response[collection_key].map do |item|
           episode = item.transform_keys(&:underscore)
           new(JSON.parse(episode.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
         end

data/lib/podcast_index/podcast.rb

@@ -1,16 +1,42 @@
 require "ostruct"
 require "delegate"
 
+# rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument
 module PodcastIndex
   class Podcast < SimpleDelegator
     class << self
+      FIND_ONE_ATTRIBUTES = %i[feed_url guid itunes_id].freeze
+      FIND_MANY_ATTRIBUTES = %i[tag medium term title trending dead recent new newly_found].freeze
+
       def find(id)
         response = Api::Podcasts.by_feed_id(id: id)
+        raise PodcastIndex::PodcastNotFound, response["description"] if response["feed"].empty?
+
         from_response(response)
       end
 
-      def find_by_feed_url(url)
-        response = Api::Podcasts.by_feed_url(url: url)
+      def find_by(attributes)
+        match = (attributes.keys & FIND_ONE_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_ONE_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_ONE_ATTRIBUTES}" if match.length > 1
+
+        send("find_by_#{match.first}", attributes[match.first])
+      end
+
+      def where(attributes)
+        return find_all_music_by_term(**attributes) if attributes[:medium] == "music" && attributes[:term].present?
+
+        match = (attributes.keys & FIND_MANY_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_MANY_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_MANY_ATTRIBUTES}" if match.length > 1
+
+        send("find_all_by_#{match.first}", **attributes)
+      end
+
+    private
+
+      def find_by_feed_url(feed_url)
+        response = Api::Podcasts.by_feed_url(url: feed_url)
         from_response(response)
       end
 
@@ -19,22 +45,67 @@ module PodcastIndex
         from_response(response)
       end
 
-      def find_by_itunes_id(id)
-        response = Api::Podcasts.by_itunes_id(id: id)
+      def find_by_itunes_id(itunes_id)
+        response = Api::Podcasts.by_itunes_id(id: itunes_id)
         from_response(response)
       end
 
-      def find_by_term(term, val: nil, aponly: nil, clean: nil, fulltext: nil)
+      def find_all_by_tag(tag:)
+        response = Api::Podcasts.by_tag(tag: tag)
+        from_response_collection(response)
+      end
+
+      def find_all_music_by_term(medium:, term:, val: nil, aponly: nil, clean: nil, fulltext: nil)
+        response = Api::Search.music_by_term(term: term, val: val, aponly: aponly, clean: clean, fulltext: fulltext)
+        from_response_collection(response)
+      end
+
+      def find_all_by_medium(medium:)
+        response = Api::Podcasts.by_medium(medium: medium)
+        from_response_collection(response)
+      end
+
+      def find_all_by_trending(trending:, max: nil, since: nil, lang: nil, categories: [], exclude_categories: [])
+        response = Api::Podcasts.trending(max: max, since: since, lang: lang, cat: categories.join(","),
+                                          notcat: exclude_categories.join(","))
+        from_response_collection(response)
+      end
+
+      def find_all_by_dead(*)
+        response = Api::Podcasts.dead
+        from_response_collection(response)
+      end
+
+      def find_all_by_term(term:, val: nil, aponly: nil, clean: nil, fulltext: nil)
         response = Api::Search.by_term(term: term, val: val, aponly: aponly, clean: clean, fulltext: fulltext)
         from_response_collection(response)
       end
 
-      def find_by_title(title, val: nil, clean: nil, fulltext: nil)
+      def find_all_by_title(title:, val: nil, clean: nil, fulltext: nil)
         response = Api::Search.by_title(title: title, val: val, clean: clean, fulltext: fulltext)
         from_response_collection(response)
       end
 
-    private
+      def find_all_by_recent(recent:, max: nil, since: nil, lang: nil, categories: [], exclude_categories: [])
+        response = Api::Recent.feeds(max: max, since: since, lang: lang, cat: categories.join(","),
+                                     notcat: exclude_categories.join(","))
+        from_response_collection(response)
+      end
+
+      def find_all_by_new(new:, max: nil, since: nil, feedid: nil, desc: nil)
+        response = Api::Recent.new_feeds(max: max, since: since, feedid: feedid, desc: desc)
+        from_response_collection(response)
+      end
+
+      def find_all_by_newly_found(newly_found:, max: nil, since: nil)
+        response = Api::Recent.data(max: max, since: since)
+        # This one has a bit of an oddball response.  It's nested in a "data" attribute and all the keys
+        # for each feed are prefixed with "feed" (see example fixture)
+        response["data"]["feeds"].map do |item|
+          feed = item.transform_keys { |key| key.delete_prefix("feed").underscore }
+          new(JSON.parse(feed.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
+        end
+      end
 
       def from_response(response)
         feed = response["feed"].transform_keys(&:underscore)
@@ -43,10 +114,11 @@ module PodcastIndex
 
       def from_response_collection(response)
         response["feeds"].map do |item|
-          episode = item.transform_keys(&:underscore)
-          new(JSON.parse(episode.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
+          feed = item.transform_keys(&:underscore)
+          new(JSON.parse(feed.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
         end
       end
     end
   end
 end
+# rubocop:enable Metrics/ParameterLists, Lint/UnusedMethodArgument

data/lib/podcast_index/soundbite.rb

@@ -0,0 +1,30 @@
+require "ostruct"
+require "delegate"
+
+module PodcastIndex
+  class Soundbite < SimpleDelegator
+    class << self
+      FIND_MANY_ATTRIBUTES = %i[recent].freeze
+
+      def where(attributes)
+        match = (attributes.keys & FIND_MANY_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_MANY_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_MANY_ATTRIBUTES}" if match.length > 1
+
+        send("find_all_by_#{match.first}", **attributes)
+      end
+
+      def find_all_by_recent(recent:, max: nil) # rubocop:disable Lint/UnusedMethodArgument
+        response = Api::Recent.soundbites(max: max)
+        from_response_collection(response)
+      end
+
+      def from_response_collection(response, collection_key = "items")
+        response[collection_key].map do |item|
+          soundbite = item.transform_keys(&:underscore)
+          new(JSON.parse(soundbite.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
+        end
+      end
+    end
+  end
+end

data/lib/podcast_index/value.rb

@@ -0,0 +1,35 @@
+require "ostruct"
+require "delegate"
+
+module PodcastIndex
+  class Value < SimpleDelegator
+    class << self
+      FIND_ONE_ATTRIBUTES = %i[feed_id feed_url].freeze
+
+      def find_by(attributes)
+        match = (attributes.keys & FIND_ONE_ATTRIBUTES)
+        raise ArgumentError, "Must supply one of the attributes: #{FIND_ONE_ATTRIBUTES}" unless match.present?
+        raise ArgumentError, "Must supply only one of the attributes: #{FIND_ONE_ATTRIBUTES}" if match.length > 1
+
+        send("find_by_#{match.first}", attributes[match.first])
+      end
+
+    private
+
+      def find_by_feed_id(feed_id)
+        response = Api::Value.by_feed_id(id: feed_id)
+        from_response(response)
+      end
+
+      def find_by_feed_url(feed_url)
+        response = Api::Value.by_feed_url(url: feed_url)
+        from_response(response)
+      end
+
+      def from_response(response)
+        value = response["value"].transform_keys(&:underscore)
+        new(JSON.parse(value.to_json, object_class: OpenStruct)) # rubocop:disable Style/OpenStructUse
+      end
+    end
+  end
+end

data/lib/podcast_index/version.rb

@@ -1,3 +1,3 @@
 module PodcastIndex
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.1".freeze
 end

data/lib/podcast_index.rb

@@ -7,8 +7,12 @@ require_relative "podcast_index/api/request"
 require_relative "podcast_index/api/podcasts"
 require_relative "podcast_index/api/episodes"
 require_relative "podcast_index/api/search"
+require_relative "podcast_index/api/recent"
+require_relative "podcast_index/api/value"
 require_relative "podcast_index/podcast"
 require_relative "podcast_index/episode"
+require_relative "podcast_index/soundbite"
+require_relative "podcast_index/value"
 
 module PodcastIndex
   include ActiveSupport::Configurable
@@ -16,6 +20,7 @@ module PodcastIndex
   config_accessor :api_key, :api_secret, :base_url
 
   class Error < StandardError; end
+  class PodcastNotFound < Error; end
 
   def self.configure
     self.base_url = "https://api.podcastindex.org/api/1.0".freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: podcast_index
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Jason York
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-07 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -173,12 +173,15 @@ files:
 - lib/podcast_index.rb
 - lib/podcast_index/api/episodes.rb
 - lib/podcast_index/api/podcasts.rb
+- lib/podcast_index/api/recent.rb
 - lib/podcast_index/api/request.rb
 - lib/podcast_index/api/search.rb
+- lib/podcast_index/api/value.rb
 - lib/podcast_index/episode.rb
 - lib/podcast_index/podcast.rb
+- lib/podcast_index/soundbite.rb
+- lib/podcast_index/value.rb
 - lib/podcast_index/version.rb
-- podcast_index.gemspec
 homepage: https://github.com/jasonyork/podcast-index
 licenses:
 - MIT

data/podcast_index.gemspec

@@ -1,41 +0,0 @@
-require_relative "lib/podcast_index/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "podcast_index"
-  spec.version = PodcastIndex::VERSION
-  spec.authors = ["Jason York"]
-
-  spec.summary = "Ruby client for the podcastindex.org API"
-  spec.description = "Exposes the podcastindex.org API through Ruby domain models."
-  spec.homepage = "https://github.com/jasonyork/podcast-index"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/jasonyork/podcast-index"
-  spec.metadata["changelog_uri"] = "https://github.com/jasonyork/podcast-index/blob/master/CHANGELOG.md"
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "activesupport", ">= 6.0", "< 8"
-  spec.add_dependency "addressable", "~> 2"
-
-  spec.add_development_dependency "codecov", "~> 0.4"
-  spec.add_development_dependency "debug", "~> 1"
-  spec.add_development_dependency "rspec-core", "~> 3"
-  spec.add_development_dependency "rspec-its", "~> 1"
-  spec.add_development_dependency "rubocop-performance", "~> 1"
-  spec.add_development_dependency "rubocop-rake", "~> 0.6"
-  spec.add_development_dependency "rubocop-rspec", "~> 2"
-  spec.add_development_dependency "webmock", "~> 3"
-end