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

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



152
153
154
155
156
 
# File 'lib/warden/strategies/base.rb', line 152

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

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 :api: public



123
124
125
126
 
# File 'lib/warden/strategies/base.rb', line 123

def fail!(message = "Failed to Login")
  @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



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

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
pararms <Hash> - Any parameters to encode into the URL
opts <Hash> - Any options to recirect with.
  available options: permanent => (true || false)

:api: public



137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/warden/strategies/base.rb', line 137

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

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



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

def success!(user, message = nil)
  halt!
  @user = user
  @message = message
  @result = :success
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