sorcery 0.8.1 → 0.9.1

data/lib/sorcery/adapters/mongo_mapper_adapter.rb

@@ -0,0 +1,110 @@
+module Sorcery
+  module Adapters
+    class MongoMapperAdapter < BaseAdapter
+      module Wrapper
+        extend ActiveSupport::Concern
+
+        included do
+          extend Sorcery::Model
+        end
+
+        def sorcery_adapter
+          @sorcery_adapter ||= Sorcery::Adapters::MongoMapperAdapter.new(self)
+        end
+
+        module ClassMethods
+          def sorcery_adapter
+            Sorcery::Adapters::MongoMapperAdapter.from(self)
+          end
+        end
+      end
+
+      def increment(attr)
+        @model[attr] ||= 0
+        @model[attr] += 1
+        @model.class.increment(@model.id, attr => 1)
+      end
+
+      def save(options = {})
+        if options.delete(:raise_on_failure) && options[:validate] != false
+          @model.save! options
+        else
+          @model.save options
+        end
+      end
+
+      def update_attributes(attrs)
+        @model.update_attributes(attrs)
+      end
+
+      class << self
+        def define_field(name, type, options={})
+          @klass.key name, type, options.slice(:default)
+        end
+
+        def define_callback(time, event, method_name, options={})
+          @klass.send "#{time}_#{event}", method_name, options.slice(:if)
+        end
+
+        def credential_regex(credential)
+          return { :$regex =>  /^#{Regexp.escape(credential)}$/i } if (@klass.sorcery_config.downcase_username_before_authenticating)
+          return credential
+        end
+
+        def find_by_credentials(credentials)
+          user = nil
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            user = @klass.where(attribute => credential_regex(credentials[0])).first
+            break if user
+          end
+          user
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          @klass.where(@user_config.provider_attribute_name => provider, @user_config.provider_uid_attribute_name => uid).first
+        end
+
+        def find_by_id(id)
+          @klass.find(id)
+        end
+
+        def find_by_username(username)
+          if @klass.sorcery_config.downcase_username_before_authenticating
+            username = username.downcase
+          end
+
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            result = @klass.where(attribute => username).first
+            return result if result
+          end
+        end
+
+        def find_by_activation_token(token)
+          @klass.where(@klass.sorcery_config.activation_token_attribute_name => token).first
+        end
+
+        def find_by_email(email)
+          @klass.where(@klass.sorcery_config.email_attribute_name => email).first
+        end
+
+        def find_by_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def transaction(&blk)
+          @klass.tap(&blk)
+        end
+
+        def find_by_sorcery_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def get_current_users
+          raise "this method is unavailable for MongoMapper"
+        end
+
+      end
+    end
+  end
+end

data/lib/sorcery/adapters/mongoid_adapter.rb

@@ -0,0 +1,97 @@
+module Sorcery
+  module Adapters
+    class MongoidAdapter < BaseAdapter
+      def increment(attr)
+        mongoid_4? ? @model.inc(attr => 1) : @model.inc(attr, 1)
+      end
+
+      def update_attributes(attrs)
+        attrs.each do |name, value|
+          attrs[name] = value.utc if value.is_a?(ActiveSupport::TimeWithZone)
+          @model.send(:"#{name}=", value)
+        end
+        @model.class.where(:_id => @model.id).update_all(attrs)
+      end
+
+      def update_attribute(name, value)
+        update_attributes(name => value)
+      end
+
+      def save(options = {})
+        mthd = options.delete(:raise_on_failure) ? :save! : :save
+        @model.send(mthd, options)
+      end
+
+      def mongoid_4?
+        Gem::Version.new(::Mongoid::VERSION) >= Gem::Version.new("4.0.0.alpha")
+      end
+
+      class << self
+
+        def define_field(name, type, options={})
+          @klass.field name, options.slice(:default).merge(type: type)
+        end
+
+        def define_callback(time, event, method_name, options={})
+          @klass.send "#{time}_#{event}", method_name, options.slice(:if)
+        end
+
+        def credential_regex(credential)
+          return { :$regex =>  /^#{Regexp.escape(credential)}$/i  } if (@klass.sorcery_config.downcase_username_before_authenticating)
+          credential
+        end
+
+        def find_by_credentials(credentials)
+          @klass.sorcery_config.username_attribute_names.each do |attribute|
+            @user = @klass.where(attribute => credential_regex(credentials[0])).first
+            break if @user
+          end
+          @user
+        end
+
+        def find_by_oauth_credentials(provider, uid)
+          @user_config ||= ::Sorcery::Controller::Config.user_class.to_s.constantize.sorcery_config
+          @klass.where(@user_config.provider_attribute_name => provider, @user_config.provider_uid_attribute_name => uid).first
+        end
+
+        def find_by_activation_token(token)
+          @klass.where(@klass.sorcery_config.activation_token_attribute_name => token).first
+        end
+
+        def find_by_remember_me_token(token)
+          @klass.where(@klass.sorcery_config.remember_me_token_attribute_name => token).first
+        end
+
+        def transaction(&blk)
+          tap(&blk)
+        end
+
+        def find_by_id(id)
+          @klass.find(id)
+        rescue ::Mongoid::Errors::DocumentNotFound
+          nil
+        end
+
+        def find_by_username(username)
+          query = @klass.sorcery_config.username_attribute_names.map {|name| {name => username}}
+          @klass.any_of(*query).first
+        end
+
+        def find_by_token(token_attr_name, token)
+          @klass.where(token_attr_name => token).first
+        end
+
+        def find_by_email(email)
+          @klass.where(@klass.sorcery_config.email_attribute_name => email).first
+        end
+
+        def get_current_users
+          config = @klass.sorcery_config
+          @klass.where(config.last_activity_at_attribute_name.ne => nil) \
+          .where("this.#{config.last_logout_at_attribute_name} == null || this.#{config.last_activity_at_attribute_name} > this.#{config.last_logout_at_attribute_name}") \
+          .where(config.last_activity_at_attribute_name.gt => config.activity_timeout.seconds.ago.utc).order_by([:_id,:asc])
+        end
+      end
+    end
+  end
+end

data/lib/sorcery/controller/config.rb

@@ -0,0 +1,65 @@
+module Sorcery
+  module Controller
+    module Config
+      class << self
+        attr_accessor :submodules,
+                      :user_class,                    # what class to use as the user class.
+                      :not_authenticated_action,      # what controller action to call for non-authenticated users.
+
+                      :save_return_to_url,            # when a non logged in user tries to enter a page that requires
+                                                      # login, save the URL he wanted to reach,
+                                                      # and send him there after login.
+
+                      :cookie_domain,                 # set domain option for cookies
+
+                      :login_sources,
+                      :after_login,
+                      :after_failed_login,
+                      :before_logout,
+                      :after_logout
+
+        def init!
+          @defaults = {
+            :@user_class                           => nil,
+            :@submodules                           => [],
+            :@not_authenticated_action             => :not_authenticated,
+            :@login_sources                        => [],
+            :@after_login                          => [],
+            :@after_failed_login                   => [],
+            :@before_logout                        => [],
+            :@after_logout                         => [],
+            :@save_return_to_url                   => true,
+            :@cookie_domain                        => nil
+          }
+        end
+
+        # Resets all configuration options to their default values.
+        def reset!
+          @defaults.each do |k,v|
+            instance_variable_set(k,v)
+          end
+        end
+
+        def update!
+          @defaults.each do |k,v|
+            instance_variable_set(k,v) if !instance_variable_defined?(k)
+          end
+        end
+
+        def user_config(&blk)
+          block_given? ? @user_config = blk : @user_config
+        end
+
+        def configure(&blk)
+          @configure_blk = blk
+        end
+
+        def configure!
+          @configure_blk.call(self) if @configure_blk
+        end
+      end
+      init!
+      reset!
+    end
+  end
+end

data/lib/sorcery/controller/submodules/activity_logging.rb

@@ -1,13 +1,13 @@
 module Sorcery
   module Controller
     module Submodules
-      # This submodule keeps track of events such as login, logout, 
+      # This submodule keeps track of events such as login, logout,
       # and last activity time, per user.
       # It helps in estimating which users are active now in the site.
-      # This cannot be determined absolutely because a user might be 
+      # This cannot be determined absolutely because a user might be
       # reading a page without clicking anything for a while.
-      # This is the controller part of the submodule, which adds hooks 
-      # to register user events, 
+      # This is the controller part of the submodule, which adds hooks
+      # to register user events,
       # and methods to collect active users data for use in the app.
       # see Socery::Model::Submodules::ActivityLogging for configuration
       # options.
@@ -19,55 +19,61 @@ module Sorcery
               attr_accessor :register_login_time
               attr_accessor :register_logout_time
               attr_accessor :register_last_activity_time
-            
+              attr_accessor :register_last_ip_address
+
               def merge_activity_logging_defaults!
                 @defaults.merge!(:@register_login_time         => true,
                                  :@register_logout_time        => true,
-                                 :@register_last_activity_time => true)
+                                 :@register_last_activity_time => true,
+                                 :@register_last_ip_address    => true
+                                 )
               end
             end
             merge_activity_logging_defaults!
           end
           Config.after_login    << :register_login_time_to_db
+          Config.after_login    << :register_last_ip_address
           Config.before_logout  << :register_logout_time_to_db
           base.after_filter :register_last_activity_time_to_db
         end
-        
+
         module InstanceMethods
           # Returns an array of the active users.
           def current_users
+            ActiveSupport::Deprecation.warn("Sorcery: `current_users` method is deprecated. Read more on Github: https://github.com/NoamB/sorcery/issues/602")
+
             user_class.current_users
-            # A possible patch here:
-            # we'll add the current_user to the users list if he's not in it
-            # (can happen when he was inactive for more than activity timeout):
-            #
-            #   users.unshift!(current_user) if logged_in? && users.find {|u| u.id == current_user.id}.nil?
-            #
-            # disadvantages: can hurt performance.
           end
-          
+
           protected
-          
+
           # registers last login time on every login.
           # This runs as a hook just after a successful login.
           def register_login_time_to_db(user, credentials)
             return unless Config.register_login_time
-            user.update_single_attribute(user.sorcery_config.last_login_at_attribute_name, Time.now.in_time_zone)
+            user.set_last_login_at(Time.now.in_time_zone)
           end
-          
+
           # registers last logout time on every logout.
           # This runs as a hook just before a logout.
           def register_logout_time_to_db(user)
             return unless Config.register_logout_time
-            user.update_single_attribute(user.sorcery_config.last_logout_at_attribute_name, Time.now.in_time_zone)
+            user.set_last_logout_at(Time.now.in_time_zone)
           end
-          
+
           # Updates last activity time on every request.
           # The only exception is logout - we do not update activity on logout
           def register_last_activity_time_to_db
             return unless Config.register_last_activity_time
             return unless logged_in?
-            current_user.update_single_attribute(current_user.sorcery_config.last_activity_at_attribute_name, Time.now.in_time_zone)
+            current_user.set_last_activity_at(Time.now.in_time_zone)
+          end
+
+          # Updates IP address on every login.
+          # This runs as a hook just after a successful login.
+          def register_last_ip_address(user, credentials)
+            return unless Config.register_last_ip_address
+            current_user.set_last_ip_addess(request.remote_ip)
           end
         end
       end

data/lib/sorcery/controller/submodules/brute_force_protection.rb

@@ -14,22 +14,22 @@ module Sorcery
           Config.after_login << :reset_failed_logins_count!
           Config.after_failed_login << :update_failed_logins_count!
         end
-        
+
         module InstanceMethods
-          
+
           protected
-          
+
           # Increments the failed logins counter on every failed login.
           # Runs as a hook after a failed login.
           def update_failed_logins_count!(credentials)
-            user = user_class.find_by_credentials(credentials)
+            user = user_class.sorcery_adapter.find_by_credentials(credentials)
             user.register_failed_login! if user
           end
-          
+
           # Resets the failed logins counter.
           # Runs as a hook after a successful login.
           def reset_failed_logins_count!(user, credentials)
-            user.update_many_attributes(user_class.sorcery_config.failed_logins_count_attribute_name => 0)
+            user.sorcery_adapter.update_attribute(user_class.sorcery_config.failed_logins_count_attribute_name, 0)
           end
         end
       end

data/lib/sorcery/controller/submodules/external.rb

@@ -2,25 +2,45 @@ module Sorcery
   module Controller
     module Submodules
       # This submodule helps you login users from external auth providers such as Twitter.
-      # This is the controller part which handles the http requests and tokens passed between the app and the provider.
+      # This is the controller part which handles the http requests and tokens passed between the app and the @provider.
       module External
         def self.included(base)
           base.send(:include, InstanceMethods)
+
+          require 'sorcery/providers/base'
+          require 'sorcery/providers/facebook'
+          require 'sorcery/providers/twitter'
+          require 'sorcery/providers/vk'
+          require 'sorcery/providers/linkedin'
+          require 'sorcery/providers/liveid'
+          require 'sorcery/providers/xing'
+          require 'sorcery/providers/github'
+          require 'sorcery/providers/heroku'
+          require 'sorcery/providers/google'
+          require 'sorcery/providers/jira'
+          require 'sorcery/providers/salesforce'
+
           Config.module_eval do
             class << self
-              attr_reader :external_providers                           # external providers like twitter.
-              attr_accessor :ca_file                                    # path to ca_file. By default use a internal ca-bundle.crt.
-
-              def merge_external_defaults!
-                @defaults.merge!(:@external_providers => [],
-                                 :@ca_file => File.join(File.expand_path(File.dirname(__FILE__)), 'external/protocols/certs/ca-bundle.crt'))
-              end
+              attr_reader :external_providers
+              attr_accessor :ca_file
 
               def external_providers=(providers)
-                providers.each do |provider|
-                  include Providers.const_get(provider.to_s.split("_").map {|p| p.capitalize}.join(""))
+                @external_providers = providers
+
+                providers.each do |name|
+                  class_eval <<-E
+                    def self.#{name}
+                      @#{name} ||= Sorcery::Providers.const_get('#{name}'.to_s.capitalize).new
+                    end
+                  E
                 end
               end
+
+              def merge_external_defaults!
+                @defaults.merge!(:@external_providers => [],
+                                 :@ca_file => File.join(File.expand_path(File.dirname(__FILE__)), '../../protocols/certs/ca-bundle.crt'))
+              end
             end
             merge_external_defaults!
           end
@@ -29,83 +49,111 @@ module Sorcery
         module InstanceMethods
           protected
 
-          # sends user to authenticate at the provider's website.
-          # after authentication the user is redirected to the callback defined in the provider config
-          def login_at(provider_name, args = {})
-            provider = Config.send(provider_name)
-            if provider.callback_url.present? && provider.callback_url[0] == '/'
+          # save the singleton ProviderClient instance into @provider
+          def sorcery_get_provider(provider_name)
+            return unless Config.external_providers.include?(provider_name.to_sym)
+            Config.send(provider_name.to_sym)
+          end
+
+          # get the login URL from the provider, if applicable.  Returns nil if the provider
+          # does not provide a login URL.  (as of v0.8.1 all providers provide a login URL)
+          def sorcery_login_url(provider_name, args = {})
+            @provider = sorcery_get_provider provider_name
+            sorcery_fixup_callback_url @provider
+            if @provider.respond_to?(:login_url) && @provider.has_callback?
+              @provider.state = args[:state]
+              return @provider.login_url(params, session)
+            else
+              return nil
+            end
+          end
+
+          # get the user hash from a provider using information from the params and session.
+          def sorcery_fetch_user_hash(provider_name)
+            # the application should never ask for user hashes from two different providers
+            # on the same request.  But if they do, we should be ready: on the second request,
+            # clear out the instance variables if the provider is different
+            provider = sorcery_get_provider provider_name
+            if @provider.nil? || @provider != provider
+              @provider = provider
+              @access_token = nil
+              @user_hash = nil
+            end
+
+            # delegate to the provider for the access token and the user hash.
+            # cache them in instance variables.
+            @access_token ||= @provider.process_callback(params, session) # sends request to oauth agent to get the token
+            @user_hash ||= @provider.get_user_hash(@access_token) # uses the token to send another request to the oauth agent requesting user info
+          end
+
+          # for backwards compatibility
+          def access_token(*args)
+            @access_token
+          end
+
+
+          # this method should be somewhere else.  It only does something once per application per provider.
+          def sorcery_fixup_callback_url(provider)
+            provider.original_callback_url ||= provider.callback_url
+            if provider.original_callback_url.present? && provider.original_callback_url[0] == '/'
               uri = URI.parse(request.url.gsub(/\?.*$/,''))
               uri.path = ''
               uri.query = nil
               uri.scheme = 'https' if(request.env['HTTP_X_FORWARDED_PROTO'] == 'https')
               host = uri.to_s
-              provider.callback_url = "#{host}#{provider.callback_url}"
-            end
-            if provider.has_callback?
-              redirect_to provider.login_url(params,session)
-            else
-              #provider.login(args)
+              provider.callback_url = "#{host}#{@provider.original_callback_url}"
             end
           end
 
+          # sends user to authenticate at the provider's website.
+          # after authentication the user is redirected to the callback defined in the provider config
+          def login_at(provider_name, args = {})
+            redirect_to sorcery_login_url(provider_name, args)
+          end
+
           # tries to login the user from provider's callback
-          def login_from(provider_name)
-            provider = Config.send(provider_name)
-            provider.process_callback(params,session)
-            user_hash = provider.get_user_hash
-            if user = user_class.load_from_provider(provider_name,user_hash[:uid].to_s)
+          def login_from(provider_name, should_remember = false)
+            sorcery_fetch_user_hash provider_name
+
+            if user = user_class.load_from_provider(provider_name, @user_hash[:uid].to_s)
+              # we found the user.
+              # clear the session
               return_to_url = session[:return_to_url]
-              reset_session
+              reset_sorcery_session
               session[:return_to_url] = return_to_url
-              auto_login(user)
+
+              # sign in the user
+              auto_login(user, should_remember)
               after_login!(user)
+
+              # return the user
               user
             end
           end
 
-          # get provider access account
-          def access_token(provider_name)
-            provider = Config.send(provider_name)
-            provider.access_token
-          end
-
           # If user is logged, he can add all available providers into his account
           def add_provider_to_user(provider_name)
-            provider_name = provider_name.to_sym
-            provider = Config.send(provider_name)
-            provider.process_callback(params,session)
-            user_hash = provider.get_user_hash
+            sorcery_fetch_user_hash provider_name
             config = user_class.sorcery_config
 
-            # first check to see if user has a particular authentication already
-            unless (current_user.send(config.authentications_class.to_s.downcase.pluralize).send("find_by_#{config.provider_attribute_name}_and_#{config.provider_uid_attribute_name}", provider_name, user_hash[:uid].to_s))
-              user = current_user.send(config.authentications_class.to_s.downcase.pluralize).build(config.provider_uid_attribute_name => user_hash[:uid], config.provider_attribute_name => provider_name.to_s)
-              user.save(:validate => false)
-            else
-              user = false
-            end
-
-            return user
+            current_user.add_provider_to_user(provider_name.to_s, @user_hash[:uid].to_s)
           end
 
           # Initialize new user from provider informations.
           # If a provider doesn't give required informations or username/email is already taken,
           # we store provider/user infos into a session and can be rendered into registration form
           def create_and_validate_from(provider_name)
-            provider_name = provider_name.to_sym
-            provider = Config.send(provider_name)
-            user_hash = provider.get_user_hash
+            sorcery_fetch_user_hash provider_name
             config = user_class.sorcery_config
 
-            attrs = user_attrs(provider.user_info_mapping, user_hash)
+            attrs = user_attrs(@provider.user_info_mapping, @user_hash)
 
-            user = user_class.new(attrs)
-            user.send(config.authentications_class.to_s.downcase.pluralize).build(config.provider_uid_attribute_name => user_hash[:uid], config.provider_attribute_name => provider_name)
+            user, saved = user_class.create_and_validate_from_provider(provider_name, @user_hash[:uid], attrs)
 
             session[:incomplete_user] = {
-              :provider => {config.provider_uid_attribute_name => user_hash[:uid], config.provider_attribute_name => provider_name},
+              :provider => {config.provider_uid_attribute_name => @user_hash[:uid], config.provider_attribute_name => provider_name},
               :user_hash => attrs
-            } unless user.save
+            } unless saved
 
             return user
           end
@@ -126,28 +174,12 @@ module Sorcery
           #
           #   create_from(provider) {|user| user.some_check }
           #
-          def create_from(provider_name)
-            provider_name = provider_name.to_sym
-            provider = Config.send(provider_name)
-            user_hash = provider.get_user_hash
+          def create_from(provider_name, &block)
+            sorcery_fetch_user_hash provider_name
             config = user_class.sorcery_config
 
-            attrs = user_attrs(provider.user_info_mapping, user_hash)
-
-            user_class.transaction do
-              @user = user_class.new()
-              attrs.each do |k,v|
-                @user.send(:"#{k}=", v)
-              end
-
-              if block_given?
-                return false unless yield @user
-              end
-
-              @user.save(:validate => false)
-              user_class.sorcery_config.authentications_class.create!({config.authentications_user_id_attribute_name => @user.id, config.provider_attribute_name => provider_name, config.provider_uid_attribute_name => user_hash[:uid]})
-            end
-            @user
+            attrs = user_attrs(@provider.user_info_mapping, @user_hash)
+            @user = user_class.create_from_provider(provider_name, @user_hash[:uid], attrs, &block)
           end
 
           def user_attrs(user_info_mapping, user_hash)

data/lib/sorcery/controller/submodules/remember_me.rb

@@ -31,14 +31,14 @@ module Sorcery
 
           # Clears the cookie and clears the token from the db.
           def forget_me!
-            @current_user.forget_me!
+            current_user.forget_me!
             cookies.delete(:remember_me_token, :domain => Config.cookie_domain)
           end
 
           # Override.
           # logins a user instance, and optionally remembers him.
           def auto_login(user, should_remember = false)
-            session[:user_id] = user.id
+            session[:user_id] = user.id.to_s
             @current_user = user
             remember_me! if should_remember
           end
@@ -55,10 +55,10 @@ module Sorcery
           # and logs the user in if found.
           # Runs as a login source. See 'current_user' method for how it is used.
           def login_from_cookie
-            user = cookies.signed[:remember_me_token] && user_class.find_by_remember_me_token(cookies.signed[:remember_me_token])
-            if user && user.remember_me_token?
+            user = cookies.signed[:remember_me_token] && user_class.sorcery_adapter.find_by_remember_me_token(cookies.signed[:remember_me_token])
+            if user && user.has_remember_me_token?
               set_remember_me_cookie!(user)
-              session[:user_id] = user.id
+              session[:user_id] = user.id.to_s
               @current_user = user
             else
               @current_user = false