warden 0.10.1 → 0.10.2

data/History.rdoc

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

data/lib/warden/config.rb

@@ -36,9 +36,15 @@ module Warden
 
     def initialize(other={})
       merge!(other)
-      self[:default_scope]          ||= :default
-      self[:default_scope_options]  ||= {}
-      self[:default_strategies]     ||= {}
+      self[:default_scope]      ||= :default
+      self[:scope_defaults]     ||= {}
+      self[:default_strategies] ||= {}
+    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 by default.
@@ -54,33 +60,27 @@ module Warden
     # Set the default strategies to use.
     # :api: public
     def default_strategies(*strategies)
-      opts = Hash === strategies.last ? strategies.pop : {}
-      scope = opts[:scope] || default_scope
-      if strategies.empty?
-        self[:default_strategies][scope]
-      else
-        self[:default_strategies][scope] = strategies.flatten
-      end
-    end
+      opts  = Hash === strategies.last ? strategies.pop : {}
+      hash  = self[:default_strategies]
+      scope = opts[:scope] || :_all
 
-    # Set the default options that are passed to set_user.  This is configured
-    # during the setup phase and is used throughout.
-    def default_scope_options(scope = default_scope, opts = nil)
-      if opts.nil?
-        # We're reading the default options for this scope
-        self[:default_scope_options][scope] ||= {}
-      else
-        # We're setting the default options forthe scope
-        self[:default_scope_options][scope] = opts
-      end
+      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 = {})
-      strategies = opts.delete(:strategies) || []
-      default_strategies(strategies, :scope => scope)
-      default_scope_options(scope, opts)
-      true
+      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
@@ -100,5 +100,12 @@ module Warden
     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/manager.rb

@@ -30,7 +30,7 @@ module Warden
     # If this is downstream from another warden instance, don't do anything.
     # :api: private
     def call(env) # :nodoc:
-      return @app.call(env) unless env['warden'].nil?
+      return @app.call(env) unless env['warden'].nil? || env['warden'].manager == self
 
       env['warden'] = Proxy.new(env, self)
       result = catch(:warden) do

data/lib/warden/proxy.rb

@@ -12,7 +12,7 @@ module Warden
 
     # An accessor to the rack env hash, the proxy owner and its config
     # :api: public
-    attr_reader :env, :manager, :config
+    attr_reader :env, :manager, :config, :winning_strategies
 
     extend ::Forwardable
     include ::Warden::Mixins::Common
@@ -20,10 +20,13 @@ module Warden
     # :api: private
     def_delegators :winning_strategy, :headers, :status, :custom_response
 
+    # :api: public
+    def_delegators :config, :default_strategies
+
     def initialize(env, manager) #:nodoc:
-      @env, @users = env, {}
-      @strategies  = Hash.new { |h,k| h[k] = {} }
-      @manager, @config = manager, manager.config
+      @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
@@ -58,36 +61,12 @@ module Warden
     def clear_strategies_cache!(*args)
       scope, opts = _retrieve_scope_and_opts(args)
 
+      @winning_strategies.delete(scope)
       @strategies[scope].each do |k, v|
         v.clear! if args.empty? || args.include?(k)
       end
     end
 
-    # Provides access to the currently defined default strategies for the proxy.
-    # This can change as it moves throughout the rack graph
-    # Any changes to this are reflected only for the duration of the request
-    # By changing this value, you can change the default strategies for a downstream branch of you rack graph.
-    #
-    # @api public
-    def default_strategies(*strategies)
-      scope, opts = _retrieve_scope_and_opts(strategies)
-      if strategies.empty?
-        _default_strategies[scope] ||= begin
-          (
-            @config.default_strategies(:scope => scope) ||
-            @config.default_strategies(:scope => @config.default_scope)
-          ).dup
-        end
-      else
-        _default_strategies[scope] = strategies.flatten
-      end
-      _default_strategies[scope]
-    end
-
-    def _default_strategies
-      @default_strategies ||= {}
-    end
-
     # Run the authentiation strategies for the given strategies.
     # If there is already a user logged in for a given scope, the strategies are not run
     # This does not halt the flow of control and is a passive attempt to authenticate only
@@ -167,10 +146,7 @@ module Warden
       scope = (opts[:scope] ||= @config.default_scope)
 
       # Get the default options from the master configuration for the given scope
-      opts = opts.dup
-      if @config.default_scope_options(scope)
-        opts = @config.default_scope_options(scope).merge(opts)
-      end
+      opts = @config.scope_defaults(scope).merge(opts)
 
       @users[scope] = user
       session_serializer.store(user, scope) unless opts[:store] == false
@@ -298,15 +274,14 @@ module Warden
 
     # Run the strategies for a given scope
     def _run_strategies_for(scope, args) #:nodoc:
-      self.winning_strategy = nil
+      self.winning_strategy = @winning_strategies[scope]
       strategies = args.empty? ? default_strategies(:scope => scope) : args
-      puts strategies.inspect
 
       strategies.each do |name|
         strategy = _fetch_strategy(name, scope)
         next unless strategy && !strategy.performed? && strategy.valid?
 
-        self.winning_strategy = strategy
+        self.winning_strategy = @winning_strategies[scope] = strategy
         strategy._run!
         break if strategy.halted?
       end

data/lib/warden/proxy_deprecation.rb

@@ -3,9 +3,9 @@ module Warden
   # Sets up a place for deprecation of methods from the main proxy
   module ProxyDeprecation
     def default_strategies=(*strategies)
-      warn "[DEPRECATION] warden.default_strateiges= is deprecated.  Instead use warden.set_default_strategies(*strategies) with an optional :scope => :scope)"
+      warn "[DEPRECATION] warden.default_strategies= is deprecated. Instead use warden.default_strategies(*strategies) with an optional :scope => :scope)"
       strategies.push(:scope => @config.default_scope)
-      set_default_strategies(*strategies)
+      default_strategies(*strategies)
     end
   end
 end

data/lib/warden/strategies/base.rb

@@ -119,8 +119,17 @@ module Warden
 
       # 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

data/lib/warden/version.rb

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

data/spec/warden/config_spec.rb

@@ -43,6 +43,6 @@ describe Warden::Config do
     c = Warden::Config.new
     c.scope_defaults :foo, :strategies => [:foo, :bar], :store => false
     c.default_strategies(:scope => :foo).should == [:foo, :bar]
-    c.default_scope_options(:foo).should == {:store => false}
+    c.scope_defaults(:foo).should == {:store => false}
   end
 end

data/spec/warden/manager_spec.rb

@@ -7,7 +7,7 @@ describe Warden::Manager do
     load_strategies
   end
 
-  it "should insert a Base object into the rack env" do
+  it "should insert a Proxy object into the rack env" do
     env = env_with_params
     setup_rack(success_app).call(env)
     env["warden"].should be_an_instance_of(Warden::Proxy)
@@ -80,8 +80,53 @@ describe Warden::Manager do
         result.first.should == 401
         env["warden.options"][:attempted_path].should == "/access/path"
       end
-    end # failure
 
+      it "should catch a resubmitted request" do
+        # this is a bit convoluted. but it's occurred in the field with Rack::OpenID
+        $count = 0
+        $throw_count = 0
+        env = env_with_params("/foo")
+        class ::ResubmittingMiddleware
+          @@app = nil
+          def initialize(app)
+            @@app = app
+          end
+
+          def self.call(env)
+            if $count > 1
+              Rack::Response.new("Bad", 401)
+            else
+              $count += 1
+              @@app.call(env)
+            end
+          end
+
+          def call(env)
+            $count += 1
+            @@app.call(env)
+          end
+
+        end
+
+        app = lambda do |e|
+          $throw_count += 1
+          throw(:warden)
+        end
+
+        builder = Rack::Builder.new do
+          use ResubmittingMiddleware
+          use Warden::Manager do |config|
+            config.failure_app = ResubmittingMiddleware
+          end
+          run app
+        end
+
+        result = builder.to_app.call(env)
+        result[0].should == 401
+        result[2].body.should == ["Bad"]
+        $throw_count.should == 2
+      end
+    end # failure
   end
 
   describe "integrated strategies" do

data/spec/warden/proxy_spec.rb

@@ -220,6 +220,18 @@ describe Warden::Proxy do
       setup_rack(app).call(env)
     end
 
+    it "should store the last winning strategy per scope" do
+      env = env_with_params("/")
+      app = lambda do |env|
+        env['warden'].authenticate(:failz)
+        env['warden'].should_not be_authenticated
+        env['warden'].authenticate(:failz)
+        env['warden'].winning_strategy.message.should == "The Fails Strategy Has Failed You"
+        valid_response
+      end
+      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|
@@ -667,7 +679,7 @@ describe "dynamic default_strategies" do
     end
 
     Warden::Strategies.add(:two) do
-      def authenticate!; $captures << :two; fail!("User not found") end
+      def authenticate!; $captures << :two; fail("User not found") end
     end
   end
 
@@ -751,7 +763,7 @@ describe "dynamic default_strategies" do
     app = wrap_app(@app) do |e|
       e['warden'].default_strategies << :one
       e['warden'].default_strategies.should == [:password, :one]
-      e['warden'].config.default_strategies.should == [:password]
+      e['warden'].manager.config.default_strategies.should == [:password]
       e['warden'].authenticate!
       Rack::Response.new("OK").finish
     end
@@ -769,8 +781,8 @@ describe "dynamic default_strategies" do
           config.default_strategies :two, :one, :scope => :foo
           config.default_strategies :two, :one, :scope => :bar
 
-          config.default_scope_options :bar, :store => false
-          config.default_scope_options :baz, :store => false
+          config.scope_defaults :bar, :store => false
+          config.scope_defaults :baz, :store => false
           config.failure_app = Warden::Spec::Helpers::FAILURE_APP
         end
         run(lambda do |e|

data/spec/warden/strategies/base_spec.rb

@@ -190,32 +190,59 @@ describe Warden::Strategies::Base do
   describe "failure" do
 
     before(:each) do
-      RAS.add(:foobar) do
+      RAS.add(:hard_fail) do
         def authenticate!
           fail!("You are not cool enough")
         end
       end
-      @str = RAS[:foobar].new(env_with_params)
+
+      RAS.add(:soft_fail) do
+        def authenticate!
+          fail("You are too soft")
+        end
+      end
+      @hard = RAS[:hard_fail].new(env_with_params)
+      @soft = RAS[:soft_fail].new(env_with_params)
     end
 
-    it "should allow you to fail" do
-      @str._run!
-      @str.user.should be_nil
+    it "should allow you to fail hard" do
+      @hard._run!
+      @hard.user.should be_nil
     end
 
-    it "should not halt the strategies when failing" do
-      @str._run!
-      @str.should_not be_halted
+    it "should halt the strategies when failing hard" do
+      @hard._run!
+      @hard.should be_halted
     end
 
-    it "should allow you to set a message when failing" do
-      @str._run!
-      @str.message.should == "You are not cool enough"
+    it "should allow you to set a message when failing hard" do
+      @hard._run!
+      @hard.message.should == "You are not cool enough"
     end
 
-    it "should set the action as :failure" do
-      @str._run!
-      @str.result.should == :failure
+    it "should set the action as :failure when failing hard" do
+      @hard._run!
+      @hard.result.should == :failure
+    end
+
+    it "should allow you to fail soft" do
+      @soft._run!
+      @soft.user.should be_nil
+    end
+
+    it "should not halt the strategies when failing soft" do
+      @soft._run!
+      @soft.should_not be_halted
+    end
+
+    it "should allow you to set a message when failing soft" do
+      @soft._run!
+      @soft.message.should == "You are too soft"
+    end
+
+    it "should set the action as :failure when failing soft" do
+      @soft._run!
+      @soft.result.should == :failure
     end
   end
 

data/warden.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{warden}
-  s.version = "0.10.1"
+  s.version = "0.10.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Neighman"]
-  s.date = %q{2010-03-23}
+  s.date = %q{2010-03-26}
   s.email = %q{has.sox@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 10
-  - 1
-  version: 0.10.1
+  - 2
+  version: 0.10.2
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 +11:00
+date: 2010-03-26 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency