sorcery 0.8.1 → 0.9.1

data/lib/sorcery/providers/heroku.rb

@@ -0,0 +1,57 @@
+module Sorcery
+  module Providers
+
+    # This class adds support for OAuth with heroku.com.
+
+    # config.heroku.key = <key>
+    # config.heroku.secret = <secret>
+    # config.heroku.callback_url = "<host>/oauth/callback?provider=heroku"
+    # config.heroku.scope = "read"
+    # config.heroku.user_info_mapping = {:email => "email", :name => "email" }
+
+    # NOTE:
+    # The full path must be set for OAuth Callback URL when configuring the API Client Information on Heroku.
+
+    class Heroku < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_path, :scope, :token_url, :user_info_path
+
+      def initialize
+        super
+
+        @scope          = nil
+        @site           = 'https://id.heroku.com'
+        @user_info_path = 'https://api.heroku.com/account'
+        @auth_path      = '/oauth/authorize'
+        @token_url      = '/oauth/token'
+        @user_info_path = '/account'
+        @state          = SecureRandom.hex(16)
+      end
+
+      def get_user_hash(access_token)
+        response = access_token.get(user_info_path)
+        body = JSON.parse(response.body)
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = body
+          h[:uid] = body['id'].to_s
+          h[:email] = body['email'].to_s
+        end
+      end
+
+      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)
+        raise "Invalid state. Potential Cross Site Forgery" if params[:state] != state
+        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/jira.rb

@@ -0,0 +1,77 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Jira
+    #
+    #   config.jira.key = <key>
+    #   config.jira.secret = <secret>
+    #   ...
+    #
+    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'
+        }
+        @user_info_path = '/users/me'
+      end
+
+      # Override included get_consumer method to provide authorize_path
+      #read extra configurations
+      def get_consumer
+        @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
+
+      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)['users'].first
+          h[:uid] = user_hash[:user_info]['id'].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)
+        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
+
+        get_request_token(
+          session[:request_token],
+          session[:request_token_secret]
+        ).authorize_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]
+        }
+
+        args.merge!({ code: params[:code] }) if params[:code]
+        get_access_token(args)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/linkedin.rb

@@ -0,0 +1,66 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Linkedin.com.
+    #
+    #   config.linkedin.key = <key>
+    #   config.linkedin.secret = <secret>
+    #   ...
+    #
+    class Linkedin < Base
+
+      include Protocols::Oauth
+
+      attr_accessor :authorize_path, :access_permissions, :access_token_path,
+                    :request_token_path, :user_info_fields, :user_info_path
+
+      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
+
+      # 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)
+      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')
+
+        auth_hash(access_token).tap do |h|
+          h[:user_info] = JSON.parse(response.body)
+          h[:uid] = h[:user_info]['id'].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)
+        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 })
+      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]
+        }
+
+        args.merge!({ code: params[:code] }) if params[:code]
+        get_access_token(args)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/liveid.rb

@@ -0,0 +1,53 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with microsoft liveid.
+    #
+    #   config.liveid.key = <key>
+    #   config.liveid.secret = <secret>
+    #   ...
+    #
+    class Liveid < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_url, :token_path, :user_info_url, :scope
+
+      def initialize
+        super
+
+        @site           = 'https://oauth.live.com/'
+        @auth_url       = '/authorize'
+        @token_path     = '/token'
+        @user_info_url  = 'https://apis.live.net/v5.0/me'
+        @scope          = 'wl.basic wl.emails wl.offline_access'
+      end
+
+      def get_user_hash(access_token)
+        access_token.token_param = '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)
+        self.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, access_token_path: token_path,
+          access_token_method: :post)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/salesforce.rb

@@ -0,0 +1,50 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with salesforce.com.
+    #
+    #   config.salesforce.key = <key>
+    #   config.salesforce.secret = <secret>
+    #   ...
+    #
+    class Salesforce < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_url, :token_url, :scope
+
+      def initialize
+        super
+
+        @site          = 'https://login.salesforce.com'
+        @auth_url      = '/services/oauth2/authorize'
+        @token_url     = '/services/oauth2/token'
+      end
+
+      def get_user_hash(access_token)
+        user_info_url = access_token.params['id']
+        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]['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_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/twitter.rb

@@ -0,0 +1,59 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with Twitter.com.
+    #
+    #   config.twitter.key = <key>
+    #   config.twitter.secret = <secret>
+    #   ...
+    #
+    class Twitter < Base
+
+      include Protocols::Oauth
+
+      attr_accessor :state, :user_info_path
+
+      def initialize
+        super
+
+        @site           = 'https://api.twitter.com'
+        @user_info_path = '/1.1/account/verify_credentials.json'
+      end
+
+      # Override included get_consumer method to provide authorize_path
+      def get_consumer
+        ::OAuth::Consumer.new(@key, secret, site: site, authorize_path: '/oauth/authenticate')
+      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]['id'].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)
+        req_token = self.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 })
+      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]
+        }
+
+        args.merge!({ code: params[:code] }) if params[:code]
+        get_access_token(args)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/vk.rb

@@ -0,0 +1,63 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with vk.com.
+    #
+    #   config.vk.key = <key>
+    #   config.vk.secret = <secret>
+    #   ...
+    #
+    class Vk < Base
+
+      include Protocols::Oauth2
+
+      attr_accessor :auth_path, :token_path, :user_info_url, :scope
+
+      def initialize
+        super
+
+        @site           = 'https://oauth.vk.com/'
+        @user_info_url  = 'https://api.vk.com/method/getProfiles'
+        @auth_path      = '/authorize'
+        @token_path     = '/access_token'
+        @scope          = 'email'
+      end
+
+      def get_user_hash(access_token)
+        user_hash = auth_hash(access_token)
+
+        params = {
+          access_token: access_token.token,
+          uids:         access_token.params['user_id'],
+          fields:       user_info_mapping.values.join(','),
+          scope:        scope
+        }
+
+        response = access_token.get(user_info_url, params: params)
+        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[:user_info]['email'] = access_token.params['email']
+        end
+        user_hash
+      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)
+        self.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_path, token_method: :post)
+      end
+
+    end
+  end
+end

data/lib/sorcery/providers/xing.rb

@@ -0,0 +1,64 @@
+module Sorcery
+  module Providers
+    # This class adds support for OAuth with xing.com.
+    #
+    #   config.xing.key = <key>
+    #   config.xing.secret = <secret>
+    #   ...
+    #
+    class Xing < Base
+
+      include Protocols::Oauth
+
+      attr_accessor :access_token_path, :authorize_path, :request_token_path,
+                    :user_info_path
+
+
+      def initialize
+        @configuration = {
+            site: 'https://api.xing.com/v1',
+            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
+      def get_consumer
+        ::OAuth::Consumer.new(@key, @secret, @configuration)
+      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)['users'].first
+          h[:uid] = h[:user_info]['id'].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)
+        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 })
+      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]
+        }
+
+        args.merge!({ code: params[:code] }) if params[:code]
+        get_access_token(args)
+      end
+
+    end
+  end
+end

data/lib/sorcery/railties/tasks.rake

@@ -1,12 +1,6 @@
-require 'fileutils'
-
 namespace :sorcery do
   desc "Adds sorcery's initializer file"
   task :bootstrap do
     warn "This task is obsolete.\nUse \"rails g sorcery:install\" now.\nSee README for more information."
-
-    src = File.join(File.dirname(__FILE__), '..', 'initializers', 'initializer.rb')
-    target = File.join(Rails.root, "config", "initializers", "sorcery.rb")
-    FileUtils.cp(src, target)
   end
-end
+end

data/lib/sorcery/test_helpers/internal/rails.rb

@@ -2,17 +2,17 @@ module Sorcery
   module TestHelpers
     module Internal
       module Rails
-        include ::Sorcery::TestHelpers::Rails
+        include ::Sorcery::TestHelpers::Rails::Controller
 
-        SUBMODUELS_AUTO_ADDED_CONTROLLER_FILTERS = [
-          :register_last_activity_time_to_db, 
-          :deny_banned_user, 
+        SUBMODULES_AUTO_ADDED_CONTROLLER_FILTERS = [
+          :register_last_activity_time_to_db,
+          :deny_banned_user,
           :validate_session
         ]
 
         def sorcery_reload!(submodules = [], options = {})
           reload_user_class
-          
+
           # return to no-module configuration
           ::Sorcery::Controller::Config.init!
           ::Sorcery::Controller::Config.reset!
@@ -20,7 +20,13 @@ module Sorcery
           # remove all plugin before_filters so they won't fail other tests.
           # I don't like this way, but I didn't find another.
           # hopefully it won't break until Rails 4.
-          ApplicationController._process_action_callbacks.delete_if {|c| SUBMODUELS_AUTO_ADDED_CONTROLLER_FILTERS.include?(c.filter) }
+          chain = if Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new("4.1.0")
+                    SorceryController._process_action_callbacks.send :chain
+                  else
+                    SorceryController._process_action_callbacks
+                  end
+
+          chain.delete_if {|c| SUBMODULES_AUTO_ADDED_CONTROLLER_FILTERS.include?(c.filter) }
 
           # configure
           ::Sorcery::Controller::Config.submodules = submodules
@@ -34,6 +40,11 @@ module Sorcery
             end
           end
           User.authenticates_with_sorcery!
+          if defined?(DataMapper) and User.ancestors.include?(DataMapper::Resource)
+            DataMapper.auto_migrate!
+            User.finalize
+            Authentication.finalize
+          end
         end
 
         def sorcery_controller_property_set(property, value)

data/lib/sorcery/test_helpers/internal.rb

@@ -15,7 +15,7 @@ module Sorcery
       end
 
       # a patch to fix a bug in testing that happens when you 'destroy' a session twice.
-      # After the first destroy, the session is an ordinary hash, and then when destroy 
+      # After the first destroy, the session is an ordinary hash, and then when destroy
       # is called again there's an exception.
       class ::Hash
         def destroy
@@ -23,35 +23,56 @@ module Sorcery
         end
       end
 
-      def create_new_user(attributes_hash = nil)
+      def build_new_user(attributes_hash = nil)
         user_attributes_hash = attributes_hash || {:username => 'gizmo', :email => "bla@bla.com", :password => 'secret'}
         @user = User.new(user_attributes_hash)
-        @user.save!
+      end
+
+      def create_new_user(attributes_hash = nil)
+        @user = build_new_user(attributes_hash)
+        @user.sorcery_adapter.save(:raise_on_failure => true)
         @user
       end
 
       def create_new_external_user(provider, attributes_hash = nil)
         user_attributes_hash = attributes_hash || {:username => 'gizmo'}
         @user = User.new(user_attributes_hash)
-        @user.save!
+        @user.sorcery_adapter.save(:raise_on_failure => true)
         @user.authentications.create!({:provider => provider, :uid => 123})
         @user
       end
 
+      def custom_create_new_external_user(provider, authentication_class, attributes_hash = nil)
+        authentication_association = authentication_class.name.underscore.pluralize
+
+        user_attributes_hash = attributes_hash || {:username => 'gizmo'}
+        @user = User.new(user_attributes_hash)
+        @user.sorcery_adapter.save(:raise_on_failure => true)
+        @user.send(authentication_association).create!({:provider => provider, :uid => 123})
+        @user
+      end
+
       def sorcery_model_property_set(property, *values)
         User.class_eval do
           sorcery_config.send(:"#{property}=", *values)
         end
       end
 
+      def update_model(&block)
+        User.class_exec(&block)
+      end
+
       private
 
       # reload user class between specs
       # so it will be possible to test the different submodules in isolation
       def reload_user_class
-        Object.send(:remove_const,:User)
+        Object.send(:remove_const, "User")
         load 'user.rb'
+        if User.respond_to?(:reset_column_information)
+          User.reset_column_information
+        end
       end
     end
   end
-end
+end

data/lib/sorcery/test_helpers/rails/controller.rb

@@ -0,0 +1,21 @@
+module Sorcery
+  module TestHelpers
+    module Rails
+      module Controller
+        def login_user(user = nil, test_context = {})
+          user ||= @user
+          @controller.send(:auto_login, user)
+          @controller.send(:after_login!, user, [user.send(user.sorcery_config.username_attribute_names.first), 'secret'])
+        end
+
+        def logout_user
+          @controller.send(:logout)
+        end
+
+        def logged_in?
+          @controller.send(:logged_in?)
+        end
+      end
+    end
+  end
+end

data/lib/sorcery/test_helpers/rails/integration.rb

@@ -0,0 +1,26 @@
+module Sorcery
+  module TestHelpers
+    module Rails
+      module Integration
+        
+        #Accepts arguments for user to login, route to use and HTTP method
+        #Defaults - @user, 'sessions_url' and POST
+        def login_user(user = nil, route = nil, http_method = :post)
+          user ||= @user
+          route ||= sessions_url
+
+          username_attr = user.sorcery_config.username_attribute_names.first
+          username = user.send(username_attr)
+          page.driver.send(http_method, route, { :"#{username_attr}" => username, :password => 'secret' })
+        end
+
+        #Accepts route and HTTP method arguments
+        #Default - 'logout_url' and GET
+        def logout_user(route = nil, http_method = :get)
+          route ||= logout_url
+          page.driver.send(http_method, route)
+        end
+      end
+    end
+  end
+end

data/lib/sorcery/version.rb

@@ -0,0 +1,3 @@
+module Sorcery
+  VERSION = "0.9.1"
+end