module ActionDispatch::Routing::Mapper::Base

def default_url_options=(options) 

def default_url_options=(options)
  @set.default_url_options = options
end

def initialize(set) #:nodoc:

:nodoc: 
def initialize(set) #:nodoc:
  @set = set
end

def match(path, options=nil)

:action will be available to the action as part of params.
action within that controller. Anything other than :controller or
controller in your application, and :action maps to the name of an
Two of these symbols are special: :controller maps to the name of a

match ':controller/:action/:id/:user_id'

Rails maps to parts of an incoming HTTP request.
When you set up a regular route, you supply a series of symbols that 
def match(path, options=nil)
  mapping = Mapping.new(@set, @scope, path, options || {}).to_route
  @set.add_route(*mapping)
  self
end

def mount(app, options = nil)

which can be used to navigate to this mounted app.
This will generate the +exciting_path+ and +exciting_url+ helpers

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

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

mount(SomeRackApp => "some_route")

Alternatively:

mount SomeRackApp, :at => "some_route"

Mount a Rack-based application to be used within the application. 
def mount(app, options = nil)
  if options
    path = options.delete(:at)
  else
    options = app
    app, path = options.find { |k, v| k.respond_to?(:call) }
    options.delete(app) if app
  end
  raise "A rack application must be specified" unless path
  match(path, options.merge(:to => app, :anchor => false, :format => false))
  self
end

def root(options = {})

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

For options, see the +match+ method's documentation, as +root+ uses it internally.

root :to => 'pages#main'

You can specify what Rails should route "/" to with the root method: 
def root(options = {})
  match '/', options.reverse_merge(:as => :root)
end