spotify-ruby 0.1.0 → 0.1.1

data/lib/spotify/sdk/base.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    ##
+    # For each SDK component, we have a Base class. We're using HTTParty.
+    #
+    class Base
+      include HTTParty
+      base_uri "api.spotify.com:443"
+
+      ##
+      # Initiate a Spotify SDK Base component.
+      #
+      # @example
+      #   @sdk = Spotify::SDK.new("access_token")
+      #   @auth = Spotify::SDK::Base.new(@sdk)
+      #
+      #   @sdk = Spotify::SDK.new("access_token_here")
+      #   @sdk.to_hash # => { access_token: ..., expires_at: ... }
+      #
+      # @param [Spotify::SDK] sdk An instance of Spotify::SDK as a reference point.
+      #
+      def initialize(sdk)
+        @sdk = sdk
+        @options = {
+          headers: {
+            Authorization: "Bearer %s" % sdk.access_token
+          }
+        }
+      end
+
+      ##
+      # Handle HTTParty responses.
+      #
+      # @example
+      #   # Return the Hash from the JSON response.
+      #   send_http_request(:get, "/v1/me/player/devices", @options)
+      #
+      #   # Return the raw HTTParty::Response object.
+      #   send_http_request(:get, "/v1/me/player/devices", @options.merge(raw: true))
+      #
+      # @param [Hash,HTTParty::Response] response The response from the HTTP request.
+      # @return
+      #
+      def send_http_request(method, endpoint, opts={}, &_block)
+        sdk_opts = opts[:_sdk_opts].presence || {}
+        opts_sdk = {raw: false, expect_nil: false}.merge(sdk_opts)
+        response = self.class.send(method, endpoint, @options.merge(opts))
+        response = response.parsed_response.try(:deep_symbolize_keys) if opts_sdk[:raw] == false
+        response = true if opts_sdk[:expect_nil] == true && response.nil?
+        response
+      end
+
+      attr_reader :sdk
+    end
+  end
+end

data/lib/spotify/sdk/connect.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Connect < Base
+      ##
+      # Collect all the user's available devices.
+      # GET /v1/me/player/devices
+      #
+      # @example
+      #   @sdk.connect.devices # => [#<Spotify::SDK::Connect::Device:...>, ...]
+      #
+      # @see https://developer.spotify.com/web-api/console/get-users-available-devices/
+      #
+      # @param [Hash] override_opts Custom options for HTTParty.
+      # @return
+      #
+      def devices(override_opts={})
+        response = send_http_request(:get, "/v1/me/player/devices", override_opts)
+        response[:devices].map do |device|
+          Spotify::SDK::Connect::Device.new(device, self)
+        end
+      end
+    end
+  end
+end

data/lib/spotify/sdk/connect/device.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Connect
+      class Device < Model
+        ##
+        # Transfer a user's playback to another device, and continue playing.
+        # PUT /v1/me/player
+        #
+        # @example
+        #   device = @sdk.connect.transfer_playback!
+        #
+        # @see https://developer.spotify.com/web-api/transfer-a-users-playback/
+        #
+        # @return [Spotify::SDK::Connect::Device] self Return itself, so chained methods can be supported.
+        #
+        def transfer_playback!
+          transfer_playback_method(playing: true)
+          self
+        end
+
+        ##
+        # Transfer a user's playback to another device, and pause.
+        # PUT /v1/me/player
+        #
+        # @example
+        #   device = @sdk.connect.transfer_state!
+        #
+        # @see https://developer.spotify.com/web-api/transfer-a-users-playback/
+        #
+        # @return [Spotify::SDK::Connect::Device] self Return itself, so chained methods can be supported.
+        #
+        def transfer_state!
+          transfer_playback_method(playing: false)
+          self
+        end
+
+        private
+
+        def transfer_playback_method(playing:)
+          override_opts = {
+            _sdk_opts: {expect_nil: true},
+            body:      {
+              device_ids: [id],
+              play:       playing
+            }.to_json
+          }
+
+          parent.send_http_request(:put, "/v1/me/player", override_opts)
+        end
+      end
+    end
+  end
+end

data/lib/spotify/sdk/initialization.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    ##
+    # Spotify::SDK::Initialization deals with parsing input for the
+    # following code block `Spotify::SDK.new(input)` and extracting
+    # the access token, expiry and refresh token.
+    #
+    # You'll never have to interact with this, unless you have other
+    # objects you want us to parse the aforementioned variables from.
+    #
+    class Initialization
+      ##
+      # This is where you mount new Initialization objects.
+      # Don't worry, we prefix Spotify::SDK::Initialization for you.
+      #
+      # @see /lib/spotify/sdk/initialization/url_string.rb
+      #
+      CLASSES = %i[
+        OAuthAccessToken
+        QueryString
+        URLString
+        PlainString
+        QueryHash
+      ].freeze
+
+      class << self
+        ##
+        # Initiate a new Spotify SDK Initialization object
+        #
+        # @example
+        #   begin
+        #     hash = Spotify::SDK::Initialization.detect("access_token")
+        #     puts "Access Token: #{hash[:access_token]}"
+        #     puts "Expires in: #{hash[:expires_in]}"
+        #     puts "Refresh Token: #{hash[:refresh_token]}"
+        #   rescue Spotify::Errors::InitializationObjectInvalidError => e
+        #     puts "Can't recognise the input because: #{e.inspect}"
+        #   end
+        #
+        # @param [String,Hash,OAuth2::AccessToken] subject An instance of Spotify::SDK as a reference point.
+        #
+        def detect(subject)
+          klasses = CLASSES.map do |klass_name|
+            ("Spotify::SDK::Initialization::%s" % klass_name).constantize.new(subject)
+          end
+
+          matches = klasses.select(&:should_perform?)
+
+          case matches.size
+          when 1
+            matches.first.perform
+          when 0
+            raise Spotify::Errors::InitializationObjectInvalidError.new
+          else
+            raise Spotify::Errors::InitializationObjectDuplicationError.new
+          end
+        end
+      end
+    end
+  end
+
+  class Errors
+    ##
+    # A Error class for when the initialization subject is not valid (see `initialize(subject)` for more info).
+    #
+    class InitializationObjectInvalidError < StandardError; end
+
+    ##
+    # A Error class for when the initialization subject matches against multiple selectors.
+    # When this Error occurs, this becomes an internal bug. It should be filed on the GitHub issue tracker.
+    #
+    class InitializationObjectDuplicationError < StandardError; end
+  end
+end

data/lib/spotify/sdk/initialization/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      ##
+      # For each SDK Initialization type, we have a base class to inherit from.
+      #
+      class Base
+        ##
+        # Initiate a Spotify SDK Initialization Base class.
+        # Note: You would not ever initiate this class, but rather inherit from it.
+        # See /lib/spotify/sdk/initialization/query_string.rb as an example.
+        #
+        # @example
+        #   Spotify::SDK::Initialization::Base.new("access_token")
+        #
+        # @param [Object] subject Any object that can be used to identify an access token.
+        #
+        def initialize(subject)
+          @subject = subject
+        end
+
+        ##
+        # Determine whether this initialization type is valid, and should be performed.
+        #
+        # @example
+        #   instance = Spotify::SDK::Initialization::Base.new("access_token")
+        #   instance.should_perform?
+        #
+        # @return [Boolean] A true or false answer as to whether to perform this initialization type.
+        #
+        def should_perform?
+          false
+        end
+
+        ##
+        # Perform the class to extract the authentication details needed for the SDK class to run.
+        #
+        # @example
+        #   instance = Spotify::SDK::Initialization::Base.new("access_token")
+        #   instance.perform if instance.should_perform?
+        #
+        # @return [Hash] A hash containing only access_token, expires_in and refresh_token.
+        #
+        def perform
+          {
+            access_token:  nil,
+            expires_in:    nil,
+            refresh_token: nil
+          }
+        end
+
+        ##
+        # The subject of the class. Usually what has been sent to Spotify::SDK.new() is the subject.
+        #
+        attr_reader :subject
+
+        # TODO: Delete this when tests are written.
+        # def sample_inputs
+        #   nil
+        # end
+
+        # SAMPLE_TOKEN = """
+        #   AQBjjlIYyEuyK2HuzqfA2ldj0B88d63KX2pgdOC0N4Pg4Iuw232M7gEgXjQS0Zdt3Y1r2J3G
+        #   rCOf4fs1JndDbyGY_uaPWj5hpYE_dMS0G5ouJKLaapDT50EysfV3XdW6aQlbw51dYjgZU-Ce
+        #   NCnj7bPsq4nXhZzbUkr0aTuR8MKEOXuW7-xaz1h8et-ZFYQDa788LTS08pLu--1waspBsmqh
+        #   SxbOl0xG5QBQ0NnTbCn1SWi-T1B7J_6twmv7GWXsR9RqeBg_U5KcT6ciz85YFrkRQ6n47PpP
+        #   HBfTFjmJxB91plroOOIZAE3fQ37-RDqdK7YzSw6gAm0
+        # """.strip
+      end
+    end
+  end
+end

data/lib/spotify/sdk/initialization/oauth_access_token.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      ##
+      # This class implements accepting OAuth2::AccessToken as an initializer.
+      #
+      class OAuthAccessToken < Base
+        ##
+        # This implements the #should_perform? method from the Base class.
+        #
+        # @see /lib/spotify/sdk/authorization/base.rb
+        #
+        def should_perform?
+          subject.instance_of? OAuth2::AccessToken
+        end
+
+        ##
+        # This implements the #perform method from the Base class.
+        #
+        # @see /lib/spotify/sdk/authorization/base.rb
+        #
+        def perform
+          {
+            access_token:  subject.token,
+            expires_in:    subject.expires_in,
+            refresh_token: subject.refresh_token
+          }
+        end
+      end
+    end
+  end
+end

data/lib/spotify/sdk/initialization/plain_string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      class PlainString < Base
+        def should_perform?
+          subject.is_a?(String) && subject =~ /^[a-zA-Z0-9_-]+$/
+        end
+
+        def perform
+          {
+            access_token:  subject,
+            expires_in:    nil,
+            refresh_token: nil
+          }
+        end
+
+        # TODO: Delete this when tests are written.
+        # def sample_inputs
+        #   [ SAMPLE_TOKEN ]
+        # end
+      end
+    end
+  end
+end

data/lib/spotify/sdk/initialization/query_hash.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      class QueryHash < Base
+        def subject_hash
+          subject.try(:with_indifferent_access) || {}
+        end
+
+        def should_perform?
+          subject_hash.has_key?(:token) || subject_hash.has_key?(:access_token)
+        end
+
+        def perform
+          subject_hash[:access_token] = subject_hash[:token] if subject_hash.has_key?(:token)
+          subject_hash.slice(:access_token, :expires_in, :refresh_token).symbolize_keys
+        end
+
+        # TODO: Delete this when tests are written.
+        # def sample_inputs
+        #   [{
+        #     token: SAMPLE_TOKEN
+        #   }, {
+        #     token:      SAMPLE_TOKEN,
+        #     expires_in: 1234567890
+        #   }, {
+        #     token:         SAMPLE_TOKEN,
+        #     expires_in:    1234567890,
+        #     refresh_token: SAMPLE_TOKEN
+        #   }, {
+        #     access_token: SAMPLE_TOKEN
+        #   }, {
+        #     access_token: SAMPLE_TOKEN,
+        #     expires_in:   1234567890
+        #   }, {
+        #     access_token:  SAMPLE_TOKEN,
+        #     expires_in:    1234567890,
+        #     refresh_token: SAMPLE_TOKEN
+        #   }]
+        # end
+      end
+    end
+  end
+end

data/lib/spotify/sdk/initialization/query_string.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      class QueryString < Base
+        def params
+          CGI.parse(subject).with_indifferent_access
+        rescue NoMethodError
+          {}
+        end
+
+        def should_perform?
+          subject.is_a?(String) && (
+            params.has_key?(:token) && params.has_key?(:access_token)
+          )
+        end
+
+        def perform
+          {
+            access_token:  params[access_token_key].to_a[0],
+            expires_in:    params[:expires_in].to_a[0],
+            refresh_token: params[:refresh_token].to_a[0]
+          }
+        end
+
+        private
+
+        def access_token_key
+          if params.has_key?(:token)
+            :token
+          elsif params.has_key?(:access_token)
+            :access_token
+          end
+        end
+
+        # TODO: Delete this when tests are written.
+        # def sample_inputs
+        #   [
+        #     "token=#{SAMPLE_TOKEN}",
+        #     "token=#{SAMPLE_TOKEN}&expires_in=1234567890",
+        #     "token=#{SAMPLE_TOKEN}&expires_in=1234567890&refresh_token=#{SAMPLE_TOKEN}",
+        #     "access_token=#{SAMPLE_TOKEN}",
+        #     "access_token=#{SAMPLE_TOKEN}&expires_in=1234567890",
+        #     "access_token=#{SAMPLE_TOKEN}&expires_in=1234567890&refresh_token=#{SAMPLE_TOKEN}"
+        #   ]
+        # end
+      end
+    end
+  end
+end