Added Spotify::SDK with Initialization (#11)

* added active support

* added files to exclude

* updated spec

* added initialization code

* added initialization spec files

* added tests for Spotify::SDK

* fixed all rubocop errors

* added oauth2_access_token method

* added more tests for sdk spec

* added to_hash method

* added docs

* fixes

Author: bih

SPEC.md

@@ -16,3 +16,18 @@ Authorization: # For integrating OAuth.
       redirect_uri: ""
     })
   ```
+
+SDK: # For building amazing things.
+
+  Initialization accepts:
+    - OAuth2::AccessToken instance
+    - Plain Access Token
+    - Query Hash containing access_token
+    - Query String containing access_token
+    - URL String containing a query or fragment containing access_token
+
+  Code sample:
+  ```
+  sdk = Spotify::SDK.new(access_token)
+  sdk.connect.devices
+  ```

lib/spotify.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require "active_support"
+require "active_support/core_ext"
+
 require "spotify/version"
 require "spotify/auth"
+require "spotify/sdk"
 
 ##
 # The declaration for the Spotify namespace.

lib/spotify/auth.rb

@@ -75,6 +75,7 @@ def initialize(config)
     #
     # @param [Hash] override_params Optional hash containing any overriding values for parameters.
     # Parameters used are client_id, redirect_uri, response_type and scope.
+    # @return [String] A fully qualified Spotify authorization URL to send the user to.
     #
     # @see https://developer.spotify.com/web-api/authorization-guide/
     #
@@ -92,6 +93,7 @@ def authorize_url(override_params={})
     # Validate initialization configuration and raise errors.
     #
     # @param [Hash] config OAuth configuration containing the Client ID, secret and redirect URL.
+    # @return [nil]
     #
     def validate_initialized_input(config)
       raise Errors::AuthClientCredentialsError.new(OAUTH_I18N[:must_be_hash]) unless config.is_a?(Hash)

lib/spotify/sdk.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spotify/sdk/initialization"
+
+module Spotify
+  ##
+  # Spotify::SDK contains the complete Ruby DSL to interact with the Spotify Platform.
+  #
+  class SDK
+    ##
+    # Initialize the Spotify SDK object.
+    #
+    # @example
+    #   # Example 1: Load it in from an access token value.
+    #   @sdk = Spotify::SDK.new("access_token_here")
+    #
+    #   # Example 2: Load it in with values from your database.
+    #   @sdk = Spotify::SDK.new({
+    #     access_token: "access_token_here",
+    #     expires_at: 3_000_000,
+    #     refresh_token: "refresh_token_here"
+    #   })
+    #
+    #   # Example 4: Load it in from an OAuth2::AccessToken object.
+    #   @sdk = Spotify::SDK.new(@auth.auth_code.get_token("auth code"))
+    #
+    #   # Example 5: Load it from a query string or a fully qualified URL.
+    #   @sdk = Spotify::SDK.new("https://localhost:8080/#token=...&expires_at=...")
+    #   @sdk = Spotify::SDK.new("token=...&expires_at=...")
+    #
+    # @param [String, Hash, OAuth2::AccessToken] obj Any supported object which contains an access token. See examples.
+    #
+    def initialize(obj)
+      @payload = Spotify::SDK::Initialization.detect(obj)
+      @access_token  = @payload[:access_token]
+      @expires_at    = @payload[:expires_at]
+      @refresh_token = @payload[:refresh_token]
+    end
+
+    ##
+    # Helper method to a fully qualified OAuth2::AccessToken instance.
+    #
+    # @example
+    #   @auth = Spotify::Auth.new({
+    #     client_id: "[client id goes here]",
+    #     client_secret: "[client secret goes here]",
+    #     redirect_uri: "http://localhost"
+    #   })
+    #
+    #   @sdk = Spotify::SDK.new("access_token_here")
+    #   @sdk.oauth2_access_token(@auth) # => #<OAuth2::AccessToken:...>
+    #
+    # @param [Spotify::Auth] client An instance of Spotify::Auth. See example.
+    # @return [OAuth2::AccessToken] An fully qualified instance of OAuth2::AccessToken.
+    #
+    def oauth2_access_token(client)
+      OAuth2::AccessToken.new(client, @access_token, expires_at:    @expires_at,
+                                                     refresh_token: @refresh_token)
+    end
+
+    ##
+    # Obtain a hash containing all of the user's authorization details.
+    #
+    # @example
+    #   @auth = Spotify::Auth.new({
+    #     client_id: "[client id goes here]",
+    #     client_secret: "[client secret goes here]",
+    #     redirect_uri: "http://localhost"
+    #   })
+    #
+    #   @sdk = Spotify::SDK.new("access_token_here")
+    #   @sdk.to_hash # => { access_token: ..., expires_at: ... }
+    #
+    # @return [Hash] Containing access_token, expires_at and refresh_token
+    #
+    def to_hash
+      @payload.with_indifferent_access.symbolize_keys
+    end
+
+    attr_reader :access_token, :expires_at, :refresh_token
+  end
+end

lib/spotify/sdk/initialization.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spotify/sdk/initialization/base"
+require "spotify/sdk/initialization/oauth_access_token"
+require "spotify/sdk/initialization/plain_string"
+require "spotify/sdk/initialization/query_hash"
+require "spotify/sdk/initialization/query_string"
+require "spotify/sdk/initialization/url_string"
+
+module Spotify
+  class SDK
+    class Initialization
+      CLASSES = %i[
+        OAuthAccessToken
+        QueryString
+        URLString
+        PlainString
+        QueryHash
+      ].freeze
+
+      class << self
+        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
+          else
+            raise Spotify::Errors::InitializationObjectDuplicationError
+          end
+        end
+      end
+    end
+  end
+
+  class Errors
+    ##
+    # A Error class for when the initialization subjectect is not valid (see `initialize(subject)` for more info).
+    #
+    class InitializationObjectInvalidError < StandardError; end
+
+    ##
+    # A Error class for when the initialization subjectect matches against multiple selectors.
+    #
+    class InitializationObjectDuplicationError < StandardError; end
+  end
+end

lib/spotify/sdk/initialization/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      class Base
+        def initialize(subject)
+          @subject = subject
+        end
+
+        def should_perform?
+          false
+        end
+
+        def perform
+          {
+            access_token:  nil,
+            expires_at:    nil,
+            refresh_token: nil
+          }
+        end
+
+        attr_accessor :subject
+      end
+    end
+  end
+end

lib/spotify/sdk/initialization/oauth_access_token.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spotify
+  class SDK
+    class Initialization
+      class OAuthAccessToken < Base
+        def should_perform?
+          subject.is_a?(OAuth2::AccessToken)
+        end
+
+        def perform
+          {
+            access_token:  subject.token,
+            expires_at:    subject.expires_at,
+            refresh_token: subject.refresh_token
+          }
+        end
+      end
+    end
+  end
+end

lib/spotify/sdk/initialization/plain_string.rb

@@ -0,0 +1,21 @@
+# 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_at:    nil,
+            refresh_token: nil
+          }
+        end
+      end
+    end
+  end
+end

lib/spotify/sdk/initialization/query_hash.rb

@@ -0,0 +1,21 @@
+# 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?(:access_token)
+        end
+
+        def perform
+          subject_hash.slice(:access_token, :expires_at, :refresh_token).symbolize_keys
+        end
+      end
+    end
+  end
+end

lib/spotify/sdk/initialization/query_string.rb

@@ -0,0 +1,27 @@
+# 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)
+        end
+
+        def perform
+          {
+            access_token:  params[:token][0].presence,
+            expires_at:    params[:expires_at][0],
+            refresh_token: params[:refresh_token][0]
+          }
+        end
+      end
+    end
+  end
+end