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

- (Base) initialize(env, scope = nil)

: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

- (Object) custom_response

:api: private



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

def custom_response
  @custom_response
end

- (Object) env (readonly)

:api: public



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

def env
  @env
end

- (Object) message

:api: public



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

def message
  @message
end

- (Object) result

:api: private



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

def result
  @result
end

- (Object) scope (readonly)

:api: public



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

def scope
  @scope
end

- (Object) status (readonly)

:api: public



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

def status
  @status
end

- (Object) user

:api: public



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

def user
  @user
end

Instance Method Details

- (Object) _run!

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

- (Object) clear!

Marks this strategy as not performed. :api: private



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

def clear!
  @performed = false
end

- (Object) custom!(response)

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



167
168
169
170
171
# File 'lib/warden/strategies/base.rb', line 167

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

- (Object) errors

Access to the errors object. :api: public



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

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

- (Object) fail(message = "Failed to Login")

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



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

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

- (Object) fail!(message = "Failed to Login")

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



130
131
132
133
134
# File 'lib/warden/strategies/base.rb', line 130

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

- (Object) halt!

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

- (Boolean) halted?

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



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

def halted?
  !!@halted
end

- (Object) headers(header = {})

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

- (Object) pass

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

- (Boolean) performed?

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



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

def performed? #:nodoc:
  @performed
end

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

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



152
153
154
155
156
157
158
159
160
161
162
163
# File 'lib/warden/strategies/base.rb', line 152

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

- (Boolean) store?

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



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

def store?
  true
end

- (Object) success!(user, message = nil)

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



119
120
121
122
123
124
# File 'lib/warden/strategies/base.rb', line 119

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

- (Boolean) valid?

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



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

def valid?; true; end