devise_ennder 1.0.1.0.9

data/lib/devise/models/token_authenticatable.rb

@@ -0,0 +1,89 @@
+require 'devise/strategies/token_authenticatable'
+
+module Devise
+  module Models
+    # Token Authenticatable Module, responsible for generate authentication token and validating
+    # authenticity of a user while signing in using an authentication token (say follows an URL).
+    #
+    # == Configuration:
+    #
+    # You can overwrite configuration values by setting in globally in Devise (+Devise.setup+),
+    # using devise method, or overwriting the respective instance method.
+    #
+    # +token_authentication_key+ - Defines name of the authentication token params key. E.g. /users/sign_in?some_key=...
+    #
+    # == Examples:
+    #
+    #    User.authenticate_with_token(:auth_token => '123456789')           # returns authenticated user or nil
+    #    User.find(1).valid_authentication_token?('rI1t6PKQ8yP7VetgwdybB')  # returns true/false
+    #
+    module TokenAuthenticatable
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+          before_save :ensure_authentication_token
+        end
+      end
+
+      # Generate new authentication token (a.k.a. "single access token").
+      def reset_authentication_token
+        self.authentication_token = self.class.authentication_token
+      end
+
+      # Generate new authentication token and save the record.
+      def reset_authentication_token!
+        reset_authentication_token
+        self.save
+      end
+
+      # Generate authentication token unless already exists.
+      def ensure_authentication_token
+        self.reset_authentication_token if self.authentication_token.blank?
+      end
+
+      # Generate authentication token unless already exists and save the record.
+      def ensure_authentication_token!
+        self.reset_authentication_token! if self.authentication_token.blank?
+      end
+
+      # Verifies whether an +incoming_authentication_token+ (i.e. from single access URL)
+      # is the user authentication token.
+      def valid_authentication_token?(incoming_auth_token)
+        incoming_auth_token.present? && incoming_auth_token == self.authentication_token
+      end
+
+      module ClassMethods
+        ::Devise::Models.config(self, :token_authentication_key)
+
+        # Authenticate a user based on authentication token.
+        def authenticate_with_token(attributes)
+          token = attributes[self.token_authentication_key]
+          resource = self.find_for_token_authentication(token)
+          resource if resource.try(:valid_authentication_token?, token)
+        end
+
+        def authentication_token
+          ::Devise.friendly_token
+        end
+
+        protected
+
+          # Find first record based on conditions given (ie by the sign in form).
+          # Overwrite to add customized conditions, create a join, or maybe use a
+          # namedscope to filter records while authenticating.
+          #
+          # == Example:
+          #
+          #   def self.find_for_token_authentication(token, conditions = {})
+          #     conditions = {:active => true}
+          #     self.find_by_authentication_token(token, :conditions => conditions)
+          #   end
+          #
+          def find_for_token_authentication(token)
+            self.find(:first, :conditions => { :authentication_token => token})
+          end
+
+      end
+    end
+  end
+end

data/lib/devise/models/trackable.rb

@@ -0,0 +1,16 @@
+require 'devise/hooks/trackable'
+
+module Devise
+  module Models
+    # Track information about your user sign in. It tracks the following columns:
+    #
+    # * sign_in_count      - Increased every time a sign in is made (by form, openid, oauth)
+    # * current_sign_in_at - A tiemstamp updated when the user signs in
+    # * last_sign_in_at    - Holds the timestamp of the previous sign in
+    # * current_sign_in_ip - The remote ip updated when the user sign in
+    # * last_sign_in_at    - Holds the remote ip of the previous sign in
+    #
+    module Trackable
+    end
+  end
+end

data/lib/devise/models/validatable.rb

@@ -0,0 +1,39 @@
+module Devise
+  module Models
+
+    # Validatable creates all needed validations for a user email and password.
+    # It's optional, given you may want to create the validations by yourself.
+    # Automatically validate if the email is present, unique and it's format is
+    # valid. Also tests presence of password, confirmation and length
+    module Validatable
+      # All validations used by this module.
+      VALIDATIONS = [ :validates_presence_of, :validates_uniqueness_of, :validates_format_of,
+                      :validates_confirmation_of, :validates_length_of ].freeze
+
+      def self.included(base)
+        assert_validations_api!(base)
+
+        base.class_eval do
+          validates_presence_of   :email
+          validates_uniqueness_of :email, :scope => authentication_keys[1..-1], :case_sensitive => false, :allow_blank => true
+          validates_format_of     :email, :with  => EMAIL_REGEX, :allow_blank => true
+
+          with_options :if => :password_required? do |v|
+            v.validates_presence_of     :password
+            v.validates_confirmation_of :password
+            v.validates_length_of       :password, :within => 6..20, :allow_blank => true
+          end
+        end
+      end
+
+      def self.assert_validations_api!(base) #:nodoc:
+        unavailable_validations = VALIDATIONS.select { |v| !base.respond_to?(v) }
+
+        unless unavailable_validations.empty?
+          raise "Could not use :validatable module since #{base} does not respond " <<
+                "to the following methods: #{unavailable_validations.to_sentence}."
+        end
+      end
+    end
+  end
+end

data/lib/devise/models.rb

@@ -0,0 +1,117 @@
+module Devise
+  module Models
+    autoload :Activatable, 'devise/models/activatable'
+    autoload :DatabaseAuthenticatable, 'devise/models/database_authenticatable'
+    autoload :Confirmable, 'devise/models/confirmable'
+    autoload :Lockable, 'devise/models/lockable'
+    autoload :Recoverable, 'devise/models/recoverable'
+    autoload :Rememberable, 'devise/models/rememberable'
+    autoload :Registerable, 'devise/models/registerable'
+    autoload :Timeoutable, 'devise/models/timeoutable'
+    autoload :Trackable, 'devise/models/trackable'
+    autoload :Validatable, 'devise/models/validatable'
+
+    # Creates configuration values for Devise and for the given module.
+    #
+    #   Devise::Models.config(Devise::Authenticable, :stretches, 10)
+    #
+    # The line above creates:
+    #
+    #   1) An accessor called Devise.stretches, which value is used by default;
+    #
+    #   2) Some class methods for your model Model.stretches and Model.stretches=
+    #      which have higher priority than Devise.stretches;
+    #
+    #   3) And an instance method stretches.
+    #
+    # To add the class methods you need to have a module ClassMethods defined
+    # inside the given class.
+    #
+    def self.config(mod, *accessors) #:nodoc:
+      accessors.each do |accessor|
+        mod.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{accessor}
+            if defined?(@#{accessor})
+              @#{accessor}
+            elsif superclass.respond_to?(:#{accessor})
+              superclass.#{accessor}
+            else
+              Devise.#{accessor}
+            end
+          end
+
+          def #{accessor}=(value)
+            @#{accessor} = value
+          end
+        METHOD
+      end
+    end
+
+    # Include the chosen devise modules in your model:
+    #
+    #   devise :authenticatable, :confirmable, :recoverable
+    #
+    # You can also give any of the devise configuration values in form of a hash,
+    # with specific values for this model. Please check your Devise initializer
+    # for a complete description on those values.
+    #
+    def devise(*modules)
+      raise "You need to give at least one Devise module" if modules.empty?
+      options = modules.extract_options!
+
+      if modules.delete(:authenticatable)
+        ActiveSupport::Deprecation.warn ":authenticatable as module is deprecated. Please give :database_authenticatable instead.", caller
+        modules << :database_authenticatable
+      end
+
+      @devise_modules = Devise::ALL & modules.map(&:to_sym).uniq
+
+      Devise.orm_class.included_modules_hook(self) do
+        devise_modules.each do |m|
+          include Devise::Models.const_get(m.to_s.classify)
+        end
+
+        options.each { |key, value| send(:"#{key}=", value) }
+      end
+    end
+
+    # Stores all modules included inside the model, so we are able to verify
+    # which routes are needed.
+    def devise_modules
+      @devise_modules ||= []
+    end
+
+    # Find an initialize a record setting an error if it can't be found.
+    def find_or_initialize_with_error_by(attribute, value, error=:invalid)
+      if value.present?
+        conditions = { attribute => value }
+        record = find(:first, :conditions => conditions)
+      end
+
+      unless record
+        record = new
+
+        if value.present?
+          record.send(:"#{attribute}=", value)
+        else
+          error, skip_default = :blank, true
+        end
+
+        add_error_on(record, attribute, error, !skip_default)
+      end
+
+      record
+    end
+
+    # Wraps add error logic in a method that works for different frameworks.
+    def add_error_on(record, attribute, error, add_default=true)
+      options = add_default ? { :default => error.to_s.gsub("_", " ") } : {}
+
+      begin
+        record.errors.add(attribute, error, options)
+      rescue ArgumentError
+        record.errors.add(attribute, error.to_s.gsub("_", " "))
+      end
+    end
+  end
+end

data/lib/devise/orm/active_record.rb

@@ -0,0 +1,41 @@
+module Devise
+  module Orm
+    # This module contains some helpers and handle schema (migrations):
+    #
+    #   create_table :accounts do |t|
+    #     t.authenticatable
+    #     t.confirmable
+    #     t.recoverable
+    #     t.rememberable
+    #     t.trackable
+    #     t.lockable
+    #     t.timestamps
+    #   end
+    #
+    # However this method does not add indexes. If you need them, here is the declaration:
+    #
+    #   add_index "accounts", ["email"],                :name => "email",                :unique => true
+    #   add_index "accounts", ["confirmation_token"],   :name => "confirmation_token",   :unique => true
+    #   add_index "accounts", ["reset_password_token"], :name => "reset_password_token", :unique => true
+    #
+    module ActiveRecord
+      # Required ORM hook. Just yield the given block in ActiveRecord.
+      def self.included_modules_hook(klass)
+        yield
+      end
+
+      include Devise::Schema
+
+      # Tell how to apply schema methods.
+      def apply_schema(name, type, options={})
+        column name, type.to_s.downcase.to_sym, options
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord)
+  ActiveRecord::Base.extend Devise::Models
+  ActiveRecord::ConnectionAdapters::Table.send :include, Devise::Orm::ActiveRecord
+  ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Devise::Orm::ActiveRecord
+end

data/lib/devise/orm/data_mapper.rb

@@ -0,0 +1,83 @@
+module Devise
+  module Orm
+    module DataMapper
+      module InstanceMethods
+        def save(flag=nil)
+          if flag == false
+            save!
+          else
+            super()
+          end
+        end
+      end
+
+      def self.included_modules_hook(klass)
+        klass.send :extend,  self
+        klass.send :include, InstanceMethods
+
+        yield
+
+        klass.devise_modules.each do |mod|
+          klass.send(mod) if klass.respond_to?(mod)
+        end
+      end
+
+      include Devise::Schema
+
+      SCHEMA_OPTIONS = {
+        :null  => :nullable,
+        :limit => :length
+      }
+
+      # Hooks for confirmable
+      def before_create(*args)
+        wrap_hook(:before, *args)
+      end
+
+      def after_create(*args)
+        wrap_hook(:after, *args)
+      end
+
+      def wrap_hook(action, *args)
+        options = args.extract_options!
+
+        args.each do |callback|
+          send action, :create, callback
+          class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def #{callback}
+              super if #{options[:if] || true}
+            end
+          METHOD
+        end
+      end
+
+      # Add ActiveRecord like finder
+      def find(*args)
+        options = args.extract_options!
+        case args.first
+          when :first
+            first(options)
+          when :all
+            all(options)
+          else
+            get(*args)
+        end
+      end
+
+      # Tell how to apply schema methods. This automatically maps :limit to
+      # :length and :null to :nullable.
+      def apply_schema(name, type, options={})
+        return unless Devise.apply_schema
+
+        SCHEMA_OPTIONS.each do |old_key, new_key|
+          next unless options.key?(old_key)
+          options[new_key] = options.delete(old_key)
+        end
+
+        property name, type, options
+      end
+    end
+  end
+end
+
+DataMapper::Model.send(:include, Devise::Models)

data/lib/devise/orm/mongo_mapper.rb

@@ -0,0 +1,52 @@
+module Devise
+  module Orm
+    module MongoMapper
+      module InstanceMethods
+        def save(options={})
+          if options == false
+            super(:validate => false)
+          else
+            super
+          end
+        end
+      end
+
+      def self.included_modules_hook(klass)
+        klass.send :extend,  self
+        klass.send :include, InstanceMethods
+        yield
+
+        klass.devise_modules.each do |mod|
+          klass.send(mod) if klass.respond_to?(mod)
+        end
+      end
+      
+      def find(*args)
+        case args.first
+        when :first, :all
+          send(args.shift, *args)
+        else
+          super
+        end
+      end
+      
+      include Devise::Schema
+
+      # Tell how to apply schema methods. This automatically converts DateTime
+      # to Time, since MongoMapper does not recognize the former.
+      def apply_schema(name, type, options={})
+        return unless Devise.apply_schema
+        type = Time if type == DateTime
+        key name, type, options
+      end
+    end
+  end
+end
+
+if MongoMapper::Version >= "0.8.0"
+  MongoMapper::Plugins::Document::ClassMethods.send(:include, Devise::Models)
+  MongoMapper::Plugins::EmbeddedDocument::ClassMethods.send(:include, Devise::Models)
+else
+  MongoMapper::Document::ClassMethods.send(:include, Devise::Models)
+  MongoMapper::EmbeddedDocument::ClassMethods.send(:include, Devise::Models)
+end

data/lib/devise/rails/routes.rb

@@ -0,0 +1,133 @@
+module ActionController::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?
+
+      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
+      end
+
+      protected
+
+        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
+
+        def confirmable(routes, mapping)
+          routes.resource :confirmation, :only => [:new, :create, :show], :as => mapping.path_names[:confirmation]
+        end
+
+        def lockable(routes, mapping)
+          routes.resource :unlock, :only => [:new, :create, :show], :as => mapping.path_names[:unlock]
+        end
+
+        def recoverable(routes, mapping)
+          routes.resource :password, :only => [:new, :create, :edit, :update], :as => mapping.path_names[:password]
+        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] }
+        end
+    end
+  end
+end

data/lib/devise/rails/warden_compat.rb

@@ -0,0 +1,60 @@
+module Warden::Mixins::Common
+  def request
+    @request ||= env['action_controller.rescue.request']
+  end
+
+  def reset_session!
+    raw_session.inspect # why do I have to inspect it to get it to clear?
+    raw_session.clear
+  end
+
+  def response
+    @response ||= env['action_controller.rescue.response']
+  end
+end
+
+class Warden::SessionSerializer
+  def serialize(record)
+    [record.class, 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]
+    headers[SET_COOKIE] = headers[SET_COOKIE].join("\n") if headers[SET_COOKIE].respond_to?(:join)
+    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)
+  end
+end

data/lib/devise/rails.rb

@@ -0,0 +1,14 @@
+require 'devise/rails/routes'
+require 'devise/rails/warden_compat'
+
+Rails.configuration.after_initialize do
+  require "devise/orm/#{Devise.orm}"
+
+  # 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
+
+  I18n.load_path.unshift File.expand_path(File.join(File.dirname(__FILE__), 'locales', 'en.yml'))
+end