sorcery 0.8.0 → 0.9.0

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

@@ -1,18 +1,18 @@
 module Sorcery
   module Model
     module Submodules
-      # This module helps protect user accounts by locking them down after too many failed attemps 
+      # This module helps protect user accounts by locking them down after too many failed attemps
       # to login were detected.
-      # This is the model part of the submodule which provides configuration options and methods 
+      # This is the model part of the submodule which provides configuration options and methods
       # for locking and unlocking the user.
       module BruteForceProtection
         def self.included(base)
           base.sorcery_config.class_eval do
             attr_accessor :failed_logins_count_attribute_name,        # failed logins attribute name.
-                          :lock_expires_at_attribute_name,            # this field indicates whether user 
+                          :lock_expires_at_attribute_name,            # this field indicates whether user
                                                                       # is banned and when it will be active again.
                           :consecutive_login_retries_amount_limit,    # how many failed logins allowed.
-                          :login_lock_time_period,                    # how long the user should be banned. 
+                          :login_lock_time_period,                    # how long the user should be banned.
                                                                       # in seconds. 0 for permanent.
 
                           :unlock_token_attribute_name,               # Unlock token attribute name
@@ -20,7 +20,7 @@ module Sorcery
                           :unlock_token_mailer_disabled,              # When true, dont send unlock token via email
                           :unlock_token_mailer                        # Mailer class
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@failed_logins_count_attribute_name              => :failed_logins_count,
                              :@lock_expires_at_attribute_name                  => :lock_expires_at,
@@ -33,82 +33,82 @@ module Sorcery
                              :@unlock_token_mailer                             => nil)
             reset!
           end
-          
+
           base.sorcery_config.before_authenticate << :prevent_locked_user_login
-          base.sorcery_config.after_config << :define_brute_force_protection_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_brute_force_protection_mongo_mapper_fields
-          end
+          base.sorcery_config.after_config << :define_brute_force_protection_fields
           base.extend(ClassMethods)
           base.send(:include, InstanceMethods)
         end
-        
+
         module ClassMethods
           def load_from_unlock_token(token)
             return nil if token.blank?
-            user = find_by_sorcery_token(sorcery_config.unlock_token_attribute_name,token)
+            user = sorcery_adapter.find_by_token(sorcery_config.unlock_token_attribute_name,token)
             user
           end
 
           protected
 
-          def define_brute_force_protection_mongoid_fields
-            field sorcery_config.failed_logins_count_attribute_name,  :type => Integer, :default => 0
-            field sorcery_config.lock_expires_at_attribute_name,      :type => Time
-            field sorcery_config.unlock_token_attribute_name,         :type => String
-          end
-
-          def define_brute_force_protection_mongo_mapper_fields
-            key sorcery_config.failed_logins_count_attribute_name, Integer, :default => 0
-            key sorcery_config.lock_expires_at_attribute_name, Time
-            key sorcery_config.unlock_token_attribute_name, String
+          def define_brute_force_protection_fields
+            sorcery_adapter.define_field sorcery_config.failed_logins_count_attribute_name, Integer, :default => 0
+            sorcery_adapter.define_field sorcery_config.lock_expires_at_attribute_name, Time
+            sorcery_adapter.define_field sorcery_config.unlock_token_attribute_name, String
           end
         end
-        
+
         module InstanceMethods
           # Called by the controller to increment the failed logins counter.
           # Calls 'lock!' if login retries limit was reached.
           def register_failed_login!
             config = sorcery_config
             return if !unlocked?
-            self.increment(config.failed_logins_count_attribute_name)
-            self.update_many_attributes(config.failed_logins_count_attribute_name => self.send(config.failed_logins_count_attribute_name))
-            self.lock! if self.send(config.failed_logins_count_attribute_name) >= config.consecutive_login_retries_amount_limit
+
+            sorcery_adapter.increment(config.failed_logins_count_attribute_name)
+
+            if self.send(config.failed_logins_count_attribute_name) >= config.consecutive_login_retries_amount_limit
+              lock!
+            end
           end
-          
+
           # /!\
           # Moved out of protected for use like activate! in controller
           # /!\
           def unlock!
             config = sorcery_config
             attributes = {config.lock_expires_at_attribute_name => nil,
-                          config.failed_logins_count_attribute_name => 0}
-            attributes[config.unlock_token_attribute_name] = nil unless config.unlock_token_mailer_disabled or config.unlock_token_mailer.nil?
-            self.update_many_attributes(attributes)
+                          config.failed_logins_count_attribute_name => 0,
+                          config.unlock_token_attribute_name => nil}
+            sorcery_adapter.update_attributes(attributes)
+          end
+
+          def locked?
+            !unlocked?
           end
 
           protected
 
           def lock!
             config = sorcery_config
-            attributes = {config.lock_expires_at_attribute_name => Time.now.in_time_zone + config.login_lock_time_period}
+            attributes = {config.lock_expires_at_attribute_name => Time.now.in_time_zone + config.login_lock_time_period,
+                          config.unlock_token_attribute_name => TemporaryToken.generate_random_token}
+            sorcery_adapter.update_attributes(attributes)
 
             unless config.unlock_token_mailer_disabled || config.unlock_token_mailer.nil?
-              attributes[config.unlock_token_attribute_name] = TemporaryToken.generate_random_token
               send_unlock_token_email!
             end
-            self.update_many_attributes(attributes)
           end
-          
+
           def unlocked?
             config = sorcery_config
             self.send(config.lock_expires_at_attribute_name).nil?
           end
 
           def send_unlock_token_email!
-            generic_send_email(:unlock_token_email_method_name, :unlock_token_mailer) unless sorcery_config.unlock_token_email_method_name.nil? or sorcery_config.unlock_token_mailer_disabled == true
+            return if sorcery_config.unlock_token_email_method_name.nil?
+
+            generic_send_email(:unlock_token_email_method_name, :unlock_token_mailer)
           end
-          
+
           # Prevents a locked user from logging in, and unlocks users that expired their lock time.
           # Runs as a hook before authenticate.
           def prevent_locked_user_login

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

@@ -8,7 +8,7 @@ module Sorcery
       # Socery assumes (read: requires) you will create external users in the same table where
       # you keep your regular users,
       # but that you will have a separate table for keeping their external authentication data,
-      # and that that separate table has a few rows for each user, facebook and twitter 
+      # and that that separate table has a few rows for each user, facebook and twitter
       # for example (a one-to-many relationship).
       #
       # External users will have a null crypted_password field, since we do not hold their password.
@@ -22,7 +22,7 @@ module Sorcery
                           :provider_uid_attribute_name
 
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@authentications_class                  => nil,
                              :@authentications_user_id_attribute_name => :user_id,
@@ -31,26 +31,70 @@ module Sorcery
 
             reset!
           end
-          
+
           base.send(:include, InstanceMethods)
           base.extend(ClassMethods)
 
         end
-        
+
         module ClassMethods
           # takes a provider and uid and finds a user by them.
           def load_from_provider(provider,uid)
             config = sorcery_config
-            authentication = config.authentications_class.find_by_provider_and_uid(provider, uid)
-            user = find(authentication.send(config.authentications_user_id_attribute_name)) if authentication
+            authentication = config.authentications_class.sorcery_adapter.find_by_oauth_credentials(provider, uid)
+            user = sorcery_adapter.find_by_id(authentication.send(config.authentications_user_id_attribute_name)) if authentication
+          end
+
+          def create_and_validate_from_provider(provider, uid, attrs)
+            user = new(attrs)
+            user.send(sorcery_config.authentications_class.to_s.downcase.pluralize).build(
+              sorcery_config.provider_uid_attribute_name => uid,
+              sorcery_config.provider_attribute_name => provider
+            )
+            saved = user.sorcery_adapter.save
+            [user, saved]
+          end
+
+          def create_from_provider(provider, uid, attrs)
+            user = new
+            attrs.each do |k,v|
+              user.send(:"#{k}=", v)
+            end
+
+            if block_given?
+              return false unless yield user
+            end
+
+            sorcery_adapter.transaction do
+              user.sorcery_adapter.save(:validate => false)
+              sorcery_config.authentications_class.create!(
+                sorcery_config.authentications_user_id_attribute_name => user.id,
+                sorcery_config.provider_attribute_name => provider,
+                sorcery_config.provider_uid_attribute_name => uid
+              )
+            end
+            user
           end
         end
-        
+
         module InstanceMethods
+          def add_provider_to_user(provider, uid)
+            authentications = sorcery_config.authentications_class.name.underscore.pluralize
+            # first check to see if user has a particular authentication already
+            if sorcery_adapter.find_authentication_by_oauth_credentials(authentications, provider, uid).nil?
+              user = send(authentications).build(sorcery_config.provider_uid_attribute_name => uid,
+                                                 sorcery_config.provider_attribute_name => provider)
+              user.sorcery_adapter.save(validate: false)
+            else
+              user = false
+            end
+
+            user
+          end
 
         end
-      
+
       end
     end
   end
-end
+end

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

@@ -1,7 +1,7 @@
 module Sorcery
   module Model
     module Submodules
-      # The Remember Me submodule takes care of setting the user's cookie so that he will 
+      # The Remember Me submodule takes care of setting the user's cookie so that he will
       # be automatically logged in to the site on every visit,
       # until the cookie expires.
       module RememberMe
@@ -12,7 +12,7 @@ module Sorcery
                           :remember_me_for                                # how long in seconds to remember.
 
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@remember_me_token_attribute_name            => :remember_me_token,
                              :@remember_me_token_expires_at_attribute_name => :remember_me_token_expires_at,
@@ -20,47 +20,43 @@ module Sorcery
 
             reset!
           end
-          
+
           base.send(:include, InstanceMethods)
+          base.sorcery_config.after_config << :define_remember_me_fields
 
-          base.sorcery_config.after_config << :define_remember_me_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_remember_me_mongo_mapper_fields
-          end
-          
           base.extend(ClassMethods)
         end
 
         module ClassMethods
           protected
 
-          def define_remember_me_mongoid_fields
-            field sorcery_config.remember_me_token_attribute_name,            :type => String
-            field sorcery_config.remember_me_token_expires_at_attribute_name, :type => Time
+          def define_remember_me_fields
+            sorcery_adapter.define_field sorcery_config.remember_me_token_attribute_name, String
+            sorcery_adapter.define_field sorcery_config.remember_me_token_expires_at_attribute_name, Time
           end
 
-          def define_remember_me_mongo_mapper_fields
-            key sorcery_config.remember_me_token_attribute_name, String
-            key sorcery_config.remember_me_token_expires_at_attribute_name, Time
-          end
         end
 
         module InstanceMethods
           # You shouldn't really use this one yourself - it's called by the controller's 'remember_me!' method.
           def remember_me!
             config = sorcery_config
-            self.update_many_attributes(config.remember_me_token_attribute_name => TemporaryToken.generate_random_token,
+            self.sorcery_adapter.update_attributes(config.remember_me_token_attribute_name => TemporaryToken.generate_random_token,
                                         config.remember_me_token_expires_at_attribute_name => Time.now.in_time_zone + config.remember_me_for)
           end
-          
+
+          def has_remember_me_token?
+            self.send(sorcery_config.remember_me_token_attribute_name).present?
+          end
+
           # You shouldn't really use this one yourself - it's called by the controller's 'forget_me!' method.
           def forget_me!
             config = sorcery_config
-            self.update_many_attributes(config.remember_me_token_attribute_name => nil,
+            self.sorcery_adapter.update_attributes(config.remember_me_token_attribute_name => nil,
                                         config.remember_me_token_expires_at_attribute_name => nil)
           end
         end
       end
     end
   end
-end
+end

data/lib/sorcery/model/submodules/reset_password.rb

@@ -9,14 +9,14 @@ module Sorcery
       # he will be able to reset his password via a form.
       #
       # When using this submodule, supplying a mailer is mandatory.
-      module ResetPassword       
+      module ResetPassword
         def self.included(base)
           base.sorcery_config.class_eval do
             attr_accessor :reset_password_token_attribute_name,              # reset password code attribute name.
                           :reset_password_token_expires_at_attribute_name,   # expires at attribute name.
                           :reset_password_email_sent_at_attribute_name,      # when was email sent, used for hammering
                                                                              # protection.
-                                                                             
+
                           :reset_password_mailer,                            # mailer class. Needed.
 
                           :reset_password_mailer_disabled,                   # when true sorcery will not automatically
@@ -25,15 +25,15 @@ module Sorcery
 
                           :reset_password_email_method_name,                 # reset password email method on your
                                                                              # mailer class.
-                                                                             
+
                           :reset_password_expiration_period,                 # how many seconds before the reset request
                                                                              # expires. nil for never expires.
-                                                                             
+
                           :reset_password_time_between_emails                # hammering protection, how long to wait
                                                                              # before allowing another email to be sent.
 
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@reset_password_token_attribute_name            => :reset_password_token,
                              :@reset_password_token_expires_at_attribute_name => :reset_password_token_expires_at,
@@ -50,15 +50,12 @@ module Sorcery
           base.extend(ClassMethods)
 
           base.sorcery_config.after_config << :validate_mailer_defined
-          base.sorcery_config.after_config << :define_reset_password_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_reset_password_mongo_mapper_fields
-          end
+          base.sorcery_config.after_config << :define_reset_password_fields
 
           base.send(:include, InstanceMethods)
 
         end
-        
+
         module ClassMethods
           # Find user by token, also checks for expiration.
           # Returns the user if token found and is valid.
@@ -67,9 +64,9 @@ module Sorcery
             token_expiration_date_attr = @sorcery_config.reset_password_token_expires_at_attribute_name
             load_from_token(token, token_attr_name, token_expiration_date_attr)
           end
-          
+
           protected
-          
+
           # This submodule requires the developer to define his own mailer class to be used by it
           # when reset_password_mailer_disabled is false
           def validate_mailer_defined
@@ -77,43 +74,49 @@ module Sorcery
             raise ArgumentError, msg if @sorcery_config.reset_password_mailer == nil and @sorcery_config.reset_password_mailer_disabled == false
           end
 
-          def define_reset_password_mongoid_fields
-            field sorcery_config.reset_password_token_attribute_name,             :type => String
-            field sorcery_config.reset_password_token_expires_at_attribute_name,  :type => Time
-            field sorcery_config.reset_password_email_sent_at_attribute_name,     :type => Time
-          end
-          
-          def define_reset_password_mongo_mapper_fields
-            key sorcery_config.reset_password_token_attribute_name, String
-            key sorcery_config.reset_password_token_expires_at_attribute_name, Time
-            key sorcery_config.reset_password_email_sent_at_attribute_name, Time
+          def define_reset_password_fields
+            sorcery_adapter.define_field sorcery_config.reset_password_token_attribute_name, String
+            sorcery_adapter.define_field sorcery_config.reset_password_token_expires_at_attribute_name, Time
+            sorcery_adapter.define_field sorcery_config.reset_password_email_sent_at_attribute_name, Time
           end
+
         end
-        
+
         module InstanceMethods
-          # generates a reset code with expiration and sends an email to the user.
-          def deliver_reset_password_instructions!
+          # generates a reset code with expiration
+          def generate_reset_password_token!
             config = sorcery_config
-            # hammering protection
-            return false if config.reset_password_time_between_emails && self.send(config.reset_password_email_sent_at_attribute_name) && self.send(config.reset_password_email_sent_at_attribute_name) > config.reset_password_time_between_emails.ago.utc
             attributes = {config.reset_password_token_attribute_name => TemporaryToken.generate_random_token,
                           config.reset_password_email_sent_at_attribute_name => Time.now.in_time_zone}
             attributes[config.reset_password_token_expires_at_attribute_name] = Time.now.in_time_zone + config.reset_password_expiration_period if config.reset_password_expiration_period
-            self.class.transaction do
-              self.update_many_attributes(attributes)
-              generic_send_email(:reset_password_email_method_name, :reset_password_mailer) unless config.reset_password_mailer_disabled
+
+            self.sorcery_adapter.update_attributes(attributes)
+          end
+
+          # generates a reset code with expiration and sends an email to the user.
+          def deliver_reset_password_instructions!
+            config = sorcery_config
+            # hammering protection
+            return false if config.reset_password_time_between_emails.present? && self.send(config.reset_password_email_sent_at_attribute_name) && self.send(config.reset_password_email_sent_at_attribute_name) > config.reset_password_time_between_emails.seconds.ago.utc
+            self.class.sorcery_adapter.transaction do
+              generate_reset_password_token!
+              send_reset_password_email! unless config.reset_password_mailer_disabled
             end
           end
-          
+
           # Clears token and tries to update the new password for the user.
           def change_password!(new_password)
             clear_reset_password_token
             self.send(:"#{sorcery_config.password_attribute_name}=", new_password)
-            save
+            sorcery_adapter.save
           end
 
           protected
 
+          def send_reset_password_email!
+            generic_send_email(:reset_password_email_method_name, :reset_password_mailer)
+          end
+
           # Clears the token.
           def clear_reset_password_token
             config = sorcery_config
@@ -121,7 +124,7 @@ module Sorcery
             self.send(:"#{config.reset_password_token_expires_at_attribute_name}=", nil) if config.reset_password_expiration_period
           end
         end
-        
+
       end
     end
   end

data/lib/sorcery/model/submodules/user_activation.rb

@@ -10,16 +10,16 @@ module Sorcery
           base.sorcery_config.class_eval do
             attr_accessor :activation_state_attribute_name,               # the attribute name to hold activation state
                                                                           # (active/pending).
-                                                                          
+
                           :activation_token_attribute_name,               # the attribute name to hold activation code
                                                                           # (sent by email).
-                                                                          
+
                           :activation_token_expires_at_attribute_name,    # the attribute name to hold activation code
-                                                                          # expiration date. 
-                                                                          
+                                                                          # expiration date.
+
                           :activation_token_expiration_period,            # how many seconds before the activation code
                                                                           # expires. nil for never expires.
-                                                                          
+
                           :user_activation_mailer,                        # your mailer class. Required when
                                                                           # activation_mailer_disabled == false.
 
@@ -29,14 +29,14 @@ module Sorcery
 
                           :activation_needed_email_method_name,           # activation needed email method on your
                                                                           # mailer class.
-                                                                          
+
                           :activation_success_email_method_name,          # activation success email method on your
                                                                           # mailer class.
-                                                                          
+
                           :prevent_non_active_users_to_login              # do you want to prevent or allow users that
                                                                           # did not activate by email to login?
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@activation_state_attribute_name             => :activation_state,
                              :@activation_token_attribute_name             => :activation_token,
@@ -49,27 +49,24 @@ module Sorcery
                              :@prevent_non_active_users_to_login           => true)
             reset!
           end
-          
+
           base.class_eval do
             # don't setup activation if no password supplied - this user is created automatically
-            before_create :setup_activation, :if => Proc.new { |user| user.send(sorcery_config.password_attribute_name).present? }
+            sorcery_adapter.define_callback :before, :create, :setup_activation, :if => Proc.new { |user| user.send(sorcery_config.password_attribute_name).present? }
             # don't send activation needed email if no crypted password created - this user is external (OAuth etc.)
-            after_create  :send_activation_needed_email!, :if => Proc.new { |user| !user.external? }
+            sorcery_adapter.define_callback :after, :create, :send_activation_needed_email!, :if => :send_activation_needed_email?
           end
-          
+
           base.sorcery_config.after_config << :validate_mailer_defined
-          base.sorcery_config.after_config << :define_user_activation_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(MongoMapper) and base.ancestors.include?(MongoMapper::Document)
-            base.sorcery_config.after_config << :define_user_activation_mongo_mapper_fields
-          end
+          base.sorcery_config.after_config << :define_user_activation_fields
           base.sorcery_config.before_authenticate << :prevent_non_active_login
-          
+
           base.extend(ClassMethods)
           base.send(:include, InstanceMethods)
 
 
         end
-        
+
         module ClassMethods
           # Find user by token, also checks for expiration.
           # Returns the user if token found and is valid.
@@ -78,9 +75,9 @@ module Sorcery
             token_expiration_date_attr = @sorcery_config.activation_token_expires_at_attribute_name
             load_from_token(token, token_attr_name, token_expiration_date_attr)
           end
-          
+
           protected
-          
+
           # This submodule requires the developer to define his own mailer class to be used by it
           # when activation_mailer_disabled is false
           def validate_mailer_defined
@@ -88,35 +85,16 @@ module Sorcery
             raise ArgumentError, msg if @sorcery_config.user_activation_mailer == nil and @sorcery_config.activation_mailer_disabled == false
           end
 
-          def define_user_activation_mongoid_fields
-            self.class_eval do
-              field sorcery_config.activation_state_attribute_name,            :type => String
-              field sorcery_config.activation_token_attribute_name,            :type => String
-              field sorcery_config.activation_token_expires_at_attribute_name, :type => Time
-            end
-          end
-
-          def define_user_activation_mongo_mapper_fields
+          def define_user_activation_fields
             self.class_eval do
-              key sorcery_config.activation_state_attribute_name, String
-              key sorcery_config.activation_token_attribute_name, String
-              key sorcery_config.activation_token_expires_at_attribute_name, Time
+              sorcery_adapter.define_field sorcery_config.activation_state_attribute_name, String
+              sorcery_adapter.define_field sorcery_config.activation_token_attribute_name, String
+              sorcery_adapter.define_field sorcery_config.activation_token_expires_at_attribute_name, Time
             end
           end
         end
-        
-        module InstanceMethods
-          # clears activation code, sets the user as 'active' and optionaly sends a success email.
-          def activate!
-            config = sorcery_config
-            self.send(:"#{config.activation_token_attribute_name}=", nil)
-            self.send(:"#{config.activation_state_attribute_name}=", "active")
-            send_activation_success_email! unless self.external?
-            save!(:validate => false) # don't run validations
-          end
-          
-          protected
 
+        module InstanceMethods
           def setup_activation
             config = sorcery_config
             generated_activation_token = TemporaryToken.generate_random_token
@@ -125,15 +103,40 @@ module Sorcery
             self.send(:"#{config.activation_token_expires_at_attribute_name}=", Time.now.in_time_zone + config.activation_token_expiration_period) if config.activation_token_expiration_period
           end
 
+          # clears activation code, sets the user as 'active' and optionaly sends a success email.
+          def activate!
+            config = sorcery_config
+            self.send(:"#{config.activation_token_attribute_name}=", nil)
+            self.send(:"#{config.activation_state_attribute_name}=", "active")
+            send_activation_success_email! if send_activation_success_email?
+            sorcery_adapter.save(:validate => false, :raise_on_failure => true)
+          end
+
+          protected
+
           # called automatically after user initial creation.
           def send_activation_needed_email!
-            generic_send_email(:activation_needed_email_method_name, :user_activation_mailer) unless sorcery_config.activation_needed_email_method_name.nil? or sorcery_config.activation_mailer_disabled == true
+            generic_send_email(:activation_needed_email_method_name, :user_activation_mailer)
           end
 
           def send_activation_success_email!
-            generic_send_email(:activation_success_email_method_name, :user_activation_mailer) unless sorcery_config.activation_success_email_method_name.nil? or sorcery_config.activation_mailer_disabled == true
+            generic_send_email(:activation_success_email_method_name, :user_activation_mailer)
           end
-          
+
+          def send_activation_success_email?
+            !external? && (
+              !(sorcery_config.activation_success_email_method_name.nil? ||
+                sorcery_config.activation_mailer_disabled == true)
+            )
+          end
+
+          def send_activation_needed_email?
+            !external? && (
+              !(sorcery_config.activation_needed_email_method_name.nil? ||
+                sorcery_config.activation_mailer_disabled == true)
+            )
+          end
+
           def prevent_non_active_login
             config = sorcery_config
             config.prevent_non_active_users_to_login ? self.send(config.activation_state_attribute_name) == "active" : true
@@ -143,4 +146,4 @@ module Sorcery
       end
     end
   end
-end
+end