Class: Merb::Authentication::Strategy

Class | Merb::Authentication::Strategy
In: | lib/merb-auth-core/strategy.rb
Parent: | Object

The Merb::Authentication::Strategy is where all the action happens in the merb-auth framework. Inherit from this class to setup your own strategy. The strategy will automatically be placed in the default_strategy_order array, and will be included in the strategy runs.

The strategy you implment should have a YourStrategy#run! method defined that returns

      1. A user object if authenticated
      2. nil if no authenticated user was found.

### Example

       class MyStrategy < Merb::Authentication::Strategy
         def run!
           u = User.get(params[:login])
           u if u.authentic?(params[:password])
         end
       end

### Methods

abstract! abstract? after before body cookies halt! halted? headers inherited new params redirect! redirected? run! session user_class

### Attributes

body | [W] |
request | [RW] |
status | [RW] | Provides a place to put the status of the response

### Public Class methods

abstract!()

Mark a strategy as abstract. This means that a strategy will not ever be run as part of the authentication. Instead this will be available to inherit from as a way to share code.

You could for example setup a strategy to check for a particular kind of login and then have a subclass for each class type of user in your system. i.e. Customer / Staff, Student / Staff etc

abstract?()

Asks is this strategy abstract. i.e. can it be run as part of the authentication

after(strategy)

Use this to declare the strategy should run after another strategy

before(strategy)

Use this to declare the strategy should run before another strategy

inherited(klass)
new(request, params)

### Public Instance methods

body()

Allows you to provide a body of content to return when halting

cookies()

An alials to the request.cookies hash

halt!()

Mark this strategy as complete for this request. Will cause that no other strategies will be executed.

halted?()

Checks to see if this strategy has been halted

headers()

Provides a place to put headers

params()

An alias to the request.params hash Only rely on this hash to find any router params you are looking for. If looking for paramteres use request.params

redirect!(url, opts = {})

Redirects causes the strategy to signal a redirect to the provided url.

#### Parameters

url<String>: | The url to redirect to
options<Hash>: | An options hash with the following keys:

      +:permanent+ Set this to true to make the redirect permanent
      +:status+ Set this to an integer for the status to return

redirected?()

Returns ture if the strategy redirected

run!()

This is the method that is called as the test for authentication and is where you put your code.

You must overwrite this method in your strategy

@api overwritable

session()

An alias to the request.session hash

user_class()

Overwrite this method to scope a strategy to a particular user type you can use this with inheritance for example to try the same strategy on different user types

By default, Merb::Authentication.user_class is used. This method allows for particular strategies to deal with a different type of user class.

For example. If Merb::Authentication.user_class is Customer and you have a PasswordStrategy, you can subclass the PasswordStrategy and change this method to return Staff. Giving you a PasswordStrategy strategy for first Customer(s) and then Staff.

@api overwritable

[Validate]