loyal_warden 0.0.5

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'rack', '1.3'
+
+group :test do
+  gem 'rspec', '~>2'
+  gem 'rack-test'
+end

data/History.rdoc

@@ -0,0 +1,150 @@
+== Version 1.2.3 / 2013-07-14
+* Fix an issue with lazy loaded sessions
+
+== Version 1.2.2 / 2013-07-12
+* Support nil session stores on logout
+* Fix strategies blowing up with undefined method base
+
+== Version 1.2.1 / 2012-06-16
+* Minor caching and speed improvements
+* Add support to #lock in the proxy
+* Add support to after_failed_fetch callback
+
+== Version 1.2.0 / 2012-05-08
+* Deprecate warden_cookies since it was never functional
+* Add support to serialize_from_session and serialize_into_session per scope
+
+== Version 1.1.1 / 2012-02-16
+* Allow run_callbacks as an option to set_user and user
+
+== Version 1.1.0 / 2011-11-02
+* Use the default scopes action when using a bare throw(:warden)
+
+== Version 1.0.6
+* Remove gem files from the packaged gem
+
+== Version 1.0.3
+* Do not renew session on user fetch
+
+== Version 1.0.2
+* Added :intercept_401 to Warden::Config
+
+== Version 1.0.1
+* Bug fix on strategies errors handler
+
+== Version 1.0.0
+* Bump!
+* Allow strategies to configure if user should be stored or not
+* Force session id renewal when user is set
+
+== Version 0.10.7
+* Performance boost. config object to use raw accessors
+* Add per strategy storage option
+
+== Version 0.10.6 / 0.10.7 / 2010-05-22
+* Bugfix set_user was not respecting logouts in hooks
+
+== Version 0.10.4 / 0.10.5 / 2010-05-20
+* Add action specifying in scope_defaults
+
+== Version 0.10.3 / 2010-03-01
+* Bugfix prevent halted winning strategy from being skipped in subsequent runs
+
+== Version 0.10.2 / 2010-03-26
+* Halt on fail!.  Add fail to allow cascading
+* cache the winning strategy
+* Make the config object Dupable
+
+== Version 0.10.1 / 2010-03-23
+* Merge previous from master
+* tag
+
+== Version 0.10.0 / 2010-03-22
+* Allow default strategies to be set on the proxy
+* Provide each scope with it's own default strategies
+* Provide each scope with default set_user opts
+* depricate the Proxy#default_strategies= method
+
+== Version 0.9.5 / 2010-02-28
+
+* Add Warden.test_mode!
+* Add Warden.on_next_request
+* Add test helpers in Warden::Test::Helpers
+** login_as
+** logout
+
+== Version 0.9.4 / 2010-02-23
+
+* Fix an issue where winning_strategy was not cleaned, allowing multiple scopes to sign in, even when the second one should not
+
+== Version 0.9.3 / 2010-02-17
+
+* Add prepend_ to all hooks (josevalim)
+
+== Version 0.9.2 / 2010-02-10
+
+* Ruby 1.9 compatibility changes (grimen)
+
+== Version 0.9.1 / 2010-02-09
+
+* Support for passing a custom message with Warden::Strategy::Base#success! as second optional (grimen)
+
+== Version 0.9.0 / 2010-01-21
+
+* Remove serializers and make strategies more powerful, including cache behavior (josevalim)
+
+== Version 0.8.1 / 2010-01-06
+
+* Fix a bug when silence missing serializers is set (josevalim)
+
+== Version 0.8.0 / 2010-01-06
+
+* enhancements
+  * Add conditionals to callbacks (josevalim)
+  * Extract Warden::Config from Warden::Manager (josevalim)
+
+== Version 0.7.0 / 2010-01-04
+
+* enhancements
+  * Expose config in warden proxy (hassox)
+
+== Version 0.6.0 / 2009-11-16
+
+* enhancements
+  * added serializers, including session serializer (set by default) and a cookie serializer (josevalim)
+
+* deprecation
+  * serializer_into_session and serializer_from_session are deprecated, overwrite serialize and deserializer in Warden::Serializers::Session instead (josevalim)
+
+== Version 0.5.3 / 2009-11-10
+* bug fixes
+  * authenticated? and unauthenticated? should return true or false, not the user or false. (hassox)
+
+== Version 0.5.2 / 2009-11-09
+* enhancements
+  * authenticated? always try to serialize the user from session (josevalim)
+  * stored_in_session? checks if user information is stored in session, without serializing (josevalim)
+  * 401 behaves exactly like throw :warden (staugaard)
+
+=== Version 0.5.1 / 2009-10-25
+* enhancements
+  * Adds yeilding to authenticated? and unauthenticated? methods (hassox)
+  * Adds an option to silence missing strategies (josevalim)
+  * Add an option to authenticate(!) to prevent storage of a user into the session (hassox)
+  * allow custom :action to be thrown (josevalim)
+
+=== Version 0.4.0 / 2009-10-12
+
+* enhancements
+  * add Content-Type header to redirects (staugaard)
+  * Make scope available to strategies (josevalim)
+
+* bug fixes
+  * Do not consume opts twice, otherwise just the first will parse the scope (josevalim)
+
+=== Version 0.3.2 / 2009-09-15
+
+* enhancements
+  * add a hook for plugins to specify how they can clear the whole section
+
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Daniel Neighman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,9 @@
+Please see the "Warden Wiki":http://wiki.github.com/hassox/warden for overview documentation.
+
+h2. Maintainers
+
+* Daniel Neighman (hassox)
+* José Valim (josevalim)
+* Justin Smestad (jsmestad)
+
+"A list of all contributors is available on Github.":https://github.com/hassox/warden/contributors

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+require 'rake'
+$:.unshift  File.join(File.dirname(__FILE__), "lib")
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+desc "Run all specs in spec directory"
+RSpec::Core::RakeTask.new(:spec)

data/lib/loyal_warden.rb

@@ -0,0 +1,2 @@
+require 'warden'
+

data/lib/warden.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'forwardable'
+
+require 'warden/mixins/common'
+require 'warden/proxy'
+require 'warden/manager'
+require 'warden/errors'
+require 'warden/session_serializer'
+require 'warden/strategies'
+require 'warden/strategies/base'
+
+module Warden
+  class NotAuthenticated < StandardError; end
+
+  module Test
+    autoload :WardenHelpers,  'warden/test/warden_helpers'
+    autoload :Helpers,        'warden/test/helpers'
+  end
+
+  # Provides helper methods to warden for testing.
+  #
+  # To setup warden in test mode call the +test_mode!+ method on warden
+  #
+  # @example
+  #   Warden.test_mode!
+  #
+  # This will provide a number of methods.
+  # Warden.on_next_request(&blk) - captures a block which is yielded the warden proxy on the next request
+  # Warden.test_reset! - removes any captured blocks that would have been executed on the next request
+  #
+  # Warden.test_reset! should be called in after blocks for rspec, or teardown methods for Test::Unit
+  def self.test_mode!
+    unless Warden::Test::WardenHelpers === Warden
+      Warden.extend Warden::Test::WardenHelpers
+      Warden::Manager.on_request do |proxy|
+        unless proxy.asset_request?
+          while blk = Warden._on_next_request.shift
+            blk.call(proxy)
+          end
+        end
+      end
+    end
+    true
+  end
+end

data/lib/warden/config.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module Warden
+  # This is a class which is yielded on use Warden::Manager. If you have a plugin
+  # and wants to add more configuration to warden, you just need to extend this
+  # class.
+  class Config < Hash
+    # Creates an accessor that simply sets and reads a key in the hash:
+    #
+    #   class Config < Hash
+    #     hash_accessor :failure_app
+    #   end
+    #
+    #   config = Config.new
+    #   config.failure_app = Foo
+    #   config[:failure_app] #=> Foo
+    #
+    #   config[:failure_app] = Bar
+    #   config.failure_app #=> Bar
+    #
+    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
+
+    hash_accessor :failure_app, :default_scope, :intercept_401
+
+    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)
+      super
+      deep_dup(:scope_defaults, other)
+      deep_dup(:default_strategies, other)
+    end
+
+    # Do not raise an error if a missing strategy is given.
+    # :api: plugin
+    def silence_missing_strategies!
+      self[:silence_missing_strategies] = true
+    end
+
+    def silence_missing_strategies? #:nodoc:
+      !!self[:silence_missing_strategies]
+    end
+
+    # Set the default strategies to use.
+    # :api: public
+    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
+
+    # A short hand way to set up a particular scope
+    # :api: public
+    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
+
+    # Quick accessor to strategies from manager
+    # :api: public
+    def strategies
+      Warden::Strategies
+    end
+
+    # Hook from configuration to serialize_into_session.
+    # :api: public
+    def serialize_into_session(*args, &block)
+      Warden::Manager.serialize_into_session(*args, &block)
+    end
+
+    # Hook from configuration to serialize_from_session.
+    # :api: public
+    def serialize_from_session(*args, &block)
+      Warden::Manager.serialize_from_session(*args, &block)
+    end
+
+  protected
+
+    def deep_dup(key, other)
+      self[key] = hash = other[key].dup
+      hash.each { |k, v| hash[k] = v.dup }
+    end
+  end
+end

data/lib/warden/errors.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+module Warden
+  class Proxy
+    # Lifted from DataMapper's dm-validations plugin :)
+    # @author Guy van den Berg
+    # @since  DM 0.9
+    class Errors
+
+      include Enumerable
+
+      # Clear existing authentication errors.
+      def clear!
+        errors.clear
+      end
+
+      # Add a authentication error. Use the field_name :general if the errors does
+      # not apply to a specific field of the Resource.
+      #
+      # @param <Symbol> field_name the name of the field that caused the error
+      # @param <String> message    the message to add
+      def add(field_name, message)
+        (errors[field_name] ||= []) << message
+      end
+
+      # Collect all errors into a single list.
+      def full_messages
+        errors.inject([]) do |list,pair|
+          list += pair.last
+        end
+      end
+
+      # Return authentication errors for a particular field_name.
+      #
+      # @param <Symbol> field_name the name of the field you want an error for
+      def on(field_name)
+        errors_for_field = errors[field_name]
+        blank?(errors_for_field) ? nil : errors_for_field
+      end
+
+      def each
+        errors.map.each do |k,v|
+          next if blank?(v)
+          yield(v)
+        end
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      def method_missing(meth, *args, &block)
+        errors.send(meth, *args, &block)
+      end
+
+      private
+      def errors
+        @errors ||= {}
+      end
+
+      def blank?(thing)
+        thing.nil? || thing == "" || (thing.respond_to?(:empty?) && thing.empty?)
+      end
+
+    end # class Errors
+  end # Proxy
+end # Warden

data/lib/warden/hooks.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+module Warden
+  module Hooks
+
+    # Hook to _run_callbacks asserting for conditions.
+    def _run_callbacks(kind, *args) #:nodoc:
+      options = args.last # Last callback arg MUST be a Hash
+
+      send("_#{kind}").each do |callback, conditions|
+        invalid = conditions.find do |key, value|
+          value.is_a?(Array) ? !value.include?(options[key]) : (value != options[key])
+        end
+
+        callback.call(*args) unless invalid
+      end
+    end
+
+    # A callback hook set to run every time after a user is set.
+    # This callback is triggered the first time one of those three events happens
+    # during a request: :authentication, :fetch (from session) and :set_user (when manually set).
+    # You can supply as many hooks as you like, and they will be run in order of decleration.
+    #
+    # If you want to run the callbacks for a given scope and/or event, you can specify them as options.
+    # See parameters and example below.
+    #
+    # Parameters:
+    # <options> Some options which specify when the callback should be executed
+    #   scope  - Executes the callback only if it maches the scope(s) given
+    #   only   - Executes the callback only if it matches the event(s) given
+    #   except - Executes the callback except if it matches the event(s) given
+    # <block> A block where you can set arbitrary logic to run every time a user is set
+    #   Block Parameters: |user, auth, opts|
+    #     user - The user object that is being set
+    #     auth - The raw authentication proxy object.
+    #     opts - any options passed into the set_user call includeing :scope
+    #
+    # Example:
+    #   Warden::Manager.after_set_user do |user,auth,opts|
+    #     scope = opts[:scope]
+    #     if auth.session["#{scope}.last_access"].to_i > (Time.now - 5.minutes)
+    #       auth.logout(scope)
+    #       throw(:warden, :scope => scope, :reason => "Times Up")
+    #     end
+    #     auth.session["#{scope}.last_access"] = Time.now
+    #   end
+    #
+    #   Warden::Manager.after_set_user :except => :fetch do |user,auth,opts|
+    #     user.login_count += 1
+    #   end
+    #
+    # :api: public
+    def after_set_user(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+
+      if options.key?(:only)
+        options[:event] = options.delete(:only)
+      elsif options.key?(:except)
+        options[:event] = [:set_user, :authentication, :fetch] - Array(options.delete(:except))
+      end
+
+      _after_set_user.send(method, [block, options])
+    end
+
+    # Provides access to the array of after_set_user blocks to run
+    # :api: private
+    def _after_set_user # :nodoc:
+      @_after_set_user ||= []
+    end
+
+    # after_authentication is just a wrapper to after_set_user, which is only invoked
+    # when the user is set through the authentication path. The options and yielded arguments
+    # are the same as in after_set_user.
+    #
+    # :api: public
+    def after_authentication(options = {}, method = :push, &block)
+      after_set_user(options.merge(:event => :authentication), method, &block)
+    end
+
+    # after_fetch is just a wrapper to after_set_user, which is only invoked
+    # when the user is fetched from sesion. The options and yielded arguments
+    # are the same as in after_set_user.
+    #
+    # :api: public
+    def after_fetch(options = {}, method = :push, &block)
+      after_set_user(options.merge(:event => :fetch), method, &block)
+    end
+
+    # A callback that runs just prior to the failur application being called.
+    # This callback occurs after PATH_INFO has been modified for the failure (default /unauthenticated)
+    # In this callback you can mutate the environment as required by the failure application
+    # If a Rails controller were used for the failure_app for example, you would need to set request[:params][:action] = :unauthenticated
+    #
+    # Parameters:
+    # <options> Some options which specify when the callback should be executed
+    #   scope  - Executes the callback only if it maches the scope(s) given
+    # <block> A block to contain logic for the callback
+    #   Block Parameters: |env, opts|
+    #     env - The rack env hash
+    #     opts - any options passed into the authenticate call includeing :scope
+    #
+    # Example:
+    #   Warden::Manager.before_failure do |env, opts|
+    #     params = Rack::Request.new(env).params
+    #     params[:action] = :unauthenticated
+    #     params[:warden_failure] = opts
+    #   end
+    #
+    # :api: public
+    def before_failure(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _before_failure.send(method, [block, options])
+    end
+
+    # Provides access to the callback array for before_failure
+    # :api: private
+    def _before_failure
+      @_before_failure ||= []
+    end
+
+    # A callback that runs if no user could be fetched, meaning there is now no user logged in.
+    #
+    # Parameters:
+    # <options> Some options which specify when the callback should be executed
+    #   scope  - Executes the callback only if it maches the scope(s) given
+    # <block> A block to contain logic for the callback
+    #   Block Parameters: |user, auth, scope|
+    #     user - The authenticated user for the current scope
+    #     auth - The warden proxy object
+    #     opts - any options passed into the authenticate call including :scope
+    #
+    # Example:
+    #   Warden::Manager.after_failed_fetch do |user, auth, opts|
+    #     I18n.locale = :en
+    #   end
+    #
+    # :api: public
+    def after_failed_fetch(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _after_failed_fetch.send(method, [block, options])
+    end
+
+    # Provides access to the callback array for after_failed_fetch
+    # :api: private
+    def _after_failed_fetch
+      @_after_failed_fetch ||= []
+    end
+
+    # A callback that runs just prior to the logout of each scope.
+    #
+    # Parameters:
+    # <options> Some options which specify when the callback should be executed
+    #   scope  - Executes the callback only if it maches the scope(s) given
+    # <block> A block to contain logic for the callback
+    #   Block Parameters: |user, auth, scope|
+    #     user - The authenticated user for the current scope
+    #     auth - The warden proxy object
+    #     opts - any options passed into the authenticate call including :scope
+    #
+    # Example:
+    #   Warden::Manager.before_logout do |user, auth, opts|
+    #     user.forget_me!
+    #   end
+    #
+    # :api: public
+    def before_logout(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _before_logout.send(method, [block, options])
+    end
+
+    # Provides access to the callback array for before_logout
+    # :api: private
+    def _before_logout
+      @_before_logout ||= []
+    end
+
+    # A callback that runs on each request, just after the proxy is initialized
+    #
+    # Parameters:
+    # <block> A block to contain logic for the callback
+    #   Block Parameters: |proxy|
+    #     proxy - The warden proxy object for the request
+    #
+    # Example:
+    #   user = "A User"
+    #   Warden::Manager.on_request do |proxy|
+    #     proxy.set_user = user
+    #   end
+    #
+    # :api: public
+    def on_request(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _on_request.send(method, [block, options])
+    end
+
+    # Provides access to the callback array for before_logout
+    # :api: private
+    def _on_request
+      @_on_request ||= []
+    end
+
+    # Add prepend filters version
+    %w(after_set_user after_authentication after_fetch on_request
+       before_failure before_logout).each do |filter|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def prepend_#{filter}(options={}, &block)
+          #{filter}(options, :unshift, &block)
+        end
+      METHOD
+    end
+  end # Hooks
+end # Warden