spotifyrb 0.1.0

data/lib/spotify/collection.rb

@@ -0,0 +1,82 @@
+module Spotify
+  class Collection
+    attr_reader :data, :total
+
+    def self.from_response(response, type:, key: nil)
+      body = response.body
+
+      if key.is_a?(String)
+        data = body[key].map { |attrs| type.new(attrs) }
+      else
+        data = body.map { |attrs| type.new(attrs) }
+      end
+
+      new(
+        data: data,
+        total: data.count,
+      )
+    end
+
+    def self.from_search_response(response)
+      body = response.body
+
+      data = []
+
+      puts body["tracks"].count
+
+      if body["tracks"] && body["tracks"]["items"]
+        data.concat(body["tracks"]["items"].map { |attrs| Track.new(attrs) })
+      end
+
+      if body["artists"] && body["artists"]["items"]
+        data.concat(body["artists"]["items"].map { |attrs| Artist.new(attrs) })
+      end
+
+      if body["albums"] && body["albums"]["items"]
+        data.concat(body["albums"]["items"].map { |attrs| Album.new(attrs) })
+      end
+
+      if body["playlists"] && body["playlists"]["items"]
+        data.concat(body["playlists"]["items"].map { |attrs| Playlist.new(attrs) })
+      end
+
+      if body["shows"] && body["shows"]["items"]
+        data.concat(body["shows"]["items"].map { |attrs| Show.new(attrs) })
+      end
+
+      if body["episodes"] && body["episodes"]["items"]
+        data.concat(body["episodes"]["items"].map { |attrs| Episode.new(attrs) })
+      end
+
+      if body["audiobooks"] && body["audiobooks"]["items"]
+        data.concat(body["audiobooks"]["items"].map { |attrs| Audiobook.new(attrs) })
+      end
+
+      new(
+        data: data,
+        total: data.count,
+      )
+    end
+
+    def initialize(data:, total:)
+      @data = data
+      @total = total
+    end
+
+    def each(&block)
+      data.each(&block)
+    end
+
+    def first
+      data.first
+    end
+
+    def last
+      data.last
+    end
+
+    def count
+      data.count
+    end
+  end
+end

data/lib/spotify/error.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Error < StandardError
+  end
+end

data/lib/spotify/error_generator.rb

@@ -0,0 +1,128 @@
+module Spotify
+  class ErrorGenerator < StandardError
+    attr_reader :http_status_code
+    attr_reader :spotify_error_code
+    attr_reader :spotify_error_message
+
+    def initialize(response_body, http_status_code)
+      @response_body = response_body
+      @http_status_code = http_status_code
+      set_spotify_error_values
+      super(build_message)
+    end
+
+    private
+
+    def set_spotify_error_values
+      @spotify_error_code = @response_body["error"]["status"]
+      @spotify_error_message = @response_body["error"]["message"]
+    end
+
+    def error_message
+      @spotify_error_message || @response_body["error"]["message"]
+    rescue NoMethodError
+      "An unknown error occurred."
+    end
+
+    def build_message
+      if spotify_error_code.nil?
+        return "Error #{@http_status_code}: #{error_message}"
+      end
+      "Error #{@http_status_code}: #{error_message} '#{spotify_error_message}'"
+    end
+  end
+
+  module Errors
+    class BadRequestError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request was malformed."
+      end
+    end
+
+    class AuthenticationMissingError < ErrorGenerator
+      private
+
+      def error_message
+        "You did not supply valid authentication credentials."
+      end
+    end
+
+    class ForbiddenError < ErrorGenerator
+      private
+
+      def error_message
+        "You are not allowed to perform that action."
+      end
+    end
+
+    class EntityNotFoundError < ErrorGenerator
+      private
+
+      def error_message
+        "No results were found for your request."
+      end
+    end
+
+    class ConflictError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request was a conflict."
+      end
+    end
+
+    class TooManyRequestsError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request exceeded the API rate limit."
+      end
+    end
+
+    class InternalError < ErrorGenerator
+      private
+
+      def error_message
+        "We were unable to perform the request due to server-side problems."
+      end
+    end
+
+    class ServiceUnavailableError < ErrorGenerator
+      private
+
+      def error_message
+        "You have been rate limited for sending more than 20 requests per second."
+      end
+    end
+
+    class NotImplementedError < ErrorGenerator
+      private
+
+      def error_message
+        "This resource has not been implemented."
+      end
+    end
+  end
+
+  class ErrorFactory
+    HTTP_ERROR_MAP = {
+      400 => Errors::BadRequestError,
+      401 => Errors::AuthenticationMissingError,
+      403 => Errors::ForbiddenError,
+      404 => Errors::EntityNotFoundError,
+      409 => Errors::ConflictError,
+      429 => Errors::TooManyRequestsError,
+      500 => Errors::InternalError,
+      503 => Errors::ServiceUnavailableError,
+      501 => Errors::NotImplementedError
+    }.freeze
+
+    def self.create(response_body, http_status_code)
+      status = http_status_code
+      error_class = HTTP_ERROR_MAP[status] || ErrorGenerator
+      error_class.new(response_body, http_status_code) if error_class
+    end
+  end
+end

data/lib/spotify/oauth.rb

@@ -0,0 +1,61 @@
+module Spotify
+  class OAuth
+    attr_reader :client_id, :client_secret
+
+    def initialize(client_id:, client_secret:)
+      @client_id = client_id
+      @client_secret = client_secret
+    end
+
+    def create(grant_type:, scope: nil)
+      send_request(url: "https://id.spotify.tv/oauth2/token", body: {
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: grant_type,
+        scope: scope
+      })
+    end
+
+    def refresh(refresh_token:)
+      send_request(url: "https://id.spotify.tv/oauth2/token", body: {
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: "refresh_token",
+        refresh_token: refresh_token
+      })
+    end
+
+    def device(scopes:)
+      send_request(url: "https://id.spotify.tv/oauth2/device", body: { client_id: client_id, scope: scopes })
+    end
+
+    def validate(token:)
+      response = Faraday.get("https://id.spotify.tv/oauth2/validate", nil, { "Authorization" => "OAuth #{token}" })
+
+      return false if response.status != 200
+
+      JSON.parse(response.body, object_class: OpenStruct)
+    end
+
+    def revoke(token:)
+      response = Faraday.post("https://id.spotify.tv/oauth2/revoke", {
+        client_id: client_id,
+        token: token
+      })
+
+      JSON.parse(response.body, object_class: OpenStruct) if response.status != 200
+
+      true
+    end
+
+    private
+
+    def send_request(url:, body:)
+      response = Faraday.post(url, body)
+
+      return false if response.status != 200
+
+      JSON.parse(response.body, object_class: OpenStruct)
+    end
+  end
+end

data/lib/spotify/object.rb

@@ -0,0 +1,19 @@
+require "ostruct"
+
+module Spotify
+  class Object < OpenStruct
+    def initialize(attributes)
+      super to_ostruct(attributes)
+    end
+
+    def to_ostruct(obj)
+      if obj.is_a?(Hash)
+        OpenStruct.new(obj.map { |key, val| [ key, to_ostruct(val) ] }.to_h)
+      elsif obj.is_a?(Array)
+        obj.map { |o| to_ostruct(o) }
+      else # Assumed to be a primitive value
+        obj
+      end
+    end
+  end
+end

data/lib/spotify/objects/album.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Album < Object
+  end
+end

data/lib/spotify/objects/artist.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Artist < Object
+  end
+end

data/lib/spotify/objects/audiobook.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Audiobook < Object
+  end
+end

data/lib/spotify/objects/device.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Device < Object
+  end
+end

data/lib/spotify/objects/episode.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Episode < Object
+  end
+end

data/lib/spotify/objects/player.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Player < Object
+  end
+end

data/lib/spotify/objects/playlist.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Playlist < Object
+  end
+end

data/lib/spotify/objects/show.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Show < Object
+  end
+end

data/lib/spotify/objects/snapshot.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Snapshot < Object
+  end
+end

data/lib/spotify/objects/track.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class Track < Object
+  end
+end

data/lib/spotify/objects/user.rb

@@ -0,0 +1,4 @@
+module Spotify
+  class User < Object
+  end
+end

data/lib/spotify/resource.rb

@@ -0,0 +1,64 @@
+module Spotify
+  class Resource
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    def get_request(url, params: {}, headers: {})
+      handle_response client.connection.get(url, params, headers)
+    end
+
+    def post_request(url, body:, headers: {})
+      handle_response client.connection.post(url, body, headers)
+    end
+
+    def patch_request(url, body:, headers: {})
+      handle_response client.connection.patch(url, body, headers)
+    end
+
+    def put_request(url, body:, headers: {})
+      handle_response client.connection.put(url, body, headers)
+    end
+
+    # def delete_request(url, params: {}, headers: {})
+    #   handle_response client.connection.delete(url, params, headers)
+    # end
+
+    def delete_request(url, body: {}, headers: {})
+      response = client.connection.delete(url) do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = body.to_json
+      end
+
+      handle_response response
+    end
+
+    def handle_response(response)
+      return true if response.status == 204 && (response.body.nil? || response.body.empty?)
+      return true if response.status == 200 && (response.body.nil? || response.body.empty?)
+      return response unless error?(response)
+
+      raise_error(response)
+    end
+
+    def error?(response)
+      [ 400, 401, 403, 404, 409, 429, 500, 501, 503 ].include?(response.status) ||
+        begin
+          body = response.body
+          body = JSON.parse(body) if body.is_a?(String) && body.strip.start_with?("{")
+          body.respond_to?(:key?) && body.key?("error")
+        rescue JSON::ParserError
+          false
+        end
+    end
+
+    def raise_error(response)
+      error = Spotify::ErrorFactory.create(response.body, response.status)
+      raise error if error
+    end
+  end
+end

data/lib/spotify/resources/albums.rb

@@ -0,0 +1,16 @@
+module Spotify
+  class AlbumsResource < Resource
+    def list(ids:, market: nil)
+      response = get_request("albums", params: { ids: ids, market: market })
+      Collection.from_response(response, type: Album, key: "albums")
+    end
+    def get(id:, market: nil)
+      response = get_request("albums/#{id}", params: { market: market })
+      Album.new response.body
+    end
+    def tracks(id:, **params)
+      response = get_request("albums/#{id}/tracks", params: params)
+      Collection.from_response(response, type: Track, key: "items")
+    end
+  end
+end

data/lib/spotify/resources/artists.rb

@@ -0,0 +1,20 @@
+module Spotify
+  class ArtistsResource < Resource
+    def list(ids:)
+      response = get_request("artists", params: { ids: ids })
+      Collection.from_response(response, type: Artist, key: "artists")
+    end
+    def get(id:, market: nil)
+      response = get_request("artists/#{id}", params: { market: market })
+      Artist.new response.body
+    end
+    def albums(id:, **params)
+      response = get_request("artists/#{id}/albums", params: params)
+      Collection.from_response(response, type: Album, key: "items")
+    end
+    def top_tracks(id:, market: nil)
+      response = get_request("artists/#{id}/top-tracks", params: { market: market })
+      Collection.from_response(response, type: Track, key: "tracks")
+    end
+  end
+end

data/lib/spotify/resources/me.rb

@@ -0,0 +1,13 @@
+module Spotify
+  class MeResource < Resource
+    def me
+      response = get_request("me")
+      User.new response.body
+    end
+
+    def playlists(**params)
+      response = get_request("me/playlists", params: params)
+      Collection.from_response(response, type: Playlist, key: "items")
+    end
+  end
+end

data/lib/spotify/resources/player.rb

@@ -0,0 +1,46 @@
+module Spotify
+  class PlayerResource < Resource
+    def state(**params)
+      response = get_request("me/player", params: params)
+      if response == true
+        nil
+      else
+        Player.new response.body
+      end
+    end
+
+    def devices
+      response = get_request("me/player/devices")
+      Collection.from_response(response, type: Device, key: "devices")
+    end
+
+    def playing(**params)
+      response = get_request("me/player/currently-playing", params: params)
+      if response == true
+        nil
+      else
+        Player.new response.body
+      end
+    end
+
+    def play(device: nil)
+      response = put_request("me/player/play", body: { device_id: device }.compact)
+      response.success?
+    end
+
+    def pause(device: nil)
+      response = put_request("me/player/pause", body: { device_id: device }.compact)
+      response.success?
+    end
+
+    def next(device: nil)
+      response = post_request("me/player/next", body: { device_id: device }.compact)
+      response.success?
+    end
+
+    def previous(device: nil)
+      response = post_request("me/player/previous", body: { device_id: device }.compact)
+      response.success?
+    end
+  end
+end

data/lib/spotify/resources/playlists.rb

@@ -0,0 +1,37 @@
+module Spotify
+  class PlaylistsResource < Resource
+    def get(id:, **params)
+      response = get_request("playlists/#{id}", params: params)
+      Playlist.new response.body
+    end
+
+    def update(id:, **attrs)
+      put_request("playlists/#{id}", body: attrs)
+    end
+
+    def tracks(id:, **params)
+      response = get_request("playlists/#{id}/tracks", params: params)
+      Collection.from_response(response, type: Track, key: "items")
+    end
+
+    def add_tracks(id:, uris:, position: nil)
+      body = { uris: uris.split(",") }
+      body[:position] = position if position
+      response = post_request("playlists/#{id}/tracks", body: body)
+      Snapshot.new response.body
+    end
+
+    def remove_tracks(id:, uris:, snapshot_id: nil)
+      body = { tracks: uris.split(",").map { |uri| { uri: uri } } }
+      body[:snapshot_id] = snapshot_id if snapshot_id
+      response = delete_request("playlists/#{id}/tracks", body: body)
+      Snapshot.new response.body
+    end
+
+    def create(user:, name:, **params)
+      attrs = { name: name }
+      response = post_request("users/#{user}/playlists", body: attrs.merge(params))
+      Playlist.new response.body
+    end
+  end
+end

data/lib/spotify/resources/search.rb

@@ -0,0 +1,10 @@
+module Spotify
+  class SearchResource < Resource
+    def search(query:, type:, market: nil, limit: nil, offset: nil)
+      params = { q: query, type: type, market: market, limit: limit, offset: offset }
+      response = get_request("search", params: params)
+
+      Collection.from_search_response(response)
+    end
+  end
+end

data/lib/spotify/resources/users.rb

@@ -0,0 +1,13 @@
+module Spotify
+  class UsersResource < Resource
+    def get(id:)
+      response = get_request("users/#{id}")
+      User.new response.body
+    end
+
+    def playlists(id:, **params)
+      response = get_request("users/#{id}/playlists", params: params)
+      Collection.from_response(response, type: Playlist, key: "items")
+    end
+  end
+end

data/lib/spotify/version.rb

@@ -0,0 +1,3 @@
+module Spotify
+  VERSION = "0.1.0"
+end

data/lib/spotify.rb

@@ -0,0 +1,36 @@
+require "faraday"
+require "json"
+require "ostruct"
+require "spotify/version"
+
+module Spotify
+  autoload :Error, "spotify/error"
+  autoload :Errors, "spotify/error_generator"
+  autoload :ErrorGenerator, "spotify/error_generator"
+  autoload :ErrorFactory, "spotify/error_generator"
+
+  autoload :Client, "spotify/client"
+  autoload :Collection, "spotify/collection"
+  autoload :Resource, "spotify/resource"
+  autoload :Object, "spotify/object"
+
+  autoload :MeResource, "spotify/resources/me"
+  autoload :SearchResource, "spotify/resources/search"
+  autoload :PlayerResource, "spotify/resources/player"
+  autoload :UsersResource, "spotify/resources/users"
+  autoload :AlbumsResource, "spotify/resources/albums"
+  autoload :ArtistsResource, "spotify/resources/artists"
+  autoload :PlaylistsResource, "spotify/resources/playlists"
+
+  autoload :User, "spotify/objects/user"
+  autoload :Album, "spotify/objects/album"
+  autoload :Track, "spotify/objects/track"
+  autoload :Artist, "spotify/objects/artist"
+  autoload :Audiobook, "spotify/objects/audiobook"
+  autoload :Episode, "spotify/objects/episode"
+  autoload :Playlist, "spotify/objects/playlist"
+  autoload :Show, "spotify/objects/show"
+  autoload :Snapshot, "spotify/objects/snapshot"
+  autoload :Player, "spotify/objects/player"
+  autoload :Device, "spotify/objects/device"
+end

data/lib/spotifyrb.rb

@@ -0,0 +1 @@
+require "spotify"

data/spotifyrb.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/spotify/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spotifyrb"
+  spec.version       = Spotify::VERSION
+  spec.authors       = [ "Dean Perry" ]
+  spec.email         = [ "dean@deanpcmad.com" ]
+
+  spec.summary       = "A Ruby library for interacting with the Spotify API"
+  spec.homepage      = "https://deanpcmad.com"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/deanpcmad/spotifyrb"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # 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(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = [ "lib" ]
+
+  spec.add_dependency "faraday", "~> 2.11"
+  spec.add_dependency "ostruct", "~> 0.6.0"
+end