Generating Controllers in Ruby on Rails: A Comprehensive Guide

Hero image for How to generate a controller with Ruby on Rails?

Learn how to efficiently create and manage controllers in Ruby on Rails, understanding their role in handling requests and responses.

Controllers are the 'C' in MVC (Model-View-Controller) architecture, serving as the brain of your Ruby on Rails application. They receive incoming requests, interact with models to fetch or manipulate data, and then render views to send a response back to the user. This guide will walk you through the process of generating controllers, understanding their structure, and best practices for their use.

Understanding the Role of a Controller

In a Rails application, when a user navigates to a URL, the request is first routed to a specific controller action. The controller then orchestrates the necessary logic, which might include querying a database (via models), performing calculations, or handling user input. Finally, it prepares data for the view and renders the appropriate template, which is then sent back to the user's browser.

sequenceDiagram
    actor User
    participant Browser
    participant RailsRouter as "Rails Router"
    participant Controller
    participant Model
    participant View

    User->>Browser: Enters URL
    Browser->>RailsRouter: HTTP Request
    RailsRouter->>Controller: Routes to action
    Controller->>Model: Interacts with data
    Model-->>Controller: Returns data
    Controller->>View: Renders template with data
    View-->>Controller: Rendered HTML
    Controller-->>Browser: HTTP Response (HTML)
    Browser->>User: Displays Page

Flow of a request through the Rails MVC architecture

Generating a Controller with Rails Generator

Rails provides a powerful generator to quickly scaffold controllers and their associated files. This saves time and ensures that your controllers adhere to Rails conventions. The rails generate controller command is the primary tool for this task.

rails generate controller Welcome index about

Generating a controller named Welcome with index and about actions.

This command will perform several actions:

Create a controller file at app/controllers/welcome_controller.rb.
Create view files for each specified action: app/views/welcome/index.html.erb and app/views/welcome/about.html.erb.
Add helper methods in app/helpers/welcome_helper.rb.
Generate test files for the controller and helper.

💡

Always use singular names for models and plural names for controllers (e.g., User model, UsersController). However, for general-purpose pages like Welcome or Dashboard, a singular controller name is often appropriate.

Configuring Routes for Your Controller

After generating a controller, you need to define routes in config/routes.rb to make its actions accessible via URLs. The generator might add basic routes, but you'll often need to customize them.

# config/routes.rb
Rails.application.routes.draw do
  get 'welcome/index'
  get 'welcome/about'
  # Define a root route
  root 'welcome#index'
end

Example routes for the Welcome controller.

The root 'welcome#index' line sets the index action of the WelcomeController as the default page for your application. You can also use resources for RESTful controllers, which automatically maps common actions (index, show, new, create, edit, update, destroy) to URLs.

1. Step 1: Generate the Controller

Open your terminal and navigate to your Rails project directory. Run the rails generate controller command, specifying the controller name and any initial actions you want to create. For example, rails generate controller Products index show new create edit update destroy.

2. Step 2: Define Routes

Edit config/routes.rb to map URLs to your controller actions. For a RESTful controller, use resources :products. For custom actions, use get 'path/to/action', to: 'controller#action'.

3. Step 3: Implement Controller Logic

Open app/controllers/your_controller_name_controller.rb and add the necessary Ruby code within each action method. This includes fetching data from models, handling parameters, and preparing instance variables for the view.

4. Step 4: Create Views

Navigate to app/views/your_controller_name/ and create or modify the .html.erb (or other template engine) files for each action. These views will use the instance variables defined in the controller to render HTML.

5. Step 5: Test Your Controller

Start your Rails server (rails s) and navigate to the defined URLs in your browser to verify that your controller and views are working as expected. You can also write unit and integration tests for your controller actions.