class Warden::Config

add more configuration to warden, you just need to extend this class.
This class is yielded inside Warden::Manager. If you have a plugin and want to

def self.hash_accessor(*names) #:nodoc:

:nodoc:

config.failure_app #=> Bar
config[:failure_app] = Bar

config[:failure_app] #=> Foo
config.failure_app = Foo
config = Config.new

end
hash_accessor :failure_app
class Config < Hash

Creates an accessor that simply sets and reads a key in the hash: 
def self.hash_accessor(*names) #:nodoc:
  names.each do |name|
    class_eval <<-METHOD, __FILE__, __LINE__ + 1
      def #{name}
        self[:#{name}]
      end
      def #{name}=(value)
        self[:#{name}] = value
      end
    METHOD
  end
end

def deep_dup(key, other) 

def deep_dup(key, other)
  self[key] = hash = other[key].dup
  hash.each { |k, v| hash[k] = v.dup }
end

def default_strategies(*strategies)

:api: public
Set the default strategies to use. 
def default_strategies(*strategies)
  opts  = Hash === strategies.last ? strategies.pop : {}
  hash  = self[:default_strategies]
  scope = opts[:scope] || :_all
  hash[scope] = strategies.flatten unless strategies.empty?
  hash[scope] || hash[:_all] || []
end

def initialize(other={}) 

def initialize(other={})
  merge!(other)
  self[:default_scope]      ||= :default
  self[:scope_defaults]     ||= {}
  self[:default_strategies] ||= {}
  self[:intercept_401] = true unless key?(:intercept_401)
end

def initialize_copy(other) 

def initialize_copy(other)
  super
  deep_dup(:scope_defaults, other)
  deep_dup(:default_strategies, other)
end

def scope_defaults(scope, opts = {})

:api: public
A short hand way to set up a particular scope 
def scope_defaults(scope, opts = {})
  if strategies = opts.delete(:strategies)
    default_strategies(strategies, :scope => scope)
  end
  if opts.empty?
    self[:scope_defaults][scope] || {}
  else
    self[:scope_defaults][scope] ||= {}
    self[:scope_defaults][scope].merge!(opts)
  end
end

def serialize_from_session(*args, &block)

:api: public
Hook from configuration to serialize_from_session. 
def serialize_from_session(*args, &block)
  Warden::Manager.serialize_from_session(*args, &block)
end

def serialize_into_session(*args, &block)

:api: public
Hook from configuration to serialize_into_session. 
def serialize_into_session(*args, &block)
  Warden::Manager.serialize_into_session(*args, &block)
end

def silence_missing_strategies!

:api: plugin
Do not raise an error if a missing strategy is given. 
def silence_missing_strategies!
  self[:silence_missing_strategies] = true
end

def silence_missing_strategies? #:nodoc:

:nodoc: 
def silence_missing_strategies? #:nodoc:
  !!self[:silence_missing_strategies]
end

def strategies

:api: public
Quick accessor to strategies from manager 
def strategies
  Warden::Strategies
end