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, Rails’ Routing works with any web server. Routes are defined in config/routes.rb.
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.
Not all routes are created equally. Routes have priority defined by the order of appearance of the routes in the config/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.
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' }
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 # => ''
You can also specify an already-defined named route in your map.root call:
# In routes.rb map.new_session :controller => 'sessions', :action => 'new' map.root :new_session
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)
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 "localhost:3000/articles/2005/11/06" maps to
params = {:year => '2005', :month => '11', :day => '06'}
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})?/ }
Formats can include the ‘ignorecase’ and ‘extended syntax’ regular expression modifiers:
map.geocode 'geocode/:postalcode', :controller => 'geocode', :action => 'show', :postalcode => /hx\d\d\s\d[a-z]{2}/i map.geocode 'geocode/:postalcode', :controller => 'geocode', :action => 'show',:requirements => { :postalcode => /# Postcode format \d{5} #Prefix (-\d{4})? #Suffix /x }
Using the multiline match modifier will raise an ArgumentError. Encoding regular expression modifiers are silently ignored. The match will always use the default encoding or ASCII.
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.
With conditions you can define restrictions on routes. Currently the only valid condition is :method.
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.
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!.
The two main methods for testing your routes:
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.
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
Run rake routes.
SEPARATORS | = | %w( / . ? ) |
HTTP_METHODS | = | [:get, :head, :post, :put, :delete] |
ALLOWED_REQUIREMENTS_FOR_OPTIMISATION | = | [:controller, :action].to_set |
Routes | = | RouteSet.new |
Returns a controller path for a new controller based on a previous controller path. Handles 4 scenarios:
controller_relative_to( nil, "groups/discussion" ) # => "groups/discussion"
controller_relative_to( "posts", "groups/discussion" ) # => "groups/posts"
controller_relative_to( "/posts", "groups/discussion" ) # => "posts"
controller_relative_to( "posts", "anything_with_no_slashes" ) # =>"posts"
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 360 360: def controller_relative_to(controller, previous) 361: if controller.nil? then previous 362: elsif controller[0] == ?/ then controller[1..-1] 363: elsif %r{^(.*)/} =~ previous then "#{$1}/#{controller}" 364: else controller 365: end 366: end
Returns an array of paths, cleaned of double-slashes and relative path references.
The returned array is sorted by length, descending.
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 295 295: def normalize_paths(paths) 296: # do the hokey-pokey of path normalization... 297: paths = paths.collect do |path| 298: path = path. 299: gsub("//", "/"). # replace double / chars with a single 300: gsub("\\\\", "\\"). # replace double \ chars with a single 301: gsub(%r{(.)[\\/]$}, '\1') # drop final / or \ if path ends with it 302: 303: # eliminate .. paths where possible 304: re = %r{[^/\\]+[/\\]\.\.[/\\]} 305: path.gsub!(re, "") while path.match(re) 306: path 307: end 308: 309: # start with longest path, first 310: paths = paths.uniq.sort_by { |path| - path.length } 311: end
Returns the array of controller names currently available to ActionController::Routing.
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 314 314: def possible_controllers 315: unless @possible_controllers 316: @possible_controllers = [] 317: 318: paths = controller_paths.select { |path| File.directory?(path) && path != "." } 319: 320: seen_paths = Hash.new {|h, k| h[k] = true; false} 321: normalize_paths(paths).each do |load_path| 322: Dir["#{load_path}/**/*_controller.rb"].collect do |path| 323: next if seen_paths[path.gsub(%r{^\.[/\\]}, "")] 324: 325: controller_name = path[(load_path.length + 1)..-1] 326: 327: controller_name.gsub!(/_controller\.rb\Z/, '') 328: @possible_controllers << controller_name 329: end 330: end 331: 332: # remove duplicates 333: @possible_controllers.uniq! 334: end 335: @possible_controllers 336: end
Replaces the internal list of controllers available to ActionController::Routing with the passed argument.
ActionController::Routing.use_controllers!([ "posts", "comments", "admin/comments" ])
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 340 340: def use_controllers!(controller_names) 341: @possible_controllers = controller_names 342: end
Expects an array of controller names as the first argument. Executes the passed block with only the named controllers named available. This method is used in internal Rails testing.
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 283 283: def with_controllers(names) 284: prior_controllers = @possible_controllers 285: use_controllers! names 286: yield 287: ensure 288: use_controllers! prior_controllers 289: end
Ensures that routes are reloaded when Rails inflections are updated.
# File vendor/rails/actionpack/lib/action_controller/routing.rb, line 374 374: def inflections_with_route_reloading(&block) 375: returning(inflections_without_route_reloading(&block)) { 376: ActionController::Routing::Routes.reload! if block_given? 377: } 378: end