sorcery 0.9.1 → 0.16.3

data/lib/sorcery/providers/instagram.rb

@@ -0,0 +1,73 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Instagram.com.
+    class Instagram < Base
+      include Protocols::Oauth2
+
+      attr_accessor :access_permissions, :token_url,
+                    :authorization_path, :user_info_path,
+                    :scope, :user_info_fields
+
+      def initialize
+        super
+
+        @site = 'https://api.instagram.com'
+        @token_url = '/oauth/access_token'
+        @authorization_path = '/oauth/authorize/'
+        @user_info_path = '/v1/users/self'
+        @scope = 'basic'
+      end
+
+      def self.included(base)
+        base.extend Sorcery::Providers
+      end
+
+      # provider implements method to build Oauth client
+      def login_url(_params, _session)
+        authorize_url(token_url: @token_url)
+      end
+
+      # overrides oauth2#authorize_url to allow customized scope.
+      def authorize_url(opts = {})
+        @scope = access_permissions.present? ? access_permissions.join(' ') : scope
+        super(opts.merge(token_url: @token_url))
+      end
+
+      # pass oauth2 param `code` provided by instgrm server
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+        get_access_token(
+          args,
+          token_url: @token_url,
+          client_id: @key,
+          client_secret: @secret
+        )
+      end
+
+      # see `user_info_mapping` in config/initializer,
+      # given `user_info_mapping` to specify
+      #   {:db_attribute_name => 'instagram_attr_name'}
+      # so that Sorcery can build AR model from attr names
+      #
+      # NOTE: instead of just getting the user info
+      # from the access_token (which already returns them),
+      # testing strategy relies on querying user_info_path
+      def get_user_hash(access_token)
+        call_api_params = {
+          access_token: access_token.token,
+          client_id: access_token[:client_id]
+        }
+        response = access_token.get(
+          "#{user_info_path}?#{call_api_params.to_param}"
+        )
+
+        user_attrs = {}
+        user_attrs[:user_info] = JSON.parse(response.body)['data']
+        user_attrs[:uid] = user_attrs[:user_info]['id']
+        user_attrs
+      end
+    end
+  end
+end

data/lib/sorcery/providers/jira.rb

@@ -7,31 +7,27 @@ module Sorcery
     #   ...
     #
     class Jira < Base
-
       include Protocols::Oauth
 
       attr_accessor :access_token_path, :authorize_path, :request_token_path,
                     :user_info_path, :site, :signature_method, :private_key_file, :callback_url
 
-
       def initialize
         @configuration = {
-            authorize_path: '/authorize',
-            request_token_path: '/request-token',
-            access_token_path: '/access-token'
+          authorize_path: '/authorize',
+          request_token_path: '/request-token',
+          access_token_path: '/access-token'
         }
         @user_info_path = '/users/me'
       end
 
       # Override included get_consumer method to provide authorize_path
-      #read extra configurations
+      # read extra configurations
       def get_consumer
-        @configuration = @configuration.merge({
-            site: site,
-            signature_method: signature_method,
-            consumer_key: key,
-            private_key_file: private_key_file
-        })
+        @configuration = @configuration.merge(site: site,
+                                              signature_method: signature_method,
+                                              consumer_key: key,
+                                              private_key_file: private_key_file)
         ::OAuth::Consumer.new(@key, @secret, @configuration)
       end
 
@@ -46,13 +42,13 @@ module Sorcery
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
+      def login_url(_params, session)
         req_token = get_request_token
         session[:request_token]         = req_token.token
         session[:request_token_secret]  = req_token.secret
 
-        #it was like that -> redirect_to authorize_url({ request_token: req_token.token, request_token_secret: req_token.secret })
-        #for some reason Jira does not need these parameters
+        # it was like that -> redirect_to authorize_url({ request_token: req_token.token, request_token_secret: req_token.secret })
+        # for some reason Jira does not need these parameters
 
         get_request_token(
           session[:request_token],
@@ -68,10 +64,9 @@ module Sorcery
           request_token_secret: session[:request_token_secret]
         }
 
-        args.merge!({ code: params[:code] }) if params[:code]
+        args[:code] = params[:code] if params[:code]
         get_access_token(args)
       end
-
     end
   end
 end

data/lib/sorcery/providers/line.rb

@@ -0,0 +1,63 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with line.com.
+    #
+    #   config.line.key = <key>
+    #   config.line.secret = <secret>
+    #   ...
+    #
+    class Line < Base
+      include Protocols::Oauth2
+
+      attr_accessor :token_url, :user_info_path, :auth_path, :scope, :bot_prompt
+
+      def initialize
+        super
+
+        @site           = 'https://access.line.me'
+        @user_info_path = 'https://api.line.me/v2/profile'
+        @token_url      = 'https://api.line.me/oauth2/v2.1/token'
+        @auth_path      = 'oauth2/v2.1/authorize'
+        @scope          = 'profile'
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_path)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)
+          h[:uid] = h[:user_info]['userId'].to_s
+        end
+      end
+
+      # calculates and returns the url to which the user should be redirected,
+      # to get authenticated at the external provider's site.
+      def login_url(_params, _session)
+        @state = SecureRandom.hex(16)
+        authorize_url(authorize_url: auth_path)
+      end
+
+      # overrides oauth2#authorize_url to add bot_prompt query.
+      def authorize_url(options = {})
+        options.merge!({
+          connection_opts: { params: { bot_prompt: bot_prompt } }
+        }) if bot_prompt.present?
+
+        super(options)
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+
+        get_access_token(
+          args,
+          token_url: token_url,
+          token_method: :post,
+          grant_type: 'authorization_code'
+        )
+      end
+    end
+  end
+end

data/lib/sorcery/providers/linkedin.rb

@@ -1,66 +1,75 @@
 module Sorcery
   module Providers
-    # This class adds support for OAuth with Linkedin.com.
+    # This class adds support for OAuth with LinkedIn.
     #
     #   config.linkedin.key = <key>
     #   config.linkedin.secret = <secret>
     #   ...
     #
     class Linkedin < Base
+      include Protocols::Oauth2
 
-      include Protocols::Oauth
-
-      attr_accessor :authorize_path, :access_permissions, :access_token_path,
-                    :request_token_path, :user_info_fields, :user_info_path
+      attr_accessor :auth_url, :scope, :token_url, :user_info_url, :email_info_url
 
       def initialize
-        @configuration = {
-          site: 'https://api.linkedin.com',
-          authorize_path: '/uas/oauth/authenticate',
-          request_token_path: '/uas/oauth/requestToken',
-          access_token_path: '/uas/oauth/accessToken'
-        }
-        @user_info_path = '/v1/people/~'
-      end
+        super
 
-      # Override included get_consumer method to provide authorize_path
-      def get_consumer
-        # Add access permissions to request token path
-        @configuration[:request_token_path] += '?scope=' + access_permissions.join('+') unless access_permissions.blank? or @configuration[:request_token_path].include? '?scope='
-        ::OAuth::Consumer.new(@key, @secret, @configuration)
+        @site           = 'https://api.linkedin.com'
+        @auth_url       = '/oauth/v2/authorization'
+        @token_url      = '/oauth/v2/accessToken'
+        @user_info_url  = 'https://api.linkedin.com/v2/me'
+        @email_info_url = 'https://api.linkedin.com/v2/emailAddress?q=members&projection=(elements*(handle~))'
+        @scope          = 'r_liteprofile r_emailaddress'
+        @state          = SecureRandom.hex(16)
       end
 
       def get_user_hash(access_token)
-        fields = self.user_info_fields.join(',')
-        response = access_token.get("#{@user_info_path}:(#{fields})", 'x-li-format' => 'json')
+        user_info = get_user_info(access_token)
 
         auth_hash(access_token).tap do |h|
-          h[:user_info] = JSON.parse(response.body)
-          h[:uid] = h[:user_info]['id'].to_s
+          h[:user_info] = user_info
+          h[:uid]       = h[:user_info]['id']
         end
       end
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
-        req_token = get_request_token
-        session[:request_token]         = req_token.token
-        session[:request_token_secret]  = req_token.secret
-        authorize_url({ request_token: req_token.token, request_token_secret: req_token.secret })
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_url)
       end
 
       # tries to login the user from access token
-      def process_callback(params, session)
-        args = {
-          oauth_verifier:       params[:oauth_verifier],
-          request_token:        session[:request_token],
-          request_token_secret: session[:request_token_secret]
-        }
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
 
-        args.merge!({ code: params[:code] }) if params[:code]
-        get_access_token(args)
+        get_access_token(args, token_url: token_url, token_method: :post)
       end
 
+      def get_user_info(access_token)
+        response  = access_token.get(user_info_url)
+        user_info = JSON.parse(response.body)
+
+        if email_in_scope?
+          email = fetch_email(access_token)
+
+          return user_info.merge(email)
+        end
+
+        user_info
+      end
+
+      def email_in_scope?
+        scope.include?('r_emailaddress')
+      end
+
+      def fetch_email(access_token)
+        email_response = access_token.get(email_info_url)
+        email_info     = JSON.parse(email_response.body)['elements'].first
+
+        email_info['handle~']
+      end
     end
   end
 end

data/lib/sorcery/providers/liveid.rb

@@ -7,7 +7,6 @@ module Sorcery
     #   ...
     #
     class Liveid < Base
-
       include Protocols::Oauth2
 
       attr_accessor :auth_url, :token_path, :user_info_url, :scope
@@ -34,20 +33,18 @@ module Sorcery
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
-        self.authorize_url({ authorize_url: auth_url })
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_url)
       end
 
       # tries to login the user from access token
-      def process_callback(params, session)
+      def process_callback(params, _session)
         args = {}.tap do |a|
           a[:code] = params[:code] if params[:code]
         end
 
-        get_access_token(args, access_token_path: token_path,
-          access_token_method: :post)
+        get_access_token(args, access_token_path: token_path, access_token_method: :post)
       end
-
     end
   end
 end

data/lib/sorcery/providers/microsoft.rb

@@ -0,0 +1,59 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Microsoft Graph.
+    #
+    #   config.microsoft.key = <key>
+    #   config.microsoft.secret = <secret>
+    #   ...
+    #
+    class Microsoft < Base
+      include Protocols::Oauth2
+
+      attr_accessor :auth_url, :scope, :token_url, :user_info_url
+
+      def initialize
+        super
+
+        @site          = 'https://login.microsoftonline.com'
+        @auth_url      = '/common/oauth2/v2.0/authorize'
+        @token_url     = '/common/oauth2/v2.0/token'
+        @user_info_url = 'https://graph.microsoft.com/v1.0/me'
+        @scope         = 'openid email https://graph.microsoft.com/User.Read'
+        @state         = SecureRandom.hex(16)
+      end
+
+      def authorize_url(options = {})
+        oauth_params = {
+          client_id: @key,
+          response_type: 'code'
+        }
+        options.merge!(oauth_params)
+        super(options)
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_url)
+
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)
+          h[:uid] = h[:user_info]['id']
+        end
+      end
+
+      # calculates and returns the url to which the user should be redirected,
+      # to get authenticated at the external provider's site.
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_url)
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+
+        get_access_token(args, token_url: token_url, token_method: :post)
+      end
+    end
+  end
+end

data/lib/sorcery/providers/paypal.rb

@@ -0,0 +1,60 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with paypal.com.
+    #
+    #   config.paypal.key = <key>
+    #   config.paypal.secret = <secret>
+    #   ...
+    #
+    class Paypal < Base
+      include Protocols::Oauth2
+
+      attr_accessor :auth_url, :scope, :token_url, :user_info_url
+
+      def initialize
+        super
+
+        @scope           = 'openid email'
+        @site            = 'https://api.paypal.com'
+        @auth_url        = 'https://www.paypal.com/webapps/auth/protocol/openidconnect/v1/authorize'
+        @user_info_url   = 'https://api.paypal.com/v1/identity/openidconnect/userinfo?schema=openid'
+        @token_url       = 'https://api.paypal.com/v1/identity/openidconnect/tokenservice'
+        @state           = SecureRandom.hex(16)
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_url)
+        body = JSON.parse(response.body)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = body
+          h[:uid] = body['user_id']
+          h[:email] = body['email']
+        end
+      end
+
+      def get_access_token(args, options = {})
+        client = build_client(options)
+        client.auth_code.get_token(
+          args[:code],
+          {
+            redirect_uri: @callback_url,
+            parse: options.delete(:parse)
+          },
+          options
+        )
+      end
+
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_url)
+      end
+
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+
+        get_access_token(args, token_url: token_url, token_method: :post)
+      end
+    end
+  end
+end

data/lib/sorcery/providers/salesforce.rb

@@ -7,7 +7,6 @@ module Sorcery
     #   ...
     #
     class Salesforce < Base
-
       include Protocols::Oauth2
 
       attr_accessor :auth_url, :token_url, :scope
@@ -32,19 +31,18 @@ module Sorcery
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
-        authorize_url({ authorize_url: auth_url })
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_url)
       end
 
       # tries to login the user from access token
-      def process_callback(params, session)
+      def process_callback(params, _session)
         args = {}.tap do |a|
           a[:code] = params[:code] if params[:code]
         end
 
         get_access_token(args, token_url: token_url, token_method: :post)
       end
-
     end
   end
 end

data/lib/sorcery/providers/slack.rb

@@ -0,0 +1,45 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with slack.com.
+
+    class Slack < Base
+      include Protocols::Oauth2
+
+      attr_accessor :auth_path, :scope, :token_url, :user_info_path
+
+      def initialize
+        super
+
+        @scope          = 'identity.basic, identity.email'
+        @site           = 'https://slack.com/'
+        @user_info_path = 'https://slack.com/api/users.identity'
+        @auth_path      = '/oauth/authorize'
+        @token_url      = '/api/oauth.access'
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_path)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)
+          h[:user_info]['email'] = h[:user_info]['user']['email']
+          h[:uid] = h[:user_info]['user']['id']
+        end
+      end
+
+      # calculates and returns the url to which the user should be redirected,
+      # to get authenticated at the external provider's site.
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_path)
+      end
+
+      # tries to login the user from access token
+      def process_callback(params, _session)
+        args = {}.tap do |a|
+          a[:code] = params[:code] if params[:code]
+        end
+
+        get_access_token(args, token_url: token_url, token_method: :post)
+      end
+    end
+  end
+end

data/lib/sorcery/providers/twitter.rb

@@ -7,7 +7,6 @@ module Sorcery
     #   ...
     #
     class Twitter < Base
-
       include Protocols::Oauth
 
       attr_accessor :state, :user_info_path
@@ -35,11 +34,11 @@ module Sorcery
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
-        req_token = self.get_request_token
+      def login_url(_params, session)
+        req_token = get_request_token
         session[:request_token]         = req_token.token
         session[:request_token_secret]  = req_token.secret
-        self.authorize_url({ request_token: req_token.token, request_token_secret: req_token.secret })
+        authorize_url(request_token: req_token.token, request_token_secret: req_token.secret)
       end
 
       # tries to login the user from access token
@@ -50,10 +49,9 @@ module Sorcery
           request_token_secret: session[:request_token_secret]
         }
 
-        args.merge!({ code: params[:code] }) if params[:code]
+        args[:code] = params[:code] if params[:code]
         get_access_token(args)
       end
-
     end
   end
 end

data/lib/sorcery/providers/vk.rb

@@ -7,10 +7,9 @@ module Sorcery
     #   ...
     #
     class Vk < Base
-
       include Protocols::Oauth2
 
-      attr_accessor :auth_path, :token_path, :user_info_url, :scope
+      attr_accessor :auth_path, :token_path, :user_info_url, :scope, :api_version
 
       def initialize
         super
@@ -29,15 +28,16 @@ module Sorcery
           access_token: access_token.token,
           uids:         access_token.params['user_id'],
           fields:       user_info_mapping.values.join(','),
-          scope:        scope
+          scope:        scope,
+          v:            api_version.to_s
         }
 
         response = access_token.get(user_info_url, params: params)
-        if user_hash[:user_info] = JSON.parse(response.body)
+        if (user_hash[:user_info] = JSON.parse(response.body))
           user_hash[:user_info] = user_hash[:user_info]['response'][0]
           user_hash[:user_info]['full_name'] = [user_hash[:user_info]['first_name'], user_hash[:user_info]['last_name']].join(' ')
 
-          user_hash[:uid] = user_hash[:user_info]['uid']
+          user_hash[:uid] = user_hash[:user_info]['id']
           user_hash[:user_info]['email'] = access_token.params['email']
         end
         user_hash
@@ -45,19 +45,18 @@ module Sorcery
 
       # calculates and returns the url to which the user should be redirected,
       # to get authenticated at the external provider's site.
-      def login_url(params, session)
-        self.authorize_url({ authorize_url: auth_path })
+      def login_url(_params, _session)
+        authorize_url(authorize_url: auth_path)
       end
 
       # tries to login the user from access token
-      def process_callback(params, session)
+      def process_callback(params, _session)
         args = {}.tap do |a|
           a[:code] = params[:code] if params[:code]
         end
 
         get_access_token(args, token_url: token_path, token_method: :post)
       end
-
     end
   end
 end