Guiarails.com.br

Chapters

1. O Propósito do Roteador do Rails
   • Conectando URLs ao código
   • Gerando Caminhos e URLs a partir do código
   • Configurando o Roteador do Rails
2. Roteando Resources (Recursos): O padrão do Rails
   • Resources na Web
   • CRUD, Verbos, e Actions
   • Helpers Path e URL
   • Definindo Múltiplos Resources ao Mesmo tempo
   • Resources no Singular
   • Controller Namespaces e Routing
   • Nested Resources (Recursos Aninhados)
   • Roteamento com método Concerns
   • Criando Paths e URLs de Objetos
   • Adicionando mais RESTful Actions
3. Rotas sem uso de Resources
   • Parâmetros Vinculados
   • Segmentos Dinâmicos
   • Segmentos Estáticos
   • Usando Query String
   • Definindo Padrões
   • Nomeando Rotas
   • Restringindo Verbos HTTP
   • Restrições de Segmento
   • Restrições Baseadas em Requisições
   • Restrições Avançadas
   • Rotas Englobadas (Glob) e Segmentos Curinga
   • Redirecionamento
   • Roteamento para Aplicações Rack
   • Usando root
   • Rotas com Caracteres Unicode
   • Rotas Diretas
   • Usando resolve
4. Customizando Rotas com Recursos
   • Especificando um Controller para Usar
   • Especificando Restrições
   • Sobrescrevendo Helpers de Nome de Rota
   • Sobrescrevendo os Segmentos new e edit
   • Prefixando os Helpers de Nome de Rota
   • Restringindo as Rotas Criadas
   • Traduzindo Caminhos
   • Sobrescrevendo a Forma Singular
   • Usando :as em Recursos Aninhados
   • Sobrescrevendo Parâmetros de Nome de Rota
5. Separando arquivos de rotas gigantes em vários arquivos menores:
   • Não use este recurso a menos que você realmente precise dele
6. Inspecionando e Testando Rotas
   • Listando Rotas Existentes
   • Testando Rotas

1 O Propósito do Roteador do Rails

O roteador do Rails organiza URLs e as direcionam para uma ação de um controller ou de um aplicativo Rack. Também pode gerar caminhos e URLs, evitando a necessidade de codificar sequências de caracteres em suas visualizações.

1.1 Conectando URLs ao código

Quando sua aplicação Rails recebe uma requisição para:

GET /patients/17

ela solicita ao roteador que corresponda com uma ação do controller. Se a primeira rota correspondente for:

get '/patients/:id', to: 'patients#show'

a requisição é direcionada para o controller patients na ação show com { id: '17' } em params.

1.2 Gerando Caminhos e URLs a partir do código

Você também pode gerar caminhos e URLs. Se a rota acima for modificada para ser:

get '/patients/:id', to: 'patients#show', as: 'patient'

e sua aplicação contém esse código no controller:

@patient = Patient.find(params[:id])

e isso na view correspondente:

<%= link_to 'Patient Record', patient_path(@patient) %>

então seu roteador irá gerar o caminho /patients/17. Isso reduz a fragilidade da sua view e faz seu código mais simples de entender. Observe que o id não não precisa ser especificado no helper da rota.

1.3 Configurando o Roteador do Rails

As rotas para sua aplicação ou engine estão dentro do arquivo config/routes.rb e tipicamente se parecem com isso:

Rails.application.routes.draw do
  resources :brands, only: [:index, :show] do
    resources :products, only: [:index, :show]
  end

  resource :basket, only: [:show, :update, :destroy]

  resolve("Basket") { route_for(:basket) }
end

Como isso é um arquivo padrão do Ruby você pode utilizar de todos os seus recursos para te ajudar a definir suas rotas, porém tenha cautela com nomes de variáveis já que ela pode conflitar com os métodos da DSL do roteador.

2 Roteando Resources (Recursos): O padrão do Rails

O roteamento de resources permite que você rapidamente declare todas as rotas comuns para um controller. Uma chamada única para resources pode declarar todas as rotas necessárias para as actions index, show, new, edit, create, update e destroy.

2.1 Resources na Web

Navegadores solicitam páginas do Rails através de uma URL usando um método HTTP específico, como GET,POST, PATCH,PUT e DELETE. Cada método é uma solicitação para executar uma operação no resource. Uma rota de resource mapeia uma série de solicitações relacionadas a actions em um único controller.

Quando sua aplicação Rails recebe uma requisição para:

DELETE /photos/17

ela pede ao roteador para enviar esta requisição para a action no seu respectivo controller. Se a primeira rota encontrada for:

resources :photos

O Rails enviará esta requisição para a action destroy no controller photos com { id: 17 } no params

2.2 CRUD, Verbos, e Actions

No Rails, uma rota de resources fornece um mapeamento entre verbos HTTP e URLs para actions do controller. Por convenção, cada ação também é mapeada para uma operação específica do CRUD em um banco de dados. Uma única entrada no arquivo de roteamento, como:

resources :photos

cria sete rotas diferentes rotas em sua aplicação, todas mapeando para o controller Photos:

2.3 Helpers Path e URL

Criando uma rota de resource vai expor um número de helpers para os controllers em sua aplicação. No caso de resources :photos:

• photos_path retorna /photos
• new_photo_path retorna /photos/new
• edit_photo_path(:id) retorna /photos/:id/edit (por exemplo, edit_photo_path(10) retorna /photos/10/edit)
• photo_path(:id) retorna /photos/:id (por exemplo, photo_path(10) retorna /photos/10)

Cada um desses helpers tem um helper _url (assim como photos_url) que retorna o mesmo path prefixado com o host atual, porta e o prefixo do path.

2.4 Definindo Múltiplos Resources ao Mesmo tempo

Se você precisa criar rotas para mais de um resource, você pode salvar um pouco de digitação definindo todos eles em uma única chamada para resources:

resources :photos, :books, :videos

Isto funciona exatamente igual a:

resources :photos
resources :books
resources :videos

2.5 Resources no Singular

Algumas vezes você tem um resource que clientes sempre veem sem referenciar um ID. Por exemplo, você gostaria que /profile sempre mostre o perfil do usuário que esta autenticado. Neste caso, você pode usar um resource no singular para mapear /profile (em vez de /profile/:id) para a action show:

get 'profile', to: 'users#show'

Passando uma String para to: ira esperar um formato controller#action. Quando usamos um Symbol, a opção to: deveria ser trocada por action:. Quando usamos uma String sem um #, a opção to: deveria ser trocada por controller::

get 'profile', action: :show, controller: 'users'

Esta rota resourceful:

resource :geocoder
resolve('Geocoder') { [:geocoder] }

cria seis rotas diferentes em sua aplicação, todas mapeando para o controller Geocoders:

Uma rota resourceful singular gera estes helpers:

• new_geocoder_path returns /geocoder/new
• edit_geocoder_path returns /geocoder/edit
• geocoder_path returns /geocoder

Assim como com resources no plural, os mesmos helpers que terminam com _url tambem vão incluir o host, porta, e o prefixo do path.

2.6 Controller Namespaces e Routing

Você pode querer organizar grupos de controllers em um namespace. Mais comumente, você pode querer agrupar controllers administrativos sob um namespace Admin::, colocar esses controllers no diretório app/controllers/admin. Você pode agrupar routes como um grupo usando o bloco namespace:

namespace :admin do
  resources :articles, :comments
end

Isto criará um número de rotas para cada controller de articles e comments. Para Admin::ArticlesController, o Rails vai criar:

Se ao invés você quiser rotear /articles (sem o prefixo /admin) para Admin::ArticlesController, você poderia especificar um module com um bloco scope:

scope module: 'admin' do
  resources :articles, :comments
end

Isso também pode ser feito para uma única rota:

resources :articles, module: 'admin'

Se ao invés você quiser rotear /admin/articles para ArticlesController (Sem o prefixo do modulo Admin::), você poderia especificar o caminho usando um bloco scope:

scope '/admin' do
  resources :articles, :comments
end

Isso também pode ser feito para uma única rota:

resources :articles, path: '/admin/articles'

Em cada um desses casos, a rota nomeada continua a mesma, como se você não tivesse usado scope. No último exemplo, os paths seguintes mapeiam para ArticlesController:

2.7 Nested Resources (Recursos Aninhados)

É comum encontrarmos resources que são "filhos" de outros. Por exemplo, supondo que sua aplicação tem esses models:

class Magazine < ApplicationRecord
  has_many :ads
end

class Ad < ApplicationRecord
  belongs_to :magazine
end

Nested routes (rotas aninhadas) permitem que você capture este relacionamento no seu roteamento. Neste caso, você poderia incluir esta declaração de rota:

resources :magazines do
  resources :ads
end

Em adição das rotas para magazines, esta declaração também adicionará rotas de ads para um AdsController. As URLs de ad vão precisar de um magazine:

Isto vai também criar routing helpers como magazine_ads_url e edit_magazine_ad_path. Esses helpers pegam uma instância de Magazine como o primeiro parâmetro (magazine_ads_url(@magazine)).

2.7.1 Limites para o Aninhamento

Você pode aninhar resources entre outros resources aninhados se você desejar. Por exemplo:

resources :publishers do
  resources :magazines do
    resources :photos
  end
end

Resources profundamente aninhados ficam confusos. Neste caso, por exemplo, a aplicação iria reconhecer paths como:

/publishers/1/magazines/2/photos/3

O helper correspondente a essa rota seria publisher_magazine_photo_url, sendo necessário especificar os objetos de todos os três níveis. De fato, esta situação é confusa o bastante que um artigo escrito por Jamis Buck propõe uma regra de ouro para um bom design no Rails:

2.7.2 Shallow Nesting (Aninhamento raso)

Uma maneira de evitar um aninhamento profundo (como recomendado acima) é gerar uma coleção de actions scoped abaixo de um pai, assim para ter uma sensação de hierarquia, mas não aninhar as actions do membro. Em outras palavras. para apenas construir routes com o mínimo de informação para identificar unicamente o recurso, como isto:

resources :articles do
  resources :comments, only: [:index, :new, :create]
end
resources :comments, only: [:show, :edit, :update, :destroy]

Essa ideia encontra um equilíbrio entre rotas descritivas e aninhamento profundo. Existe uma sintaxe abreviada para conseguir exatamente isso, via a opção :shallow:

resources :articles do
  resources :comments, shallow: true
end

Isso vai gerar as mesmas rotas do primeiro exemplo, Você pode também especificar a opção :shallow no seu resource pai, em cada caso todos os resources aninhados serão rasos:

resources :articles, shallow: true do
  resources :comments
  resources :quotes
  resources :drafts
end

O resources de artigos aqui terá as seguintes rotas geradas para ele:

O método shallow do DSL cria um scope em que todos os aninhamentos são rasos. Isso gera as mesmas rotas que o exemplo anterior:

shallow do
  resources :articles do
    resources :comments
    resources :quotes
    resources :drafts
  end
end

Existem duas opções no scope para customizar shallow routes. :shallow_path prefixa seus paths membros com o parâmetro especificado:

scope shallow_path: "sekret" do
  resources :articles do
    resources :comments, shallow: true
  end
end

O resource comments aqui terá gerado as seguintes rotas para si:

A opção :shallow_prefix adiciona o parÂmetro especificado para os helpers da rota nomeada:

scope shallow_prefix: "sekret" do
  resources :articles do
    resources :comments, shallow: true
  end
end

O resource comments aqui terá gerado as seguintes rotas para si:

2.8 Roteamento com método Concerns

Roteamento com método concerns permitem você declarar rotas comuns que podem ser reutilizadas dentro de outros resources e rotas. Para definir um concern, use um bloco concern:

concern :commentable do
  resources :comments
end

concern :image_attachable do
  resources :images, only: :index
end

Estes concerns podem ser usados em resources para evitar duplicação de códigos e compartilhar o mesmo comportamento por entre as rotas:

resources :messages, concerns: :commentable

resources :articles, concerns: [:commentable, :image_attachable]

O exemplo acima é equivalente a:

resources :messages do
  resources :comments
end

resources :articles do
  resources :comments
  resources :images, only: :index
end

Além disso você pode usá-los em qualquer lugar que você quiser chamando concerns. Por exemplo, em um bloco de scope ou namespace:

namespace :articles do
  concerns :commentable
end

2.9 Criando Paths e URLs de Objetos

Além de usarmos os helpers de roteamento, o Rails pode também criar paths e URLs de um array de parâmetros. Por exemplo, imagine que você tem este grupo de rotas:

resources :magazines do
  resources :ads
end

Enquanto estiver usando magazine_ad_path, você pode passar as instâncias de Magazine e Ad em contrapartida a IDs numéricos:

<%= link_to 'Ad details', magazine_ad_path(@magazine, @ad) %>

Você pode também usar url_for com um grupo de objetos, e o Rails vai automaticamente determinar qual rota você quer:

<%= link_to 'Ad details', url_for([@magazine, @ad]) %>

Neste caso, o Rails verá que @magazine é um Magazine e @ad é um Ad e vai portanto usar o helper magazine_ad_path. em helpers como link_to, você pode especificar apenas o objeto no lugar da chamada url_for inteira:

<%= link_to 'Ad details', [@magazine, @ad] %>

Se você queria apenas o link da magazine:

<%= link_to 'Magazine details', @magazine %>

Para outras actions, você apenas precisa inserir o nome desta action como o primeiro elemento deste array:

<%= link_to 'Edit Ad', [:edit, @magazine, @ad] %>

Isto permite você tratar instâncias de seus models como URLs, e é uma vantagem chave de usar o estilo resourceful.

2.10 Adicionando mais RESTful Actions

Você não esta limitado as sete rotas que o RESTful routing cria por padrão. Se você quiser, pode criar rotas adicionais que aplicam a uma coleção ou membros individuais da coleção.

2.10.1 Adicionando Rotas de Membros

Para adicionar uma rota para um membro, apenas adicione um bloco member em um bloco de resource:

resources :photos do
  member do
    get 'preview'
  end
end

Isso vai reconhecer /photos/1/preview com GET, e rotear para a action preview de PhotosController, com o valor do resource id passado em params[:id]. Isso vai tambem criar os helpers preview_photo_url e preview_photo_path.

Dentro do bloco de rotas para membros, cada nome de rota especifica o verbo HTTP que vai ser reconhecido. Você pode usar get, patch, put, post ou delete aqui. Se você não tiver múltiplas rotas para membros, você pode também passar :on para a rota, eliminando o bloco:

resources :photos do
  get 'preview', on: :member
end

Você pode deixar fora a opção :on, isso vai criar o mesmo member route exceto que o valor do resource id estará disponível em params[:photo_id] ao invés de params[:id]. Helpers de rota tambem serão renomeados de preview_photo_url para photo_preview_url e photo_preview_path.

2.10.2 Adicionando Collection Routes

Para adicionar uma rota para uma coleção, use um bloco collection:

resources :photos do
  collection do
    get 'search'
  end
end

Isto vai permitir que o Rails reconheça paths como /photos/search com GET, e a rota para a action search do PhotosController. Isto também criará os helpers search_photos_url e search_photos_path.

Assim como em member routes, você pode passar :on para uma rota:

resources :photos do
  get 'search', on: :collection
end

2.10.3 Adicionando Rotas para Novas Actions Adicionais

Para adicionar uma action alternativa nova usando o atalho :on:

resources :comments do
  get 'preview', on: :new
end

Isto vai permitir que o Rails reconheça paths como /comments/new/preview com GET, e rotear para a action preview do CommentesController. Isto também vai criar os helpers preview_new_comment_url e preview_new_comment_path.

3 Rotas sem uso de Resources

Além do roteamento de resources, o Rails possui um suporte poderoso para rotear URLs arbitrárias para actions. Aqui, você não obtém grupos de rotas gerados automaticamente pelo roteamento de resources. Em vez disso, você configura cada rota separadamente na sua aplicação.

Embora você geralmente deva usar roteamento com resources, ainda existem muitos lugares em que o roteamento mais simples é mais apropriado. Não é necessário tentar encaixar todas as partes do seu aplicativo em uma estrutura de resources se isso não for um bom ajuste.

Em particular, o roteamento simples facilita o mapeamento de URLs herdados para novas actions do Rails.

3.1 Parâmetros Vinculados

Ao configurar uma rota regular, você fornece uma série de symbols que o Rails mapeia para partes de uma requisição HTTP chegando na aplicação. Por exemplo, considere esta rota:

get 'photos(/:id)', to: 'photos#display'

Se uma requisição para /photos/1 for processada por esta rota (porque não corresponde a nenhuma rota anterior no arquivo), o resultado será invocar a action display do PhotosController, e tornar o parâmetro final "1" disponível como params[:id]. Esta rota também encaminhará uma requisição recebida de /photos para PhotosController#display, pois :id é um parâmetro opcional, indicado por parênteses.

3.2 Segmentos Dinâmicos

Você pode configurar quantos segmentos dinâmicos em uma rota regular desejar. Qualquer segmento estará disponível para a action como parte de params. Se você configurar esta rota:

get 'photos/:id/:user_id', to: 'photos#show'

Uma requisição para o endereço /photos/1/2 será enviada para a action show do PhotosController. params[:id] será "1" e params[:user_id] será "2".

3.3 Segmentos Estáticos

Você pode especificar segmentos estáticos ao criar uma rota somente não acrescentando dois pontos a um segmento:

get 'photos/:id/with_user/:user_id', to: 'photos#show'

Esta rota responderia a caminhos como /photos/1/with_user/2. Nesse caso, params seria { controller: 'photos', action: 'show', id: '1', user_id: '2' }.

3.4 Usando Query String

Os params também incluirão quaisquer parâmetros da query string. Por exemplo, com esta rota:

get 'photos/:id', to: 'photos#show'

Uma requisição para o caminho /photos/1?user_id=2 será enviada para a action show do controller Photos. params será { controller: 'photos', action: 'show', id: '1', user_id: '2' }.

3.5 Definindo Padrões

Você pode definir padrões em uma rota fornecendo um hash para a opção :defaults. Isso também se aplica a parâmetros que você não especifica como segmentos dinâmicos. Por exemplo:

get 'photos/:id', to: 'photos#show', defaults: { format: 'jpg' }

O Rails corresponderia photos/12 com a action show do PhotosController e definiria params[:format] como "jpg".

Você também pode usar defaults em um formato de bloco para definir os padrões para múltiplos itens:

defaults format: :json do
  resources :photos
end

3.6 Nomeando Rotas

Você pode especificar um nome para qualquer rota usando a opção :as:

get 'exit', to: 'sessions#destroy', as: :logout

Isso criará logout_path e logout_url como helpers de rota em sua aplicação. Chamar logout_path retornará /exit.

Você também pode usar isso para substituir os métodos de roteamento definidos pelos resources usando rotas customizadas antes do resource ser definido, da seguinte forma:

get ':username', to: 'users#show', as: :user
resources :users

Isso definirá um método user_path que estará disponível em controllers, helpers e views que irão para uma rota como /bob. Dentro da action show do UsersController, params[:username] conterá o nome do usuário. Altere :username na definição da rota se você não quiser que o nome do seu parâmetro seja :username.

3.7 Restringindo Verbos HTTP

Em geral, você deve usar os métodos get, post, put, patch e delete para restringir uma rota a um verbo específico. Você pode usar o método match com a opção :via para combinar vários verbos ao mesmo tempo:

match 'photos', to: 'photos#show', via: [:get, :post]

Você pode combinar todos os verbos em uma rota específica usando via: :all:

match 'photos', to: 'photos#show', via: :all

3.8 Restrições de Segmento

Você pode usar a opção :constraints para impor um formato para um segmento dinâmico:

get 'photos/:id', to: 'photos#show', constraints: { id: /[A-Z]\d{5}/ }

Essa rota corresponderia a caminhos como /photos/A12345, mas não /photos/893. Você pode expressar de forma mais sucinta a mesma rota desta maneira:

get 'photos/:id', to: 'photos#show', id: /[A-Z]\d{5}/

: constraints usam expressões regulares com a restrição de que as âncoras regexp não podem ser usadas. Por exemplo, a seguinte rota não funcionará:

get '/:id', to: 'articles#show', constraints: { id: /^\d/ }

No entanto, note que você não precisa usar âncoras porque todas as rotas estão ancoradas no início e no fim.

Por exemplo, as rotas a seguir permitiriam articles com valores to_param como 1-hello-world que sempre começam com um número e users com valores to_param como david que nunca começam com um número compartilhem o mesmo namespace raiz:

get '/:id', to: 'articles#show', constraints: { id: /\d.+/ }
get '/:username', to: 'users#show'

3.9 Restrições Baseadas em Requisições

Você também pode restringir uma rota com base em qualquer método no objeto request que retorna uma String.

Você especifica uma restrição baseada em requisições da mesma maneira que especifica uma restrição de segmento:

get 'photos', to: 'photos#index', constraints: { subdomain: 'admin' }

Você também pode especificar restrições usando blocos de constraints:

namespace :admin do
  constraints subdomain: 'admin' do
    resources :photos
  end
end

3.10 Restrições Avançadas

Se você tiver uma restrição mais avançada, poderá fornecer um objeto que responda a matches? que o Rails deve usar. Digamos que você queira rotear todos os usuários em uma lista restrita para o RestrictedListController. Você poderia fazer:

class RestrictedListConstraint
  def initialize
    @ips = RestrictedList.retrieve_ips
  end

  def matches?(request)
    @ips.include?(request.remote_ip)
  end
end

Rails.application.routes.draw do
  get '*path', to: 'restricted_list#index',
    constraints: RestrictedListConstraint.new
end

Você também pode especificar restrições como uma lambda:

Rails.application.routes.draw do
  get '*path', to: 'restricted_list#index',
    constraints: lambda { |request| RestrictedList.retrieve_ips.include?(request.remote_ip) }
end

Tanto o método matches? quanto a lambda usam o objeto request como argumento.

3.10.1 Constraints em forma de bloco

Você pode especificar restrições em forma de bloco. Isso é útil quando você precisa aplicar a mesma regra a várias rotas. Por exemplo:

class RestrictedListConstraint
  # ...Same as the example above
end

Rails.application.routes.draw do
  constraints(RestrictedListConstraint.new) do
    get '*path', to: 'restricted_list#index'
    get '*other-path', to: 'other_restricted_list#index'
  end
end

Você também pode usar lambda:

Rails.application.routes.draw do
  constraints(lambda { |request| RestrictedList.retrieve_ips.include?(request.remote_ip) }) do
    get '*path', to: 'restricted_list#index'
    get '*other-path', to: 'other_restricted_list#index'
  end
end

3.11 Rotas Englobadas (Glob) e Segmentos Curinga

O englobamento de rota é uma maneira de especificar que um parâmetro em particular deve corresponder a todas as partes restantes de uma rota. Por exemplo:

get 'photos/*other', to: 'photos#unknown'

Esta rota irá corresponder a photos/12 ou /photos/long/path/to/12, definindo params[:other] como "12" ou "long/path/to/12". Os segmentos prefixados com um asterisco são chamados de "segmentos curinga".

Segmentos curinga podem ocorrer em qualquer lugar da rota. Por exemplo:

get 'books/*section/:title', to: 'books#show'

corresponderia books/some/section/last-words-a-memoir para params[:section] igual a 'some/section' e params[:title] igual a 'last-words-a-memoir'.

Tecnicamente, uma rota pode ter ainda mais de um segmento curinga. O matcher de rotas atribui segmentos aos parâmetros de maneira intuitiva. Por exemplo:

get '*a/foo/*b', to: 'test#index'

corresponderia zoo/woo/foo/bar/baz para params[:a] igual a 'zoo/woo', e params[:b] igual a 'bar/baz'.

get '*pages', to: 'pages#show', format: false

get '*pages', to: 'pages#show', format: true

3.12 Redirecionamento

Você pode redirecionar qualquer rota para outra usando o auxiliar redirect no seu roteador:

get '/stories', to: redirect('/articles')

Você também pode reutilizar segmentos dinâmicos para corresponder a rotas e redirecionar para:

get '/stories/:name', to: redirect('/articles/%{name}')

Você também pode fornecer um bloco para redirecionar, que recebe os parâmetros do caminho simbolizado e o objeto request:

get '/stories/:name', to: redirect { |path_params, req| "/articles/#{path_params[:name].pluralize}" }
get '/stories', to: redirect { |path_params, req| "/articles/#{req.subdomain}" }

Observe que o redirecionamento padrão é um redirecionamento 301 "Moved Permanently". Lembre-se de que alguns navegadores da Web ou servidores proxy armazenam em cache esse tipo de redirecionamento, tornando a página antiga inacessível. Você pode usar a opção :status para alterar o status da resposta:

get '/stories/:name', to: redirect('/articles/%{name}', status: 302)

Em todos esses casos, se você não fornecer o host principal (http://www.example.com), o Rails obterá esses detalhes da requisição atual.

3.13 Roteamento para Aplicações Rack

Em vez de uma String como 'articles#index', que corresponde à action index no ArticlesController, você pode especificar qualquer aplicação Rack como o endpoint:

match '/application.js', to: MyRackApp, via: :all

Desde que o MyRackApp responda ao método call e retorne um [status, headers, body], o roteador não saberá a diferença entre a aplicação Rack e uma action. Este é um uso apropriado de via: :all, pois você deseja permitir que sua aplicação Rack manipule todos os verbos conforme considerar apropriado.

Se você especificar uma aplicação Rack como endpoint, lembre-se de que a rota não será alterada na aplicação de recebimento. Com a seguinte rota sua aplicação Rack deve esperar que a rota seja /admin:

match '/admin', to: AdminApp, via: :all

Se você preferir que sua aplicação Rack receba requisições no root path em vez disso, use mount:

mount AdminApp, at: '/admin'

3.14 Usando root

Você pode especificar para onde o Rails deve rotear '/' com o método root:

root to: 'pages#main'
root 'pages#main' # shortcut for the above

Você deve colocar a rota root no topo do arquivo, porque é a rota mais popular e deve ser correspondida primeiro.

Você também pode usar o root dentro de namespaces e scopes. Por exemplo:

namespace :admin do
  root to: "admin#index"
end

root to: "home#index"

3.15 Rotas com Caracteres Unicode

Você pode especificar rotas de caracteres unicode diretamente. Por exemplo:

get 'こんにちは', to: 'welcome#index'

3.16 Rotas Diretas

Você pode criar URL helpers personalizados diretamente chamando direct. Por exemplo:

direct :homepage do
  "https://rubyonrails.org"
end

# >> homepage_url
# => "https://rubyonrails.org"

O valor de retorno do bloco deve ser um argumento válido para o método url_for. Portanto, você pode transmitir uma URL como string válida, Hash, Array, ou uma instância de Active Model ou uma classe Active Model.

direct :commentable do |model|
  [ model, anchor: model.dom_id ]
end

direct :main do
  { controller: 'pages', action: 'index', subdomain: 'www' }
end

3.17 Usando resolve

O método resolve permite personalizar o mapeamento polimórfico de models. Por exemplo:

resource :basket

resolve("Basket") { [:basket] }

<%= form_with model: @basket do |form| %>
  <!-- basket form -->
<% end %>

Isso irá gerar uma URL singular /basket ​​em vez da habitual /baskets/:id.

4 Customizando Rotas com Recursos

Enquanto as rotas padrões e helpers gerados por resources normalmente atendem a maior parte dos casos de uso, você pode querer customizá-los de alguma forma. O Rails lhe permite customizar virtualmente qualquer parte genérica dos helpers de recursos.

4.1 Especificando um Controller para Usar

A opção :controller permite que você especifique um controller de forma explícita para usar para o recurso. Por exemplo:

resources :photos, controller: 'images'

vai reconhecer caminhos requisitados iniciando com /photos mas vai rotear para o controller Images:

Você pode usar a notação de diretório para controllers com namespaces associados. Por exemplo:

resources :user_permissions, controller: 'admin/user_permissions'

Isso vai direcionar a chamada da rota para o controller Admin::UserPermissions.

4.2 Especificando Restrições

Você pode usar a opção :constraints pra especificar um formato exigido no id implícito. Por exemplo:

resources :photos, constraints: { id: /[A-Z][A-Z][0-9]+/ }

Essa declaração restringe o parâmetro :id de forma que ele seja igual à especificação da expressão regular. Então, nesse caso, o roteador não iria mais aceitar /photos/1 para essa rota. Por outro lado, a requisição /photos/RR27 seria aceita.

Você pode especificar uma única restrição para aplicar a mais de uma rota usando a forma de bloco:

constraints(id: /[A-Z][A-Z][0-9]+/) do
  resources :photos
  resources :accounts
end

4.3 Sobrescrevendo Helpers de Nome de Rota

A opção :as permite que você sobrescreva a convenção de nomes para os helpers de nome de rota. Por exemplo:

resources :photos, as: 'images'

vai reconhecer chamadas que chegarem iniciando com /photos e direcionar as requisições para o PhotosController, mas vai usar o valor especificado na opção :as para nomear os helpers.

4.4 Sobrescrevendo os Segmentos new e edit

A opção :path_names permite que você sobrescreva os segmentos new e edit gerados automaticamente nos caminhos:

resources :photos, path_names: { new: 'make', edit: 'change' }

Isso faz o roteamento reconhecer caminhos como:

/photos/make
/photos/1/change

scope path_names: { new: 'make' } do
  # rest of your routes
end

4.5 Prefixando os Helpers de Nome de Rota

Você pode usar a opção :as pra prefixar os helpers de nome de rota que o Rails gera. Use esta opção para evitar colisões de nomes entre rotas usando um escopo de caminho. Por exemplo:

scope 'admin' do
  resources :photos, as: 'admin_photos'
end

resources :photos

Isto fornecerá helpers de rota como admin_photos_path, new_admin_photo_path, etc.

Para prefixar um grupo de helpers de rota, utilize :as com scope:

scope 'admin', as: 'admin' do
  resources :photos, :accounts
end

resources :photos, :accounts

Isto irá gerar rotas como admin_photos_path e admin_accounts_path que são mapeadas para /admin/photos e /admin/accounts respectivamente.

4.5.1 Parametric Scopes

You can prefix routes with a named parameter:

scope ':account_id', as: 'account', constraints: { account_id: /\d+/ } do
  resources :articles
end

This will provide you with paths such as /1/articles/9 and will allow you to reference the account_id part of the path as params[:account_id] in controllers, helpers, and views.

It will also generate path and URL helpers prefixed with account_, into which you can pass your objects as expected:

account_article_path(@account, @article) # => /1/article/9
url_for([@account, @article])            # => /1/article/9
form_with(model: [@account, @article])   # => <form action="/1/article/9" ...>

We are using a constraint to limit the scope to only match ID-like strings. You can change the constraint to suit your needs, or omit it entirely. The :as option is also not strictly required, but without it, Rails will raise an error when evaluating url_for([@account, @article]) or other helpers that rely on url_for, such as form_with.

4.6 Restringindo as Rotas Criadas

O Rails cria rotas para sete ações diferentes (index, show, new, create, edit, update, and destroy) por padrão pra cada rota RESTful na sua aplicação. A opção :only diz ao Rails para criar apenas as rotas especificadas:

resources :photos, only: [:index, :show]

Agora, a requisição GET para /photos daria certo, mas uma requisição POST para /photos (que por padrão iria para ação create) falhará.

A opção :except específica uma rota ou lista de rotas que o Rails não deve criar:

resources :photos, except: :destroy

Nesse caso, o Rails vai criar todas as rotas normais exceto a rota para destroy (uma requisição DELETE para /photos/:id).

4.7 Traduzindo Caminhos

Podemos alterar nomes de caminho gerados por resources usando scope:

scope(path_names: { new: 'neu', edit: 'bearbeiten' }) do
  resources :categories, path: 'kategorien'
end

O Rails agora cria rotas para o CategoriesController.

4.8 Sobrescrevendo a Forma Singular

Se você quer sobrescrever a forma singular de um recurso, você deve colocar regras adicionais para o Inflector via inflections:

ActiveSupport::Inflector.inflections do |inflect|
  inflect.irregular 'tooth', 'teeth'
end

4.9 Usando :as em Recursos Aninhados

A opção :as sobrescreve o nome gerado automaticamente para o recurso em helpers de rota aninhados. Por exemplo:

resources :magazines do
  resources :ads, as: 'periodical_ads'
end

Isto criará helpers de rota como magazine_periodical_ads_url e edit_magazine_periodical_ad_path.

4.10 Sobrescrevendo Parâmetros de Nome de Rota

A opção :param sobrescreve o identificador padrão de recurso :id (nome do segmento dinâmico usado para gerar as rotas). Você pode acessar o segmento do seu controller usando params[<:param>].

resources :videos, param: :identifier

    videos GET  /videos(.:format)                  videos#index
           POST /videos(.:format)                  videos#create
 new_video GET  /videos/new(.:format)              videos#new
edit_video GET  /videos/:identifier/edit(.:format) videos#edit

Video.find_by(identifier: params[:identifier])

Você pode sobrescrever ActiveRecord::Base#to_param de um model associado para construir a URL:

class Video < ApplicationRecord
  def to_param
    identifier
  end
end

video = Video.find_by(identifier: "Roman-Holiday")
edit_video_path(video) # => "/videos/Roman-Holiday/edit"

5 Separando arquivos de rotas gigantes em vários arquivos menores:

Se você trabalha em uma aplicação grande com milhares de rotas, um único arquivo config/routes.rb pode se tornar complicado e difícil de ler.

O Rails oferece uma forma de quebrar esse único gigante routes.rb em vários arquivos pequenos usando a macro draw.

Você pode ter uma rota admin.rb que contém todas as rotas para a área de administração, outro arquivo api.rb para recursos relacionados à API, etc.

# config/routes.rb

Rails.application.routes.draw do
  get 'foo', to: 'foo#bar'

  draw(:admin) # Carregará outro arquivo de rotas localizado em: `config/routes/admin.rb`
end

# config/routes/admin.rb

namespace :admin do
  resources :comments
end

Chamar o draw(:admin) dentro do próprio bloco Rails.application.routes.draw tentará carregar um arquivo de rotas com o mesmo nome do argumento passado (admin.rb neste exemplo). Para isso o arquivo precisa estar localizado dentro da pasta config/routes ou algum subdiretório (ex: config/routes/admin.rb or config/routes/external/admin.rb)

Você pode usar a DSL de roteamento normal dentro do arquivo de rotas admin.rb, porém, você não deve cercá-lo com o bloco Rails.application.routes.draw como fez no arquivo principal config/routes.rb.

5.1 Não use este recurso a menos que você realmente precise dele

Ter vários arquivos de roteamento dificulta a descoberta e a compreensão. Para a maioria das aplicações - mesmo aqueles com algumas centenas de rotas - é mais fácil para as pessoas desenvolvedoras terem um único arquivo de roteamento. A DSL de roteamento Rails já oferece uma forma de quebrar rotas de forma organizada com namespace e scope.

6 Inspecionando e Testando Rotas

Rails oferece recursos para inspecionar e testar suas rotas.

6.1 Listando Rotas Existentes

Para obter uma lista completa de rotas disponíveis na sua aplicação, visite http://localhost:3000/rails/info/routes no browser quando o servidor estiver rodando em ambiente de desenvolvimento. Você pode também executar o comando bin/rails routes no terminal para reproduzir o mesmo resultado.

Ambos os métodos irão listas todas suas rotas, na mesma ordem que aparece em config/routes.rb. Para cada rota, você irá ver:

• O Nome da rota (se houver)
• O verbo HTTP usado (se a rota não responder a todos os verbos)
• O padrão ao qual a URL deve corresponder
• Os parâmetros para a cada rota

Por exemplo, segue uma pequena parte da resposta bin/rails routes para uma rota RESTful:

    users GET    /users(.:format)          users#index
          POST   /users(.:format)          users#create
 new_user GET    /users/new(.:format)      users#new
edit_user GET    /users/:id/edit(.:format) users#edit

Você pode também utilizar a opção --expanded para ativar o modo de formatação por tabela expandida.

$ bin/rails routes --expanded

--[ Route 1 ]----------------------------------------------------
Prefix            | users
Verb              | GET
URI               | /users(.:format)
Controller#Action | users#index
--[ Route 2 ]----------------------------------------------------
Prefix            |
Verb              | POST
URI               | /users(.:format)
Controller#Action | users#create
--[ Route 3 ]----------------------------------------------------
Prefix            | new_user
Verb              | GET
URI               | /users/new(.:format)
Controller#Action | users#new
--[ Route 4 ]----------------------------------------------------
Prefix            | edit_user
Verb              | GET
URI               | /users/:id/edit(.:format)
Controller#Action | users#edit

Você pode procurar por rotas utilizando a opção grep: -g. Isso resulta qualquer rota que corresponda parcialmente ao nome do método da URL, o verbo HTTP, ou a URL.

$ bin/rails routes -g new_comment
$ bin/rails routes -g POST
$ bin/rails routes -g admin

Se você quiser ver somente as rotas que mapeiam um controller especifico, existe a opção -c.

$ bin/rails routes -c users
$ bin/rails routes -c admin/users
$ bin/rails routes -c Comments
$ bin/rails routes -c Articles::CommentsController

6.2 Testando Rotas

Rotas deveriam ser incluidas na sua estratégia de testes (assim como resto da sua aplicação). Rails oferece três validações nativas desenvolvidas para fazer os testes de rotas mais simples:

• assert_generates
• assert_recognizes
• assert_routing

6.2.1 A validação assert_generates

assert_generates valida que um conjunto de opções em particular gera um caminho equivalente que pode ser usar com rota padrão ou rota customizada. Por exemplo:

assert_generates '/photos/1', { controller: 'photos', action: 'show', id: '1' }
assert_generates '/about', controller: 'pages', action: 'about'

6.2.2 A validação assert_recognizes

assert_recognizes é o inverso de assert_generates. Valida que um dado caminho é reconhecido e roteia-o a um lugar determinado na sua aplicação. Por exemplo:

assert_recognizes({ controller: 'photos', action: 'show', id: '1' }, '/photos/1')

Você pode passar um argumento :method para especificar um verbo HTTP:

assert_recognizes({ controller: 'photos', action: 'create' }, { path: 'photos', method: :post })

6.2.3 A validação assert_routing

A validação assert_routing testa a rota dos dois jeitos: Testa que um caminho gera opções, e que opções gera um caminho. Logo, Ela combina as validações assert_generates e assert_recognizes:

assert_routing({ path: 'photos', method: :post }, { controller: 'photos', action: 'create' })

Feedback

Você é incentivado a ajudar a melhorar a qualidade deste guia.

Por favor, contribua caso veja quaisquer erros, inclusive erros de digitação. Para começar, você pode ler nossa sessão de contribuindo com a documentação.

Você também pode encontrar conteúdo incompleto ou coisas que não estão atualizadas. Por favor, adicione qualquer documentação em falta na main do Rails. Certifique-se de checar o Edge Guides (en-US) primeiro para verificar se o problema já foi resolvido ou não no branch main. Verifique as Diretrizes do Guia Ruby on Rails para estilo e convenções.

Se, por qualquer motivo, você encontrar algo para consertar, mas não conseguir consertá-lo, por favor abra uma issue no nosso Guia.

E por último, mas não menos importante, qualquer tipo de discussão sobre a documentação do Ruby on Rails é muito bem vinda na forum oficial do Ruby on Rails e nas issues do Guia em português.