devise 0.8.2 → 0.9.0

data/lib/devise/models/cookie_serializer.rb

@@ -1,21 +0,0 @@
-require 'devise/serializers/cookie'
-
-module Devise
-  module Models
-    module CookieSerializer
-      # Create the cookie key using the record id and remember_token
-      def serialize_into_cookie(record)
-        "#{record.id}::#{record.remember_token}"
-      end
-
-      # Recreate the user based on the stored cookie
-      def serialize_from_cookie(cookie)
-        record_id, record_token = cookie.split('::')
-        record = find(:first, :conditions => { :id => record_id }) if record_id
-        record if record.try(:valid_remember_token?, record_token)
-      end
-
-      Devise::Models.config(self, :remember_for)
-    end
-  end
-end

data/lib/devise/models/session_serializer.rb

@@ -1,19 +0,0 @@
-require 'devise/serializers/session'
-
-module Devise
-  module Models
-    module SessionSerializer
-      # Hook to serialize user into session. Overwrite if you want.
-      def serialize_into_session(record)
-        [record.class, record.id]
-      end
-
-      # Hook to serialize user from session. Overwrite if you want.
-      def serialize_from_session(keys)
-        klass, id = keys
-        raise "#{self} cannot serialize from #{klass} session since it's not one of its ancestors" unless klass <= self
-        klass.find(:first, :conditions => { :id => id })
-      end
-    end
-  end
-end

data/lib/devise/serializers/base.rb

@@ -1,23 +0,0 @@
-require 'devise/strategies/base'
-
-module Devise
-  module Serializers
-    module Base
-      include Devise::Strategies::Base
-      attr_reader :scope
-
-      def serialize(record)
-        record.class.send(:"serialize_into_#{klass_type}", record)
-      end
-
-      def deserialize(keys)
-        mapping.to.send(:"serialize_from_#{klass_type}", keys)
-      end
-
-      def fetch(scope)
-        @scope = scope
-        super
-      end
-    end
-  end
-end

data/lib/devise/serializers/cookie.rb

@@ -1,43 +0,0 @@
-require 'devise/serializers/base'
-
-module Devise
-  module Serializers
-    # This is a cookie serializer which stores the information if a :remember_me
-    # is sent in the params and if the model responds to remember_me! as well.
-    # As in Session serializer, the invoked methods are:
-    #
-    #   User.serialize_into_cookie(@user)
-    #   User.serialize_from_cookie(*args)
-    #
-    # An implementation for such methods can be found at Devise::Models::Rememberable.
-    #
-    # Differently from session, this approach is based in a token which is stored in
-    # the database. So if you want to sign out all clients at once, you just need to
-    # clean up the token column.
-    #
-    class Cookie < Warden::Serializers::Cookie
-      include Devise::Serializers::Base
-
-      def store(record, scope)
-        remember_me = params[scope].try(:fetch, :remember_me, nil)
-        if Devise::TRUE_VALUES.include?(remember_me) && record.respond_to?(:remember_me!)
-          record.remember_me!
-          super
-        end
-      end
-
-      def default_options(record)
-        super.merge!(:expires => record.remember_expires_at)
-      end
-
-      def delete(scope, record=nil)
-        if record && record.respond_to?(:forget_me!)
-          record.forget_me! 
-          super
-        end
-      end
-    end
-  end
-end
-
-Warden::Serializers.add(:cookie, Devise::Serializers::Cookie)

data/lib/devise/serializers/session.rb

@@ -1,22 +0,0 @@
-require 'devise/serializers/base'
-
-module Devise
-  module Serializers
-    # This serializer stores sign in information in th client session. It just
-    # extends Warden own serializer to move all the serialization logic to a
-    # class. For example, if a @user resource is given, it will call the following
-    # two methods to serialize and deserialize a record:
-    #
-    #   User.serialize_into_session(@user)
-    #   User.serialize_from_session(*args)
-    #
-    # This can be used any strategy and the default implementation is available
-    # at Devise::Models::SessionSerializer.
-    #
-    class Session < Warden::Serializers::Session
-      include Devise::Serializers::Base
-    end
-  end
-end
-
-Warden::Serializers.add(:session, Devise::Serializers::Session)

data/test/controllers/filters_test.rb

@@ -1,177 +0,0 @@
-require 'test/test_helper'
-require 'ostruct'
-
-class MockController < ApplicationController
-  attr_accessor :env
-
-  def request
-    self
-  end
-
-  def path
-    ''
-  end
-end
-
-class ControllerAuthenticableTest < ActionController::TestCase
-  tests MockController
-
-  def setup
-    @controller = MockController.new
-    @mock_warden = OpenStruct.new
-    @controller.env = { 'warden' => @mock_warden }
-    @controller.session = {}
-  end
-
-  test 'setup warden' do
-    assert_not_nil @controller.warden
-  end
-
-  test 'provide access to warden instance' do
-    assert_equal @controller.warden, @controller.env['warden']
-  end
-
-  test 'run authenticate? with scope on warden' do
-    @mock_warden.expects(:authenticated?).with(:my_scope)
-    @controller.signed_in?(:my_scope)
-  end
-
-  test 'proxy signed_in? to authenticated' do
-    @mock_warden.expects(:authenticated?).with(:my_scope)
-    @controller.signed_in?(:my_scope)
-  end
-
-  test 'run user with scope on warden' do
-    @mock_warden.expects(:user).with(:admin).returns(true)
-    @controller.current_admin
-
-    @mock_warden.expects(:user).with(:user).returns(true)
-    @controller.current_user
-  end
-
-  test 'proxy user_authenticate! to authenticate with user scope' do
-    @mock_warden.expects(:authenticate!).with(:scope => :user)
-    @controller.authenticate_user!
-  end
-
-  test 'proxy admin_authenticate! to authenticate with admin scope' do
-    @mock_warden.expects(:authenticate!).with(:scope => :admin)
-    @controller.authenticate_admin!
-  end
-
-  test 'proxy user_authenticated? to authenticate with user scope' do
-    @mock_warden.expects(:authenticated?).with(:user)
-    @controller.user_signed_in?
-  end
-
-  test 'proxy admin_authenticated? to authenticate with admin scope' do
-    @mock_warden.expects(:authenticated?).with(:admin)
-    @controller.admin_signed_in?
-  end
-
-  test 'proxy user_session to session scope in warden' do
-    @mock_warden.expects(:session).with(:user).returns({})
-    @controller.user_session
-  end
-
-  test 'proxy admin_session to session scope in warden' do
-    @mock_warden.expects(:session).with(:admin).returns({})
-    @controller.admin_session
-  end
-
-  test 'sign in proxy to set_user on warden' do
-    user = User.new
-    @mock_warden.expects(:set_user).with(user, :scope => :user).returns(true)
-    @controller.sign_in(:user, user)
-  end
-
-  test 'sign in accepts a resource as argument' do
-    user = User.new
-    @mock_warden.expects(:set_user).with(user, :scope => :user).returns(true)
-    @controller.sign_in(user)
-  end
-
-  test 'sign out proxy to logout on warden' do
-    @mock_warden.expects(:user).with(:user).returns(true)
-    @mock_warden.expects(:logout).with(:user).returns(true)
-    @controller.sign_out(:user)
-  end
-
-  test 'sign out accepts a resource as argument' do
-    @mock_warden.expects(:user).with(:user).returns(true)
-    @mock_warden.expects(:logout).with(:user).returns(true)
-    @controller.sign_out(User.new)
-  end
-
-  test 'stored location for returns the location for a given scope' do
-    assert_nil @controller.stored_location_for(:user)
-    @controller.session[:"user.return_to"] = "/foo.bar"
-    assert_equal "/foo.bar", @controller.stored_location_for(:user)
-  end
-
-  test 'stored location for accepts a resource as argument' do
-    assert_nil @controller.stored_location_for(:user)
-    @controller.session[:"user.return_to"] = "/foo.bar"
-    assert_equal "/foo.bar", @controller.stored_location_for(User.new)
-  end
-
-  test 'stored location cleans information after reading' do
-    @controller.session[:"user.return_to"] = "/foo.bar"
-    assert_equal "/foo.bar", @controller.stored_location_for(:user)
-    assert_nil @controller.session[:"user.return_to"]
-  end
-
-  test 'after sign in path defaults to root path if none by was specified for the given scope' do
-    assert_equal root_path, @controller.after_sign_in_path_for(:user)
-  end
-
-  test 'after sign in path defaults to the scoped root path' do
-    assert_equal admin_root_path, @controller.after_sign_in_path_for(:admin)
-  end
-
-  test 'after sign out path defaults to the root path' do
-    assert_equal root_path, @controller.after_sign_out_path_for(:admin)
-    assert_equal root_path, @controller.after_sign_out_path_for(:user)
-  end
-
-  test 'sign in and redirect uses the stored location' do
-    user = User.new
-    @controller.session[:"user.return_to"] = "/foo.bar"
-    @mock_warden.expects(:set_user).with(user, :scope => :user).returns(true)
-    @controller.expects(:redirect_to).with("/foo.bar")
-    @controller.sign_in_and_redirect(user)
-  end
-
-  test 'sign in and redirect uses the configured after sign in path' do
-    admin = Admin.new
-    @mock_warden.expects(:set_user).with(admin, :scope => :admin).returns(true)
-    @controller.expects(:redirect_to).with(admin_root_path)
-    @controller.sign_in_and_redirect(admin)
-  end
-
-  test 'only redirect if just a symbol is given' do
-    @controller.expects(:redirect_to).with(admin_root_path)
-    @controller.sign_in_and_redirect(:admin)
-  end
-
-  test 'sign out and redirect uses the configured after sign out path' do
-    @mock_warden.expects(:user).with(:admin).returns(true)
-    @mock_warden.expects(:logout).with(:admin).returns(true)
-    @controller.expects(:redirect_to).with(admin_root_path)
-    @controller.instance_eval "def after_sign_out_path_for(resource); admin_root_path; end"
-    @controller.sign_out_and_redirect(:admin)
-  end
-
-  test 'is not a devise controller' do
-    assert_not @controller.devise_controller?
-  end
-
-  test 'default url options are retrieved from devise' do
-    begin
-      Devise.default_url_options {{ :locale => I18n.locale }}
-      assert_equal({ :locale => :en }, @controller.send(:default_url_options))
-    ensure
-      Devise.default_url_options {{ }}
-    end
-  end
-end

data/test/rails_app/app/active_record/account.rb

@@ -1,7 +0,0 @@
-class Account < ActiveRecord::Base
-  devise :all
-
-  def self.find_for_authentication(conditions)
-    nil
-  end
-end

data/test/rails_app/app/mongo_mapper/account.rb

@@ -1,9 +0,0 @@
-class Account
-  include MongoMapper::Document
-
-  devise :all
-
-  def self.find_for_authentication(conditions)
-    nil
-  end
-end