doorkeeper 1.1.0 → 1.2.0

data/lib/doorkeeper/oauth/password_access_token_request.rb

@@ -1,71 +1,74 @@
-module Doorkeeper::OAuth
-  class PasswordAccessTokenRequest
-    include Doorkeeper::Validations
-    include Doorkeeper::OAuth::Helpers
+module Doorkeeper
+  module OAuth
+    class PasswordAccessTokenRequest
+      include Doorkeeper::Validations
+      include Doorkeeper::OAuth::Helpers
 
-    validate :client,         :error => :invalid_client
-    validate :resource_owner, :error => :invalid_resource_owner
-    validate :scopes,         :error => :invalid_scope
+      validate :client,         error: :invalid_client
+      validate :resource_owner, error: :invalid_resource_owner
+      validate :scopes,         error: :invalid_scope
 
-    attr_accessor :server, :resource_owner, :credentials, :access_token
-    attr_accessor :client
+      attr_accessor :server, :resource_owner, :credentials, :access_token
+      attr_accessor :client
 
-    def initialize(server, credentials, resource_owner, parameters = {})
-      @server          = server
-      @resource_owner  = resource_owner
-      @credentials     = credentials
-      @original_scopes = parameters[:scope]
+      def initialize(server, credentials, resource_owner, parameters = {})
+        @server          = server
+        @resource_owner  = resource_owner
+        @credentials     = credentials
+        @original_scopes = parameters[:scope]
 
-      @client = Doorkeeper::Application.authenticate(credentials.uid, credentials.secret) if credentials
-    end
-
-    def authorize
-      validate
-      @response = if valid?
-        issue_token
-        TokenResponse.new access_token
-      else
-        ErrorResponse.from_request self
+        if credentials
+          @client = Doorkeeper::Application.authenticate credentials.uid,
+                                                         credentials.secret
+        end
       end
-    end
 
-    def valid?
-      self.error.nil?
-    end
+      def authorize
+        validate
+        @response = if valid?
+                      issue_token
+                      TokenResponse.new access_token
+                    else
+                      ErrorResponse.from_request self
+                    end
+      end
 
-    def scopes
-      @scopes ||= if @original_scopes.present?
-        Doorkeeper::OAuth::Scopes.from_string(@original_scopes)
-      else
-        server.default_scopes
+      def valid?
+        error.nil?
       end
-    end
 
-  private
+      def scopes
+        @scopes ||= if @original_scopes.present?
+                      Doorkeeper::OAuth::Scopes.from_string(@original_scopes)
+                    else
+                      server.default_scopes
+                    end
+      end
 
-    def issue_token
-      application_id = client.id if client
+      private
 
-      @access_token = Doorkeeper::AccessToken.create!({
-        :application_id     => application_id,
-        :resource_owner_id  => resource_owner.id,
-        :scopes             => scopes.to_s,
-        :expires_in         => server.access_token_expires_in,
-        :use_refresh_token  => server.refresh_token_enabled?
-      })
-    end
+      def issue_token
+        @access_token = Doorkeeper::AccessToken.create!(
+          application_id:    client.try(:id),
+          resource_owner_id: resource_owner.id,
+          scopes:            scopes.to_s,
+          expires_in:        server.access_token_expires_in,
+          use_refresh_token: server.refresh_token_enabled?
+        )
+      end
 
-    def validate_scopes
-      return true unless @original_scopes.present?
-      ScopeChecker.valid?(@original_scopes, @server.scopes)
-    end
+      def validate_scopes
+        return true unless @original_scopes.present?
+        ScopeChecker.valid?(@original_scopes, @server.scopes)
+      end
 
-    def validate_resource_owner
-      !!resource_owner
-    end
+      def validate_resource_owner
+        !!resource_owner
+      end
 
-    def validate_client
-      !credentials || !!client
+      def validate_client
+        !credentials || !!client
+      end
     end
   end
 end

data/lib/doorkeeper/oauth/pre_authorization.rb

@@ -3,10 +3,10 @@ module Doorkeeper
     class PreAuthorization
       include Doorkeeper::Validations
 
-      validate :response_type, :error => :unsupported_response_type
-      validate :client, :error => :invalid_client
-      validate :scopes, :error => :invalid_scope
-      validate :redirect_uri, :error => :invalid_redirect_uri
+      validate :response_type, error: :unsupported_response_type
+      validate :client, error: :invalid_client
+      validate :scopes, error: :invalid_scope
+      validate :redirect_uri, error: :invalid_redirect_uri
 
       attr_accessor :server, :client, :response_type, :redirect_uri, :state
       attr_writer   :scope
@@ -36,10 +36,10 @@ module Doorkeeper
         Doorkeeper::OAuth::ErrorResponse.from_request(self)
       end
 
-    private
+      private
 
       def validate_response_type
-        %w[code token].include? response_type
+        server.authorization_response_types.include? response_type
       end
 
       def validate_client
@@ -55,7 +55,7 @@ module Doorkeeper
       def validate_redirect_uri
         return false unless redirect_uri.present?
         Helpers::URIChecker.test_uri?(redirect_uri) ||
-        Helpers::URIChecker.valid_for_authorization?(redirect_uri, client.redirect_uri)
+          Helpers::URIChecker.valid_for_authorization?(redirect_uri, client.redirect_uri)
       end
     end
   end

data/lib/doorkeeper/oauth/refresh_token_request.rb

@@ -4,10 +4,10 @@ module Doorkeeper
       include Doorkeeper::Validations
       include Doorkeeper::OAuth::Helpers
 
-      validate :token,        :error => :invalid_request
-      validate :client,       :error => :invalid_client
-      validate :client_match, :error => :invalid_grant
-      validate :scope,        :error => :invalid_scope
+      validate :token,        error: :invalid_request
+      validate :client,       error: :invalid_client
+      validate :client_match, error: :invalid_grant
+      validate :scope,        error: :invalid_scope
 
       attr_accessor :server, :refresh_token, :credentials, :access_token
       attr_accessor :client
@@ -18,32 +18,35 @@ module Doorkeeper
         @credentials      = credentials
         @requested_scopes = parameters[:scopes]
 
-        @client = Doorkeeper::Application.authenticate(credentials.uid, credentials.secret) if credentials
+        if credentials
+          @client = Doorkeeper::Application.authenticate credentials.uid,
+            credentials.secret
+        end
       end
 
       def authorize
         validate
         @response = if valid?
-          revoke_and_create_access_token
-          TokenResponse.new access_token
-        else
-          ErrorResponse.from_request self
-        end
+                      revoke_and_create_access_token
+                      TokenResponse.new access_token
+                    else
+                      ErrorResponse.from_request self
+                    end
       end
 
       def valid?
-        self.error.nil?
+        error.nil?
       end
 
       def scopes
         @scopes ||= if @requested_scopes.present?
-          Scopes.from_string @requested_scopes
-        else
-          refresh_token.scopes
-        end
+                      Scopes.from_string @requested_scopes
+                    else
+                      refresh_token.scopes
+                    end
       end
 
-    private
+      private
 
       def revoke_and_create_access_token
         refresh_token.revoke
@@ -51,13 +54,13 @@ module Doorkeeper
       end
 
       def create_access_token
-        @access_token = Doorkeeper::AccessToken.create!({
-          :application_id    => refresh_token.application_id,
-          :resource_owner_id => refresh_token.resource_owner_id,
-          :scopes            => scopes.to_s,
-          :expires_in        => server.access_token_expires_in,
-          :use_refresh_token => true
-        })
+        @access_token = Doorkeeper::AccessToken.create!(
+          application_id:    refresh_token.application_id,
+          resource_owner_id: refresh_token.resource_owner_id,
+          scopes:            scopes.to_s,
+          expires_in:        server.access_token_expires_in,
+          use_refresh_token: true
+        )
       end
 
       def validate_token
@@ -65,7 +68,7 @@ module Doorkeeper
       end
 
       def validate_client
-        (!credentials || !!client)
+        !credentials || !!client
       end
 
       def validate_client_match

data/lib/doorkeeper/oauth/scopes.rb

@@ -5,7 +5,7 @@ module Doorkeeper
       include Comparable
 
       def self.from_string(string)
-        string ||= ""
+        string ||= ''
         new.tap do |scope|
           scope.add(*string.split)
         end
@@ -17,7 +17,7 @@ module Doorkeeper
         end
       end
 
-      delegate :each, :to => :@scopes
+      delegate :each, to: :@scopes
 
       def initialize
         @scopes = []
@@ -37,7 +37,7 @@ module Doorkeeper
       end
 
       def to_s
-        @scopes.join(" ")
+        @scopes.join(' ')
       end
 
       def has_scopes?(scopes)

data/lib/doorkeeper/oauth/token.rb

@@ -13,7 +13,33 @@ module Doorkeeper
         def from_bearer_authorization(request)
           pattern = /^Bearer /
           header  = request.authorization
-          header.gsub pattern, '' if header && header.match(pattern)
+          token_from_header(header, pattern) if match?(header, pattern)
+        end
+
+        def from_basic_authorization(request)
+          pattern = /^Basic /
+          header  = request.authorization
+          token_from_basic_header(header, pattern) if match?(header, pattern)
+        end
+
+        private
+
+        def token_from_basic_header(header, pattern)
+          encoded_header = token_from_header(header, pattern)
+          token, _ = decode_basic_credentials(encoded_header)
+          token
+        end
+
+        def decode_basic_credentials(encoded_header)
+          Base64.decode64(encoded_header).split(/:/, 2)
+        end
+
+        def token_from_header(header, pattern)
+          header.gsub pattern, ''
+        end
+
+        def match?(header, pattern)
+          header && header.match(pattern)
         end
       end
 

data/lib/doorkeeper/oauth/token_request.rb

@@ -10,18 +10,28 @@ module Doorkeeper
       end
 
       def authorize
-        @response = if pre_auth.authorizable?
+        if pre_auth.authorizable?
           auth = Authorization::Token.new(pre_auth, resource_owner)
           auth.issue_token
-          CodeResponse.new pre_auth, auth, :response_on_fragment => true
+          @response = CodeResponse.new pre_auth,
+                                       auth,
+                                       response_on_fragment: true
         else
-          ErrorResponse.from_request pre_auth, :redirect_uri => pre_auth.redirect_uri, :response_on_fragment => true
+          @response = error_response
         end
       end
 
       def deny
         pre_auth.error = :access_denied
-        ErrorResponse.from_request(pre_auth, :redirect_uri => pre_auth.redirect_uri, :response_on_fragment => true)
+        error_response
+      end
+
+      private
+
+      def error_response
+        ErrorResponse.from_request pre_auth,
+                                   redirect_uri: pre_auth.redirect_uri,
+                                   response_on_fragment: true
       end
     end
   end

data/lib/doorkeeper/rails/routes.rb

@@ -16,11 +16,11 @@ module Doorkeeper
       end
 
       def self.warn_if_using_mount_method!
-        paths = ::Rails.application.config.paths["config/routes"] ||
-          ::Rails.application.config.paths["config/routes.rb"]
+        paths = ::Rails.application.config.paths['config/routes'] ||
+          ::Rails.application.config.paths['config/routes.rb']
 
         paths.each do |path|
-          if File.read(::Rails.root.join(path)) =~ %r[mount Doorkeeper::Engine]
+          if File.read(::Rails.root.join(path)) =~ %r{mount Doorkeeper::Engine}
             warn "\n[DOORKEEPER] `mount Doorkeeper::Engine` is not being used anymore. Please replace it with `use_doorkeeper` in your #{path} file\n"
           end
         end
@@ -34,16 +34,18 @@ module Doorkeeper
 
       def generate_routes!(options)
         @mapping = Mapper.new.map(&@block)
-        routes.scope options[:scope] || 'oauth', :as => 'oauth' do
+        routes.scope options[:scope] || 'oauth', as: 'oauth' do
           map_route(:authorizations, :authorization_routes)
           map_route(:tokens, :token_routes)
+          map_route(:tokens, :revoke_routes)
           map_route(:applications, :application_routes)
           map_route(:authorized_applications, :authorized_applications_routes)
           map_route(:token_info, :token_info_routes)
         end
       end
 
-    private
+      private
+
       def map_route(name, method)
         unless @mapping.skipped?(name)
           send method, @mapping[name]
@@ -51,39 +53,46 @@ module Doorkeeper
       end
 
       def authorization_routes(mapping)
-          routes.resource(
-            :authorization, :path => 'authorize',
-            :only => [:create, :update, :destroy],
-            :as => mapping[:as],
-            :controller => mapping[:controllers]
-          ) do
-            routes.get '/:code', :action => :show, :on => :member
-            routes.get '/', :action => :new, :on => :member
-          end
+        routes.resource(
+          :authorization,
+          path: 'authorize',
+          only: [:create, :update, :destroy],
+          as: mapping[:as],
+          controller: mapping[:controllers]
+        ) do
+          routes.get '/:code', action: :show, on: :member
+          routes.get '/', action: :new, on: :member
+        end
       end
 
       def token_routes(mapping)
         routes.resource(
-          :token, :path => 'token',
-          :only => [:create], :as => mapping[:as],
-          :controller => mapping[:controllers]
+          :token,
+          path: 'token',
+          only: [:create], as: mapping[:as],
+          controller: mapping[:controllers]
         )
       end
 
+      def revoke_routes(mapping)
+        routes.post 'revoke', controller: mapping[:controllers], action: :revoke
+      end
+
       def token_info_routes(mapping)
         routes.resource(
-          :token_info, :path => 'token/info',
-          :only => [:show], :as => mapping[:as],
-          :controller => mapping[:controllers]
+          :token_info,
+          path: 'token/info',
+          only: [:show], as: mapping[:as],
+          controller: mapping[:controllers]
         )
       end
 
       def application_routes(mapping)
-        routes.resources :applications, :controller => mapping[:controllers]
+        routes.resources :applications, controller: mapping[:controllers]
       end
 
       def authorized_applications_routes(mapping)
-        routes.resources :authorized_applications, :only => [:index, :destroy], :controller => mapping[:controllers]
+        routes.resources :authorized_applications, only: [:index, :destroy], controller: mapping[:controllers]
       end
     end
   end