sorcery 0.7.0 → 0.8.0

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

@@ -24,7 +24,10 @@ module Sorcery
           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
+          
           base.extend(ClassMethods)
         end
 
@@ -36,23 +39,25 @@ module Sorcery
             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
+          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.send(:"#{config.remember_me_token_attribute_name}=", TemporaryToken.generate_random_token)
-            self.send(:"#{config.remember_me_token_expires_at_attribute_name}=", Time.now + config.remember_me_for)
-            self.save!(:validate => false)
+            self.update_many_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
           
           # 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.send(:"#{config.remember_me_token_attribute_name}=", nil)
-            self.send(:"#{config.remember_me_token_expires_at_attribute_name}=", nil)
-            self.save!(:validate => false)
+            self.update_many_attributes(config.remember_me_token_attribute_name => nil,
+                                        config.remember_me_token_expires_at_attribute_name => nil)
           end
         end
       end

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

@@ -18,6 +18,11 @@ module Sorcery
                                                                              # protection.
                                                                              
                           :reset_password_mailer,                            # mailer class. Needed.
+
+                          :reset_password_mailer_disabled,                   # when true sorcery will not automatically
+                                                                             # email password reset details and allow you to
+                                                                             # manually handle how and when email is sent
+
                           :reset_password_email_method_name,                 # reset password email method on your
                                                                              # mailer class.
                                                                              
@@ -34,6 +39,7 @@ module Sorcery
                              :@reset_password_token_expires_at_attribute_name => :reset_password_token_expires_at,
                              :@reset_password_email_sent_at_attribute_name    => :reset_password_email_sent_at,
                              :@reset_password_mailer                          => nil,
+                             :@reset_password_mailer_disabled                 => false,
                              :@reset_password_email_method_name               => :reset_password_email,
                              :@reset_password_expiration_period               => nil,
                              :@reset_password_time_between_emails             => 5 * 60 )
@@ -45,6 +51,9 @@ module Sorcery
 
           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.send(:include, InstanceMethods)
 
@@ -61,16 +70,23 @@ 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 reset_password_mailer_disabled is false
           def validate_mailer_defined
             msg = "To use reset_password submodule, you must define a mailer (config.reset_password_mailer = YourMailerClass)."
-            raise ArgumentError, msg if @sorcery_config.reset_password_mailer == nil
+            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 => DateTime
-            field sorcery_config.reset_password_email_sent_at_attribute_name,     :type => DateTime
+            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
           end
         end
         
@@ -79,13 +95,13 @@ module Sorcery
           def deliver_reset_password_instructions!
             config = sorcery_config
             # hammering protection
-            return 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
-            self.send(:"#{config.reset_password_token_attribute_name}=", TemporaryToken.generate_random_token)
-            self.send(:"#{config.reset_password_token_expires_at_attribute_name}=", Time.now.utc + config.reset_password_expiration_period) if config.reset_password_expiration_period
-            self.send(:"#{config.reset_password_email_sent_at_attribute_name}=", Time.now.utc)
+            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.save!(:validate => false)
-              generic_send_email(:reset_password_email_method_name, :reset_password_mailer)
+              self.update_many_attributes(attributes)
+              generic_send_email(:reset_password_email_method_name, :reset_password_mailer) unless config.reset_password_mailer_disabled
             end
           end
           
@@ -109,4 +125,4 @@ module Sorcery
       end
     end
   end
-end
+end

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,11 +54,14 @@ 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)
@@ -71,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
@@ -103,16 +122,16 @@ module Sorcery
             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.
@@ -10,7 +12,7 @@ module Sorcery
       
       # Random code, used for salt and temporary tokens.
       def self.generate_random_token
-        Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+        SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
       end
       
       module ClassMethods
@@ -18,7 +20,7 @@ module Sorcery
           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)
@@ -17,38 +17,39 @@ module Sorcery
               include InstanceMethods
               include TemporaryToken
             end
-            
+
             include_required_submodules!
 
             # This runs the options block set in the initializer on the model class.
             ::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!
-            
+
             @sorcery_config.after_config << :add_config_inheritance if @sorcery_config.subclasses_inherit_config
             @sorcery_config.after_config.each { |c| send(c) }
           end
-          
+
           protected
-          
-          # includes required submodules into the model class, 
+
+          # includes required submodules into the model class,
           # which usually is called User.
           def include_required_submodules!
             self.class_eval do
               @sorcery_config.submodules = ::Sorcery::Controller::Config.submodules
               @sorcery_config.submodules.each do |mod|
                 begin
-                  include Submodules.const_get(mod.to_s.split("_").map {|p| p.capitalize}.join("")) 
+                  include Submodules.const_get(mod.to_s.split("_").map {|p| p.capitalize}.join(""))
                 rescue NameError
-                  # don't stop on a missing submodule. Needed because some submodules are only defined 
+                  # don't stop on a missing submodule. Needed because some submodules are only defined
                   # in the controller side.
                 end
               end
             end
           end
-          
+
           # defines mongoid fields on the model class,
           # using 1.8.x hash syntax to perserve compatibility.
           def init_mongoid_support!
@@ -61,55 +62,80 @@ module Sorcery
               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
       end
     end
-    
+
     module ClassMethods
       # Returns the class instance variable for configuration, when called by the class itself.
       def sorcery_config
         @sorcery_config
       end
-      
+
       # The default authentication method.
       # Takes a username and password,
       # Finds the user by the username and compares the user's password to the one supplied to the method.
       # 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
-      
+
       # encrypt tokens using current encryption_provider.
       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
+
+        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?
         @sorcery_config.encryption_provider.matches?(crypted, *tokens)
       end
-      
+
       def add_config_inheritance
         self.class_eval do
           def self.inherited(subclass)
@@ -123,23 +149,23 @@ module Sorcery
           end
         end
       end
-      
+
     end
-    
+
     module InstanceMethods
       # Returns the class instance variable for configuration, when called by an instance.
       def sorcery_config
         self.class.sorcery_config
       end
-      
+
       # identifies whether this user is regular, i.e. we hold his credentials in our db,
       # or that he is external, and his credentials are saved elsewhere (twitter/facebook etc.).
       def external?
         send(sorcery_config.crypted_password_attribute_name).nil?
       end
-      
+
       protected
-      
+
       # creates new salt and saves it.
       # encrypts password with salt and saves it.
       def encrypt_password
@@ -152,47 +178,50 @@ module Sorcery
         config = sorcery_config
         self.send(:"#{config.password_attribute_name}=", nil)
       end
-      
+
       # calls the requested email method on the configured mailer
       # supports both the ActionMailer 3 way of calling, and the plain old Ruby object way.
       def generic_send_email(method, mailer)
         config = sorcery_config
         mail = config.send(mailer).send(config.send(method),self)
-        if defined?(ActionMailer) and config.send(mailer).superclass == ActionMailer::Base
+        if defined?(ActionMailer) and config.send(mailer).kind_of?(Class) and config.send(mailer) < ActionMailer::Base
           mail.deliver
         end
       end
     end
 
     # Each class which calls 'activate_sorcery!' receives an instance of this class.
-    # Every submodule which gets loaded may add accessors to this class so that all 
+    # Every submodule which gets loaded may add accessors to this class so that all
     # options will be configured from a single place.
     class Config
 
       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.
                     :stretches,                         # how many times to apply encryption to the password.
                     :encryption_key,                    # encryption key used to encrypt reversible encryptions such as
                                                         # AES256.
-                                                        
+
                     :subclasses_inherit_config,         # make this configuration inheritable for subclasses. Useful for
                                                         # ActiveRecord's STI.
-                    
+
                     :submodules,                        # configured in config/application.rb
                     :before_authenticate,               # an array of method names to call before authentication
                                                         # completes. used internally.
-                                                        
+
                     :after_config                       # an array of method names to call after configuration by user.
                                                         # used internally.
-                    
+
       attr_reader   :encryption_provider,               # change default encryption_provider.
                     :custom_encryption_provider,        # use an external encryption class.
                     :encryption_algorithm               # encryption algorithm name. See 'encryption_algorithm=' below
@@ -203,6 +232,7 @@ module Sorcery
           :@submodules                           => [],
           :@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,
@@ -217,26 +247,26 @@ module Sorcery
           :@after_config                         => []
         }
         reset!
-      end     
-           
+      end
+
       # Resets all configuration options to their default values.
       def reset!
         @defaults.each do |k,v|
           instance_variable_set(k,v)
-        end       
+        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
-      
+
       def encryption_algorithm=(algo)
         @encryption_algorithm = algo
-        @encryption_provider = case @encryption_algorithm
+        @encryption_provider = case @encryption_algorithm.to_sym
         when :none   then nil
         when :md5    then CryptoProviders::MD5
         when :sha1   then CryptoProviders::SHA1
@@ -245,10 +275,11 @@ module Sorcery
         when :aes256 then CryptoProviders::AES256
         when :bcrypt then CryptoProviders::BCrypt
         when :custom then @custom_encryption_provider
+        else raise ArgumentError.new("Encryption algorithm supplied, #{algo}, is invalid")
         end
       end
-      
+
     end
-    
+
   end
-end
+end

data/lib/sorcery/railties/tasks.rake

@@ -3,6 +3,8 @@ require 'fileutils'
 namespace :sorcery do
   desc "Adds sorcery's initializer file"
   task :bootstrap do
+    warn "This task is obsolete.\nUse \"rails g sorcery:install\" now.\nSee README for more information."
+
     src = File.join(File.dirname(__FILE__), '..', 'initializers', 'initializer.rb')
     target = File.join(Rails.root, "config", "initializers", "sorcery.rb")
     FileUtils.cp(src, target)

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'
@@ -33,12 +34,13 @@ module Sorcery
           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'
+          autoload :Linkedin, 'sorcery/controller/submodules/external/providers/linkedin'
+          autoload :Vkontakte, 'sorcery/controller/submodules/external/providers/vkontakte'
         end
       end
     end
-    module Adapters
-      autoload :Sinatra, 'sorcery/controller/adapters/sinatra'
-    end
   end
   module CryptoProviders
     autoload :Common, 'sorcery/crypto_providers/common'
@@ -52,12 +54,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
@@ -77,6 +76,9 @@ module Sorcery
     end
   end
 
-  require 'sorcery/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
-  require 'sorcery/sinatra' if defined?(Sinatra)
+  if defined?(MongoMapper)
+    MongoMapper::Document.send(:plugin, Sorcery::Model::Adapters::MongoMapper)
+  end
+
+  require 'sorcery/engine' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
 end