Rails Introduction: Controllers and Templates

Lecture Notes for CS142
Winter Quarter 2009
John Ousterhout

Rails: a Web application framework based on the Ruby language. Often referred to as "Ruby on Rails".

Rails applications have an MVC (model-view-controller) structure:
- Model: manages the application data
  - Each class encapsulates the data in a particular database table.
- View: generates Web page.
- Controller: glue between the model and view:
  - Responds to incoming HTTP requests
  - Fetches/modifies data in the models
- The MVC pattern has been around since the late 1970's; originally conceived in the Smalltalk project at Xerox PARC.
Lifecycle of an HTTP request:
- Dispatching:
  - Rails receives incoming request
  - Rails invokes a method in a Controller class, based on the URL:
    - Default: URL /first/second will be dispatched to method second in class FirstController. The controller should be defined in the file /app/controllers/first_controller.rb
    - You can define other mappings.
  - The controller method corresponding to a URL is called an action method.
  - Controller can several action methods; typically a controller manages a related group of URLs.
- Controller action method:
  - Collects data needed to generate the page, saves in instance variables of the controller object.
  - Typically does this by calling Model classes.
  - URL information:
    - Query values available through params[:foo]
    - If the URL had the form /class/method/id, where id is an integer, then that value is available through params[:id]. Commonly used to hold the primary key for a database record to display the page.
- View:
  - A template that generates the HTML for the page.
  - For URL /first/second, the view will be in the file /app/views/first/second.html.erb
  - By default, Rails automatically invokes the view once the controller action method returns.
  - Can override this by invoking render explicitly in the controller.

Templates:

The most common way to generate dynamic HTML; available in virtually all Web development frameworks.

Simple Rails example:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Hello, User</title>
  </head>
  <body>
    <p>
    This page was fetched at <%= Time.now() %>
    </p>
  </body>
</html>

Basic ideas:
- Write HTML document containing parts of the page that are always the same.
- Add bits of code that generate the parts that are dynamic.
- The template gets expanded by executing code snippets, substituting the results into the document.
Benefits of templates:
- Easy to visualize HTML structure
- Easy to see how dynamic data fits in
Two kinds of annotation in Rails templates:
- <%= ... %>: substitute value of expression
- <% ... %>: execute Ruby code, but no substitution of result: use concat in code to generate HTML

Can interleave Ruby control structures with HTML:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Rails Parameters</title>
  </head>
  <body>
    <p>
    The <code>params</code> hash contains the following values:
    </p>
    <% params.each do |key, value| %>
      <p><%= key %>: <%= value %></p>
    <% end %>
  </body>
</html>

Useful "helper" functions for Rails templates:
- link_to: convenient for generating links; see pages 475-478 in the Rails book. Example:
```
<%= link_to(@name, {:action => "userInfo", :id => @user_id}) %>
```
- h: method to escape special HTML characters.