Module ActionController::Routing
In: vendor/rails/actionpack/lib/action_controller/routing_optimisation.rb
vendor/rails/actionpack/lib/action_controller/routing.rb

Routing

The routing module provides URL rewriting in native Ruby. It‘s a way to redirect incoming requests to controllers and actions. This replaces mod_rewrite rules. Best of all, RailsRouting works with any web server. Routes are defined in routes.rb in your RAILS_ROOT/config directory.

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.

Suppose you get an incoming request for /blog/edit/22, you‘ll end up with:

  params = { :controller => 'blog',
             :action     => 'edit',
             :id         => '22'
          }

Think of creating routes as drawing a map for your requests. The map tells them where to go based on some predefined pattern:

 ActionController::Routing::Routes.draw do |map|
  Pattern 1 tells some request to go to one place
  Pattern 2 tell them to go to another
  ...
 end

The following symbols are special:

  :controller maps to your controller name
  :action     maps to an action with your controllers

Other names simply map to a parameter as in the case of +:id+.

Route priority

Not all routes are created equally. Routes have priority defined by the order of appearance of the routes in the routes.rb file. The priority goes from top to bottom. The last route in that file is at the lowest priority and will be applied last. If no route matches, 404 is returned.

Within blocks, the empty pattern is at the highest priority. In practice this works out nicely:

 ActionController::Routing::Routes.draw do |map|
   map.with_options :controller => 'blog' do |blog|
     blog.show '',  :action => 'list'
   end
   map.connect ':controller/:action/:view'
 end

In this case, invoking blog controller (with an URL like ’/blog/’) without parameters will activate the ‘list’ action by default.

Defaults routes and default parameters

Setting a default route is straightforward in Rails - you simply append a Hash at the end of your mapping to set any default parameters.

Example:

 ActionController::Routing:Routes.draw do |map|
   map.connect ':controller/:action/:id', :controller => 'blog'
 end

This sets up blog as the default controller if no other is specified. This means visiting ’/’ would invoke the blog controller.

More formally, you can define defaults in a route with the +:defaults+ key.

  map.connect ':controller/:action/:id', :action => 'show', :defaults => { :page => 'Dashboard' }

Named routes

Routes can be named with the syntax map.name_of_route options, allowing for easy reference within your source as name_of_route_url for the full URL and name_of_route_path for the URI path.

Example:

  # In routes.rb
  map.login 'login', :controller => 'accounts', :action => 'login'

  # With render, redirect_to, tests, etc.
  redirect_to login_url

Arguments can be passed as well.

  redirect_to show_item_path(:id => 25)

Use map.root as a shorthand to name a route for the root path "".

  # In routes.rb
  map.root :controller => 'blogs'

  # would recognize http://www.example.com/ as
  params = { :controller => 'blogs', :action => 'index' }

  # and provide these named routes
  root_url   # => 'http://www.example.com/'
  root_path  # => ''

Note: when using with_options, the route is simply named after the method you call on the block parameter rather than map.

  # In routes.rb
  map.with_options :controller => 'blog' do |blog|
    blog.show    '',            :action  => 'list'
    blog.delete  'delete/:id',  :action  => 'delete',
    blog.edit    'edit/:id',    :action  => 'edit'
  end

  # provides named routes for show, delete, and edit
  link_to @article.title, show_path(:id => @article.id)

Pretty URLs

Routes can generate pretty URLs. For example:

 map.connect 'articles/:year/:month/:day',
             :controller => 'articles',
             :action     => 'find_by_date',
             :year       => /\d{4}/,
             :month      => /\d{1,2}/,
             :day        => /\d{1,2}/

 # Using the route above, the url below maps to:
 # params = {:year => '2005', :month => '11', :day => '06'}
 # http://localhost:3000/articles/2005/11/06

Regular Expressions and parameters

You can specify a regular expression to define a format for a parameter.

 map.geocode 'geocode/:postalcode', :controller => 'geocode',
             :action => 'show', :postalcode => /\d{5}(-\d{4})?/

or, more formally:

  map.geocode 'geocode/:postalcode', :controller => 'geocode',
              :action => 'show', :requirements => { :postalcode => /\d{5}(-\d{4})?/ }

Route globbing

Specifying *[string] as part of a rule like:

 map.connect '*path' , :controller => 'blog' , :action => 'unrecognized?'

will glob all remaining parts of the route that were not recognized earlier. This idiom must appear at the end of the path. The globbed values are in params[:path] in this case.

Route conditions

With conditions you can define restrictions on routes. Currently the only valid condition is :method.

  • :method - Allows you to specify which method can access the route. Possible values are :post, :get, :put, :delete and :any. The default value is :any, :any means that any method can access the route.

Example:

  map.connect 'post/:id', :controller => 'posts', :action => 'show',
              :conditions => { :method => :get }
  map.connect 'post/:id', :controller => 'posts', :action => 'create_comment',
              :conditions => { :method => :post }

Now, if you POST to /posts/:id, it will route to the create_comment action. A GET on the same URL will route to the show action.

Reloading routes

You can reload routes if you feel you must:

 ActionController::Routing::Routes.reload

This will clear all named routes and reload routes.rb if the file has been modified from last load. To absolutely force reloading, use +reload!+.

Testing Routes

The two main methods for testing your routes:

assert_routing

 def test_movie_route_properly_splits
  opts = {:controller => "plugin", :action => "checkout", :id => "2"}
  assert_routing "plugin/checkout/2", opts
 end

assert_routing lets you test whether or not the route properly resolves into options.

assert_recognizes

 def test_route_has_options
  opts = {:controller => "plugin", :action => "show", :id => "12"}
  assert_recognizes opts, "/plugins/show/12"
 end

Note the subtle difference between the two: assert_routing tests that a URL fits options while assert_recognizes tests that a URL breaks into parameters properly.

In tests you can simply pass the URL or named route to get or post.

 def send_to_jail
   get '/jail'
   assert_response :success
   assert_template "jail/front"
 end

 def goes_to_login
   get login_url
   #...
 end

View a list of all your routes

Run rake routes.

Methods

Classes and Modules

Module ActionController::Routing::Helpers
Module ActionController::Routing::Optimisation
Module ActionController::Routing::RouteSet

Constants

SEPARATORS = %w( / . ? )
HTTP_METHODS = [:get, :head, :post, :put, :delete]
ALLOWED_REQUIREMENTS_FOR_OPTIMISATION = [:controller, :action].to_set
Routes = RouteSet.new

Public Class methods

[Source]

     # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 346
346:       def controller_relative_to(controller, previous)
347:         if controller.nil?           then previous
348:         elsif controller[0] == ?/    then controller[1..-1]
349:         elsif %r{^(.*)/} =~ previous then "#{$1}/#{controller}"
350:         else controller
351:         end
352:       end

[Source]

     # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 300
300:       def normalize_paths(paths)
301:         # do the hokey-pokey of path normalization...
302:         paths = paths.collect do |path|
303:           path = path.
304:             gsub("//", "/").           # replace double / chars with a single
305:             gsub("\\\\", "\\").        # replace double \ chars with a single
306:             gsub(%r{(.)[\\/]$}, '\1')  # drop final / or \ if path ends with it
307: 
308:           # eliminate .. paths where possible
309:           re = %r{\w+[/\\]\.\.[/\\]}
310:           path.gsub!(%r{\w+[/\\]\.\.[/\\]}, "") while path.match(re)
311:           path
312:         end
313: 
314:         # start with longest path, first
315:         paths = paths.uniq.sort_by { |path| - path.length }
316:       end

[Source]

     # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 318
318:       def possible_controllers
319:         unless @possible_controllers
320:           @possible_controllers = []
321: 
322:           paths = controller_paths.select { |path| File.directory?(path) && path != "." }
323: 
324:           seen_paths = Hash.new {|h, k| h[k] = true; false}
325:           normalize_paths(paths).each do |load_path|
326:             Dir["#{load_path}/**/*_controller.rb"].collect do |path|
327:               next if seen_paths[path.gsub(%r{^\.[/\\]}, "")]
328: 
329:               controller_name = path[(load_path.length + 1)..-1]
330: 
331:               controller_name.gsub!(/_controller\.rb\Z/, '')
332:               @possible_controllers << controller_name
333:             end
334:           end
335: 
336:           # remove duplicates
337:           @possible_controllers.uniq!
338:         end
339:         @possible_controllers
340:       end

[Source]

     # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 342
342:       def use_controllers!(controller_names)
343:         @possible_controllers = controller_names
344:       end

[Source]

     # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 292
292:       def with_controllers(names)
293:         prior_controllers = @possible_controllers
294:         use_controllers! names
295:         yield
296:       ensure
297:         use_controllers! prior_controllers
298:       end

Public Instance methods

[Source]

      # File vendor/rails/actionpack/lib/action_controller/routing.rb, line 1492
1492:       def inflections_with_route_reloading(&block)
1493:         returning(inflections_without_route_reloading(&block)) {
1494:           ActionController::Routing::Routes.reload! if block_given?
1495:         }
1496:       end

[Validate]