loyal_warden 0.0.5

data/lib/warden/session_serializer.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Warden
+  class SessionSerializer
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    def key_for(scope)
+      "warden.user.#{scope}.key"
+    end
+
+    def serialize(user)
+      user
+    end
+
+    def deserialize(key)
+      key
+    end
+
+    def store(user, scope)
+      return unless user
+      method_name = "#{scope}_serialize"
+      specialized = respond_to?(method_name)
+      session[key_for(scope)] = specialized ? send(method_name, user) : serialize(user)
+    end
+
+    def fetch(scope)
+      key = session[key_for(scope)]
+      return nil unless key
+
+      method_name = "#{scope}_deserialize"
+      user = respond_to?(method_name) ? send(method_name, key) : deserialize(key)
+      delete(scope) unless user
+      user
+    end
+
+    def stored?(scope)
+      !!session[key_for(scope)]
+    end
+
+    def delete(scope, user=nil)
+      session.delete(key_for(scope))
+    end
+
+    # We can't cache this result because the session can be lazy loaded
+    def session
+      env["rack.session"] || {}
+    end
+  end # SessionSerializer
+end # Warden

data/lib/warden/strategies.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+module Warden
+  module Strategies
+    class << self
+      # Add a strategy and store it in a hash.
+      def add(label, strategy = nil, &block)
+        strategy ||= Class.new(Warden::Strategies::Base)
+        strategy.class_eval(&block) if block_given?
+
+        unless strategy.method_defined?(:authenticate!)
+          raise NoMethodError, "authenticate! is not declared in the #{label.inspect} strategy"
+        end
+
+        base = Warden::Strategies::Base
+        unless strategy.ancestors.include?(base)
+          raise "#{label.inspect} is not a #{base}"
+        end
+
+        _strategies[label] = strategy
+      end
+
+      # Update a previously given strategy.
+      def update(label, &block)
+        strategy = _strategies[label]
+        raise "Unknown strategy #{label.inspect}" unless strategy
+        add(label, strategy, &block)
+      end
+
+      # Provides access to strategies by label
+      # :api: public
+      def [](label)
+        _strategies[label]
+      end
+
+      # Clears all declared.
+      # :api: public
+      def clear!
+        _strategies.clear
+      end
+
+      # :api: private
+      def _strategies
+        @strategies ||= {}
+      end
+    end # << self
+  end # Strategies
+end # Warden

data/lib/warden/strategies/base.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+module Warden
+  module Strategies
+    # A strategy is a place where you can put logic related to authentication. Any strategy inherits
+    # from Warden::Strategies::Base.
+    #
+    # The Warden::Strategies.add method is a simple way to provide custom strategies.
+    # You _must_ declare an @authenticate!@ method.
+    # You _may_ provide a @valid?@ method.
+    # The valid method should return true or false depending on if the strategy is a valid one for the request.
+    #
+    # The parameters for Warden::Strategies.add method is:
+    #   <label: Symbol> The label is the name given to a strategy.  Use the label to refer to the strategy when authenticating
+    #   <strategy: Class|nil> The optional stragtegy argument if set _must_ be a class that inherits from Warden::Strategies::Base and _must_
+    #                         implement an @authenticate!@ method
+    #   <block> The block acts as a convinient way to declare your strategy.  Inside is the class definition of a strategy.
+    #
+    # Examples:
+    #
+    #   Block Declared Strategy:
+    #    Warden::Strategies.add(:foo) do
+    #      def authenticate!
+    #        # authentication logic
+    #      end
+    #    end
+    #
+    #    Class Declared Strategy:
+    #      Warden::Strategies.add(:foo, MyStrategy)
+    #
+    class Base
+      # :api: public
+      attr_accessor :user, :message
+
+      # :api: private
+      attr_accessor :result, :custom_response
+
+      # :api: public
+      attr_reader :env, :scope, :status
+
+      include ::Warden::Mixins::Common
+
+      # :api: private
+      def initialize(env, scope=nil) # :nodoc:
+        @env, @scope = env, scope
+        @status, @headers = nil, {}
+        @halted, @performed = false, false
+      end
+
+      # The method that is called from above. This method calls the underlying authenticate! method
+      # :api: private
+      def _run! # :nodoc:
+        @performed = true
+        authenticate!
+        self
+      end
+
+      # Returns if this strategy was already performed.
+      # :api: private
+      def performed? #:nodoc:
+        @performed
+      end
+
+      # Marks this strategy as not performed.
+      # :api: private
+      def clear!
+        @performed = false
+      end
+
+      # Acts as a guarding method for the strategy.
+      # If #valid? responds false, the strategy will not be executed
+      # Overwrite with your own logic
+      # :api: overwritable
+      def valid?; true; end
+
+      # Provides access to the headers hash for setting custom headers
+      # :api: public
+      def headers(header = {})
+        @headers ||= {}
+        @headers.merge! header
+        @headers
+      end
+
+      # Access to the errors object.
+      # :api: public
+      def errors
+        @env['warden'].errors
+      end
+
+      # Cause the processing of the strategies to stop and cascade no further
+      # :api: public
+      def halt!
+        @halted = true
+      end
+
+      # Checks to see if a strategy was halted
+      # :api: public
+      def halted?
+        !!@halted
+      end
+
+      # Checks to see if a strategy should result in a permanent login
+      # :api: public
+      def store?
+        true
+      end
+
+      # A simple method to return from authenticate! if you want to ignore this strategy
+      # :api: public
+      def pass; end
+
+      # Whenever you want to provide a user object as "authenticated" use the +success!+ method.
+      # This will halt the strategy, and set the user in the approprieate scope.
+      # It is the "login" method
+      #
+      # Parameters:
+      #   user - The user object to login.  This object can be anything you have setup to serialize in and out of the session
+      #
+      # :api: public
+      def success!(user, message = nil)
+        halt!
+        @user = user
+        @message = message
+        @result = :success
+      end
+
+      # This causes the strategy to fail.  It does not throw an :warden symbol to drop the request out to the failure application
+      # You must throw an :warden symbol somewhere in the application to enforce this
+      # Halts the strategies so that this is the last strategy checked
+      # :api: public
+      def fail!(message = "Failed to Login")
+        halt!
+        @message = message
+        @result = :failure
+      end
+
+      # Casuses the strategy to fail, but not halt.  The strategies will cascade after this failure and warden will check the next strategy.  The last strategy to fail will have it's message displayed.
+      # :api: public
+      def fail(message = "Failed to Login")
+        @message = message
+        @result = :failure
+      end
+
+      # Causes the authentication to redirect.  An :warden symbol must be thrown to actually execute this redirect
+      #
+      # Parameters:
+      #  url <String> - The string representing the URL to be redirected to
+      #  pararms <Hash> - Any parameters to encode into the URL
+      #  opts <Hash> - Any options to recirect with.
+      #    available options: permanent => (true || false)
+      #
+      # :api: public
+      def redirect!(url, params = {}, opts = {})
+        halt!
+        @status = opts[:permanent] ? 301 : 302
+        headers["Location"] = url
+        headers["Location"] << "?" << Rack::Utils.build_query(params) unless params.empty?
+        headers["Content-Type"] = opts[:content_type] || 'text/plain'
+
+        @message = opts[:message] || "You are being redirected to #{headers["Location"]}"
+        @result = :redirect
+
+        headers["Location"]
+      end
+
+      # Return a custom rack array.  You must throw an :warden symbol to activate this
+      # :api: public
+      def custom!(response)
+        halt!
+        @custom_response = response
+        @result = :custom
+      end
+
+    end # Base
+  end # Strategies
+end # Warden

data/lib/warden/test/helpers.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Warden
+  module Test
+    # A collection of test helpers for testing full stack rack applications using Warden
+    # These provide the ability to login and logout on any given request
+    # Note: During the teardown phase of your specs you should include: Warden.test_reset!
+    module Helpers
+      def self.included(base)
+        ::Warden.test_mode!
+      end
+
+      # A helper method that will peform a login of a user in warden for the next request
+      # Provide it the same options as you would to Warden::Proxy#set_user
+      # @see Warden::Proxy#set_user
+      # @api public
+      def login_as(user, opts = {})
+        Warden.on_next_request do |proxy|
+          opts[:event] ||= :authentication
+          proxy.set_user(user, opts)
+        end
+      end
+
+      # Logs out a user from the session.
+      # Without arguments, all users will be logged out
+      # Provide a list of scopes to only log out users with that scope.
+      # @see Warden::Proxy#logout
+      # @api public
+      def logout(*scopes)
+        Warden.on_next_request do |proxy|
+          proxy.logout(*scopes)
+        end
+      end
+    end
+  end
+end

data/lib/warden/test/warden_helpers.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Warden
+
+  module Test
+    module WardenHelpers
+      # Returns list of regex objects that match paths expected to be an asset
+      # @see Warden::Proxy#asset_request?
+      # @api public
+      def asset_paths
+        @asset_paths ||= [/^\/assets\//]
+      end
+
+      # Sets list of regex objects that match paths expected to be an asset
+      # @see Warden::Proxy#asset_request?
+      # @api public
+      def asset_paths=(*vals)
+        @asset_paths = vals
+      end
+
+      # Adds a block to be executed on the next request when the stack reaches warden.
+      # The warden proxy is yielded to the block
+      # @api public
+      def on_next_request(&blk)
+        _on_next_request << blk
+      end
+
+      # resets wardens tests
+      # any blocks queued to execute will be removed
+      # @api public
+      def test_reset!
+        _on_next_request.clear
+      end
+
+      # A containter for the on_next_request items.
+      # @api private
+      def _on_next_request
+        @_on_next_request ||= []
+        @_on_next_request
+      end
+    end
+  end
+end

data/lib/warden/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Warden
+  VERSION = "1.2.3".freeze
+end

data/loyal_warden.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require './lib/warden/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{loyal_warden}
+  # s.version = Warden::VERSION.dup
+  s.version = '0.0.5'
+  s.authors = ["Daniel Neighman"]
+  s.email = %q{has.sox@gmail.com}
+  s.license = "MIT"
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = Dir["**/*"] - Dir["*.gem"] - ["Gemfile.lock"]
+  s.homepage = %q{http://github.com/hassox/warden}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{warden}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Rack middleware that provides authentication for rack applications}
+
+  s.add_dependency "rack", ">= 1.0"
+end
+

data/spec/helpers/request_helper.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Warden::Spec
+  module Helpers
+    FAILURE_APP = lambda{|e|[401, {"Content-Type" => "text/plain"}, ["You Fail!"]] }
+
+    def env_with_params(path = "/", params = {}, env = {})
+      method = params.delete(:method) || "GET"
+      env = { 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => "#{method}" }.merge(env)
+      Rack::MockRequest.env_for("#{path}?#{Rack::Utils.build_query(params)}", env)
+    end
+
+    def setup_rack(app = nil, opts = {}, &block)
+      app ||= block if block_given?
+
+      opts[:failure_app]         ||= failure_app
+      opts[:default_strategies]  ||= [:password]
+      opts[:default_serializers] ||= [:session]
+      blk = opts[:configurator] || proc{}
+
+      Rack::Builder.new do
+        use opts[:session] || Warden::Spec::Helpers::Session unless opts[:nil_session]
+        use Warden::Manager, opts, &blk
+        run app
+      end
+    end
+
+    def valid_response
+      Rack::Response.new("OK").finish
+    end
+
+    def failure_app
+      Warden::Spec::Helpers::FAILURE_APP
+    end
+
+    def success_app
+      lambda{|e| [200, {"Content-Type" => "text/plain"}, ["You Win"]]}
+    end
+
+    class Session
+      attr_accessor :app
+      def initialize(app,configs = {})
+        @app = app
+      end
+
+      def call(e)
+        e['rack.session'] ||= {}
+        @app.call(e)
+      end
+    end # session
+  end
+end

data/spec/helpers/strategies/failz.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+Warden::Strategies.add(:failz) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :failz
+    fail!("The Fails Strategy Has Failed You")
+  end
+end