sorcery 0.6.1 → 0.7.10

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

@@ -20,7 +20,13 @@ module Sorcery
                           :activation_token_expiration_period,            # how many seconds before the activation code
                                                                           # expires. nil for never expires.
                                                                           
-                          :user_activation_mailer,                        # your mailer class. Required.
+                          :user_activation_mailer,                        # your mailer class. Required when
+                                                                          # activation_mailer_disabled == false.
+
+                          :activation_mailer_disabled,                    # when true sorcery will not automatically
+                                                                          # email activation details and allow you to
+                                                                          # manually handle how and when email is sent
+
                           :activation_needed_email_method_name,           # activation needed email method on your
                                                                           # mailer class.
                                                                           
@@ -37,6 +43,7 @@ module Sorcery
                              :@activation_token_expires_at_attribute_name  => :activation_token_expires_at,
                              :@activation_token_expiration_period          => nil,
                              :@user_activation_mailer                      => nil,
+                             :@activation_mailer_disabled                  => false,
                              :@activation_needed_email_method_name         => :activation_needed_email,
                              :@activation_success_email_method_name        => :activation_success_email,
                              :@prevent_non_active_users_to_login           => true)
@@ -47,15 +54,17 @@ module Sorcery
             # 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 => Proc.new { |user| !user.external?}
+            after_create  :send_activation_needed_email!, :if => Proc.new { |user| !user.external? }
           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.before_authenticate << :prevent_non_active_login
           
           base.extend(ClassMethods)
-          base.send(:include, TemporaryToken)
           base.send(:include, InstanceMethods)
 
 
@@ -72,17 +81,26 @@ module Sorcery
           
           protected
           
-          # This submodule requires the developer to define his own mailer class to be used by it.
+          # 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
             msg = "To use user_activation submodule, you must define a mailer (config.user_activation_mailer = YourMailerClass)."
-            raise ArgumentError, msg if @sorcery_config.user_activation_mailer == nil
+            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 => DateTime
+              field sorcery_config.activation_token_expires_at_attribute_name, :type => Time
+            end
+          end
+
+          def define_user_activation_mongo_mapper_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
         end
@@ -101,19 +119,19 @@ module Sorcery
 
           def setup_activation
             config = sorcery_config
-            generated_activation_token = generate_random_token
+            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.utc + config.activation_token_expiration_period) if config.activation_token_expiration_period
+            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) unless sorcery_config.activation_needed_email_method_name.nil?
+            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
           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?
+            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
           end
           
           def prevent_non_active_login

data/lib/sorcery/model/temporary_token.rb

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Sorcery
   module Model
     # This module encapsulates the logic for temporary token.
@@ -8,12 +10,17 @@ module Sorcery
         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)
           if !user.blank? && !user.send(token_expiration_date_attr).nil?
-            return Time.now.utc < user.send(token_expiration_date_attr) ? user : nil
+            return Time.now.in_time_zone < user.send(token_expiration_date_attr) ? user : nil
           end
           user
         end

data/lib/sorcery/model.rb

@@ -3,8 +3,8 @@ module Sorcery
   # It should be included into the ORM base class.
   # In the case of Rails this is usually ActiveRecord (actually, in that case, the plugin does this automatically).
   #
-  # When included it defines a single method: 'activate_sorcery!' which when called adds the other capabilities 
-  # to the class.
+  # When included it defines a single method: 'authenticates_with_sorcery!'
+  # which when called adds the other capabilities to the class.
   # This method is also the place to configure the plugin in the Model layer.
   module Model
     def self.included(klass)
@@ -15,6 +15,7 @@ module Sorcery
             self.class_eval do
               extend ClassMethods # included here, before submodules, so they can be overriden by them.
               include InstanceMethods
+              include TemporaryToken
             end
             
             include_required_submodules!
@@ -23,6 +24,7 @@ module Sorcery
             ::Sorcery::Controller::Config.user_config.tap{|blk| blk.call(@sorcery_config) if blk}
             
             init_mongoid_support! if defined?(Mongoid) and self.ancestors.include?(Mongoid::Document)
+            init_mongo_mapper_support! if defined?(MongoMapper) and self.ancestors.include?(MongoMapper::Document)
 
             init_orm_hooks!
             
@@ -52,20 +54,38 @@ module Sorcery
           # using 1.8.x hash syntax to perserve compatibility.
           def init_mongoid_support!
             self.class_eval do
-              field sorcery_config.username_attribute_name,         :type => String
-              field sorcery_config.email_attribute_name,            :type => String unless sorcery_config.username_attribute_name == sorcery_config.email_attribute_name
+              sorcery_config.username_attribute_names.each do |username|
+                field username,         :type => String
+              end
+              field sorcery_config.email_attribute_name,            :type => String unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
               field sorcery_config.crypted_password_attribute_name, :type => String
               field sorcery_config.salt_attribute_name,             :type => String
             end
           end
           
+          # defines mongo_mapper fields on the model class,
+          def init_mongo_mapper_support!
+            self.class_eval do
+              sorcery_config.username_attribute_names.each do |username|
+                key username, String
+              end
+              key sorcery_config.email_attribute_name, String unless sorcery_config.username_attribute_names.include?(sorcery_config.email_attribute_name)
+              key sorcery_config.crypted_password_attribute_name, String
+              key sorcery_config.salt_attribute_name, String
+            end
+          end
+
           # add virtual password accessor and ORM callbacks.
           def init_orm_hooks!
             self.class_eval do
               attr_accessor @sorcery_config.password_attribute_name
               attr_protected @sorcery_config.crypted_password_attribute_name, @sorcery_config.salt_attribute_name
-              before_save :encrypt_password, :if => Proc.new { |record| record.send(sorcery_config.password_attribute_name).present? }
-              after_save :clear_virtual_password, :if => Proc.new { |record| record.send(sorcery_config.password_attribute_name).present? }
+              before_save :encrypt_password, :if => Proc.new { |record|
+                record.send(sorcery_config.password_attribute_name).present?
+              }
+              after_save :clear_virtual_password, :if => Proc.new { |record|
+                record.send(sorcery_config.password_attribute_name).present?
+              }
             end
           end
         end
@@ -84,7 +104,11 @@ module Sorcery
       # returns the user if success, nil otherwise.
       def authenticate(*credentials)
         raise ArgumentError, "at least 2 arguments required" if credentials.size < 2
+        credentials[0].downcase! if @sorcery_config.downcase_username_before_authenticating
         user = find_by_credentials(credentials)
+
+        set_encryption_attributes()
+
         _salt = user.send(@sorcery_config.salt_attribute_name) if user && !@sorcery_config.salt_attribute_name.nil? && !@sorcery_config.encryption_provider.nil?
         user if user && @sorcery_config.before_authenticate.all? {|c| user.send(c)} && credentials_match?(user.send(@sorcery_config.crypted_password_attribute_name),credentials[1],_salt)
       end
@@ -93,14 +117,19 @@ module Sorcery
       def encrypt(*tokens)
         return tokens.first if @sorcery_config.encryption_provider.nil?
         
-        @sorcery_config.encryption_provider.stretches = @sorcery_config.stretches if @sorcery_config.encryption_provider.respond_to?(:stretches) && @sorcery_config.stretches
-        @sorcery_config.encryption_provider.join_token = @sorcery_config.salt_join_token if @sorcery_config.encryption_provider.respond_to?(:join_token) && @sorcery_config.salt_join_token
-        CryptoProviders::AES256.key = @sorcery_config.encryption_key if @sorcery_config.encryption_algorithm == :aes256
+        set_encryption_attributes()
+
+        CryptoProviders::AES256.key = @sorcery_config.encryption_key
         @sorcery_config.encryption_provider.encrypt(*tokens)
       end
       
       protected
-      
+
+      def set_encryption_attributes()
+        @sorcery_config.encryption_provider.stretches = @sorcery_config.stretches if @sorcery_config.encryption_provider.respond_to?(:stretches) && @sorcery_config.stretches
+        @sorcery_config.encryption_provider.join_token = @sorcery_config.salt_join_token if @sorcery_config.encryption_provider.respond_to?(:join_token) && @sorcery_config.salt_join_token
+      end
+
       # Calls the configured encryption provider to compare the supplied password with the encrypted one.
       def credentials_match?(crypted, *tokens)
         return crypted == tokens.join if @sorcery_config.encryption_provider.nil?
@@ -141,7 +170,7 @@ module Sorcery
       # encrypts password with salt and saves it.
       def encrypt_password
         config = sorcery_config
-        self.send(:"#{config.salt_attribute_name}=", new_salt = generate_random_token) if !config.salt_attribute_name.nil?
+        self.send(:"#{config.salt_attribute_name}=", new_salt = TemporaryToken.generate_random_token) if !config.salt_attribute_name.nil?
         self.send(:"#{config.crypted_password_attribute_name}=", self.class.encrypt(self.send(config.password_attribute_name),new_salt))
       end
 
@@ -159,11 +188,6 @@ module Sorcery
           mail.deliver
         end
       end
-      
-      # Random code, used for salt and temporary tokens.
-      def generate_random_token
-        Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
-      end
     end
 
     # Each class which calls 'activate_sorcery!' receives an instance of this class.
@@ -171,13 +195,16 @@ module Sorcery
     # options will be configured from a single place.
     class Config
 
-      attr_accessor :username_attribute_name,           # change default username attribute, for example, to use :email
+      attr_accessor :username_attribute_names,           # change default username attribute, for example, to use :email
                                                         # as the login.
                                                         
                     :password_attribute_name,           # change *virtual* password attribute, the one which is used
                                                         # until an encrypted one is generated.
                                                         
                     :email_attribute_name,              # change default email attribute.
+
+                    :downcase_username_before_authenticating, # downcase the username before trying to authenticate, default is false
+
                     :crypted_password_attribute_name,   # change default crypted_password attribute.
                     :salt_join_token,                   # what pattern to use to join the password with the salt
                     :salt_attribute_name,               # change default salt attribute.
@@ -203,8 +230,9 @@ module Sorcery
       def initialize
         @defaults = {
           :@submodules                           => [],
-          :@username_attribute_name              => :username,
+          :@username_attribute_names              => [:username],
           :@password_attribute_name              => :password,
+          :@downcase_username_before_authenticating => false,
           :@email_attribute_name                 => :email,
           :@crypted_password_attribute_name      => :crypted_password,
           :@encryption_algorithm                 => :bcrypt,
@@ -228,6 +256,10 @@ module Sorcery
         end       
       end
       
+      def username_attribute_names=(fields)
+        @username_attribute_names = fields.kind_of?(Array) ? fields : [fields]
+      end
+      
       def custom_encryption_provider=(provider)
         @custom_encryption_provider = @encryption_provider = provider
       end
@@ -249,4 +281,4 @@ module Sorcery
     end
     
   end
-end
+end

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

@@ -12,7 +12,7 @@ module Sorcery
 
         def sorcery_reload!(submodules = [], options = {})
           reload_user_class
-
+          
           # return to no-module configuration
           ::Sorcery::Controller::Config.init!
           ::Sorcery::Controller::Config.reset!

data/lib/sorcery/test_helpers/rails.rb

@@ -4,8 +4,8 @@ module Sorcery
       # logins a user and calls all callbacks
       def login_user(user = nil)
         user ||= @user
-        @controller.send(:login_user,user)
-        @controller.send(:after_login!,user,[user.send(user.sorcery_config.username_attribute_name),'secret'])
+        @controller.send(:auto_login,user)
+        @controller.send(:after_login!,user,[user.send(user.sorcery_config.username_attribute_names.first),'secret'])
       end
 
       def logout_user

data/lib/sorcery.rb

@@ -5,6 +5,7 @@ module Sorcery
     module Adapters
       autoload :ActiveRecord, 'sorcery/model/adapters/active_record'
       autoload :Mongoid, 'sorcery/model/adapters/mongoid'
+      autoload :MongoMapper, 'sorcery/model/adapters/mongo_mapper'
     end
     module Submodules
       autoload :UserActivation, 'sorcery/model/submodules/user_activation'
@@ -32,12 +33,12 @@ module Sorcery
         module Providers
           autoload :Twitter, 'sorcery/controller/submodules/external/providers/twitter'
           autoload :Facebook, 'sorcery/controller/submodules/external/providers/facebook'
+          autoload :Github, 'sorcery/controller/submodules/external/providers/github'
+          autoload :Google, 'sorcery/controller/submodules/external/providers/google'
+          autoload :Liveid, 'sorcery/controller/submodules/external/providers/liveid'
         end
       end
     end
-    module Adapters
-      autoload :Sinatra, 'sorcery/controller/adapters/sinatra'
-    end
   end
   module CryptoProviders
     autoload :Common, 'sorcery/crypto_providers/common'
@@ -51,12 +52,9 @@ module Sorcery
   autoload :TestHelpers, 'sorcery/test_helpers'
   module TestHelpers
     autoload :Rails, 'sorcery/test_helpers/rails'
-    autoload :Sinatra, 'sorcery/test_helpers/sinatra'
     autoload :Internal, 'sorcery/test_helpers/internal'
     module Internal
       autoload :Rails, 'sorcery/test_helpers/internal/rails'
-      autoload :Sinatra, 'sorcery/test_helpers/internal/sinatra'
-      autoload :SinatraModular, 'sorcery/test_helpers/internal/sinatra_modular'
     end
 
   end
@@ -76,6 +74,9 @@ module Sorcery
     end
   end
 
+  if defined?(MongoMapper)
+    MongoMapper::Document.send(:plugin, Sorcery::Model::Adapters::MongoMapper)
+  end
+
   require 'sorcery/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
-  require 'sorcery/sinatra' if defined?(Sinatra)
 end