What makes Devise truly interesting is its modularity. The following modules are provided by Devise:

These 11 modules are the essence of Devise. With these modules, you can do anything related to application authorization, which is very useful in modern applications.

We are going to learn how to install this interesting authorization plugin to your Rails application. For your information, this is the specification of application sample that I used:

Let's create our Rails application by executing this command:

$ rails new learning-devise

The first thing that should be done is you need to add the Devise gem to your Gemfile.

gem 'devise'

To make sure that everything is installed properly, you can execute the following command inside your Rails application folder:

$ bundle install

The command will install the Devise gem, and now you have to install the configuration files for Devise. You can install it all at once by executing the following command:

$ rails generate devise:install

The result of the command is shown in the following screenshot:

Devise installation

As you can see from the screenshot, Devise generates two new files in your Rails application. Those two files are:

Not just generating files, the installation command also prints some information that will be useful for our complete Devise setup. This information will tell us about:

The next step is generating a Devise model. Let's name our Devise model as user. For your information, this model name can be replaced with any name you wish. This name also determines the Devise helper's name. We will see how we use it later in this chapter. To generate the Devise model, you can execute the following command:

$ rails generate devise user

The result of this command can be seen in the following screenshot:

Generate Devise model

Based on the previous screenshot, Devise generates four kinds of files:

The command also modifies the model file to attach the default modules and the route file (routes.rb). Devise modifies the route so the application recognizes some routes generated by Devise. This is the code which is added by Devise to the route file:

devise_for :users

Now, let's open a user model file (user.rb) and you're going to see this code:

class User < ActiveRecord::Base
# Include default devise modules. Others available 
# are:
# :token_authenticatable, :encryptable, 
# :confirmable, :lockable, :timeoutable and 
# :omniauthable
devise :database_authenticatable, :registerable,
:recoverable, :rememberable, :trackable, 
:validatable

end

From the code, we will know that Devise will attach some default modules such as Database Authenticable, Registerable, Recoverable, Rememberable, Trackable, and Validatable. As I wrote earlier in this chapter, I suppose you already knew what the modules are for.

At this point, you have prepared all the basic settings that a Rails application needs to implement Devise. So, the next step is creating the table on your database by migrating the migration file. If you don't make any change to the Devise migration file, it means Devise will only generate columns for its default modules. But, if you make some changes like commenting on other modules such as t.encryptable, t.confirmable, t.lockable, and t.tocken_authenticatble, you will have extra columns in your user's table that will handle some specific Devise modules. So, it depends on your requirement whether you are going to use the modules or not.

We have prepared our migration file, now let's create the table. I presume that you already have the database and have prepared the database configuration at config/database.yml. If so, all you need to do is execute this command:

$ rake db:migrate

Now, you have prepared everything to make Devise run smoothly on your Rails application. But, there's one more thing that I want to show you. It's about how to wrap controllers with your authorization and see it in action.

In this section, we are going to talk about how to wrap your controllers with Devise authorization and use some Devise helper in your views. First, I want to generate a single controller by executing this command:

$ rails generate controller home index

This command will generate the controller (home_controller.rb) with an action named index. It also generates a view file located at views/home/index.html.erb. Let's start by opening the controller file and add a code (:authenticate_user!) between class definition and first action definition. Why :authenticate_user!? As I stated before, we have our Devise model named as user and this code is one of the Devise helpers that I meant. So, in the future, when you have a Devise model with a different name, you can change the user part in the code with your actual model name. According to our example, the controller code will be like the following:

class HomeController < ApplicationController
before_filter :authenticate_user!

def index
end
end

By adding the highlighted code, your Rails application will run the controller filter, which is executed before executing all the actions defined in the controller. You can also modify the filter so that it will be executed only for all actions using :only or :except code. By adding this code, you will be able to define which actions should be authorized and which should not. For example, it will be like the following code:

class HomeController < ApplicationController
  before_filter :authenticate_user!, :only => [:index, :new]

  def index
  end

  def new
  end

  def edit
  end 
end

The code shows that the actions index and new are authorized, so users need to sign in before getting into the action page.

Now, let's start our Rails server by executing the command $ rails server. See it in action by visiting http://localhost:3000. The application will automatically redirect you to the sign-in page, like this:

First Devise application

Now, you have run your first application with Devise. With current modules, you can only perform sign-in, sign-up, reset password, remember me action, and sign-in tracker. We will play with other modules in the next chapters, but before that, I want to show some Devise's helpers, which are very helpful in view files. Those helpers are as follows:

These helpers are the ones that I mentioned before. The actual name is based on your Devise model name. So, when you create or use another model name, you can use all these helpers by replacing the user keyword in the helpers name with the one that you have.

At this point, you've known how to set up Devise at your Rails application, saw it in action, and the helpers from Devise. We're going to dig deeper into Devise and I'm sure, if you've understood all of this, the following chapters will be easier for you.