warden 0.5.3 → 0.6.0

data/lib/warden/serializers.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'warden/declarable'
+
+module Warden
+  module Serializers
+    extend Warden::Declarable
+    
+    class << self
+      def check_validity!(label, serializer)
+        [:fetch, :store, :stored?, :delete].each do |method|
+          next if serializer.method_defined?(method)
+          raise NoMethodError, "#{method} is not declared in the #{label.inspect} serializer"
+        end
+      end
+      
+      alias :_serializers :_declarations
+    end # << self
+
+  end # Serializers
+end # Warden

data/lib/warden/serializers/base.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Warden
+  module Serializers
+    # A serializer is a place where you put the logic to serializing and deserializing an user. All serializers
+    # inherits from Warden::Serializers::Base.
+    #
+    # The Warden::Serializers.add method is a simple way to provide custom serializers. In order to do so,
+    # you _must_ declare @store@, @fetch@, @delete@ and @stored?@ methods.
+    # 
+    # The parameters for Warden::Serializers.add method is: 
+    #   <label: Symbol> The label is the name given to a serializer. Use the label to refer to the serializer when authenticating
+    #   <serializer: Class|nil> The optional serializer argument if set _must_ be a class that inherits from Warden::Serializers::Base
+    #   <block> The block acts as a convinient way to declare your serializer.  Inside is the class definition of a serializer.
+    #
+    # Check Session and Cookie serializers for more information.
+    #
+    class Base
+      attr_accessor :env
+      include ::Warden::Mixins::Common
+
+      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
+    end # Base
+  end # Serializers
+end # Warden

data/lib/warden/serializers/cookie.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Warden
+  module Serializers
+    # A cookie serializer provided by Warden. You need to implement the serialize and deserialize
+    # methods in order to use it.
+    class Cookie < Base
+      def store(user, scope)
+        response.set_cookie key_for(scope), default_options(user)
+      end
+
+      def fetch(scope)
+        key = request.cookies[key_for(scope)]
+        return nil unless key
+        user = deserialize(key)
+        delete(scope) unless user
+        user
+      end
+
+      def stored?(scope)
+        !!request.cookies[key_for(scope)]
+      end
+
+      def delete(scope, user=nil)
+        response.delete_cookie(key_for(scope))
+      end
+
+      def default_options(user)
+        { :value => serialize(user), :expires => (Time.now + 7 * 24 * 3600), :path => "/" }
+      end
+    end # Cookie
+
+    Serializers.add(:cookie, Cookie)
+  end # Serializers
+end # Warden

data/lib/warden/serializers/session.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Warden
+  module Serializers
+    # A session serializer provided by Warden. You need to implement the serialize and deserialize
+    # methods in order to use it.
+    class Session < Base
+      def store(user, scope)
+        session[key_for(scope)] = serialize(user)
+      end
+
+      def fetch(scope)
+        key = session[key_for(scope)]
+        return nil unless key
+        user = 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
+    end # Session
+
+    Serializers.add(:session, Session)
+  end # Serializers
+end # Warden

data/lib/warden/strategies.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'warden/declarable'
+
+module Warden
+  module Strategies
+    extend Warden::Declarable
+    
+    class << self
+      def check_validity!(label, strategy)
+        return if strategy.method_defined?(:authenticate!)
+        raise NoMethodError, "authenticate! is not declared in the #{label.inspect} strategy" 
+      end
+      
+      alias :_strategies :_declarations
+    end # << self
+
+  end # Strategies
+end # Warden

data/lib/warden/{authentication/strategy_base.rb → strategies/base.rb}

@@ -1,6 +1,32 @@
 # 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
@@ -24,7 +50,7 @@ module Warden
         @halted = false
       end
 
-      # The method that is called from above.  This method calls the underlying authenticate! method
+      # The method that is called from above. This method calls the underlying authenticate! method
       # :api: private
       def _run! # :nodoc:
         result = authenticate!
@@ -107,7 +133,6 @@ module Warden
         headers["Content-Type"] = opts[:content_type] || 'text/plain'
 
         @message = opts[:message].nil? ? "You are being redirected to #{headers["Location"]}" : opts[:message]
-
         @result = :redirect
 
         headers["Location"]

data/lib/warden/version.rb

@@ -1,3 +1,3 @@
 module Warden
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/spec/helpers/request_helper.rb

@@ -1,49 +1,51 @@
 module Warden::Spec
   module Helpers
-    
+
     FAILURE_APP = lambda{|e|[401, {"Content-Type" => "text/plain"}, ["You Fail!"]] }
-    
+
     def env_with_params(path = "/", params = {})
       method = params.fetch(:method, "GET")
       Rack::MockRequest.env_for(path, :input => Rack::Utils.build_query(params),
                                      'HTTP_VERSION' => '1.1',
                                      'REQUEST_METHOD' => "#{method}")
     end
-    
+
     def setup_rack(app = nil, opts = {}, &block)
       app ||= block if block_given?
-      opts[:default_strategies] ||= [:password]
+      opts[:default_strategies]  ||= [:password]
+      opts[:default_serializers] ||= [:session]
       opts[:failure_app] ||= Warden::Spec::Helpers::FAILURE_APP
-      Rack::Builder.new do 
+      Rack::Builder.new do
         use Warden::Spec::Helpers::Session
         use Warden::Manager, opts do |manager|
           manager.failure_app = Warden::Spec::Helpers::FAILURE_APP
           manager.default_strategies *opts[:default_strategies]
+          manager.default_serializers *opts[:default_serializers]
         end
         run app
       end
     end
-    
+
     def valid_response
-      [200,{'Content-Type' => 'text/plain'},'OK']
+      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'] ||= {}      
+        e['rack.session'] ||= {}
         @app.call(e)
       end
     end # session

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ Spec::Runner.configure do |config|
   config.include(Warden::Spec::Helpers)
 
   def load_strategies
-    Dir[File.join(File.dirname(__FILE__), "warden", "strategies", "**/*.rb")].each do |f|
+    Dir[File.join(File.dirname(__FILE__), "helpers", "strategies", "**/*.rb")].each do |f|
       load f
     end
   end

data/spec/warden/authenticated_data_store_spec.rb

@@ -5,9 +5,9 @@ describe "authenticated data store" do
   before(:each) do
     @env = env_with_params
     @env['rack.session'] = {
-        "warden.user.foo.key"      => "foo user",
-        "warden.user.default.key"  => "default user",
-        :foo => "bar"
+      "warden.user.foo.key"     => "foo user",
+      "warden.user.default.key" => "default user",
+      :foo => "bar"
     }
   end
 
@@ -18,7 +18,7 @@ describe "authenticated data store" do
       e['warden'].should be_authenticated
       e['warden'].should be_authenticated(:foo)
 
-      # Store the data for :deafult
+      # Store the data for :default
       e['warden'].session[:key] = "value"
       valid_response
     end

data/spec/warden/manager_spec.rb

@@ -12,14 +12,6 @@ describe Warden::Manager do
     env["warden"].should be_an_instance_of(Warden::Proxy)
   end
 
-  describe "user storage" do
-    it "should take a user and store it in the provided session" do
-      session = {}
-      Warden::Manager._store_user("The User", session, "some_scope")
-      session["warden.user.some_scope.key"].should == "The User"
-    end
-  end
-
   describe "thrown auth" do
     before(:each) do
       @basic_app = lambda{|env| [200,{'Content-Type' => 'text/plain'},'OK']}

data/spec/warden/proxy_spec.rb

@@ -165,9 +165,9 @@ describe Warden::Proxy do
           env['warden'].authenticate(:pass, :scope => :foo)
           env['warden'].authenticate(:pass, :scope => :bar)
           env['warden'].authenticate(:password)
-          env['warden'].authenticated?(:foo).should == true
-          env['warden'].authenticated?(:bar).should == true
-          env['warden'].authenticated?.should == false
+          env['warden'].authenticated?(:foo).should be_true
+          env['warden'].authenticated?(:bar).should be_true
+          env['warden'].authenticated?.should be_false
           valid_response
         end
         env = env_with_params
@@ -195,7 +195,7 @@ describe Warden::Proxy do
     end
   end # describe "authentication"
 
-  describe "stored in session" do
+  describe "stored?" do
     before(:each) do
       @env['rack.session'] ||= {}
       @env['rack.session']['warden.user.default.key'] = "User"
@@ -203,7 +203,7 @@ describe Warden::Proxy do
 
     it "returns true if user key is stored in session" do
       app = lambda do |env|
-        env['warden'].stored_in_session?.should be_true
+        env['warden'].stored?.should be_true
         valid_response
       end
       setup_rack(app).call(@env)
@@ -212,11 +212,31 @@ describe Warden::Proxy do
     it "returns false if user key is not stored in session" do
       @env['rack.session'].delete("warden.user.default.key")
       app = lambda do |env|
-        env['warden'].stored_in_session?.should be_false
+        env['warden'].stored?.should be_false
         valid_response
       end
       setup_rack(app).call(@env)
     end
+
+    it "returns false if scope given is not stored in session" do
+      app = lambda do |env|
+        env['warden'].stored?.should be_true
+        env['warden'].stored?(:another).should be_false
+        valid_response
+      end
+      setup_rack(app).call(@env)
+    end
+
+    it "returns based on the given store" do
+      @env['rack.session'].delete("warden.user.default.key")
+      @env["HTTP_COOKIE"] = "warden.user.default.key=user;"
+      app = lambda do |env|
+        env['warden'].stored?(:default, :session).should be_false
+        env['warden'].stored?(:default, :cookie).should be_true
+        valid_response
+      end
+      setup_rack(app, :default_serializers => [:session, :cookie]).call(@env)
+    end
   end
 
   describe "set user" do
@@ -232,6 +252,19 @@ describe Warden::Proxy do
       setup_rack(app).call(env)
     end
 
+    it "should store the user in all serializers" do
+      env = env_with_params("/")
+      app = lambda do |env|
+        env['warden'].authenticate(:pass)
+        env['warden'].should be_authenticated
+        env['warden'].user.should == "Valid User"
+        valid_response
+      end
+      setup_rack(app, :default_serializers => [:session, :cookie]).call(env)
+      headers = env['warden'].serializers.last.response.headers
+      headers['Set-Cookie'].split(";").first.should == "warden.user.default.key=Valid+User"
+    end
+
     it "should not store the user if the :store option is set to false" do
       env = env_with_params("/")
       app = lambda do |e|
@@ -268,6 +301,15 @@ describe Warden::Proxy do
       setup_rack(app).call(@env)
     end
 
+    it "should load user from others serializers" do
+      @env["HTTP_COOKIE"] = "warden.user.default.key=user;"
+      app = lambda do |env|
+        env['warden'].user.should == "user"
+        valid_response
+      end
+      setup_rack(app, :default_serializers => [:session, :cookie]).call(@env)
+    end
+
     describe "previously logged in" do
 
       before(:each) do
@@ -299,14 +341,14 @@ describe Warden::Proxy do
     before(:each) do
       @env = env = env_with_params
       @env['rack.session'] = {"warden.user.default.key" => "default key", "warden.user.foo.key" => "foo key", :foo => "bar"}
-      app = lambda do |e|
+      @app = lambda do |e|
         e['warden'].logout(env['warden.spec.which_logout'])
         valid_response
       end
-      @app = setup_rack(app)
     end
 
     it "should logout only the scoped foo user" do
+      @app = setup_rack(@app)
       @env['warden.spec.which_logout'] = :foo
       @app.call(@env)
       @env['rack.session']['warden.user.default.key'].should == "default key"
@@ -315,6 +357,7 @@ describe Warden::Proxy do
     end
 
     it "should logout only the scoped default user" do
+      @app = setup_rack(@app)
       @env['warden.spec.which_logout'] = :default
       @app.call(@env)
       @env['rack.session']['warden.user.default.key'].should be_nil
@@ -343,7 +386,6 @@ describe Warden::Proxy do
       end
       setup_rack(app).call(@env)
       @env['warden'].user.should be_nil
-
     end
 
     it "should clear the session data when logging out" do
@@ -357,6 +399,15 @@ describe Warden::Proxy do
       setup_rack(app).call(@env)
     end
 
+    it "should clear the session in all serializers" do
+      @app = setup_rack(@app, :default_serializers => [:session, :cookie])
+      @env['warden.spec.which_logout'] = :default
+      @app.call(@env)
+      @env['warden'].serializers.last.should_not be_nil
+      headers = @env['warden'].serializers.last.response.headers
+      headers['Set-Cookie'].first.split(";").first.should == "warden.user.default.key="
+    end
+
     it "should clear out the session by calling reset_session! so that plugins can setup their own session clearing" do
       @env['rack.session'].should_not be_nil
       app = lambda do |e|
@@ -395,7 +446,7 @@ describe Warden::Proxy do
     it "should return false for authenticated when there are no valid? strategies" do
      @env['rack.session'] = {}
      app = lambda do |e|
-       e['warden'].authenticated?(:invalid).should == false
+       e['warden'].authenticated?(:invalid).should be_false
      end
      setup_rack(app).call(@env)
     end