warden 0.10.7 → 1.0.0

data/History.rdoc

@@ -1,3 +1,26 @@
+== 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

data/Rakefile

@@ -15,7 +15,7 @@ begin
     gem.authors = ["Daniel Neighman"]
     gem.rubyforge_project = "warden"
     gem.add_dependency "rack", ">= 1.0.0"
-    gem.add_development_dependency "rspec", ">= 1.0.0"
+    gem.add_development_dependency "rspec", "~>1"
   end
 
   Jeweler::GemcutterTasks.new

data/TODO.textile

@@ -1,4 +1,2 @@
 * Allow a spec / test mode where a _spec_authenticate! method is called on a strategy instead if present
-* Implement back urls
-* Move all configuration to Warden::Config
-* Allow serializers to be chosen on storing/fetching/deleting
+* Implement back urls

data/lib/warden/config.rb

@@ -47,7 +47,7 @@ module Warden
       deep_dup(:default_strategies, other)
     end
 
-    # Do not raise an error if a missing strategy is given by default.
+    # Do not raise an error if a missing strategy is given.
     # :api: plugin
     def silence_missing_strategies!
       self[:silence_missing_strategies] = true

data/lib/warden/errors.rb

@@ -1,11 +1,6 @@
 # encoding: utf-8
 module Warden
   class Proxy 
-    # :api: public
-    def errors
-      @env['warden.errors'] ||= Errors.new
-    end
-
     # Lifted from DataMapper's dm-validations plugin :)
     # @author Guy van den Berg
     # @since  DM 0.9

data/lib/warden/hooks.rb

@@ -170,7 +170,6 @@ module Warden
       @_on_request ||= []
     end
 
-
     # Add prepend filters version
     %w(after_set_user after_authentication after_fetch on_request
        before_failure before_logout).each do |filter|

data/lib/warden/proxy.rb

@@ -15,6 +15,9 @@ module Warden
     extend ::Forwardable
     include ::Warden::Mixins::Common
 
+    ENV_WARDEN_ERRORS = 'warden.errors'.freeze
+    ENV_SESSION_OPTIONS = 'rack.session.options'.freeze
+
     # :api: private
     def_delegators :winning_strategy, :headers, :status, :custom_response
 
@@ -25,10 +28,15 @@ module Warden
       @env, @users, @winning_strategies = env, {}, {}
       @manager, @config = manager, manager.config.dup
       @strategies = Hash.new { |h,k| h[k] = {} }
-      errors # setup the error object in the session
       manager._run_callbacks(:on_request, self)
     end
 
+    # Lazily initiate errors object in session.
+    # :api: public
+    def errors
+      @env[ENV_WARDEN_ERRORS] ||= Errors.new
+    end
+
     # Points to a SessionSerializer instance responsible for handling
     # everything related with storing, fetching and removing the user
     # session.
@@ -140,14 +148,17 @@ module Warden
     #
     # :api: public
     def set_user(user, opts = {})
-      return unless user
       scope = (opts[:scope] ||= @config.default_scope)
 
       # Get the default options from the master configuration for the given scope
-      opts = @config.scope_defaults(scope).merge(opts)
-
+      opts = (@config[:scope_defaults][scope] || {}).merge(opts)
       @users[scope] = user
-      session_serializer.store(user, scope) unless opts[:store] == false
+
+      unless opts[:store] == false
+        options = env[ENV_SESSION_OPTIONS]
+        options[:renew] = true if options
+        session_serializer.store(user, scope)
+      end
 
       opts[:event] ||= :set_user
       manager._run_callbacks(:after_set_user, user, self, opts)
@@ -167,8 +178,10 @@ module Warden
     #
     # :api: public
     def user(scope = @config.default_scope)
-      @users[scope] ||= set_user(session_serializer.fetch(scope),
-                                 :scope => scope, :event => :fetch)
+      @users[scope] ||= begin
+        user = session_serializer.fetch(scope)
+        set_user(user, :scope => scope, :event => :fetch) if user
+      end
     end
 
     # Provides a scoped session data for authenticated users.
@@ -258,6 +271,7 @@ module Warden
       _run_strategies_for(scope, args)
 
       if winning_strategy && winning_strategy.user
+        opts[:store] = opts.fetch(:store, winning_strategy.store?)
         set_user(winning_strategy.user, opts.merge!(:event => :authentication))
       end
 
@@ -267,7 +281,7 @@ module Warden
     def _retrieve_scope_and_opts(args) #:nodoc:
       opts  = args.last.is_a?(Hash) ? args.pop : {}
       scope = opts[:scope] || @config.default_scope
-      opts  = (config[:scope_defaults][scope] || {}).merge(opts)
+      opts  = (@config[:scope_defaults][scope] || {}).merge(opts)
       [scope, opts]
     end
 
@@ -276,9 +290,12 @@ module Warden
       self.winning_strategy = @winning_strategies[scope]
       return if winning_strategy && winning_strategy.halted?
 
-      strategies = args.empty? ? default_strategies(:scope => scope) : args
+      if args.empty?
+        defaults   = @config[:default_strategies]
+        strategies = defaults[scope] || defaults[:_all]
+      end
 
-      strategies.each do |name|
+      (strategies || args).each do |name|
         strategy = _fetch_strategy(name, scope)
         next unless strategy && !strategy.performed? && strategy.valid?
 
@@ -290,9 +307,7 @@ module Warden
 
     # Fetchs strategies and keep them in a hash cache.
     def _fetch_strategy(name, scope)
-      return @strategies[scope][name] if @strategies[scope].key?(name)
-
-      @strategies[scope][name] = if klass = Warden::Strategies[name]
+      @strategies[scope][name] ||= if klass = Warden::Strategies[name]
         klass.new(@env, scope)
       elsif @config.silence_missing_strategies?
         nil

data/lib/warden/strategies/base.rb

@@ -98,6 +98,12 @@ module Warden
         !!@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

data/lib/warden/version.rb

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

data/spec/helpers/request_helper.rb

@@ -1,14 +1,12 @@
 # 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 = {})
-      method = params.fetch(:method, "GET")
-      Rack::MockRequest.env_for(path, :input => Rack::Utils.build_query(params),
-                                     'HTTP_VERSION' => '1.1',
-                                     'REQUEST_METHOD' => "#{method}")
+    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)
@@ -19,7 +17,7 @@ module Warden::Spec
       opts[:default_serializers] ||= [:session]
 
       Rack::Builder.new do
-        use Warden::Spec::Helpers::Session
+        use opts[:session] || Warden::Spec::Helpers::Session
         use Warden::Manager, opts
         run app
       end

data/spec/helpers/strategies/single.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+Warden::Strategies.add(:single) do
+  def authenticate!
+    request.env['warden.spec.strategies'] ||= []
+    request.env['warden.spec.strategies'] << :single
+    success!("Valid User")
+  end
+  
+  def store?
+    false
+  end
+end

data/spec/warden/proxy_spec.rb

@@ -17,8 +17,7 @@ describe Warden::Proxy do
         [401,{'Content-Type' => 'text/plain'},"You Fail"]
       end
     end
-    @env = Rack::MockRequest.
-      env_for('/', 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => 'GET')
+    @env = env_with_params("/")
   end # before(:each)
 
   describe "authentication" do
@@ -70,39 +69,35 @@ describe Warden::Proxy do
     end
 
     it "should raise error on missing strategies" do
-      env = env_with_params('/')
       app = lambda do |env|
         env['warden'].authenticate(:unknown)
       end
       lambda {
-        setup_rack(app).call(env)
+        setup_rack(app).call(@env)
       }.should raise_error(RuntimeError, "Invalid strategy unknown")
     end
 
     it "should not raise error on missing strategies if silencing" do
-      env = env_with_params('/')
       app = lambda do |env|
         env['warden'].authenticate
         valid_response
       end
       lambda {
-        setup_rack(app, :silence_missing_strategies => true, :default_strategies => [:unknown]).call(env)
+        setup_rack(app, :silence_missing_strategies => true, :default_strategies => [:unknown]).call(@env)
       }.should_not raise_error
     end
 
     it "should allow me to get access to the user at warden.user." do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:pass)
         env['warden'].should be_authenticated
         env['warden.spec.strategies'].should == [:pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should run strategies when authenticate? is asked" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].should_not be_authenticated
         env['warden'].authenticate?(:pass)
@@ -110,29 +105,27 @@ describe Warden::Proxy do
         env['warden.spec.strategies'].should == [:pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should properly send the scope to the strategy" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:pass, :scope => :failz)
         env['warden'].should_not be_authenticated
         env['warden.spec.strategies'].should == [:pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should try multiple authentication strategies" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:password,:pass)
         env['warden'].should be_authenticated
         env['warden.spec.strategies'].should == [:password, :pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should look for an active user in the session with authenticate" do
@@ -141,9 +134,8 @@ describe Warden::Proxy do
         env['warden'].authenticate(:pass)
         valid_response
       end
-      env = env_with_params
-      setup_rack(app).call(env)
-      env['warden'].user.should == "foo as a user"
+      setup_rack(app).call(@env)
+      @env['warden'].user.should == "foo as a user"
     end
 
     it "should look for an active user in the session with authenticate?" do
@@ -152,9 +144,8 @@ describe Warden::Proxy do
         env['warden'].authenticate?(:pass, :scope => :foo_scope)
         valid_response
       end
-      env = env_with_params
-      setup_rack(app).call(env)
-      env['warden'].user(:foo_scope).should == "a foo user"
+      setup_rack(app).call(@env)
+      @env['warden'].user(:foo_scope).should == "a foo user"
     end
 
     it "should look for an active user in the session with authenticate!" do
@@ -163,9 +154,8 @@ describe Warden::Proxy do
         env['warden'].authenticate!(:pass, :scope => :foo_scope)
         valid_response
       end
-      env = env_with_params
-      setup_rack(app).call(env)
-      env['warden'].user(:foo_scope).should == "a foo user"
+      setup_rack(app).call(@env)
+      @env['warden'].user(:foo_scope).should == "a foo user"
     end
 
     it "should throw an error when authenticate!" do
@@ -173,8 +163,7 @@ describe Warden::Proxy do
         env['warden'].authenticate!(:pass, :scope => :failz)
         raise "OMG"
       end
-      env = env_with_params
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should login 2 different users from the session" do
@@ -186,11 +175,10 @@ describe Warden::Proxy do
         env['warden'].should_not be_authenticated # default scope
         valid_response
       end
-      env = env_with_params
-      setup_rack(app).call(env)
-      env['warden'].user(:foo).should == 'foo user'
-      env['warden'].user(:bar).should == 'bar user'
-      env['warden'].user.should be_nil
+      setup_rack(app).call(@env)
+      @env['warden'].user(:foo).should == 'foo user'
+      @env['warden'].user(:bar).should == 'bar user'
+      @env['warden'].user.should be_nil
     end
 
     it "should not authenticate other scopes just because the first is authenticated" do
@@ -201,14 +189,66 @@ describe Warden::Proxy do
         env['warden'].should_not be_authenticated(:bar)
         valid_response
       end
-      env = env_with_params
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
+    end
+
+    SID_REGEXP = /rack\.session=([^;]*);/
+
+    it "should renew session" do
+      app = lambda do |env|
+        env["rack.session"]["counter"] ||= 0
+        env["rack.session"]["counter"] += 1
+        if env["warden.on"]
+          env["warden"].authenticate!(:pass) 
+          env['warden'].should be_authenticated
+        end
+        valid_response
+      end
+
+      # Setup a rack app with Pool session.
+      app = setup_rack(app, :session => Rack::Session::Pool).to_app
+      response = app.call(@env)
+      @env["rack.session"]["counter"].should == 1
+
+      # Ensure a cookie was given back
+      cookie = response[1]["Set-Cookie"]
+      cookie.should_not be_nil
+
+      # Ensure a session id was given
+      sid = cookie.match(SID_REGEXP)[1]
+      sid.should_not be_nil
+
+      # Do another request, but now passing the session id cookie
+      env = env_with_params("/", {}, "HTTP_COOKIE" => cookie)
+      response = app.call(env)
+      env["rack.session"]["counter"].should == 2
+
+      # Depending on rack version, a cookie will be returned with the
+      # same session id or no cookie is given back (becase it did not change).
+      # If we don't get any of these two behaviors, raise an error.
+      new_cookie = response[1]["Set-Cookie"]
+      if new_cookie && new_cookie.match(SID_REGEXP)[1] != sid
+        raise "Expected a cookie to not be sent or session id to match"
+      end
+
+      # Do another request, giving a cookie but turning on warden authentication
+      env = env_with_params("/", {}, "HTTP_COOKIE" => cookie, "warden.on" => true)
+      response = app.call(env)
+      @env["rack.session"]["counter"].should == 3
+
+      # Regardless of rack version, a cookie should be sent back
+      new_cookie = response[1]["Set-Cookie"]
+      new_cookie.should_not be_nil
+
+      # And the session id in this cookie should not be the same as the previous one
+      new_sid = new_cookie.match(SID_REGEXP)[1]
+      new_sid.should_not be_nil
+      new_sid.should_not == sid
     end
   end
 
   describe "authentication cache" do
     it "should run strategies just once for a given scope" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:password, :pass, :scope => :failz)
         env['warden'].should_not be_authenticated(:failz)
@@ -217,11 +257,10 @@ describe Warden::Proxy do
         env['warden.spec.strategies'].should == [:password, :pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should run strategies for a given scope several times if cache is cleaned" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:password, :pass, :scope => :failz)
         env['warden'].clear_strategies_cache!(:scope => :failz)
@@ -229,11 +268,10 @@ describe Warden::Proxy do
         env['warden.spec.strategies'].should == [:password, :pass, :password, :pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should clear the cache for a specified strategy" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:password, :pass, :scope => :failz)
         env['warden'].clear_strategies_cache!(:password, :scope => :failz)
@@ -241,11 +279,10 @@ describe Warden::Proxy do
         env['warden.spec.strategies'].should == [:password, :pass, :password]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should run the strategies several times for different scopes" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:password, :pass, :scope => :failz)
         env['warden'].should_not be_authenticated(:failz)
@@ -254,11 +291,10 @@ describe Warden::Proxy do
         env['warden.spec.strategies'].should == [:password, :pass, :password, :pass]
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should not run strategies until cache is cleaned if latest winning strategy halted" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:failz)
         env['warden'].should_not be_authenticated
@@ -266,14 +302,25 @@ describe Warden::Proxy do
         env['warden'].winning_strategy.message.should == "The Fails Strategy Has Failed You"
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
+    end
+
+    it "should not store user if strategy isn't meant for permanent login" do
+      session = Warden::SessionSerializer.new(@env)
+      app = lambda do |env|
+        env['warden'].authenticate(:single)
+        env['warden'].should be_authenticated
+        env['warden'].user.should == "Valid User"
+        session.should_not be_stored(:default)
+        valid_response
+      end
+      setup_rack(app).call(@env)
     end
 
   end
 
   describe "set user" do
     it "should store the user into the session" do
-      env = env_with_params("/")
       app = lambda do |env|
         env['warden'].authenticate(:pass)
         env['warden'].should be_authenticated
@@ -281,19 +328,18 @@ describe Warden::Proxy do
         env['rack.session']["warden.user.default.key"].should == "Valid User"
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
 
     it "should not store the user if the :store option is set to false" do
-      env = env_with_params("/")
-      app = lambda do |e|
+      app = lambda do |env|
         env['warden'].authenticate(:pass, :store => false)
         env['warden'].should be_authenticated
         env['warden'].user.should == "Valid User"
         env['rack.session']['warden.user.default.key'].should be_nil
         valid_response
       end
-      setup_rack(app).call(env)
+      setup_rack(app).call(@env)
     end
   end
 
@@ -348,10 +394,9 @@ describe Warden::Proxy do
   describe "logout" 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|
-        e['warden'].logout(env['warden.spec.which_logout'])
+        e['warden'].logout(e['warden.spec.which_logout'])
         valid_response
       end
     end
@@ -428,7 +473,7 @@ describe Warden::Proxy do
       app = lambda do |e|
         e['warden'].authenticate! :failz
       end
-      result = setup_rack(app, :failure_app => failure).call(env_with_params)
+      result = setup_rack(app, :failure_app => failure).call(@env)
       result.last.should == ["The Fails Strategy Has Failed You"]
     end
 
@@ -440,7 +485,7 @@ describe Warden::Proxy do
         e['warden'].authenticate! :pass_with_message
         success.call(e)
       end
-      result = setup_rack(app).call(env_with_params)
+      result = setup_rack(app).call(@env)
       result.last.should == ["The Success Strategy Has Accepted You"]
     end
 
@@ -448,7 +493,7 @@ describe Warden::Proxy do
       app = lambda do |e|
         [200, {"Content-Type" => "text/plain"}, [e['warden'].message]]
       end
-      result = setup_rack(app).call(env_with_params)
+      result = setup_rack(app).call(@env)
       result[2].should == [nil]
     end
   end
@@ -546,9 +591,8 @@ describe Warden::Proxy do
             env['warden'].authenticated?(:foo_scope)
             valid_response
           end
-          env = env_with_params
-          setup_rack(app).call(env)
-          env['warden'].user(:foo_scope).should be_nil
+          setup_rack(app).call(@env)
+          @env['warden'].user(:foo_scope).should be_nil
         ensure
           Warden::Manager.serialize_from_session { |k| k }
         end
@@ -686,6 +730,7 @@ describe "dynamic default_strategies" do
 
   before(:each) do
     @app = lambda{|e| e['warden'].authenticate! }
+    @env = env_with_params("/")
     $captures = []
   end
 
@@ -705,7 +750,7 @@ describe "dynamic default_strategies" do
       e['warden'].authenticate!
       Rack::Response.new("OK").finish
     end
-    setup_rack(app).call(env_with_params)
+    setup_rack(app).call(@env)
 
     $captures.should == [:one]
   end
@@ -717,7 +762,7 @@ describe "dynamic default_strategies" do
       e['warden'].authenticate!
       Rack::Response.new("OK").finish
     end
-    setup_rack(app).call(env_with_params)
+    setup_rack(app).call(@env)
 
     $captures.should == [:one]
   end
@@ -734,7 +779,7 @@ describe "dynamic default_strategies" do
       w.authenticate
       $captures.should == [:two]
     end
-    setup_rack(app).call(env_with_params)
+    setup_rack(app).call(@env)
     $captures.should == [:two]
   end
 
@@ -756,7 +801,7 @@ describe "dynamic default_strategies" do
         $captures << :complete
       end)
     end
-    builder.to_app.call(env_with_params)
+    builder.to_app.call(@env)
     $captures.should include(:complete)
   end
 
@@ -768,7 +813,7 @@ describe "dynamic default_strategies" do
       e['warden'].authenticate!
       Rack::Response.new("OK").finish
     end
-    setup_rack(app).call(env_with_params)
+    setup_rack(app).call(@env)
 
     $captures.should == [:one]
   end
@@ -821,9 +866,8 @@ describe "dynamic default_strategies" do
           Rack::Response.new("OK").finish
         end)
       end
-      env = env_with_params
-      session = env["rack.session"] = {}
-      builder.to_app.call(env)
+      session = @env["rack.session"] = {}
+      builder.to_app.call(@env)
       $captures.should include(:complete)
       session['warden.user.default.key'].should == "User"
       session['warden.user.foo.key'].should == "User"

data/warden.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{warden}
-  s.version = "0.10.7"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Neighman"]
-  s.date = %q{2010-05-31}
+  s.date = %q{2010-09-24}
   s.email = %q{has.sox@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -43,6 +43,7 @@ Gem::Specification.new do |s|
      "spec/helpers/strategies/pass.rb",
      "spec/helpers/strategies/pass_with_message.rb",
      "spec/helpers/strategies/password.rb",
+     "spec/helpers/strategies/single.rb",
      "spec/spec_helper.rb",
      "spec/warden/authenticated_data_store_spec.rb",
      "spec/warden/config_spec.rb",
@@ -71,6 +72,7 @@ Gem::Specification.new do |s|
      "spec/helpers/strategies/pass.rb",
      "spec/helpers/strategies/pass_with_message.rb",
      "spec/helpers/strategies/password.rb",
+     "spec/helpers/strategies/single.rb",
      "spec/spec_helper.rb",
      "spec/warden/authenticated_data_store_spec.rb",
      "spec/warden/config_spec.rb",
@@ -92,14 +94,14 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rack>, [">= 1.0.0"])
-      s.add_development_dependency(%q<rspec>, [">= 1.0.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 1"])
     else
       s.add_dependency(%q<rack>, [">= 1.0.0"])
-      s.add_dependency(%q<rspec>, [">= 1.0.0"])
+      s.add_dependency(%q<rspec>, ["~> 1"])
     end
   else
     s.add_dependency(%q<rack>, [">= 1.0.0"])
-    s.add_dependency(%q<rspec>, [">= 1.0.0"])
+    s.add_dependency(%q<rspec>, ["~> 1"])
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: warden
 version: !ruby/object:Gem::Version 
-  hash: 57
+  hash: 23
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 10
-  - 7
-  version: 0.10.7
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-31 00:00:00 +10:00
+date: 2010-09-24 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,14 +40,12 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 1
         segments: 
         - 1
-        - 0
-        - 0
-        version: 1.0.0
+        version: "1"
   type: :development
   version_requirements: *id002
 description: 
@@ -87,6 +85,7 @@ files:
 - spec/helpers/strategies/pass.rb
 - spec/helpers/strategies/pass_with_message.rb
 - spec/helpers/strategies/password.rb
+- spec/helpers/strategies/single.rb
 - spec/spec_helper.rb
 - spec/warden/authenticated_data_store_spec.rb
 - spec/warden/config_spec.rb
@@ -142,6 +141,7 @@ test_files:
 - spec/helpers/strategies/pass.rb
 - spec/helpers/strategies/pass_with_message.rb
 - spec/helpers/strategies/password.rb
+- spec/helpers/strategies/single.rb
 - spec/spec_helper.rb
 - spec/warden/authenticated_data_store_spec.rb
 - spec/warden/config_spec.rb