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



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

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

Instance Attribute Details

#custom_response ⇒ Object

:api: private



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

def custom_response
  @custom_response
end

#env ⇒ Object (readonly)

:api: public



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

def env
  @env
end

#message ⇒ Object

:api: public



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

def message
  @message
end

#result ⇒ Object

:api: private



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

def result
  @result
end

#scope ⇒ Object (readonly)

:api: public



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

def scope
  @scope
end

#status ⇒ Object (readonly)

:api: public



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

def status
  @status
end

#user ⇒ Object

:api: public



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

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



51
52
53
54
55
 
# File 'lib/warden/strategies/base.rb', line 51

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

#clear! ⇒ Object

Marks this strategy as not performed. :api: private



65
66
67
 
# File 'lib/warden/strategies/base.rb', line 65

def clear!
  @performed = false
end

#custom!(response) ⇒ Object

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



172
173
174
175
176
 
# File 'lib/warden/strategies/base.rb', line 172

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

#errors ⇒ Object

Access to the errors object. :api: public



85
86
87
 
# File 'lib/warden/strategies/base.rb', line 85

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



143
144
145
146
 
# File 'lib/warden/strategies/base.rb', line 143

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



135
136
137
138
139
 
# File 'lib/warden/strategies/base.rb', line 135

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



91
92
93
 
# File 'lib/warden/strategies/base.rb', line 91

def halt!
  @halted = true
end

#halted? ⇒ Boolean

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

Returns:

  • (Boolean) 


97
98
99
 
# File 'lib/warden/strategies/base.rb', line 97

def halted?
  !!@halted
end

#headers(header = {}) ⇒ Object

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



77
78
79
80
81
 
# File 'lib/warden/strategies/base.rb', line 77

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



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

def pass; end

#performed? ⇒ Boolean

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

Returns:

  • (Boolean) 


59
60
61
 
# File 'lib/warden/strategies/base.rb', line 59

def performed? #:nodoc:
  @performed
end

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

Causes the authentication to redirect. An :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



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

def redirect!(url, params = {}, opts = {})
  halt!
  @status = opts[:permanent] ? 301 : 302
  headers["Location"] = url
  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) 


103
104
105
 
# File 'lib/warden/strategies/base.rb', line 103

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



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

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) 


112
113
114
 
# File 'lib/warden/strategies/base.rb', line 112

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) 


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

def valid?; true; end