sorcery 0.8.1 → 0.9.0

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

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