Class: Warden::Strategies::Base

Inherits:
Object
  • Object
show all
Includes:
Mixins::Common
Defined in:
lib/warden/strategies/base.rb

Overview

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 are:

<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 strategy 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 convenient 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)

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Mixins::Common

#params, #request, #reset_session!, #session, #warden_cookies

Constructor Details

#initialize(env, scope = nil) ⇒ Base

:api: private



44
45
46
47
48
49
 
# File 'lib/warden/strategies/base.rb', line 44

def initialize(env, scope=nil) # :nodoc:
  @env, @scope = env, scope
  @status, @headers = nil, {}
  @halted, @performed = false, false
  @result = nil
end

Instance Attribute Details

#custom_response ⇒ Object

:api: private



36
37
38
 
# File 'lib/warden/strategies/base.rb', line 36

def custom_response
  @custom_response
end

#env ⇒ Object (readonly)

:api: public



39
40
41
 
# File 'lib/warden/strategies/base.rb', line 39

def env
  @env
end

#message ⇒ Object

:api: public



33
34
35
 
# File 'lib/warden/strategies/base.rb', line 33

def message
  @message
end

#result ⇒ Object

:api: private



36
37
38
 
# File 'lib/warden/strategies/base.rb', line 36

def result
  @result
end

#scope ⇒ Object (readonly)

:api: public



39
40
41
 
# File 'lib/warden/strategies/base.rb', line 39

def scope
  @scope
end

#status ⇒ Object (readonly)

:api: public



39
40
41
 
# File 'lib/warden/strategies/base.rb', line 39

def status
  @status
end

#user ⇒ Object

:api: public



33
34
35
 
# File 'lib/warden/strategies/base.rb', line 33

def user
  @user
end

Instance Method Details

#_run! ⇒ Object

The method that is called from above. This method calls the underlying authenticate! method :api: private



53
54
55
56
57
 
# File 'lib/warden/strategies/base.rb', line 53

def _run! # :nodoc:
  @performed = true
  authenticate!
  self
end

#clear! ⇒ Object

Marks this strategy as not performed. :api: private



67
68
69
 
# File 'lib/warden/strategies/base.rb', line 67

def clear!
  @performed = false
end

#custom!(response) ⇒ Object

Return a custom rack array. You must throw an :warden symbol to activate this :api: public



174
175
176
177
178
 
# File 'lib/warden/strategies/base.rb', line 174

def custom!(response)
  halt!
  @custom_response = response
  @result = :custom
end

#errors ⇒ Object

Access to the errors object. :api: public



87
88
89
 
# File 'lib/warden/strategies/base.rb', line 87

def errors
  @env['warden'].errors
end

#fail(message = "Failed to Login") ⇒ Object

Causes 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



145
146
147
148
 
# File 'lib/warden/strategies/base.rb', line 145

def fail(message = "Failed to Login")
  @message = message
  @result = :failure
end

#fail!(message = "Failed to Login") ⇒ Object

This causes the strategy to fail. It does not throw a :warden symbol to drop the request out to the failure application You must throw a :warden symbol somewhere in the application to enforce this Halts the strategies so that this is the last strategy checked :api: public



137
138
139
140
141
 
# File 'lib/warden/strategies/base.rb', line 137

def fail!(message = "Failed to Login")
  halt!
  @message = message
  @result = :failure
end

#halt! ⇒ Object

Cause the processing of the strategies to stop and cascade no further :api: public



93
94
95
 
# File 'lib/warden/strategies/base.rb', line 93

def halt!
  @halted = true
end

#halted? ⇒ Boolean

Checks to see if a strategy was halted :api: public

Returns:

  • (Boolean) 


99
100
101
 
# File 'lib/warden/strategies/base.rb', line 99

def halted?
  !!@halted
end

#headers(header = {}) ⇒ Object

Provides access to the headers hash for setting custom headers :api: public



79
80
81
82
83
 
# File 'lib/warden/strategies/base.rb', line 79

def headers(header = {})
  @headers ||= {}
  @headers.merge! header
  @headers
end

#pass ⇒ Object

A simple method to return from authenticate! if you want to ignore this strategy :api: public



111
 
# File 'lib/warden/strategies/base.rb', line 111

def pass; end

#performed? ⇒ Boolean

Returns if this strategy was already performed. :api: private

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/warden/strategies/base.rb', line 61

def performed? #:nodoc:
  @performed
end

#redirect!(url, params = {}, opts = {}) ⇒ Object

Causes the authentication to redirect. A :warden symbol must be thrown to actually execute this redirect

Parameters:

url <String> - The string representing the URL to be redirected to
params <Hash> - Any parameters to encode into the URL
opts <Hash> - Any options to redirect with.
  available options: permanent => (true || false)

:api: public



159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/warden/strategies/base.rb', line 159

def redirect!(url, params = {}, opts = {})
  halt!
  @status = opts[:permanent] ? 301 : 302
  headers["Location"] = url.dup
  headers["Location"] << "?" << Rack::Utils.build_query(params) unless params.empty?
  headers["Content-Type"] = opts[:content_type] || 'text/plain'

  @message = opts[:message] || "You are being redirected to #{headers["Location"]}"
  @result = :redirect

  headers["Location"]
end

#store? ⇒ Boolean

Checks to see if a strategy should result in a permanent login :api: public

Returns:

  • (Boolean) 


105
106
107
 
# File 'lib/warden/strategies/base.rb', line 105

def store?
  true
end

#success!(user, message = nil) ⇒ Object

Whenever you want to provide a user object as “authenticated” use the success! method. This will halt the strategy, and set the user in the appropriate scope. It is the “login” method

Parameters:

user - The user object to login.  This object can be anything you have setup to serialize in and out of the session

:api: public



126
127
128
129
130
131
 
# File 'lib/warden/strategies/base.rb', line 126

def success!(user, message = nil)
  halt!
  @user = user
  @message = message
  @result = :success
end

#successful? ⇒ Boolean

Returns true only if the result is a success and a user was assigned.

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/warden/strategies/base.rb', line 114

def successful?
  @result == :success && !user.nil?
end

#valid? ⇒ Boolean

Acts as a guarding method for the strategy. If #valid? responds false, the strategy will not be executed Overwrite with your own logic :api: overwritable

Returns:

  • (Boolean) 


75
 
# File 'lib/warden/strategies/base.rb', line 75

def valid?; true; end