spotify-ruby-api 0.7.0

data/lib/spotify/api/base.rb

@@ -0,0 +1,150 @@
+require 'json'
+
+module Spotify
+  module API
+
+    class Base
+
+      attr_reader :response, :retries, :timeout, :url, :params, :request
+
+      #
+      # The API base URL.
+      #
+      BASE_URL = "https://api.spotify.com/v1/"
+
+      #
+      # The API search endpoint.
+      #
+      SEARCH_URL = "#{BASE_URL}search"
+
+      #
+      # The max retries limit.
+      #
+      MAX_RETRIES = 5
+
+      #
+      # Restrict value for market variable on search methods.
+      #
+      FROM_TOKEN = :from_token
+
+      #
+      # Initializes the optional arguments.
+      #
+      # @param [Hash] the optional arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      def initialize(args = {})
+        @args    = args.except(:timeout, :retries)
+        @timeout = args[:timeout].to_i
+        @retries = args[:retries].to_i
+      end
+
+      #
+      # Performs a request on the given url with its arguments.
+      #
+      # @param [String] url the request API url.
+      # @param [Hash] params the request arguments.
+      #
+      def get(url, params = {})
+        @url     = url
+        @params  = params
+        @request = prepare_request
+
+        make_request
+      end
+
+      #
+      # Performs the request respecting the given timeout.
+      #
+      # @param [Proc] block a block of code to perform the request.
+      #
+      def run_with_timeout(&block)
+        Timeout.timeout(@timeout) do
+          yield
+        end
+      end
+
+      #
+      # Prepares the Proc instructions to perform the request.
+      #
+      def prepare_request
+        lambda do
+          sleep(3)
+          uri       = URI(@url)
+          uri.query = URI.encode_www_form(@params)
+          @response = Net::HTTP.get(uri)
+        end
+      end
+
+      #
+      # Handles the request behavior.
+      #
+      # @param [Fixnum] attempts the current attempt number.
+      #
+      def make_request(attempts = 0)
+        @attempts = attempts
+
+        if attempts > MAX_RETRIES || attempts > @retries
+          set_response(Spotify::API::Errors::MAX_RETRIES, true)
+
+        else
+          begin
+            if @timeout > 0
+              run_with_timeout { request.call }
+            else
+              request.call
+            end
+
+          rescue Timeout::Error
+            set_response(Spotify::API::Errors::TIMEOUT)
+          rescue
+            set_response(Spotify::API::Errors::UNEXPECTED)
+          end
+        end
+
+      end
+
+      #
+      # Sets the response in case of something goes wrong during the
+      # extraction process.
+      #
+      # @param [String] error the raised error during the extraction.
+      # @param [Boolean] force if should return error independent of retries.
+      #
+      def set_response(error, force = false)
+        if force == false && @retries > 0
+          make_request(@attempts + 1)
+        else
+          @response = { error: error }.to_json
+        end
+      end
+
+      #
+      # Parses the response to JSON to get more flexible.
+      #
+      # @return [Hash] the parsed response.
+      #
+      def body
+        @response = JSON.parse(response)
+      end
+
+      def define_response(&block)
+        response = body
+
+        # The if statement covers a case for Users requests.
+        if response.class != Spotify::Models::Error
+          if response['error']
+            response = Spotify::Models::Error.default(response['error'])
+          else
+            response = yield
+          end
+        end
+
+        response
+      end
+
+    end
+
+  end
+end

data/lib/spotify/api/track.rb

@@ -0,0 +1,127 @@
+module Spotify
+  module API
+
+    class Track < Spotify::API::Base
+
+      #
+      # API endpoint for tracks.
+      #
+      TRACKS_URL = "#{BASE_URL}tracks"
+
+      #
+      # Gets the tracks related to the given parameters.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      # @return [Spotify::Models::Paging] the extracted tracks.
+      #
+      def self.search(args = {})
+        args[:type] = :track
+
+        service_params = args.slice(:timeout, :retries)
+        args           = args.slice(:q, :market, :type, :limit, :offset)
+
+        self.new(service_params).search(args)
+      end
+
+      #
+      # Gets a track.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      # @return [Full::Track] the extracted track.
+      #
+      def self.search_by_id(args = {})
+        service_params = args.slice(:timeout, :retries)
+        args           = args.slice(:id, :market)
+
+        self.new(service_params).search_by_id(args)
+      end
+
+      #
+      # Gets several tracks.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      # @return [Array<Full::Track>] an array containing
+      #   the extracted tracks.
+      #
+      def self.search_by_ids(args = {})
+        args[:ids] = Array(args[:ids]).join(',')
+
+        service_params = args.slice(:timeout, :retries)
+        args           = args.slice(:ids, :market)
+
+        self.new(service_params).search_by_ids(args)
+      end
+
+      #
+      # Gets the tracks related to the given parameters.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      # @return [Spotify::Models::Paging] the extracted tracks.
+      #
+      def search(args = {})
+        if args[:market].to_s.to_sym == FROM_TOKEN
+          # TODO: Authorization.
+          return Spotify::API::Errors::NOT_AVAILABLE
+        end
+
+        get(SEARCH_URL, args)
+
+        define_response do
+          klass = Spotify::Models::Full::Track
+
+          Spotify::Models::Paging.new(response["tracks"], klass)
+        end
+      end
+
+      #
+      # Gets a track.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [String] :id the track id.
+      # @option [String] :market the market.
+      #
+      # @return [Full::Track] the extracted track.
+      #
+      def search_by_id(args = {})
+        get(TRACKS_URL + '/' + args[:id].to_s, args.slice(:market))
+
+        define_response do
+          Spotify::Models::Full::Track.new(response)
+        end
+      end
+
+      #
+      # Gets several tracks.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [String] :ids the tracks ids between ",".
+      # @option [String] :market the market.
+      #
+      # @return [Array<Full::Track>] an array containing
+      #   the extracted tracks.
+      #
+      def search_by_ids(args = {})
+        get(TRACKS_URL, args)
+
+        define_response do
+          response["tracks"].map do |track|
+            Spotify::Models::Full::Track.new(track)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/spotify/api/user.rb

@@ -0,0 +1,58 @@
+module Spotify
+  module API
+
+    class User < Spotify::API::Base
+
+      #
+      # API endpoint for users.
+      #
+      USERS_URL = "#{BASE_URL}users"
+
+      #
+      # Gets an user.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [Fixnum] :timeout the max time a request can take.
+      # @option [Fixnum] :retries the number of retries if necessary.
+      #
+      # @return [Public::User] the extracted user.
+      #
+      def self.search_by_id(args = {})
+        service_params = args.slice(:timeout, :retries)
+        args           = args.slice(:id)
+
+        self.new(service_params).search_by_id(args)
+      end
+
+      #
+      # Gets a track.
+      #
+      # @param [Hash] args the search arguments.
+      # @option [String] :id the track id.
+      # @option [String] :market the market.
+      #
+      # @return [Public::User] the extracted user.
+      #
+      def search_by_id(args = {})
+        get(USERS_URL + '/' + args[:id].to_s)
+
+        define_response do
+          Spotify::Models::Simplified::User.new(response)
+        end
+      end
+
+      #
+      # Parses the response to JSON to get more flexible.
+      #
+      # @return [Hash] the parsed response.
+      #
+      def body
+        @response = JSON.parse(response)
+      rescue
+        Spotify::Models::Error.parser_error
+      end
+
+    end
+
+  end
+end

data/lib/spotify/api/version.rb

@@ -0,0 +1,5 @@
+module Spotify
+  module API
+    VERSION = "0.7.0"
+  end
+end

data/lib/spotify/api.rb

@@ -0,0 +1,12 @@
+require "spotify/api/base"
+require "spotify/api/version"
+
+require "spotify/api/album"
+require "spotify/api/artist"
+require "spotify/api/track"
+require "spotify/api/user"
+
+module Spotify
+  module API
+  end
+end

data/lib/spotify/models/album.rb

@@ -0,0 +1,42 @@
+module Spotify
+
+  module Models
+
+    class Album
+
+      attr_reader :album_type, :available_markets, :external_urls,
+        :genres, :href, :id, :images, :name, :type, :uri
+
+      #
+      # Sets the arguments to its variables.
+      #
+      # @param [Hash] args the arguments that will be placed on each variable.
+      #
+      # @return [Album] an album object.
+      #
+      def initialize(args = {})
+        args = Hash(args).with_indifferent_access
+
+        # Arrays
+        images = Array(args[:images]).map { |i| Spotify::Models::Image.new(i) }
+
+        # Objects
+        external_urls = Spotify::Models::ExternalURL.new(args[:external_urls])
+
+        @album_type             = args[:album_type]
+        @available_markets      = args[:available_markets]
+        @external_urls          = external_urls
+        @genres                 = args[:genres]
+        @href                   = args[:href]
+        @id                     = args[:id]
+        @images                 = images
+        @name                   = args[:name]
+        @type                   = args[:type]
+        @uri                    = args[:uri]
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/artist.rb

@@ -0,0 +1,34 @@
+module Spotify
+
+  module Models
+
+    class Artist
+
+      attr_reader :external_urls, :href, :id, :name, :type, :uri
+
+      #
+      # Sets the arguments to its variables.
+      #
+      # @param [Hash] args the arguments that will be placed on each variable.
+      #
+      # @return [Album] an artist object.
+      #
+      def initialize(args = {})
+        args = Hash(args).with_indifferent_access
+
+        # Objects
+        external_urls = Spotify::Models::ExternalURL.new(args[:external_urls])
+
+        @external_urls = external_urls
+        @href          = args[:href]
+        @id            = args[:id]
+        @name          = args[:name]
+        @type          = args[:type]
+        @uri           = args[:uri]
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/category.rb

@@ -0,0 +1,23 @@
+module Spotify
+
+  module Models
+
+    class Category
+
+      attr_reader :href, :icons, :id, :name
+
+      def initialize(args = {})
+        args  = args.with_indifferent_access
+        icons = args[:icons].map { |icon| Spotify::Models::Image.new(icon) }
+
+        @href  = args[:href]
+        @icons = icons
+        @id    = args[:id]
+        @name  = args[:name]
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/copyright.rb

@@ -0,0 +1,27 @@
+module Spotify
+
+  module Models
+
+    class Copyright
+
+      attr_reader :text, :type
+
+      #
+      # Sets the arguments to its variables.
+      #
+      # @param [Hash] args the arguments that will be placed on each variable.
+      #
+      # @return [Image] a copyright object.
+      #
+      def initialize(args = {})
+        args = Hash(args).with_indifferent_access
+
+        @text = args[:text]
+        @type = args[:type]
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/cursor.rb

@@ -0,0 +1,19 @@
+module Spotify
+
+  module Models
+
+    class Cursor
+
+      attr_reader :after
+
+      def initialize(args = {})
+        args = args.with_indifferent_access
+
+        @after = args[:after]
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/cursorbased_paging.rb

@@ -0,0 +1,24 @@
+module Spotify
+
+  module Models
+
+    class CursorbasedPaging
+
+      attr_reader :href, :items, :limit, :next, :cursors, :total
+
+      def initialize(args = {}, klass)
+        args = args.with_indifferent_access
+
+        @href    = args[:href]
+        @items   = args[:items].map { |item| klass.new(item) }
+        @limit   = args[:limit]
+        @next    = args[:next]
+        @total   = args[:total]
+        @cursors = Cursor.new(args[:cursors])
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/error.rb

@@ -0,0 +1,122 @@
+module Spotify
+
+  module Models
+
+    class Error
+
+      attr_reader :status, :message
+
+      #
+      # Identifies that the error is returned from some request.
+      #
+      DEFAULT = :default
+
+      #
+      # Defines the text and status for each message known.
+      #
+      ERRORS = {
+        timeout: {
+          status:  700,
+          message: "Timed out."
+        },
+        unexpected: {
+          status: 710,
+          message: "Unexpected error."
+        },
+        max_retries: {
+          status: 720,
+          message: "Max retries exceeded."
+        },
+        not_available: {
+          status: 730,
+          message: "This feature is not available yet."
+        },
+        parser_error: {
+          status: 740,
+          message: "Something went wrong. Please verify the parameters"
+        }
+      }
+
+      #
+      # Creates the message.
+      #
+      # @param [Hash] type the type of the message to be shown.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def initialize(type, args = {})
+        if type == DEFAULT
+          error = {
+            status:  args[:status],
+            message: args[:message]
+          }
+        else
+          error = ERRORS[type]
+        end
+
+        @status  = error[:status]
+        @message = error[:message]
+      end
+
+      #
+      # Creates an error representing a timeout error.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.timeout
+        self.new(:timeout)
+      end
+
+      #
+      # Creates an error representing an unexpected error.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.unexpected_error
+        self.new(:unexpected_error)
+      end
+
+      #
+      # Creates an error representing that the retries limit was reached.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.max_retries
+        self.new(:max_retries)
+      end
+
+      #
+      # Creates an error representing that the requested feature is not
+      # available yet.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.not_available
+        self.new(:not_available)
+      end
+
+      #
+      # Creates an error representing a parser error.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.parser_error
+        self.new(:parser_error)
+      end
+
+      #
+      # Creates an error representing the site response error.
+      #
+      # @return [Parsers::Error] a message to be shown to the user.
+      #
+      def self.default(args = {})
+        args = Hash(args).with_indifferent_access
+
+        self.new(:default, args)
+      end
+
+    end
+
+  end
+
+end

data/lib/spotify/models/external_id.rb

@@ -0,0 +1,41 @@
+module Spotify
+
+  module Models
+
+    class ExternalID
+
+      #
+      # Sets the arguments to its variables.
+      #
+      # @param [Hash] args the arguments that will be placed on each variable.
+      #
+      # @return [ExternalID] an external id object.
+      #
+      def initialize(args = {})
+        args = Hash(args).with_indifferent_access
+
+        hsh = {
+          isrc: args[:isrc],
+          ean:  args[:ean],
+          upc:  args[:upc]
+        }
+
+        hsh = hsh.reject { |_, v| v.blank? }
+
+        if hsh.present?
+          # Generates the keys dynamically
+          hsh.each do |k, v|
+            key   = k
+            value = v
+
+            eval("@#{key} = value")
+            class_eval { attr_reader key.to_sym }
+          end
+        end
+      end
+
+    end
+
+  end
+
+end