module ActionDispatch::Routing - actionpack-4.2.4 Documentation

# module ActionDispatch::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, Rails' Routing works with any web server. Routes are defined in `config/routes.rb`.

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

    Rails.application.routes.draw do
      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`.

## Resources¶ ↑

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your `index`, `show`, `new`, `edit`, `create`, `update` and `destroy` actions, a resourceful route declares them in a single line of code:

    resources :photos

Sometimes, you have a resource that clients always look up without referencing an ID. A common example, /profile always shows the profile of the currently logged in user. In this case, you can use a singular resource to map /profile (rather than /profile/:id) to the show action.

    resource :profile

It's common to have resources that are logically children of other resources:

    resources :magazines do
      resources :ads
    end

You may wish to organize groups of controllers under a namespace. Most commonly, you might group a number of administrative controllers under an `admin` namespace. You would place these controllers under the `app/controllers/admin` directory, and you can group them together in your router:

    namespace "admin" do
      resources :posts, :comments
    end

Alternately, you can add prefixes to your path without using a separate directory by using `scope`. `scope` takes additional options which apply to all enclosed routes.

    scope path: "/cpanel", as: 'admin' do
      resources :posts, :comments
    end

For more, see `Routing::Mapper::Resources#resources`, `Routing::Mapper::Scoping#namespace`, and `Routing::Mapper::Scoping#scope`.

## Non-resourceful routes¶ ↑

For routes that don't fit the `resources` mold, you can use the HTTP helper methods `get`, `post`, `patch`, `put` and `delete`.

    get 'post/:id' => 'posts#show'
    post 'post/:id' => 'posts#create_comment'

If your route needs to respond to more than one HTTP method (or all methods) then using the `:via` option on `match` is preferable.

    match 'post/:id' => 'posts#show', via: [:get, :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.

## Named routes¶ ↑

Routes can be named by passing an `:as` option, 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
    get '/login' => 'accounts#login', as: '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 `root` as a shorthand to name a route for the root path “/”.

    # In routes.rb
    root to: 'blogs#index'

    # 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 `controller`, the route is simply named after the method you call on the block parameter rather than map.

    # In routes.rb
    controller :blog do
      get 'blog/show'     => :list
      get 'blog/delete'   => :delete
      get 'blog/edit/:id' => :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:

    get '/articles/:year/:month/:day' => 'articles#find_by_id', constraints: {
      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'}

## Regular Expressions and parameters¶ ↑

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

    controller 'geocode' do
      get 'geocode/:postalcode' => :show, constraints: {
        postalcode: /\d{5}(-\d{4})?/
      }

Constraints can include the 'ignorecase' and 'extended syntax' regular expression modifiers:

    controller 'geocode' do
      get 'geocode/:postalcode' => :show, constraints: {
        postalcode: /hx\d\d\s\d[a-z]{2}/i
      }
    end

    controller 'geocode' do
      get 'geocode/:postalcode' => :show, constraints: {
        postalcode: /# Postcode format
           \d{5} #Prefix
           (-\d{4})? #Suffix
           /x
      }
    end

Using the multiline modifier will raise an `ArgumentError`. Encoding regular expression modifiers are silently ignored. The match will always use the default encoding or ASCII.

## External redirects¶ ↑

You can redirect any path to another path using the redirect helper in your router:

    get "/stories" => redirect("/posts")

## Unicode character routes¶ ↑

You can specify unicode character routes in your router:

    get "こんにちは" => "welcome#index"

## Routing to Rack Applications¶ ↑

Instead of a String, like `posts#index`, which corresponds to the index action in the PostsController, you can specify any Rack application as the endpoint for a matcher:

    get "/application.js" => Sprockets

## Reloading routes¶ ↑

You can reload routes if you feel you must:

    Rails.application.reload_routes!

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¶ ↑

    rake routes

Target specific controllers by prefixing the command with `CONTROLLER=x`.