Ruby on Rails 2.1 Routes System

Advertisements

Rails parses the URL to determine the controller, action, and parameters for the request. With Rails routing, parts of the URL
can specify additional parameters, and the entire routing process is under your control. Routing rules work the same on any
web server.

The config/routes.rb file is at the heart of the Rails routing system. This file contains rules that try to match the URL path of a request and determine where to direct that request. The rules are tested in the order that they're defined in the file. The first rule to match a request's URL path determines the fate of that request.

The routing system actually does two things:

It maps requests to action methods inside the controllers.

It writes URLs for you for use as arguments to methods like link_to, redirect_to, and form_tag.

Thus, the routing system knows how to turn a visitor's request URL into a controller/action sequence. It also knows how to manufacture URL strings based on your specifications.

Consider the following route, installed by Rails when you generate your application:

map.connect ':controller/:action/:id'

This route states that it expects requests to consist of a :controller followed by an :action that in turn is fed some :id.

So if you get an incoming request for "http://localhost:3000/book/edit/2", then it will map as follows:

params = { :controller => 'book',
:action => 'edit',
:id => '2'
}

Thus the default routing (if you don't modify the routing rules) is

http://<base-url>/<controller>/<action>/<id>

So a URL like http://www.example.com/book/update/20 calls the update method (the action) in the BooksController class (the controller) with an id parameter set to the value 20.

Following will set up book as the default controller if no other is specified. This means visiting '/' would invoke the book controller.

Now to call action from the given controller you would have to write your URL as follows:

http://localhost:3000/action/controller/id

It's not particularly logical to put action and controller in such sequence. The original default (the default default) route is better and recommended.

The Ante-Default Route:

The 'ante-default' route) looks like this:

map.connect ':controller/:action/:id.:format'

The .:format at the end matches a literal dot and a wildcard "format" value after
the id field. That means it will match, for example, a URL like this:

http://localhost:3000/book/show/3.xml

Here, inside the controller action your params[:format] will be set to xml.

The Empty Route:

The empty route is sort of the opposite of the default route. In a newly generated routes.rb file, the empty route is commented out, because there's no universal or reasonable default for it. You need to decide what this nothing URL should do for each application you write.

The first one will search for welcome action inside main controller even if you type just http://localhost:3000

That last one will connect to http://localhost:3000/main/index. Here index is the default action when there's none specified.

Rails 2.0 introduces a mapper method named root which becomes the proper way to define the empty route for a Rails application, like this:

map.root :controller => "homepage"

Defining the empty route gives people something to look at when they connect to your site with nothing but the domain name.

Named routes:

As you continue developing your application, you will probably have a few links that you use throughout your application. For example, you will probably often be putting a link back to the main listings page. Instead of having to add the following line throughout your application, you can instead create a named route that enables you to link to a shorthand version of that link:

link_to 'Home', :controller => 'classified', :action => 'list'

You can define named routes as follows. Here instead of using connect, you are using a unique name that you can define. In this case, the route is called home. The rest of the route looks similar to the others you have created.

map.home '', :controller => 'classified', :action => 'list'

Now you can use this in the controllers or views as follows:

<%= link_to 'Back', home_url %>

Here, instead of listing the :controller and :action to which you will be linking, you are instead putting the name of the route followed by _url. Your user shouldn't notice any difference. Named routing is merely a convenience for the Rails developer
to save some typing. Above case can be written without named route as follows: