sorcery 0.8.6 → 0.9.1

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

@@ -3,22 +3,23 @@ module Sorcery
     module Submodules
       # 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 reading a page without clicking anything 
+      # This cannot be determined absolutely because a user might be reading a page without clicking anything
       # for a while.
       # This is the model part of the submodule, which provides configuration options.
       module ActivityLogging
         def self.included(base)
           base.extend(ClassMethods)
+          base.send(:include, InstanceMethods)
 
           base.sorcery_config.class_eval do
             attr_accessor :last_login_at_attribute_name,                  # last login attribute name.
                           :last_logout_at_attribute_name,                 # last logout attribute name.
                           :last_activity_at_attribute_name,               # last activity attribute name.
                           :last_login_from_ip_address_name,               # last activity login source
-                          :activity_timeout                               # how long since last activity is 
+                          :activity_timeout                               # how long since last activity is
                                                                           #the user defined logged out?
           end
-          
+
           base.sorcery_config.instance_eval do
             @defaults.merge!(:@last_login_at_attribute_name                => :last_login_at,
                              :@last_logout_at_attribute_name               => :last_logout_at,
@@ -28,47 +29,39 @@ module Sorcery
             reset!
           end
 
-          base.sorcery_config.after_config << :define_activity_logging_mongoid_fields if defined?(Mongoid) and base.ancestors.include?(Mongoid::Document)
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            # NOTE raise exception if data-store is not supported
-            unless base.repository.adapter.is_a?(DataMapper::Adapters::MysqlAdapter)
-              raise 'Unsupported DataMapper Adapter'
-            end
-            base.sorcery_config.after_config << :define_activity_logging_datamapper_fields
+          base.sorcery_config.after_config << :define_activity_logging_fields
+        end
+
+        module InstanceMethods
+          def set_last_login_at(time)
+            sorcery_adapter.update_attribute(sorcery_config.last_login_at_attribute_name, time)
+          end
+
+          def set_last_logout_at(time)
+            sorcery_adapter.update_attribute(sorcery_config.last_logout_at_attribute_name, time)
+          end
+
+          def set_last_activity_at(time)
+            sorcery_adapter.update_attribute(sorcery_config.last_activity_at_attribute_name, time)
+          end
+
+          def set_last_ip_addess(ip_address)
+            sorcery_adapter.update_attribute(sorcery_config.last_login_from_ip_address_name, ip_address)
           end
         end
-        
+
         module ClassMethods
           # get all users with last_activity within timeout
           def current_users
-            config = sorcery_config
-            get_current_users
+            sorcery_adapter.get_current_users
           end
 
           protected
-
-          def define_activity_logging_mongoid_fields
-            field sorcery_config.last_login_at_attribute_name,    :type => Time
-            field sorcery_config.last_logout_at_attribute_name,   :type => Time
-            field sorcery_config.last_activity_at_attribute_name, :type => Time
-            field sorcery_config.last_login_from_ip_address_name, :type => String
-          end
-
-          def define_activity_logging_datamapper_fields
-            property sorcery_config.last_login_at_attribute_name,    Time
-            property sorcery_config.last_logout_at_attribute_name,   Time
-            property sorcery_config.last_activity_at_attribute_name, Time
-            property sorcery_config.last_login_from_ip_address_name, String
-            # Workaround local timezone retrieval problem NOTE dm-core issue #193
-            [sorcery_config.last_login_at_attribute_name,
-             sorcery_config.last_logout_at_attribute_name,
-             sorcery_config.last_activity_at_attribute_name].each do |sym|
-               alias_method "orig_#{sym}", sym
-               define_method(sym) do
-                 t = send("orig_#{sym}")
-                 t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-               end
-             end
+          def define_activity_logging_fields
+            sorcery_adapter.define_field sorcery_config.last_login_at_attribute_name,    Time
+            sorcery_adapter.define_field sorcery_config.last_logout_at_attribute_name,   Time
+            sorcery_adapter.define_field sorcery_config.last_activity_at_attribute_name, Time
+            sorcery_adapter.define_field sorcery_config.last_login_from_ip_address_name, String
           end
         end
       end

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

@@ -35,13 +35,7 @@ module Sorcery
           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
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_brute_force_protection_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_brute_force_protection_fields
           base.extend(ClassMethods)
           base.send(:include, InstanceMethods)
         end
@@ -49,35 +43,16 @@ module Sorcery
         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
-          end
-
-          def define_brute_force_protection_datamapper_fields
-            property sorcery_config.failed_logins_count_attribute_name, Integer, :default => 0
-            property sorcery_config.lock_expires_at_attribute_name,     Time
-            property sorcery_config.unlock_token_attribute_name,        String
-            [sorcery_config.lock_expires_at_attribute_name].each do |sym|
-              alias_method "orig_#{sym}", sym
-              define_method(sym) do
-                t = send("orig_#{sym}")
-                t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-              end
-            end
+          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
 
@@ -87,9 +62,12 @@ module Sorcery
           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
 
           # /!\
@@ -100,7 +78,11 @@ module Sorcery
             attributes = {config.lock_expires_at_attribute_name => nil,
                           config.failed_logins_count_attribute_name => 0,
                           config.unlock_token_attribute_name => nil}
-            self.update_many_attributes(attributes)
+            sorcery_adapter.update_attributes(attributes)
+          end
+
+          def locked?
+            !unlocked?
           end
 
           protected
@@ -109,7 +91,7 @@ module Sorcery
             config = sorcery_config
             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}
-            self.update_many_attributes(attributes)
+            sorcery_adapter.update_attributes(attributes)
 
             unless config.unlock_token_mailer_disabled || config.unlock_token_mailer.nil?
               send_unlock_token_email!
@@ -122,7 +104,9 @@ module Sorcery
           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?
+            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.

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
@@ -22,14 +22,7 @@ module Sorcery
           end
 
           base.send(:include, InstanceMethods)
-
-          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
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_remember_me_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_remember_me_fields
 
           base.extend(ClassMethods)
         end
@@ -37,41 +30,29 @@ module Sorcery
         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
-          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
+          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_datamapper_fields
-            property sorcery_config.remember_me_token_attribute_name,            String
-            property sorcery_config.remember_me_token_expires_at_attribute_name, Time
-            [sorcery_config.remember_me_token_expires_at_attribute_name].each do |sym|
-              alias_method "orig_#{sym}", sym
-              define_method(sym) do
-                t = send("orig_#{sym}")
-                t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-              end
-            end
-          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

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

@@ -50,13 +50,7 @@ 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
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_reset_password_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_reset_password_fields
 
           base.send(:include, InstanceMethods)
 
@@ -80,45 +74,33 @@ 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
+          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
 
-          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
-          end
-
-          def define_reset_password_datamapper_fields
-            property sorcery_config.reset_password_token_attribute_name,            String
-            property sorcery_config.reset_password_token_expires_at_attribute_name, Time
-            property sorcery_config.reset_password_email_sent_at_attribute_name,    Time
-            [sorcery_config.reset_password_token_expires_at_attribute_name,
-             sorcery_config.reset_password_email_sent_at_attribute_name].each do |sym|
-               alias_method "orig_#{sym}", sym
-               define_method(sym) do
-                 t = send("orig_#{sym}")
-                 t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-               end
-            end
-          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)
-              send_reset_password_email! unless sorcery_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
 
@@ -126,11 +108,11 @@ module Sorcery
           def change_password!(new_password)
             clear_reset_password_token
             self.send(:"#{sorcery_config.password_attribute_name}=", new_password)
-            sorcery_save
+            sorcery_adapter.save
           end
 
           protected
-          
+
           def send_reset_password_email!
             generic_send_email(:reset_password_email_method_name, :reset_password_mailer)
           end

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

@@ -15,7 +15,7 @@ module Sorcery
                                                                           # (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.
@@ -51,33 +51,14 @@ module Sorcery
           end
 
           base.class_eval do
-            if defined?(DataMapper) && self.ancestors.include?(DataMapper::Resource)
-              before :valid? do
-                if self.send(sorcery_config.password_attribute_name).present?
-                  setup_activation
-                end
-              end
-              after :create do
-                if send_activation_needed_email?
-                  send_activation_needed_email!
-                end
-              end
-            else
-              # 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? }
-              # don't send activation needed email if no crypted password created - this user is external (OAuth etc.)
-              after_create  :send_activation_needed_email!, :if => :send_activation_needed_email?
-            end
+            # don't setup activation if no password supplied - this user is created automatically
+            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.)
+            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
-          if defined?(DataMapper) and base.ancestors.include?(DataMapper::Resource)
-            base.sorcery_config.after_config << :define_user_activation_datamapper_fields
-          end
+          base.sorcery_config.after_config << :define_user_activation_fields
           base.sorcery_config.before_authenticate << :prevent_non_active_login
 
           base.extend(ClassMethods)
@@ -104,58 +85,35 @@ 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
-            end
-          end
-
-          def define_user_activation_datamapper_fields
-            self.class_eval do
-              property sorcery_config.activation_state_attribute_name,            String
-              property sorcery_config.activation_token_attribute_name,            String
-              property sorcery_config.activation_token_expires_at_attribute_name, Time
-              [sorcery_config.activation_token_expires_at_attribute_name].each do |sym|
-                alias_method "orig_#{sym}", sym
-                define_method(sym) do
-                  t = send("orig_#{sym}")
-                  t && Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, 0)
-                end
-              end
+              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
+          def setup_activation
+            config = sorcery_config
+            generated_activation_token = TemporaryToken.generate_random_token
+            self.send(:"#{config.activation_token_attribute_name}=", generated_activation_token)
+            self.send(:"#{config.activation_state_attribute_name}=", "pending")
+            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_save(:validate => false, :raise_on_failure => true)
+            sorcery_adapter.save(:validate => false, :raise_on_failure => true)
           end
 
           protected
 
-          def setup_activation
-            config = sorcery_config
-            generated_activation_token = TemporaryToken.generate_random_token
-            self.send(:"#{config.activation_token_attribute_name}=", generated_activation_token)
-            self.send(:"#{config.activation_state_attribute_name}=", "pending")
-            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
-
           # called automatically after user initial creation.
           def send_activation_needed_email!
             generic_send_email(:activation_needed_email_method_name, :user_activation_mailer)
@@ -164,14 +122,14 @@ module Sorcery
           def send_activation_success_email!
             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? ||

data/lib/sorcery/model/temporary_token.rb

@@ -3,22 +3,22 @@ require 'securerandom'
 module Sorcery
   module Model
     # This module encapsulates the logic for temporary token.
-    # A temporary token is created to identify a user in scenarios 
+    # A temporary token is created to identify a user in scenarios
     # such as reseting password and activating the user by email.
     module TemporaryToken
       def self.included(base)
         base.extend(ClassMethods)
       end
-      
+
       # Random code, used for salt and temporary tokens.
       def self.generate_random_token
         SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
       end
-      
+
       module ClassMethods
         def load_from_token(token, token_attr_name, token_expiration_date_attr)
           return nil if token.blank?
-          user = find_by_sorcery_token(token_attr_name,token)
+          user = sorcery_adapter.find_by_token(token_attr_name,token)
           if !user.blank? && !user.send(token_expiration_date_attr).nil?
             return Time.now.in_time_zone < user.send(token_expiration_date_attr) ? user : nil
           end