warden 0.9.7 → 0.10.0

data/History.rdoc

@@ -1,3 +1,9 @@
+== 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
+* Provide each scope with default set_user opts
+* depricate the Proxy#default_strategies= method
+
 == Version 0.9.5 / 2010-02-28
 
 * Add Warden.test_mode!

data/Rakefile

@@ -28,5 +28,5 @@ task :default => :spec
 desc "Run specs"
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = %w(-fs --color)
+  t.spec_opts = %w(-fs --color --backtrace)
 end

data/lib/warden/config.rb

@@ -36,8 +36,9 @@ module Warden
 
     def initialize(other={})
       merge!(other)
-      self[:default_scope]       ||= :default
-      self[:default_strategies]  ||= []
+      self[:default_scope]          ||= :default
+      self[:default_scope_options]  ||= {}
+      self[:default_strategies]     ||= {}
     end
 
     # Do not raise an error if a missing strategy is given by default.
@@ -53,13 +54,35 @@ 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]
+        self[:default_strategies][scope]
       else
-        self[:default_strategies] = strategies.flatten
+        self[:default_strategies][scope] = strategies.flatten
       end
     end
 
+    # 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
+    end
+
+    # A short hand way to set up a particular scope
+    def scope_defaults(scope, opts = {})
+      strategies = opts.delete(:strategies) || []
+      default_strategies(strategies, :scope => scope)
+      default_scope_options(scope, opts)
+      true
+    end
+
     # Quick accessor to strategies from manager
     # :api: public
     def strategies
@@ -78,4 +101,4 @@ module Warden
       Warden::Manager.serialize_from_session(*args, &block)
     end
   end
-end
+end

data/lib/warden/manager.rb

@@ -18,7 +18,10 @@ module Warden
     # configure the Warden::Manager.
     # :api: public
     def initialize(app, options={})
+      default_strategies = options.delete(:default_strategies)
+
       @app, @config = app, Warden::Config.new(options)
+      @config.default_strategies *default_strategies if default_strategies
       yield @config if block_given?
       self
     end
@@ -37,13 +40,14 @@ module Warden
       result ||= {}
       case result
       when Array
-        if result.first == 401 && !env['warden'].custom_failure?
-          process_unauthenticated(env)
+        if result.first == 401
+          process_unauthenticated({:original_response => result, :action => :unauthenticated}, env)
         else
           result
         end
       when Hash
-        process_unauthenticated(env, result || {})
+        result[:action] ||= :unauthenticated
+        process_unauthenticated(result, env)
       end
     end
 
@@ -83,33 +87,30 @@ module Warden
     # When a request is unauthentiated, here's where the processing occurs.
     # It looks at the result of the proxy to see if it's been executed and what action to take.
     # :api: private
-    def process_unauthenticated(env, options={})
-      options[:action] ||= :unauthenticated
-
-      proxy  = env['warden']
-      result = options[:result] || proxy.result
+    def process_unauthenticated(result, env)
+      action = result[:result] || env['warden'].result
 
-      case result
-      when :redirect
-        body = proxy.message || "You are being redirected to #{proxy.headers['Location']}"
-        [proxy.status, proxy.headers, [body]]
-      when :custom
-        proxy.custom_response
-      else
-        call_failure_app(env, options)
+      case action
+        when :redirect
+          [env['warden'].status, env['warden'].headers, [env['warden'].message || "You are being redirected to #{env['warden'].headers['Location']}"]]
+        when :custom
+          env['warden'].custom_response
+        else
+          call_failure_app(env, result)
       end
     end
 
     # Calls the failure app.
     # The before_failure hooks are run on each failure
     # :api: private
-    def call_failure_app(env, options = {})
-      if config.failure_app
-        options.merge!(:attempted_path => ::Rack::Request.new(env).fullpath)
-        env["PATH_INFO"] = "/#{options[:action]}"
-        env["warden.options"] = options
+    def call_failure_app(env, opts = {})
+      if env['warden'].custom_failure?
+        opts[:original_response]
+      elsif config.failure_app
+        env["PATH_INFO"] = "/#{opts[:action]}"
+        env["warden.options"] = opts
 
-        _run_callbacks(:before_failure, env, options)
+        _run_callbacks(:before_failure, env, opts)
         config.failure_app.call(env).to_a
       else
         raise "No Failure App provided"

data/lib/warden/proxy.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
+require 'warden/proxy_deprecation'
+
 module Warden
   class UserNotSet < RuntimeError; end
 
   class Proxy
+    include ProxyDeprecation
     # An accessor to the winning strategy
     # :api: private
     attr_accessor :winning_strategy
@@ -66,14 +69,23 @@ module Warden
     # By changing this value, you can change the default strategies for a downstream branch of you rack graph.
     #
     # @api public
-    def default_strategies
-      @default_strategies ||= config.default_strategies.dup
+    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
 
-    # Allows you to set the default strategies for this request.
-    # @api public
-    def default_strategies=(*strategies)
-      @default_strategies = strategies.flatten
+    def _default_strategies
+      @default_strategies ||= {}
     end
 
     # Run the authentiation strategies for the given strategies.
@@ -154,6 +166,12 @@ module Warden
       return unless user
       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
+
       @users[scope] = user
       session_serializer.store(user, scope) unless opts[:store] == false
 
@@ -281,7 +299,8 @@ module Warden
     # Run the strategies for a given scope
     def _run_strategies_for(scope, args) #:nodoc:
       self.winning_strategy = nil
-      strategies = args.empty? ? default_strategies : args
+      strategies = args.empty? ? default_strategies(:scope => scope) : args
+      puts strategies.inspect
 
       strategies.each do |name|
         strategy = _fetch_strategy(name, scope)

data/lib/warden/proxy_deprecation.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+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)"
+      strategies.push(:scope => @config.default_scope)
+      set_default_strategies(*strategies)
+    end
+  end
+end

data/lib/warden/strategies/base.rb

@@ -121,7 +121,6 @@ module Warden
       # You must throw an :warden symbol somewhere in the application to enforce this
       # :api: public
       def fail!(message = "Failed to Login")
-        halt!
         @message = message
         @result = :failure
       end

data/lib/warden/version.rb

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

data/spec/warden/config_spec.rb

@@ -38,4 +38,11 @@ describe Warden::Config do
   it "should merge given options on initialization" do
     Warden::Config.new(:foo => :bar)[:foo].should == :bar
   end
+
+  it "should setup defaults with the scope_defaults method" 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}
+  end
 end

data/spec/warden/manager_spec.rb

@@ -69,17 +69,6 @@ describe Warden::Manager do
         result.first.should == 401
         result.last.should == ["You Fail!"]
       end
-
-      it "should set the attempted url in warden.options hash" do
-        env = env_with_params("/access/path", {})
-        app = lambda do |env|
-          env['warden'].authenticate(:pass)
-          throw(:warden)
-        end
-        result = setup_rack(app, :failure_app => @fail_app).call(env)
-        result.first.should == 401
-        env["warden.options"][:attempted_path].should == "/access/path"
-      end
     end # failure
 
   end

data/spec/warden/proxy_spec.rb

@@ -672,8 +672,8 @@ describe "dynamic default_strategies" do
   end
 
   before(:each) do
-    $captures = []
     @app = lambda{|e| e['warden'].authenticate! }
+    $captures = []
   end
 
   def wrap_app(app, &blk)
@@ -688,7 +688,7 @@ describe "dynamic default_strategies" do
     app = wrap_app(@app) do |e|
       e['warden'].default_strategies.should == [:password]
       e['warden'].config.default_strategies.should == [:password]
-      e['warden'].default_strategies = [:one]
+      e['warden'].default_strategies :one
       e['warden'].authenticate!
       Rack::Response.new("OK").finish
     end
@@ -708,6 +708,45 @@ describe "dynamic default_strategies" do
 
     $captures.should == [:one]
   end
+
+  it "should allow me to set the default strategies on a per scope basis" do
+    app = wrap_app(@app) do |e|
+      w = e['warden']
+      w.default_strategies(:two, :one, :scope => :foo)
+      w.default_strategies(:two, :scope => :default)
+      w.default_strategies(:scope => :foo).should == [:two, :one]
+      w.authenticate(:scope => :foo)
+      $captures.should == [:two, :one]
+      $captures.clear
+      w.authenticate
+      $captures.should == [:two]
+    end
+    setup_rack(app).call(env_with_params)
+    $captures.should == [:two]
+  end
+
+  it "should allow me to setup default strategies for each scope on the manager" do
+    builder = Rack::Builder.new do
+      use Warden::Spec::Helpers::Session
+      use Warden::Manager do |config|
+        config.default_strategies :one
+        config.default_strategies :two, :one, :scope => :foo
+        config.failure_app = Warden::Spec::Helpers::FAILURE_APP
+      end
+      run(lambda do |e|
+        w = e['warden']
+        w.authenticate
+        $captures.should == [:one]
+        $captures.clear
+        w.authenticate(:scope => :foo)
+        $captures.should == [:two, :one]
+        $captures << :complete
+      end)
+    end
+    builder.to_app.call(env_with_params)
+    $captures.should include(:complete)
+  end
+
   it "should not change the master configurations strategies when I change them" do
     app = wrap_app(@app) do |e|
       e['warden'].default_strategies << :one
@@ -720,4 +759,43 @@ describe "dynamic default_strategies" do
 
     $captures.should == [:one]
   end
+
+  describe "default scope options" do
+    it "should allow me to set store, false on a given scope" do
+      $captures = []
+      builder = Rack::Builder.new do
+        use Warden::Manager do |config|
+          config.default_strategies :one
+          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.failure_app = Warden::Spec::Helpers::FAILURE_APP
+        end
+        run(lambda do |e|
+          w = e['warden']
+          w.authenticate
+          w.authenticate(:scope => :foo)
+          w.authenticate(:one, :scope => :bar)
+          w.authenticate(:one, :scope => :baz, :store => true)
+          w.user.should == "User"
+          w.user(:foo).should == "User"
+          w.user(:bar).should == "User"
+          w.user(:baz).should == "User"
+          $captures << :complete
+          Rack::Response.new("OK").finish
+        end)
+      end
+      env = env_with_params
+      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"
+      session.key?('warden.user.bar.key').should be_false
+      session['warden.user.bar.key'].should be_nil
+      session['warden.user.baz.key'].should == "User"
+    end
+  end
 end

data/spec/warden/strategies/base_spec.rb

@@ -203,9 +203,9 @@ describe Warden::Strategies::Base do
       @str.user.should be_nil
     end
 
-    it "should halt the strategies when failing" do
+    it "should not halt the strategies when failing" do
       @str._run!
-      @str.should be_halted
+      @str.should_not be_halted
     end
 
     it "should allow you to set a message when failing" do

data/warden.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{warden}
-  s.version = "0.9.7"
+  s.version = "0.10.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Neighman"]
-  s.date = %q{2010-03-11}
+  s.date = %q{2010-03-22}
   s.email = %q{has.sox@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
      "lib/warden/manager_deprecation.rb",
      "lib/warden/mixins/common.rb",
      "lib/warden/proxy.rb",
+     "lib/warden/proxy_deprecation.rb",
      "lib/warden/session_serializer.rb",
      "lib/warden/strategies.rb",
      "lib/warden/strategies/base.rb",

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 9
-  - 7
-  version: 0.9.7
+  - 10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 +01:00
+date: 2010-03-22 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,6 +69,7 @@ files:
 - lib/warden/manager_deprecation.rb
 - lib/warden/mixins/common.rb
 - lib/warden/proxy.rb
+- lib/warden/proxy_deprecation.rb
 - lib/warden/session_serializer.rb
 - lib/warden/strategies.rb
 - lib/warden/strategies/base.rb