myobie-rails-auth 0.0.3 → 0.0.4

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 0
-:patch: 3
 :major: 0
+:minor: 0
+:patch: 4

data/lib/rails-auth/authenticated_helper.rb

@@ -8,7 +8,7 @@ module Rails
     
     protected
     def ensure_authenticated(*strategies)
-      session.authenticate!(self, *strategies) unless session.authenticated?
+      session.authenticate!(request, params, *strategies) unless session.authenticated?
       auth = session.authentication
       if auth.halted?
         response.headers.merge!(auth.headers)

data/spec/core/activation_fixture.rb

@@ -0,0 +1,2 @@
+class TheActivationTest
+end

data/spec/core/authentication_spec.rb

@@ -0,0 +1,250 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe "Rails::Authentication Session" do
+  
+  before(:each) do
+    ActionController::TestSession.send :include, Rails::Authentication::SessionMixin
+    @session = ActionController::TestSession.new
+  end
+  
+  describe "module methods" do
+    
+    before(:each) do
+      @m = mock("mock")
+      clear_strategies!
+    end
+    
+    after(:all) { clear_strategies! }
+    
+    describe "store_user" do
+      it{@session.authentication.should respond_to(:store_user)}
+    end
+    
+    describe "fetch_user" do
+      it{@session.authentication.should respond_to(:fetch_user)}
+    end
+    
+  end
+  
+  describe "error_message" do
+    
+    before(:each) do
+      @auth = Rails::Authentication.new(@session)
+    end
+    
+    it "should be 'Could not log in' by default" do
+      @auth.error_message.should == "Could not log in"
+    end
+    
+    it "should allow a user to set the error message" do
+      @auth.error_message = "You won't!"
+      @auth.error_message.should == "You won't!"
+    end
+    
+  end
+  
+  describe "user" do
+
+    it "should call fetch_user with the session contents to load the user" do
+      @session[:user] = 42
+      @session.authentication.should_receive(:fetch_user).with(42)
+      @session.user
+    end
+
+    it "should set the @user instance variable" do
+      @session[:user] = 42
+      @session.authentication.should_receive(:fetch_user).and_return("THE USER")
+      @session.user
+      @session.authentication.user.should == "THE USER"
+    end
+
+    it "should cache the user in an instance variable" do
+      @session[:user] = 42
+      @session.authentication.should_receive(:fetch_user).once.and_return("THE USER")
+      @session.user
+      @session.authentication.user.should == "THE USER"
+      @session.user
+    end
+
+    it "should set the ivar to nil if the session is nil" do
+      @session[:user] = nil
+      @session.user.should be_nil
+    end
+    
+  end
+  
+  describe "user=" do
+    before(:each) do
+      @user = mock("user")
+      @session.authentication.stub!(:fetch_user).and_return(@user)
+    end
+    
+    it "should call store_user on the session to get the value to store in the session" do
+      @session.authentication.should_receive(:store_user).with(@user)
+      @session.user = @user
+    end
+    
+    it "should set the instance variable to nil if the return of store_user is nil" do
+      @session.authentication.should_receive(:store_user).and_return(nil)
+      @session.user = @user
+      @session.user.should be_nil
+    end
+    
+    it "should set the instance varaible to nil if the return of store_user is false" do
+      @session.authentication.should_receive(:store_user).and_return(false)
+      @session.user = @user
+      @session.user.should be_nil
+    end
+    
+    it "should set the instance variable to the value of user if store_user is not nil or false" do
+      @session.authentication.should_receive(:store_user).and_return(42)
+      @session.user = @user
+      @session.user.should == @user
+      @session[:user].should == 42
+    end
+  end
+  
+  describe "abandon!" do
+    
+    before(:each) do
+      @user = mock("user")
+      @session.authentication.stub!(:fetch_user).and_return(@user)
+      @session.authentication.stub!(:store_user).and_return(42)
+      @session[:user] = 42
+      @session.user
+    end
+    
+    it "should delete the session" do
+      @session.should_receive(:clear)
+      @session.abandon!
+    end
+    
+    it "should not have a user after it is abandoned" do
+      @session.user.should == @user
+      @session.abandon!
+      @session.user.should be_nil
+    end
+  end
+  
+  describe "#authenticate" do
+    
+    before(:all) do
+      clear_strategies!
+    end
+    
+    after(:all) do
+      clear_strategies!
+    end
+    
+    before(:each) do
+      class Sone < Rails::Authentication::Strategy
+        def run!
+          Viking.capture(Sone)
+          params[:pass_1]
+        end
+      end
+      class Stwo < Rails::Authentication::Strategy
+        def run!
+          Viking.capture(Stwo) 
+          params[:pass_2]
+        end
+      end
+      class Sthree < Rails::Authentication::Strategy
+        def run!
+          Viking.capture(Sthree)
+          params[:pass_3] 
+        end
+      end
+      class Sfour < Rails::Authentication::Strategy
+        abstract!
+        
+        def run!
+           "BAD MAN"
+        end
+      end
+      
+      Sfour.should_not_receive(:run!)
+      @request = ActionController::TestRequest.new
+      @auth = Rails::Authentication.new(@request.session)
+      Viking.captures.clear
+    end
+    
+    it "should execute the strategies in the default order" do
+      @request.params[:pass_3] = true
+      @auth.authenticate!(@request, @request.params)
+      @auth.selected_strategy.should == Sthree
+      Viking.captures.should == %w( Sone Stwo Sthree )
+    end
+    
+    
+    it "should run the strategeis until if finds a non nil non false" do
+      @request.params[:pass_2] = true
+      @auth.authenticate!(@request, @request.params)
+      @auth.selected_strategy.should == Stwo
+      Viking.captures.should == %w( Sone Stwo )
+    end
+    
+    it "should raise an Unauthenticated exception if no 'user' is found" do
+      lambda do
+        @auth.authenticate!(@request, @request.params)
+        @auth.selected_strategy.should be_nil
+      end.should raise_error(Rails::Authentication::Unauthenticated)
+    end
+    
+    it "should store the user into the session if one is found" do
+      @auth.should_receive(:user=).with("WINNA")
+      @request.params[:pass_1] = "WINNA"
+      @auth.authenticate!(@request, @request.params)
+    end
+    
+    it "should use the Authentiation#error_message as the error message" do
+      @auth.should_receive(:error_message).and_return("BAD BAD BAD")
+      lambda do
+        @auth.authenticate!(@request, @request.params)
+      end.should raise_error(Rails::Authentication::Unauthenticated, "BAD BAD BAD")
+    end
+    
+    it "should execute the strategies as passed into the authenticate! method" do
+      @request.params[:pass_1] = true
+      @auth.authenticate!(@request, @request.params, Stwo, Sone)
+      @auth.selected_strategy.should == Sone
+      Viking.captures.should == ["Stwo", "Sone"]
+    end
+    
+    describe "Strategy loading as strings" do
+      
+      before :each do
+        Rails::Authentication.reset_strategy_lookup!
+        
+        class Rails::Authentication::Strategies::Zone < Rails::Authentication::Strategy
+          def run!
+            Viking.capture(Rails::Authentication::Strategies::Zone)
+            params[:z_one] 
+          end
+        end
+      end
+      
+      it "should allow for loading the strategies as strings" do
+        @request.params[:z_one] = "z_one"
+        @request.session.authenticate!(@request, @request.params, "Zone")
+        @request.session.user.should == "z_one"
+      end
+      
+      it "should raise a const missing error when the strategy is not namespaced" do
+        @request.params[:pass_1] = "s_one"
+        lambda do
+          @request.session.authenticate!(@request, @request.params, "Sone")
+        end.should raise_error(NameError)
+      end
+        
+    
+      it "should allow a mix of strategies as strings or classes" do
+        @request.params[:pass_2] = "s_two"
+        @request.session.authenticate!(@request, @request.params, "Zone", Sone, Stwo)
+        Viking.captures.should == %w(Rails::Authentication::Strategies::Zone Sone Stwo)
+      end
+    end
+
+  end
+  
+end

data/spec/core/callbacks_spec.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), "..", 'spec_helper.rb')
+ 
+describe "Authentication callbacks" do
+  
+  before(:all) do
+    ActionController::TestSession.send :include, Rails::Authentication::SessionMixin
+  end
+  
+  
+  before(:each) do
+    Rails::Authentication.after_callbacks.clear
+    clear_strategies!
+    Viking.captures.clear
+    
+    # A basic user model that has some simple methods 
+    # to set and aknowlege that it's been called  
+    class AUser
+      attr_accessor :active, :name
+      
+      def initialize(params)
+        params.each do |k,v|
+          instance_variable_set("@#{k}", v)
+        end
+      end
+      
+      def acknowledge(value)
+        Viking.capture(value)
+      end
+      
+      def acknowledge!(value = "default acknowledge")
+        throw(:acknowledged, value)
+      end
+ 
+      def method_missing(name, *args)
+        if /(.*?)\?$/ =~ name.to_s
+          !!instance_variable_get("@#{$1}")
+        end
+      end
+    end
+    
+    # Create a strategy to test the after stuff
+    class MyStrategy < Rails::Authentication::Strategy
+      def run!
+        AUser.new(request.params[:user] || {}) unless request.params[:no_user]
+      end
+    end
+  
+    @request  = fake_request
+    @params   = @request.params
+    @auth     = Rails::Authentication.new(@request.session)
+  end
+  
+  after(:all) do
+    clear_strategies!
+    Rails::Authentication.after_callbacks.clear
+  end
+  
+  it "should allow you to setup a callback as a block" do
+    Rails::Authentication.after_authentication{ |user, request, params| user.acknowledge!("w00t threw it") }
+    result = catch(:acknowledged) do
+      @request.session.authenticate!(@request, @params)
+    end
+    result.should == "w00t threw it"
+  end
+  
+  it "should allow you to setup a callback as a method" do
+    Rails::Authentication.after_authentication(:acknowledge!)
+    result = catch(:acknowledged) do
+      result = @request.session.authenticate!(@request,@params)
+    end
+    result.should == "default acknowledge"
+  end
+  
+  it "should allow many callbacks to be setup and executed" do
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("first");  u}
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("second"); u}
+    @request.session.authenticate!(@request, @params)
+    Viking.captures.should == %w(first second)
+  end
+ 
+  it "should stop processing if the user is not returned from the callback" do
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("first");  nil}
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("second"); u}
+    lambda do
+      @request.session.authenticate!(@request,@params)
+    end.should raise_error(Rails::Authentication::Unauthenticated)
+    Viking.captures.should == ["first"]
+  end
+  
+  it "should raise an Unauthenticated if a callback returns nil" do
+    Rails::Authentication.after_authentication{|u,r,p| nil }
+    lambda do
+      @request.session.authenticate!(@request,@params)
+    end.should raise_error(Rails::Authentication::Unauthenticated)
+  end
+  
+  it "should not try to process the callbacks when no user is found" do
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("first");  u}
+    Rails::Authentication.after_authentication{|u,r,p| u.acknowledge("second"); u}
+    @request.params[:no_user] = true
+    lambda do
+      @request.session.authenticate!(@request,@params)
+    end.should raise_error(Rails::Authentication::Unauthenticated)
+    Viking.captures.should be_empty
+  end
+    
+end

data/spec/core/costumizations_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+# NOT SUPPORTED YET!
+# 
+# describe "Rails::Authentication.customizations" do
+#   
+#   before(:each) do
+#     Rails::Authentication.default_customizations.clear
+#   end
+#   
+#   it "should allow addition to the customizations" do
+#     Rails::Authentication.customize_default { "ONE" }
+#     Rails::Authentication.default_customizations.first.call.should == "ONE"
+#   end
+#   
+#   it "should allow multiple additions to the customizations" do
+#     Rails::Authentication.customize_default {"ONE"}
+#     Rails::Authentication.customize_default {"TWO"}
+# 
+#     Rails::Authentication.default_customizations.first.call.should == "ONE"
+#     Rails::Authentication.default_customizations.last.call.should  == "TWO"
+#   end
+#   
+# end

data/spec/core/errors_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Rails::Authentication::Errors do
+  
+  before(:each) do
+    @errors = Rails::Authentication::Errors.new
+  end
+  
+  it "should report that it is empty on first creation" do
+    @errors.empty?.should == true
+  end
+
+  it "should continue to report that it is empty even after being checked" do
+    @errors.on(:foo)
+    @errors.empty?.should == true
+  end
+
+  it "should add an error" do
+    @errors.add(:login, "Login or password incorrect")
+    @errors[:login].should == ["Login or password incorrect"]
+  end
+
+  it "should allow many errors to be added to the same field" do
+    @errors.add(:login, "bad 1")
+    @errors.add(:login, "bad 2")
+    @errors.on(:login).should == ["bad 1", "bad 2"]
+  end
+
+  it "should give the full messages for an error" do
+    @errors.add(:login, "login wrong")
+    @errors.add(:password, "password wrong")
+    ["password wrong", "login wrong"].each do |msg|
+      @errors.full_messages.should include(msg)
+    end
+  end
+
+  it "should return the error for a specific field / label" do
+    @errors.add(:login, "wrong")
+    @errors.on(:login).should == ["wrong"]
+  end
+
+  it "should return nil for a specific field if it's not been set" do
+    @errors.on(:not_there).should be_nil
+  end
+
+  it "should provide an errors instance method on the Authentication instance" do
+    a = Rails::Authentication.new(ActionController::TestSession.new)
+    a.errors.should be_a_kind_of(Rails::Authentication::Errors)
+  end  
+  
+end

data/spec/core/strategy_spec.rb

@@ -0,0 +1,266 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Rails::Authentication::Strategy do
+  
+  before(:each) { clear_strategies! }
+  after(:all) { clear_strategies! }
+  
+  describe "adding a strategy" do
+    
+    it "should add an strategy" do
+      class MyStrategy < Rails::Authentication::Strategy; end
+      Rails::Authentication.strategies.include?(MyStrategy).should be_true
+    end
+    
+    it "should keep track of the strategies" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      Rails::Authentication.strategies.should include(Uno, Dos)
+      Rails::Authentication.default_strategy_order.pop
+      Rails::Authentication.strategies.should include(Uno, Dos)
+    end
+  
+    it "should add multiple strategies in order of declaration" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      Rails::Authentication.default_strategy_order.should == [Uno, Dos]
+    end
+    
+    it "should allow an strategy to be inserted _before_ another strategy in the default order" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      class MyStrategy < Rails::Authentication::Strategy
+        before Dos
+      end
+      Rails::Authentication.default_strategy_order.should == [Uno, MyStrategy, Dos]
+    end
+
+    it "should allow an strategy to be inserted _after_ another strategy in the default order" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      class MyStrategy < Rails::Authentication::Strategy
+        after Uno
+      end
+      Rails::Authentication.default_strategy_order.should == [Uno, MyStrategy, Dos]
+    end
+  
+  end
+  
+  describe "the default order" do
+    
+    it "should allow a user to overwrite the default order" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      Rails::Authentication.default_strategy_order = [Dos]
+      Rails::Authentication.default_strategy_order.should == [Dos]
+    end
+    
+    it "should get raise an error if any strategy is not a Rails::Authentication::Strategy subclass" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      lambda do 
+        Rails::Authentication.default_strategy_order = [Dos, String]
+      end.should raise_error(ArgumentError)
+    end
+    
+    it "should raise a not implemented error if the run! method is not defined in the subclass" do
+      class Uno < Rails::Authentication::Strategy; end
+      class Dos < Rails::Authentication::Strategy; end
+      lambda do
+        request = fake_request
+        Dos.new(request, request.params).run!
+      end.should raise_error(Rails::Authentication::NotImplemented)
+    end
+    
+    it "should not raise an implemented error if the run! method is defined on the subclass" do
+      class Dos < Rails::Authentication::Strategy; def run!; end; end
+      lambda do
+        request = fake_request
+        Dos.new(request, request.params).run!
+      end.should_not raise_error(Rails::Authentication::NotImplemented)
+    end
+    
+  end
+
+  describe "convinience methods" do
+    
+    before(:each) do
+      class Uno < Rails::Authentication::Strategy; def run; end; end
+      @request = fake_request
+      @strategy = Uno.new(@request, { :params => true })
+    end
+    
+    it "should provide a params helper that defers to the controller's request" do
+      @strategy.params.should == { :params => true }
+    end
+    
+    it "should provide a cookies helper" do
+      @request.should_receive(:cookies).and_return("COOKIES")
+      @strategy.cookies.should == "COOKIES"
+    end
+  end
+
+
+  describe "#user_class" do
+
+    # This allows you to scope a particular strategy to a particular user class object
+    # By inheriting you can add multiple user types to the authentication process
+
+    before(:each) do
+      class Sone < Rails::Authentication::Strategy; def run!; end; end
+      class Stwo < Sone; end
+
+      class Mone < Rails::Authentication::Strategy
+        def user_class; String; end
+        def run!; end
+      end
+      class Mtwo < Mone; end
+
+      class Pone < Rails::Authentication::Strategy
+        abstract!
+        def user_class; Hash; end
+        def special_method; true end
+      end
+      class Ptwo < Pone; end;
+
+      @request = fake_request
+    end
+    
+    it "should allow being set to an abstract strategy" do
+      Pone.abstract?.should be_true
+    end
+    
+    it "should not set the child class of an abstract class to be abstract" do
+      Ptwo.abstract?.should be_false
+    end
+    
+    it "should implement a user_class helper" do
+      s = Sone.new(@request, @request.params)
+      s.user_class.should == User
+    end
+    
+    it "should make it into the strategies collection when subclassed from a subclass" do
+      Rails::Authentication.strategies.should include(Mtwo)
+    end
+    
+    it "should make it in the default_strategy_order when subclassed from a subclass" do
+      Rails::Authentication.default_strategy_order.should include(Mtwo)
+    end
+    
+    it "should defer to the Merb::Authentication.user_class if not over written" do
+      Rails::Authentication.should_receive(:user_class).and_return(User)
+      s = Sone.new(@request, @request.params)
+      s.user_class
+    end
+    
+    it "should inherit the user class from it's parent by default" do
+      Rails::Authentication.should_receive(:user_class).and_return(User)
+      s = Stwo.new(@request, @request.params)
+      s.user_class.should == User
+    end
+    
+    it "should inherit the user_class form it's parent when the parent defines a new one" do
+      Rails::Authentication.should_not_receive(:user_class)
+      m = Mtwo.new(@request, @request.params)
+      m.user_class.should == String
+    end
+    
+  end
+
+  describe "#redirect!" do
+    
+    before(:all) do
+      class FooController < ActionController::Base
+        def index; "FooController#index"; end
+      end
+    end
+    
+    before(:each) do
+      class MyStrategy < Rails::Authentication::Strategy
+        def run!
+          if params[:url]
+            params[:status] ? redirect!(params[:url], :status => params[:status]) : redirect!(params[:url])
+          else
+            "WHATHA"
+          end
+        end #run!
+      end # MyStrategy
+      
+      ActionController::Routing::Routes.reload!
+      ActionController::Routing::Routes.draw { |map| map.root :controller => 'foo' }
+      @request = fake_request
+      @s = MyStrategy.new(@request, @request.params)
+    end
+    
+    it "allow for a redirect!" do
+      @s.redirect!("/somewhere")
+      @s.headers["Location"].should == "/somewhere"
+    end
+    
+    it "should provide access to setting the headers" do
+      @s.headers["Location"] = "/a/uri"
+      @s.headers["Location"].should == "/a/uri"
+    end
+    
+    it "should allow access to the setting header" do
+      @s.status = 403
+      @s.status.should == 403
+    end
+    
+    it "should return nil for the Location if it is not redirected" do
+      @s.should_not be_redirected
+      @s.headers["Location"].should be_nil
+    end
+    
+    it "should pass through the options to the redirect options" do
+      @s.redirect!("/somewhere", :status => 401)
+      @s.headers["Location"].should == "/somewhere"
+      @s.status.should == 401
+    end
+    
+    it "should set a redirect with a permanent true" do
+      @s.redirect!("/somewhere", :permanent => true)
+      @s.status.should == 301
+    end
+    
+    it "should be redirected?" do
+      @s.should_not be_redirected
+      @s.redirect!("/somewhere")
+      @s.should be_redirected
+    end
+    
+    it "should set an strategy to halted" do
+      @s.redirect!("/somewhere")
+      @s.should be_halted
+    end
+    
+    it "should allow a body to be set" do
+      @s.body = "body"
+      @s.body.should == "body"
+    end
+    
+  end
+=begin  
+  describe "register strategies" do
+  
+    it "should allow for a strategy to be registered" do
+      Rails::Authentication.register(:test_one, "/path/to/strategy")
+      Rails::Authentication.registered_strategies[:test_one].should == "/path/to/strategy"
+    end
+    
+    it "should activate a strategy" do
+      Rails::Authentication.register(:test_activation, File.expand_path(File.dirname(__FILE__)) / 'activation_fixture')
+      defined?(TheActivationTest).should be_nil
+      Rails::Authentication.activate!(:test_activation)
+      defined?(TheActivationTest).should_not be_nil
+    end
+  
+    it "should raise if the strategy is not registered" do
+      lambda do
+        Rails::Authentication.activate!(:not_here)
+      end.should raise_error
+    end
+  
+  end
+=end  
+end

data/spec/rcov.opts

@@ -0,0 +1 @@
+--exclude "spec/*"

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format progress
+--loadby mtime
+--reverse
+

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require "rubygems"
+require "action_controller"
+require "action_controller/test_process"
+require "spec"
+#require "spec/rails"
+require "rails-auth"
+
+module StrategyHelper
+  
+  def clear_strategies!
+    Rails::Authentication.strategies.each do |s|
+      begin
+        Object.class_eval{ remove_const(s.name) if defined?(s)}
+      rescue
+      end
+    end
+    Rails::Authentication.strategies.clear
+    Rails::Authentication.default_strategy_order.clear
+  end
+
+end
+
+module TestRequestHelper
+  
+  def fake_request(env = {})
+    ActionController::TestRequest.new(env)
+  end
+  
+end
+
+Spec::Runner.configure do |config|
+  config.include(TestRequestHelper)
+  config.include(StrategyHelper)
+end
+
+class User
+  attr_accessor :name, :age, :id
+  
+  def initialize(opts = {})
+    @name = opts.fetch(:name, "NAME")
+    @age = opts.fetch(:age, 30)
+    @id = opts.fetch(:id, 23)
+  end
+end
+
+class Application < ActionController::Base
+end
+
+class UsersController < Application
+  before_filter :ensure_authenticated
+  
+  def index
+    "You made it pal!"
+  end
+end
+
+class DingbatsController < Application
+  skip_before_filter :ensure_authenticated
+  
+  def index
+    "You made it buddy!"
+  end
+end
+
+class Rails::Authentication
+  def fetch_user(id=23)
+    if id.nil?
+      nil
+    else
+      u = User.new(:id => id)
+    end
+  end
+  
+  def store_user(user)
+    user.nil? ? nil : 23
+  end
+  
+end
+
+Rails::Authentication.user_class = 'User'
+
+class Viking
+  def self.captures
+    @captures ||= []
+  end
+  
+  def self.capture(klass)
+    @captures ||= []
+    case klass
+    when Class
+      @captures << klass.name
+    else
+      @captures << klass
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: myobie-rails-auth
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Nathan Herald
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-10 00:00:00 -08:00
+date: 2009-03-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -41,12 +41,20 @@ files:
 - lib/rails-auth/session_mixin.rb
 - lib/rails-auth/strategies
 - lib/rails-auth/strategies/abstract_password.rb
-- lib/rails-auth/strategies/password_form.rb
 - lib/rails-auth/strategies/openid.rb
+- lib/rails-auth/strategies/password_form.rb
 - lib/rails-auth/strategy.rb
 - lib/rails-auth.rb
-- test/rails-auth_test.rb
-- test/test_helper.rb
+- spec/core
+- spec/core/activation_fixture.rb
+- spec/core/authentication_spec.rb
+- spec/core/callbacks_spec.rb
+- spec/core/costumizations_spec.rb
+- spec/core/errors_spec.rb
+- spec/core/strategy_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/myobie/rails-auth
 post_install_message: