I took the lazy Sunday evening to catch up on my reading of the official Rails guides on Action Controller. I paired that with chapter 4 of Obie Fernandez’s The Rails 5 Way, which is all about working with Rails controllers. This post tries to summarize the essentials, providing a brief overview of Rails controllers.
The controller is responsible for managing the control flow of the application. It acts as a middleman between the model and the view, making the model available to the view to display the data to the user.
Naming Convention: Prefer the pluralized version, e.g. PostsController
instead of PostController
. This contrasts with the naming convention for the models, which are supposed to be singular, e.g. Post
.
In its basic form, a Rails controller is a Ruby class extending from ApplicationController
, which itself extends from ActionController:Base
.
class PostsController < ApplicationController
def index
end
end
Upon receiving a request, the routing mechanism determines which controller#action
to use. Then Rails creates an instance of the controller and invokes that action method. For example, a request for /posts/new
instructs Rails to create an instance of PostsController
and call its new
method.
Primarily, the controller does two things, understand the incoming request to figure out what to do and produce the appropriate view in response.
There are two ways to send data to the server:
- Query string parameters:
/search?query=admin
- POST data, submitted via a form.
Both query string parameters and the POST data are available in the params
hash in the controller.
class HomeController < ApplicationController
def index
end
# Fetch the query string parameter
# from the request URL: /home/search?query=admin
def search
@query = params[:query] #admin
end
end
When Rails renders a view, it uses the instance variables set by the controller.
Q. How can a view, which is an instance of
ActionView::Base
access the instance variables of a controller, which is anActionController
?A. Rails loops through the controller object’s variables, and for each one, creates an instance variable for the view with the same name and value.
Action Callbacks
Action callbacks enable controllers to run code before and after an action. You can use them for authentication, caching, or logging. The callbacks are nothing but class methods that appear at the top of the controller class. The actual methods that these callbacks call should be made private or protected.
class HomeController < ApplicationController
before_action :authenticate
def index
end
private
def authenticate
# authentication code
end
end
Action callbacks can access the request
and response
objects set by Rails, along with all the instance variables set by the actions. They can set any instance variables to be used by other actions.
You can also limit action callbacks to specific actions using the :only
or :except
options. Both options accept a single action only: :index
or an array of actions except: [:foo, :bar]
.