devise 1.0.11 → 1.1.0

data/lib/devise/rails/routes.rb

@@ -1,133 +1,248 @@
-module ActionController::Routing
+module ActionDispatch::Routing
   class RouteSet #:nodoc:
-
     # Ensure Devise modules are included only after loading routes, because we
-    # need devise_for mappings already declared to create magic filters and
-    # helpers.
-    def load_routes_with_devise!
-      load_routes_without_devise!
-      return if Devise.mappings.empty?
-
+    # need devise_for mappings already declared to create filters and helpers.
+    def finalize_with_devise!
+      finalize_without_devise!
+      Devise.configure_warden!
       ActionController::Base.send :include, Devise::Controllers::Helpers
-      ActionController::Base.send :include, Devise::Controllers::UrlHelpers
-
-      ActionView::Base.send :include, Devise::Controllers::UrlHelpers
     end
-    alias_method_chain :load_routes!, :devise
-
-    class Mapper #:doc:
-      # Includes devise_for method for routes. This method is responsible to
-      # generate all needed routes for devise, based on what modules you have
-      # defined in your model.
-      # Examples: Let's say you have an User model configured to use
-      # authenticatable, confirmable and recoverable modules. After creating this
-      # inside your routes:
-      #
-      #   map.devise_for :users
-      #
-      # this method is going to look inside your User model and create the
-      # needed routes:
-      #
-      #  # Session routes for Authenticatable (default)
-      #       new_user_session GET  /users/sign_in                    {:controller=>"sessions", :action=>"new"}
-      #           user_session POST /users/sign_in                    {:controller=>"sessions", :action=>"create"}
-      #   destroy_user_session GET  /users/sign_out                   {:controller=>"sessions", :action=>"destroy"}
-      #
-      #  # Password routes for Recoverable, if User model has :recoverable configured
-      #      new_user_password GET  /users/password/new(.:format)     {:controller=>"passwords", :action=>"new"}
-      #     edit_user_password GET  /users/password/edit(.:format)    {:controller=>"passwords", :action=>"edit"}
-      #          user_password PUT  /users/password(.:format)         {:controller=>"passwords", :action=>"update"}
-      #                        POST /users/password(.:format)         {:controller=>"passwords", :action=>"create"}
-      #
-      #  # Confirmation routes for Confirmable, if User model has :confirmable configured
-      #  new_user_confirmation GET  /users/confirmation/new(.:format) {:controller=>"confirmations", :action=>"new"}
-      #      user_confirmation GET  /users/confirmation(.:format)     {:controller=>"confirmations", :action=>"show"}
-      #                        POST /users/confirmation(.:format)     {:controller=>"confirmations", :action=>"create"}
-      #
-      # You can configure your routes with some options:
-      #
-      #  * :class_name => setup a different class to be looked up by devise, if it cannot be correctly find by the route name.
-      #
-      #    map.devise_for :users, :class_name => 'Account'
-      #
-      #  * :as => allows you to setup path name that will be used, as rails routes does. The following route configuration would setup your route as /accounts instead of /users:
-      #
-      #    map.devise_for :users, :as => 'accounts'
-      #
-      #  * :scope => setup the scope name. This is used as the instance variable name in controller, as the name in routes and the scope given to warden. Defaults to the singular of the given name:
-      #
-      #    map.devise_for :users, :scope => :account
-      #
-      #  * :path_names => configure different path names to overwrite defaults :sign_in, :sign_out, :password and :confirmation.
-      #
-      #    map.devise_for :users, :path_names => { :sign_in => 'login', :sign_out => 'logout', :password => 'secret', :confirmation => 'verification' }
-      #
-      #  * :path_prefix => the path prefix to be used in all routes.
-      #
-      #    map.devise_for :users, :path_prefix => "/:locale"
-      #
-      #  * :sign_out_via => restirct the HTTP method(s) accepted for the :sign_out action (default: :get), possible values are :post, :get, :put, :delete and :any, e.g. if you wish to restrict this to accept only :delete requests you should do:
-      #
-      #    map.devise_for :users, :sign_out_via => :delete
-      #
-      #    You need to make sure that your sign_out controls trigger a request with a matching HTTP method.
-      #
-      #  Any other options will be passed to route definition. If you need conditions for your routes, just map:
-      #
-      #    map.devise_for :users, :conditions => { :subdomain => /.+/ }
-      #
-      #  If you are using a dynamic prefix, like :locale above, you need to configure default_url_options through Devise. You can do that in config/initializers/devise.rb or setting a Devise.default_url_options:
-      #
-      #    Devise.default_url_options do
-      #      { :locale => I18n.locale }
-      #    end
-      #
-      def devise_for(*resources)
-        options = resources.extract_options!
-
-        resources.map!(&:to_sym)
-        resources.each do |resource|
-          mapping = Devise::Mapping.new(resource, options.dup)
-          Devise.default_scope ||= mapping.name
-          Devise.mappings[mapping.name] = mapping
-
-          route_options = mapping.route_options.merge(:path_prefix => mapping.raw_path, :name_prefix => "#{mapping.name}_")
-
-          with_options(route_options) do |routes|
-            mapping.for.each do |mod|
-              send(mod, routes, mapping) if self.respond_to?(mod, true)
-            end
-          end
-        end
+    alias_method_chain :finalize!, :devise
+  end
+
+  class Mapper
+    # Includes devise_for method for routes. This method is responsible to
+    # generate all needed routes for devise, based on what modules you have
+    # defined in your model.
+    #
+    # ==== Examples
+    #
+    # Let's say you have an User model configured to use authenticatable,
+    # confirmable and recoverable modules. After creating this inside your routes:
+    #
+    #   devise_for :users
+    #
+    # This method is going to look inside your User model and create the
+    # needed routes:
+    #
+    #  # Session routes for Authenticatable (default)
+    #       new_user_session GET  /users/sign_in                    {:controller=>"devise/sessions", :action=>"new"}
+    #           user_session POST /users/sign_in                    {:controller=>"devise/sessions", :action=>"create"}
+    #   destroy_user_session GET  /users/sign_out                   {:controller=>"devise/sessions", :action=>"destroy"}
+    #
+    #  # Password routes for Recoverable, if User model has :recoverable configured
+    #      new_user_password GET  /users/password/new(.:format)     {:controller=>"devise/passwords", :action=>"new"}
+    #     edit_user_password GET  /users/password/edit(.:format)    {:controller=>"devise/passwords", :action=>"edit"}
+    #          user_password PUT  /users/password(.:format)         {:controller=>"devise/passwords", :action=>"update"}
+    #                        POST /users/password(.:format)         {:controller=>"devise/passwords", :action=>"create"}
+    #
+    #  # Confirmation routes for Confirmable, if User model has :confirmable configured
+    #  new_user_confirmation GET  /users/confirmation/new(.:format) {:controller=>"devise/confirmations", :action=>"new"}
+    #      user_confirmation GET  /users/confirmation(.:format)     {:controller=>"devise/confirmations", :action=>"show"}
+    #                        POST /users/confirmation(.:format)     {:controller=>"devise/confirmations", :action=>"create"}
+    #
+    # ==== Options
+    #
+    # You can configure your routes with some options:
+    #
+    #  * :class_name => setup a different class to be looked up by devise,
+    #                   if it cannot be correctly find by the route name.
+    #
+    #      devise_for :users, :class_name => 'Account'
+    #
+    #  * :path => allows you to setup path name that will be used, as rails routes does.
+    #             The following route configuration would setup your route as /accounts instead of /users:
+    #
+    #      devise_for :users, :path => 'accounts'
+    #
+    #  * :singular => setup the singular name for the given resource. This is used as the instance variable name in
+    #                 controller, as the name in routes and the scope given to warden.
+    #
+    #      devise_for :users, :singular => :user
+    #
+    #  * :path_names => configure different path names to overwrite defaults :sign_in, :sign_out, :sign_up,
+    #                   :password, :confirmation, :unlock.
+    #
+    #      devise_for :users, :path_names => { :sign_in => 'login', :sign_out => 'logout', :password => 'secret', :confirmation => 'verification' }
+    #
+    #  * :controllers => the controller which should be used. All routes by default points to Devise controllers.
+    #    However, if you want them to point to custom controller, you should do:
+    #
+    #      devise_for :users, :controllers => { :sessions => "users/sessions" }
+    #
+    #  * :module => the namespace to find controlers. By default, devise will access devise/sessions,
+    #    devise/registrations and so on. If you want to namespace all at once, use module:
+    #
+    #      devise_for :users, :module => "users"
+    #
+    #    Notice that whenever you use namespace in the router DSL, it automatically sets the module.
+    #    So the following setup:
+    #
+    #      namespace :publisher
+    #        devise_for :account
+    #      end
+    #
+    #    Will use publisher/sessions controller instead of devise/sessions controller. You can revert
+    #    this by providing the :module option to devise_for.
+    #
+    #  * :skip => tell which controller you want to skip routes from being created:
+    #
+    #      devise_for :users, :skip => :sessions
+    #
+    # ==== Scoping
+    #
+    # Following Rails 3 routes DSL, you can nest devise_for calls inside a scope:
+    #
+    #   scope "/my" do
+    #     devise_for :users
+    #   end
+    #
+    # However, since Devise uses the request path to retrieve the current user, it has one caveats.
+    # If you are using a dynamic segment, as below:
+    #
+    #   scope ":locale" do
+    #     devise_for :users
+    #   end
+    #
+    # You are required to configure default_url_options in your ApplicationController class level, so
+    # Devise can pick it:
+    #
+    #   class ApplicationController < ActionController::Base
+    #     def self.default_url_options
+    #       { :locale => I18n.locale }
+    #     end
+    #   end
+    #
+    def devise_for(*resources)
+      options = resources.extract_options!
+
+      if as = options.delete(:as)
+        ActiveSupport::Deprecation.warn ":as is deprecated, please use :path instead."
+        options[:path] ||= as
       end
 
-      protected
+      if scope = options.delete(:scope)
+        ActiveSupport::Deprecation.warn ":scope is deprecated, please use :singular instead."
+        options[:singular] ||= scope
+      end
 
-        def database_authenticatable(routes, mapping)
-          routes.with_options(:controller => 'sessions', :name_prefix => nil) do |session|
-            session.send(:"new_#{mapping.name}_session",     mapping.path_names[:sign_in],  :action => 'new',     :conditions => { :method => :get })
-            session.send(:"#{mapping.name}_session",         mapping.path_names[:sign_in],  :action => 'create',  :conditions => { :method => :post })
-            destroy_options = { :action => 'destroy' }
-            destroy_options.merge! :conditions => { :method => mapping.sign_out_via } unless mapping.sign_out_via == :any
-            session.send(:"destroy_#{mapping.name}_session", mapping.path_names[:sign_out], destroy_options)
-          end
-        end
+      options[:as]          ||= @scope[:as]     if @scope[:as].present?
+      options[:module]      ||= @scope[:module] if @scope[:module].present?
+      options[:path_prefix] ||= @scope[:path]   if @scope[:path].present?
+      options[:path_names]    = (@scope[:path_names] || {}).merge(options[:path_names] || {})
 
-        def confirmable(routes, mapping)
-          routes.resource :confirmation, :only => [:new, :create, :show], :as => mapping.path_names[:confirmation]
-        end
+      resources.map!(&:to_sym)
 
-        def lockable(routes, mapping)
-          routes.resource :unlock, :only => [:new, :create, :show], :as => mapping.path_names[:unlock]
-        end
+      resources.each do |resource|
+        mapping = Devise.add_mapping(resource, options)
 
-        def recoverable(routes, mapping)
-          routes.resource :password, :only => [:new, :create, :edit, :update], :as => mapping.path_names[:password]
+        begin
+          raise_no_devise_method_error!(mapping.class_name) unless mapping.to.respond_to?(:devise)
+        rescue NameError => e
+          raise unless mapping.class_name == resource.to_s.classify
+          warn "[WARNING] You provided devise_for #{resource.inspect} but there is " <<
+            "no model #{mapping.class_name} defined in your application"
+          next
+        rescue NoMethodError => e
+          raise unless e.message.include?("undefined method `devise'")
+          raise_no_devise_method_error!(mapping.class_name)
         end
 
-        def registerable(routes, mapping)
-          routes.resource :registration, :only => [:new, :create, :edit, :update, :destroy], :as => mapping.raw_path[1..-1], :path_prefix => nil, :path_names => { :new => mapping.path_names[:sign_up] }
+        routes  = mapping.routes
+        routes -= Array(options.delete(:skip)).map { |s| s.to_s.singularize.to_sym }
+
+        devise_scope mapping.name do
+          yield if block_given?
+          with_devise_exclusive_scope mapping.fullpath, mapping.name do
+            routes.each { |mod| send(:"devise_#{mod}", mapping, mapping.controllers) }
+          end
         end
+      end
+    end
+
+    # Allow you to add authentication request from the router:
+    #
+    #   authenticate(:user) do
+    #     resources :post
+    #   end
+    #
+    def authenticate(scope)
+      constraint = lambda do |request|
+        request.env["warden"].authenticate!(:scope => scope)
+      end
+
+      constraints(constraint) do
+        yield
+      end
+    end
+
+    # Sets the devise scope to be used in the controller. If you have custom routes,
+    # you are required to call this method (also aliased as :as) in order to specify
+    # to which controller it is targetted.
+    #
+    #   as :user do
+    #     get "sign_in", :to => "devise/sessions#new"
+    #   end
+    #
+    # Notice you cannot have two scopes mapping to the same URL. And remember, if
+    # you try to access a devise controller without specifying a scope, it will
+    # raise ActionNotFound error.
+    def devise_scope(scope)
+      constraint = lambda do |request|
+        request.env["devise.mapping"] = Devise.mappings[scope]
+        true
+      end
+
+      constraints(constraint) do
+        yield
+      end
     end
+    alias :as :devise_scope
+
+    protected
+
+      def devise_session(mapping, controllers) #:nodoc:
+        scope :controller => controllers[:sessions], :as => :session do
+          get  :new,     :path => mapping.path_names[:sign_in]
+          post :create,  :path => mapping.path_names[:sign_in], :as => ""
+          get  :destroy, :path => mapping.path_names[:sign_out]
+        end
+      end
+ 
+      def devise_password(mapping, controllers) #:nodoc:
+        resource :password, :only => [:new, :create, :edit, :update],
+          :path => mapping.path_names[:password], :controller => controllers[:passwords]
+      end
+ 
+      def devise_confirmation(mapping, controllers) #:nodoc:
+        resource :confirmation, :only => [:new, :create, :show],
+          :path => mapping.path_names[:confirmation], :controller => controllers[:confirmations]
+      end
+ 
+      def devise_unlock(mapping, controllers) #:nodoc:
+        if mapping.to.unlock_strategy_enabled?(:email)
+          resource :unlock, :only => [:new, :create, :show],
+            :path => mapping.path_names[:unlock], :controller => controllers[:unlocks]
+        end
+      end
+
+      def devise_registration(mapping, controllers) #:nodoc:
+        resource :registration, :only => [:new, :create, :edit, :update, :destroy], :path => mapping.path_names[:registration],
+                 :path_names => { :new => mapping.path_names[:sign_up] }, :controller => controllers[:registrations]
+      end
+
+      def with_devise_exclusive_scope(new_path, new_as) #:nodoc:
+        old_as, old_path, old_module = @scope[:as], @scope[:path], @scope[:module]
+        @scope[:as], @scope[:path], @scope[:module] = new_as, new_path, nil
+        yield
+      ensure
+        @scope[:as], @scope[:path], @scope[:module] = old_as, old_path, old_module
+      end
+
+      def raise_no_devise_method_error!(klass) #:nodoc:
+        raise "#{klass} does not respond to 'devise' method. This usually means you haven't " <<
+          "loaded your ORM file or it's being loaded too late. To fix it, be sure to require 'devise/orm/YOUR_ORM' " <<
+          "inside 'config/initializers/devise.rb' or before your application definition in 'config/application.rb'"
+      end
   end
 end

data/lib/devise/rails/warden_compat.rb

@@ -1,6 +1,6 @@
 module Warden::Mixins::Common
   def request
-    @request ||= env['action_controller.rescue.request']
+    @request ||= ActionDispatch::Request.new(env)
   end
 
   def reset_session!
@@ -8,56 +8,32 @@ module Warden::Mixins::Common
     raw_session.clear
   end
 
-  def response
-    @response ||= env['action_controller.rescue.response']
+  def cookies
+    request.cookie_jar
   end
 end
 
 class Warden::SessionSerializer
   def serialize(record)
-    [record.class, record.id]
+    [record.class.name, record.id]
   end
 
   def deserialize(keys)
     klass, id = keys
-    klass.find(:first, :conditions => { :id => id })
-  end
-end
 
-class ActionController::Request
-  def reset_session
-    session.destroy if session && session.respond_to?(:destroy)
-    self.session = {}
-  end
-end
-
-# Solve a bug in Rails where Set-Cookie is returning an array.
-class Devise::CookieSanitizer
-  SET_COOKIE = "Set-Cookie".freeze
-
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    response = @app.call(env)
-    headers = response[1]
-    cookies = headers[SET_COOKIE]
-    if cookies.respond_to?(:join)
-      headers[SET_COOKIE] = cookies.join("\n").squeeze("\n")
+    if klass.is_a?(Class)
+      raise "Devise changed how it stores objects in session. If you are seeing this message, " <<
+        "you can fix it by changing one character in your cookie secret, forcing all previous " <<
+        "cookies to expire, or cleaning up your database sessions if you are using a db store."
     end
-    response
-  end
-end
 
-Rails.configuration.middleware.insert_after ActionController::Failsafe, Devise::CookieSanitizer
-
-Warden::Manager.after_set_user :event => [:set_user, :authentication] do |record, warden, options|
-  if options[:scope] && warden.authenticated?(options[:scope])
-    request = warden.request
-    backup = request.session.to_hash
-    backup.delete(:session_id)
-    request.reset_session
-    request.session.update(backup)
+    klass.constantize.find(:first, :conditions => { :id => id })
+  rescue NameError => e
+    if e.message =~ /uninitialized constant/
+      Rails.logger.debug "Trying to deserialize invalid class #{klass}"
+      nil
+    else
+      raise
+    end
   end
-end
+end

data/lib/devise/rails.rb

@@ -1,14 +1,69 @@
 require 'devise/rails/routes'
 require 'devise/rails/warden_compat'
 
-Rails.configuration.after_initialize do
-  require "devise/orm/#{Devise.orm}"
+# Include UrlHelpers in ActionController and ActionView as soon as they are loaded.
+ActiveSupport.on_load(:action_controller) { include Devise::Controllers::UrlHelpers }
+ActiveSupport.on_load(:action_view) { include Devise::Controllers::UrlHelpers }
 
-  # Adds Warden Manager to Rails middleware stack, configuring default devise
-  # strategy and also the failure app.
-  Rails.configuration.middleware.use Warden::Manager do |config|
-    Devise.configure_warden(config)
-  end
+module Devise
+  class Engine < ::Rails::Engine
+    config.devise = Devise
+
+    config.app_middleware.use Warden::Manager do |config|
+      Devise.warden_config = config
+    end
+
+    # Force routes to be loaded if we are doing any eager load.
+    config.before_eager_load { |app| app.reload_routes! }
+
+    config.after_initialize do
+      Devise.encryptor ||= begin
+        warn "[WARNING] config.encryptor is not set in your config/initializers/devise.rb. " \
+          "Devise will then set it to :bcrypt. If you were using the previous default " \
+          "encryptor, please add config.encryptor = :sha1 to your configuration file." if Devise.mailer_sender
+        :bcrypt
+      end
+    end
+
+    initializer "devise.add_filters" do |app|
+      app.config.filter_parameters += [:password, :password_confirmation]
+      app.config.filter_parameters.uniq
+    end
+
+    unless Rails.env.production?
+      config.after_initialize do
+        actions = [:confirmation_instructions, :reset_password_instructions, :unlock_instructions]
+
+        translations = begin
+          I18n.t("devise.mailer", :raise => true).map { |k, v| k if v.is_a?(String) }.compact
+        rescue Exception => e # Do not care if something fails
+          []
+        end
 
-  I18n.load_path.unshift File.expand_path(File.join(File.dirname(__FILE__), 'locales', 'en.yml'))
-end
+        keys = actions & translations
+
+        keys.each do |key|
+          ActiveSupport::Deprecation.warn "The I18n message 'devise.mailer.#{key}' is deprecated. " \
+            "Please use 'devise.mailer.#{key}.subject' instead."
+        end
+      end
+
+      config.after_initialize do
+        flash = [:unauthenticated, :unconfirmed, :invalid, :invalid_token, :timeout, :inactive, :locked]
+
+        translations = begin
+          I18n.t("devise.sessions", :raise => true).keys
+        rescue Exception => e # Do not care if something fails
+          []
+        end
+
+        keys = flash & translations
+
+        if keys.any?
+          ActiveSupport::Deprecation.warn "The following I18n messages in 'devise.sessions' " \
+            "are deprecated: #{keys.to_sentence}. Please move them to 'devise.failure' instead."
+        end
+      end
+    end
+  end
+end

data/lib/devise/schema.rb

@@ -12,6 +12,11 @@ module Devise
     #
     # == Options
     # * :null - When true, allow columns to be null.
+    # * :default - Should be set to "" when :null is false.
+    #
+    # == Notes
+    # For Datamapper compatibility, we explicitly hardcode the limit for the
+    # encrypter password field in 128 characters.
     def database_authenticatable(options={})
       null    = options[:null] || false
       default = options[:default] || ""
@@ -20,53 +25,72 @@ module Devise
         ActiveSupport::Deprecation.warn ":encryptor as option is deprecated, simply remove it."
       end
 
-      apply_schema :email,              String, :null => null, :default => default
-      apply_schema :encrypted_password, String, :null => null, :default => default, :limit => 128
-      apply_schema :password_salt,      String, :null => null, :default => default
-    end
+      apply_devise_schema :email,              String, :null => null, :default => default
+      apply_devise_schema :encrypted_password, String, :null => null, :default => default, :limit => 128
+      apply_devise_schema :password_salt,      String, :null => null, :default => default
+    end      
 
     # Creates authentication_token.
-    def token_authenticatable
-      apply_schema :authentication_token, String
+    def token_authenticatable(options={})
+      apply_devise_schema :authentication_token, String
     end
 
     # Creates confirmation_token, confirmed_at and confirmation_sent_at.
     def confirmable
-      apply_schema :confirmation_token,   String
-      apply_schema :confirmed_at,         DateTime
-      apply_schema :confirmation_sent_at, DateTime
+      apply_devise_schema :confirmation_token,   String
+      apply_devise_schema :confirmed_at,         DateTime
+      apply_devise_schema :confirmation_sent_at, DateTime
     end
 
     # Creates reset_password_token.
     def recoverable
-      apply_schema :reset_password_token, String
+      apply_devise_schema :reset_password_token, String
     end
 
     # Creates remember_token and remember_created_at.
     def rememberable
-      apply_schema :remember_token,      String
-      apply_schema :remember_created_at, DateTime
+      apply_devise_schema :remember_token,      String
+      apply_devise_schema :remember_created_at, DateTime
     end
 
     # Creates sign_in_count, current_sign_in_at, last_sign_in_at,
     # current_sign_in_ip, last_sign_in_ip.
     def trackable
-      apply_schema :sign_in_count,      Integer, :default => 0
-      apply_schema :current_sign_in_at, DateTime
-      apply_schema :last_sign_in_at,    DateTime
-      apply_schema :current_sign_in_ip, String
-      apply_schema :last_sign_in_ip,    String
+      apply_devise_schema :sign_in_count,      Integer, :default => 0
+      apply_devise_schema :current_sign_in_at, DateTime
+      apply_devise_schema :last_sign_in_at,    DateTime
+      apply_devise_schema :current_sign_in_ip, String
+      apply_devise_schema :last_sign_in_ip,    String
     end
 
-    # Creates failed_attempts, unlock_token and locked_at
-    def lockable
-      apply_schema :failed_attempts, Integer, :default => 0
-      apply_schema :unlock_token,    String
-      apply_schema :locked_at,       DateTime
+    # Creates failed_attempts, unlock_token and locked_at depending on the options given.
+    #
+    # == Options
+    # * :unlock_strategy - The strategy used for unlock. Can be :time, :email, :both (default), :none.
+    #   If :email or :both, creates a unlock_token field.
+    # * :lock_strategy - The strategy used for locking. Can be :failed_attempts (default) or :none.
+    def lockable(options={})
+      unlock_strategy   = options[:unlock_strategy]
+      unlock_strategy ||= self.unlock_strategy if respond_to?(:unlock_strategy)
+      unlock_strategy ||= :both
+
+      lock_strategy   = options[:lock_strategy]
+      lock_strategy ||= self.lock_strategy if respond_to?(:lock_strategy)
+      lock_strategy ||= :failed_attempts
+
+      if lock_strategy == :failed_attempts
+        apply_devise_schema :failed_attempts, Integer, :default => 0
+      end
+
+      if [:both, :email].include?(unlock_strategy)
+        apply_devise_schema :unlock_token, String
+      end
+
+      apply_devise_schema :locked_at, DateTime
     end
 
     # Overwrite with specific modification to create your own schema.
-    def apply_schema(name, type, options={})
+    def apply_devise_schema(name, type, options={})
       raise NotImplementedError
     end
   end