Instance Public methods
Also aliased as: default_url_options
# File actionpack/lib/action_dispatch/routing/mapper.rb, line 412
def default_url_options=(options)
  @set.default_url_options = options
match(path, options=nil)

Matches a url pattern to one or more routes. Any symbols in a pattern are interpreted as url query parameters and thus available as paramsin an action:

# sets :controller, :action and :id in params
match ':controller/:action/:id'

Two of these symbols are special, :controllermaps to the controller and :actionto the controller's action. A pattern can also map wildcard segments (globs) to params:

match 'songs/*category/:title' => 'songs#show'

# 'songs/rock/classic/stairway-to-heaven' sets
#  params[:category] = 'rock/classic'
#  params[:title] = 'stairway-to-heaven'

When a pattern points to an internal route, the route's :actionand :controllershould be set in options or hash shorthand. Examples:

match 'photos/:id' => 'photos#show'
match 'photos/:id', :to => 'photos#show'
match 'photos/:id', :controller => 'photos', :action => 'show'

A pattern can also point to a Rackendpoint i.e. anything that responds to call:

match 'photos/:id' => lambda {|hash| [200, {}, "Coming soon"] }
match 'photos/:id' => PhotoRackApp
# Yes, controller actions are just rack endpoints
match 'photos/:id' => PhotosController.action(:show)


Any options not seen here are passed on as params with the url.


The route's controller.


The route's action.


The path prefix for the routes.


The namespace for :controller.

match 'path' => 'c#a', :module => 'sekret', :controller => 'posts'
#=> Sekret::PostsController

See Scoping#namespacefor its scope equivalent.


The name used to generate routing helpers.


Allowed HTTP verb(s) for route.

match 'path' => 'c#a', :via => :get
match 'path' => 'c#a', :via => [:get, :post]

Points to a Rackendpoint. Can be an object that responds to callor a string representing a controller's action.

match 'path', :to => 'controller#action'
match 'path', :to => lambda { |env| [200, {}, "Success!"] }
match 'path', :to => RackApp

Shorthand for wrapping routes in a specific RESTful context. Valid values are :member, :collection, and :new. Only use within resource(s)block. For example:

resource :bar do
  match 'foo' => 'c#a', :on => :member, :via => [:get, :post]

Is equivalent to:

resource :bar do
  member do
    match 'foo' => 'c#a', :via => [:get, :post]

Constrains parameters with a hash of regular expressions or an object that responds to matches?

match 'path/:id', :constraints => { :id => /[A-Z]\d{5}/ }

class Blacklist
  def matches?(request) request.remote_ip == '' end
match 'path' => 'c#a', :constraints =>

See Scoping#constraintsfor more examples with its scope equivalent.


Sets defaults for parameters

# Sets params[:format] to 'jpg' by default
match 'path' => 'c#a', :defaults => { :format => 'jpg' }

See Scoping#defaultsfor its scope equivalent.


Boolean to anchor a matchpattern. Default is true. When set to false, the pattern matches any request prefixed with the given path.

# Matches any request starting with 'path'
match 'path' => 'c#a', :anchor => false
# File actionpack/lib/action_dispatch/routing/mapper.rb, line 371
def match(path, options=nil)
mount(app, options = nil)

Mount a Rack-based application to be used within the application.

mount SomeRackApp, :at => "some_route"


mount(SomeRackApp => "some_route")

For options, see match, as mountuses it internally.

All mounted applications come with routing helpers to access them. These are named after the class specified, so for the above example the helper is either some_rack_app_pathor some_rack_app_url. To customize this helper's name, use the :asoption:

mount(SomeRackApp => "some_route", :as => "exciting")

This will generate the exciting_pathand exciting_urlhelpers which can be used to navigate to this mounted app.

# File actionpack/lib/action_dispatch/routing/mapper.rb, line 393
def mount(app, options = nil)
  if options
    path = options.delete(:at)
    options = app
    app, path = options.find { |k, v| k.respond_to?(:call) }
    options.delete(app) if app

  raise "A rack application must be specified" unless path

  options[:as] ||= app_name(app)

  match(path, options.merge(:to => app, :anchor => false, :format => false))

  define_generate_prefix(app, options[:as])
root(options = {})

You can specify what Rails should route “/” to with the root method:

root :to => 'pages#main'

For options, see match, as rootuses it internally.

You should put the root route at the top of config/routes.rb, because this means it will be matched first. As this is the most popular route of most Rails applications, this is beneficial.

# File actionpack/lib/action_dispatch/routing/mapper.rb, line 252
def root(options = {})
  match '/', { :as => :root }.merge(options)
with_default_scope(scope, &block)
# File actionpack/lib/action_dispatch/routing/mapper.rb, line 417
def with_default_scope(scope, &block)
  scope(scope) do