Rotas do Rails de Fora pra Dentro — Ruby on Rails Guides
Rotas do Rails de Fora pra Dentro
Esse guia cobre os recursos de roteamento que os usuários podem utilizar no Rails.
Como interpretar o código em config/routes.rb.
Como construir suas próprias rotas, seja usando o formato preferido de resources ou o método match.
Como declarar parâmetros de rota, que são passados para ações do controller.
Como criar automaticamente caminhos e URLs usando helpers de rota.
Técnicas avançadas como criar restrições e montar endpoints Rack.
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
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
Rotas sem uso de Resources
Parâmetros Vinculados
Usando Query String
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
Roteamento para Aplicações Rack
Rotas com Caracteres Unicode
Usando resolve
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
Separando arquivos de rotas gigantes em vários arquivos menores:
Quando usar ou não essa funcionalidade
Inspecionando e Testando Rotas
Listando Rotas Existentes
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:
ela solicita ao roteador que corresponda com uma ação do controller. Se a primeira rota correspondente for:
a requisição é direcionada para o controller patients na ação show com { id: '17' } em params.
O Rails usa snake_case para nomes de controller no roteamento, se você tem um controller com várias palavras como MonsterTrucksController, você deve usar monster_trucks#show, por exemplo.
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:
e sua aplicação contém esse código no controller:
e isso na view correspondente:
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.
O bloco Rails.application.routes.draw do ... end que encapsula suas definições de rotas é necessário para estabelecer o escopo do roteador da DSL e não deve ser deletado.
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.
ela pede ao roteador para enviar esta requisição para a action no seu respectivo controller. Se a primeira rota encontrada for:
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:
cria sete rotas diferentes rotas em sua aplicação, todas mapeando para o controller Photos:
GET /photos photos#index mostra uma lista de todas as fotos
GET /photos/new photos#new retorna um formulário HTML para criar uma nova foto
POST /photos photos#create cria uma nova foto
GET /photos/:id photos#show mostra uma foto específica
GET /photos/:id/edit photos#edit retorna um formulário HTML para editar uma foto
PATCH/PUT /photos/:id photos#update atualiza uma foto específica
DELETE /photos/:id photos#destroy deleta uma foto específica
Por conta do roteador utilizar os verbos HTTP e a URL para corresponder as requisições de entrada, quatro URLs equivalem a sete actions diferentes.
Rotas de aplicações Rails são combinadas na ordem que são especificadas, portanto, se você tem resources :photos acima de get 'photos/poll', a rota da action show para a linha do resources será correspondida antes da linha get. Para resolver este problema, mova a linha get acima da linha resources, assim a rota será equiparada primeiro.
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:
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:
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::
Esta rota resourceful:
resource :geocoder resolve('Geocoder') { [:geocoder] }
cria seis rotas diferentes em sua aplicação, todas mapeando para o controller Geocoders:
GET /geocoder/new geocoders#new retorna um formulário HTML para criar o geocoder
POST /geocoder geocoders#create cria o novo geocoder
GET /geocoder geocoders#show mostra o único geocoder resource
GET /geocoder/edit geocoders#edit retorna um formulário HTML para editar o geocoder
PATCH/PUT /geocoder geocoders#update atualiza o único geocoder resource
DELETE /geocoder geocoders#destroy deleta o geocoder resource
Como você pode querer usar o mesmo controller para uma singular route (/account) e uma plural route (/accounts /45), os singular resources são mapeados para os plural controllers. Assim, por exemplo, resource: photo eresources: photos criam rotas singular e plural que são mapeadas para o mesmo controlador (PhotosController).
Uma rota resourceful singular gera estes helpers:
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:
Helper de rota nomeado
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:
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
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:
Se você precisar usar um namespace de controller diferente dentro de um bloco namespace você pode especificar um path absoluto de controller, e.g: get '/foo', to: '/foo#index'.
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 AdsContriller. As URLs de ad vão precisar de um magazine:
GET /magazines/:magazine_id/ads ads#index mostra a lista de todos os ads para um magazine específico
GET /magazines/:magazine_id/ads/new ads#new retorna um formulário HTML para a criação de um novo ad pertencente de um magazine específico
POST /magazines/:magazine_id/ads ads#create cria um novo ad pertencente a um magazine específico
GET /magazines/:magazine_id/ads/:id ads#show exibe um ad pertencente a um magazine específico
GET /magazines/:magazine_id/ads/:id/edit ads#edit retorna um formulário HTML para editar um ad pertencente a um magazine específico
PATCH/PUT /magazines/:magazine_id/ads/:id ads#update atualiza um ad específico pertencente a um magazine específico
DELETE /magazines/:magazine_id/ads/:id ads#destroy deleta um ad específico pertencente a um magazine específico
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:
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:
Resources não devem nunca ser aninhados mais de um nível de profundidade.
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 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
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:
Enquanto estiver usando magazine_ad_path, você pode passar as instâncias de Magazine e Ad em contrapartida a IDs numéricos:
Você pode também usar url_for com um grupo de objetos, e o Rails vai automaticamente determinar qual rota você quer:
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:
Se você queria apenas o link da magazine:
Para outras actions, você apenas precisa inserir o nome desta action como o primeiro elemento deste array:
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
Se vocês estão definindo rotas de resource adicionais com um symbol como o primeiro argumento posicional, tenha em mente que não é igual a usar uma string. Symbols inferem actions do controller enquanto strings inferem paths.
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.
Se você se encontrar adicionando muitas actions extras para uma rota resourceful, é um bom momento para perguntar a si mesmo se você está mascarando a presença de outro resource.
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:
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:
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".
Por padrão, os segmentos dinâmicos não aceitam pontos - isso ocorre porque o ponto é usado como um separador para rotas formatadas. Se você precisar usar um ponto em um segmento dinâmico, adicione uma restrição que o substitua - por exemplo, id: /[^\/]+/ permite qualquer coisa, exceto uma barra.
3.3 Segmentos Estáticos
Você pode especificar segmentos estáticos ao criar uma rota somente não acrescentando dois pontos a um segmento:
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:
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:
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
Você não pode substituir os padrões via query parameters por motivos de segurança. Os únicos padrões que podem ser substituídos são segmentos dinâmicos via substituição no caminho da URL.
3.6 Nomeando Rotas
Você pode especificar um nome para qualquer rota usando a opção :as:
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:
Você pode combinar todos os verbos em uma rota específica usando via: :all:
Rotear solicitações GET e POST para uma única action tem implicações de segurança. Em geral, você deve evitar rotear todos os verbos para uma action, a menos que tenha um bom motivo.
GET no Rails não verificará o token CSRF. Você nunca deve escrever no banco de dados a partir de solicitações GET, para obter mais informações, consulte o guia de segurança para contramedidas CSRF.
3.8 Restrições de Segmento
Você pode usar a opção :constraints para impor um formato para um segmento dinâmico:
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:
: 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á:
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:
Você também pode especificar restrições usando blocos de constraints:
namespace :admin do constraints subdomain: 'admin' do resources :photos end end
As restrições de requisição funcionam chamando um método no Objeto request com o mesmo nome que a chave de hash e, em seguida, compara o valor retornado com o valor de hash. Portanto, os valores de restrição devem corresponder ao tipo de retorno do método no objeto request correspondente. Por exemplo: constraints: { subdomain: 'api' } corresponderá a um subdomínio api conforme o esperado. No entanto, o uso de um símbolo constraints: { subdomain: :api } não será, porque request.subdomain retorna 'api' como uma String.
Há uma exceção para a restrição format: embora seja um método no objeto request, também é um parâmetro opcional implícito em todos os endereços. Restrições de segmento têm precedência e a restrição de format só é aplicada quando através de um hash. Por exemplo, get 'foo', constraints: { format: 'json' } corresponderão a GET /foo porque o formato é opcional por padrão. No entanto, você pode usar uma expressão lambda como em get 'foo', constraints: lambda { |req| req.format == :json } assim a rota corresponderá apenas a requisições JSON explícitas.
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:
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:
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:
corresponderia zoo/woo/foo/bar/baz para params[:a] igual a 'zoo/woo', e params[:b] igual a 'bar/baz'.
Ao solicitar '/foo/bar.json', seu params[:pages] serão iguais a 'foo/bar' com o formato de solicitação JSON. Se você quiser o antigo comportamento 3.0.x de volta, poderá fornecer format: false assim:
Se você quiser tornar o segmento de formato obrigatório, para que ele não possa ser omitido, você pode fornecer format: true assim:
3.12 Redirecionamento
Você pode redirecionar qualquer rota para outra usando o auxiliar redirect no seu roteador:
Você também pode reutilizar segmentos dinâmicos para corresponder a rotas e redirecionar para:
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:
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:
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.
Para os curiosos, 'articles#index' na verdade se expande para ArticlesController.action(:index), que retorna uma aplicação Rack válida.
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:
Se você preferir que sua aplicação Rack receba requisições no root path em vez disso, use mount:
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.
A rota root direciona apenas requisições GET para a action.
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:
3.16 Rotas Diretas
Você pode criar URL helpers personalizados diretamente chamando direct. Por exemplo:
direct :homepage do "http://www.rubyonrails.org" end # >> homepage_url # => "http://www.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.
3.17 Usando resolve
O método resolve permite personalizar o mapeamento polimórfico de models. Por exemplo:
<%= 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:
vai reconhecer caminhos requisitados iniciando com /photos mas vai rotear para o controller Images:
Nome do Helper de Rota
Utilize photos_path, new_photo_path, etc. para gerar caminhos para este recurso.
Você pode usar a notação de diretório para controllers com namespaces associados. Por exemplo:
Isso vai direcionar a chamada da rota para o controller Admin::UserPermissions.
Apenas a notação de diretório é suportada. Especificar o controller com a notação de constante do Ruby (e.g. controller: 'Admin::UserPermissions') pode causar problemas e resulta em um aviso.
4.2 Especificando Restrições
Você pode usar a opção :constraints pra especificar um formato exigido no id implícito. Por exemplo:
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
De fato, você pode usar restrições mais avançadas disponíveis em rotas sem recursos nesse contexto.
Por padrão o parâmetro :id não aceita pontos - isto acontece pois os pontos são usados como separadores para rotas com formato de arquivo especificado. Se você precisa usar um ponto dentro do :id adicione uma restrição que sobrescreva isto - a expressão regular id: /[^\/]+/ permite tudo exceto uma barra (\).
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:
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:
Isso faz o roteamento reconhecer caminhos como:
/photos/make /photos/1/change
Os nomes das ações não sofrem alterações devido a esta opção. Os dois caminhos exibidos ainda apontarão para as ações new e edit.
Se você quiser mudar esta opção para todas as rotas, você pode usar um scope. Da seguinte forma:
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.
O scope namespace adicionará automaticamente os prefixos :as, assim como :module e :path.
Você pode prefixar as rotas com um named parameter também:
scope ':username' do resources :articles end
Isto vai lhe deixar com URLs como /bob/articles/-1 e também permitirá referir à parte username do caminho como params[:username] nos controllers, helpers, e views.
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:
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:
Nesse caso, o Rails vai criar todas as rotas normais exceto a rota para destroy (uma requisição DELETE para /photos/:id).
Se sua aplicação tem muitas rotas RESTful, usar :only e :except para gerar somente as rotas que você realmente precisa pode reduzir o consumo de memória e agilizar o processo de roteamento.
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>].
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
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.
draw(:admin) # Carregará outro arquivo de rotas localizado em: `config/routes/admin.rb`
# 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 caso). 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 Quando usar ou não essa funcionalidade
Definir rotas através de arquivos externos pode ser muito útil para organizar uma grande quantidade de rotas em vários arquivos. Você pode ter um arquivo admin.rb que conterá todas as rotas para a área administrativa, outro arquivo api.rb para as rotas relacionadas aos recursos da sua API, etc...
No entanto, você não deve abusar dessa funcionalidade criando muitos arquivos, pois torna a descoberta e compreensibilidade mais difícil. Dependendo da aplicação, pode ser mais fácil para os desenvolvedores ter apenas um arquivo de rotas mesmo que contenha centenas de rotas. Você não deve tentar criar um novo arquivo de rotas para cada categoria (ex: admin, api) a todo custo; A DSL de rotas do Rails já oferece uma forma de separar as rotas de forma organizada através de namespaces e scopes.
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
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
O resultado do comando bin/rails routes fica muito mais legível se você ampliar a janela do seu terminal até que não haja quebra de linha.
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:
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:
Você pode passar um argumento :method para especificar um verbo HTTP:
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: