Una de las opciones que existen para controlar el acceso de tu aplicación en RoR es authlogic el cual es de código abierto y lo podemos usar libremente.

Conceptos base

Lo primero que se tiene que notar es que es código exclusivamente para el manejo de los usuarios y sus sesiones. Esto quiere decir que no hay generadores (de vistas u otros) y se tienen que hacer algunas modificaciones “a mano” para poder hacer uso de authlogic, sin embargo, las ventajas y claridad que se obtienen a cambio de no tener generadores es algo que se nota a distancia en la complejidad final ya que todo el código que se escribe, es hecho por el mismo programador y no por un generador no especifico a la aplicación.

El usuario es aquel modelo en el cual se encuentran los datos que nos importan del mismo como su email, su password (el cual debe de estar cifrado en la base de datos y también se tiene que ocultar de los logs de la aplicación) y otras cosas que queramos tener bajo el control de este modelo, talvez, si es un admin o algunos otros parámetros. Este modelo lo único que tiene que incluir es acts_as_authentic con lo cual se activa el modelo de autenticación de authlogic y el cual incluye un tratamiento para algunas columnas especiales en el modelo como la de crypted_password (que como el nombre lo indica, es el password encriptado).

Por otra parte un usuario sólo se podría dar de alta, baja y modificar sus parámetros, lo que necesitamos para que sea de más uso en nuestra aplicación es tener una sesión de usuario con la cual el browser podrá mantener un indicador para identificar como que usuario esta identificado a través del recorrer de la aplicación en las diferentes ventanas que se le muestren al usuario.

Instalación

Para instalarlo, lo puedes instalar como una gema o lo puedes instalar como un plugin en tu directorio de trabajo

script/plugin install git://github.com/binarylogic/authlogic.git

Con lo cual se ha instalado bajo el directorio

vendor/plugins/authlogic

Usando nifty_generators

Usaremos los nifty-generators se pueden instalar como plugin o como gema.

Creando al usuario, activando authlogic haciendo pequeñas modificaciones

Los nifty_generatos nos dejan especificar algunos parámetros extra a diferencia de los generadores normales como saltarnos el modelo o nada más generar para el controlador “new” y “edit” como a continuación se hace para generar el scaffold del usuario

script/generate nifty_scaffold user username:string email:string password:string new edit

Antes de generar la migración se debe de editar la misma en

db/migrations/timestamp_create_users.rb

Y agregamos al inicio de “password” la palabra “crypted_” también agregamos “password_salt” y “persistance_token” que son unas columnas especialmente tratadas por authlogic. También hay que notar que nosotros podemos agregar alguna columna extra como is_admin que esta comentada en este caso.

class CreateUsers < ActiveRecord::Migration
  def self.up
    create_table :users do |t|
      t.string :username
      t.string :email
      t.string :crypted_password
      t.string :password_salt
      t.string :persistence_token
#      t.boolean :is_admin # esto se podría usar como un esquema simple para identificar al admin del sitio, pero no lo usaremos aquí.
      t.timestamps
    end
  end
 
  def self.down
    drop_table :users
  end
end

Ya podemos migrar la base de datos

rake db:migrate

Para activar authlogic para el modelo en user.rb se hace agregando la línea acts_as_authentic

class User < ActiveRecord::Base
    acts_as_authentic
end

Ya que al crear el scaffold el password quedo como un campo de texto o un text_field se debe de reemplazar por un password_field y también podemos agregar una confirmación de password confirmación de password. Se debe de notar que se tienen validaciones preconstruidas para la forma como: checar el formato del email, los usuarios su nick no sean repetidos, no se este usando el mismo o su mail para diferentes usuarios.

  <p>
    <%= f.label :password_confirmation %><br />
    <%= f.password_field :password_confirmation %>
  </p>
  <p>
    <%= f.label :password_confirmation %><br />
    <%= f.password_field :password_confirmation %>
  </p>

Creando la sesión de usuario, métodos de ayuda, las rutas de login y logout

Ya que tenemos todo lo que necesitamos para el usuario, crearemos la sesión para que pueda logearse/deslogearse del sistema.

script/generate session user_session

Este generador sólo crea un modelo para el manejo de la sesión.

Hasta este momento sólo tenemos un formulario para registrar un nuevo usuario pero no tenemos uno para logearnos en el sistema. Para crear nuestra forma de inicio de sesión, lo podemos hacer de esta forma (notar que nos saltamos el modelo ya que lo hemos creado con el generador de session y sólo requerimos de crear y eliminar la sesión)

script/generate nifty_scaffold user_session --skip_model username:string password:string new destroy

Finalmente modificamos el controlador de la sesión para que quede como

class UserSessionsController < ApplicationController
  def new
    @user_session = UserSession.new
  end
 
  def create
    @user_session = UserSession.new(params[:user_session])
    if @user_session.save
      flash[:notice] = "Successfully logged in."
      redirect_to root_url
    else
      render :action => 'new'
    end
  end
 
  def destroy
    @user_session = UserSession.find #(params[:id]) se usa la sesion actual no el ID de una sesion
    @user_session.destroy
    flash[:notice] = "Successfully logged out."
    redirect_to root_url
  end
end

En el formulario de la sesión views/user_sessions/new.html.erb se cambia como anteriormente en el formulario de registro el text_field por el password_field.

Para facilitar el manejo de la entrada y salida agregamos unas rutas con nombre a routes.rb que nos servirán para referirnos a las acciones login y logout de manera sencilla.

  map.login "login", :controller => "user_sessions", :action => "new"
  map.logout "logout", :controller => "user_sessions", :action => "destroy"

Ahora creemos unos métodos de ayuda o helper methods en controllers/application.rb, notar que con filter_parameter_logging se ha evitado guardar como texto en el log los parametros de password y su confirmación (aunque el segundo no parece ser necesario ya que parece que lo filtra como password*).

class ApplicationController < ActionController::Base
  helper :all # include all helpers, all the time
  filter_parameter_logging :password, :password_confirmation
 
  helper_method :current_user_session, :current_user
 
  private
  def current_user_session
    return @current_user_session if defined?(@current_user)
    @current_user_session = UserSession.find
  end
 
  def current_user
    return @current_user if defined?(@current_user)
    @current_user = current_user_session && current_user_session.record
  end
end

Visualizando la funcionalidad

Los métodos de ayuda nos servirán finalmente para ver lo que hemos hecho hasta el momento y su acción. Agregamos un div por instancia en nuestro views/layouts/application.html.rb para tener nuestro login, register, logout, edit respecto al usuario y su sesión.

<div id="user_nav">
    <%= link_to "Home", root_path %> | 
    <% if current_user %>
        <%= link_to "Edit profile", edit_user_path(:current) %>
        <%= link_to "Logout", logout_path %>
    <% else %>
        <%= link_to "Register", new_user_path %> |
        <%= link_to "Login", login_path %>
    <% end %>    
</div>

Con esto debemos de contar con las acciones de registrar un usuario, logearnos al sistema y una vez ahi salir de la sesión o modificar los datos del usuario.

Notar que podemos agregar otros métodos de ayuda para ver si se trata de un usuario específico, si es el admin entre otras cosas que podemos hacer respecto a los usuarios, para mayor información respecto a las columnas especiales o algunos otros métodos de ayuda consultar el authlogic_example disponible como referencia de authlogic.