¿Cómo crear rutas y controladores en Rails?

Las rutas en Rails son el mapa que conecta cada URL de tu aplicación con el código que debe ejecutarse.

¿Alguna vez te preguntaste qué pasa exactamente cuando alguien escribe una dirección en su navegador? En Rails, la respuesta empieza siempre en el mismo lugar: el archivo de rutas.

El archivo donde todo comienza

Rails tiene un archivo llamado config/routes.rb. Ahí defines qué URLs acepta tu aplicación y qué controlador se encarga de cada una.

Piénsalo como la recepcionista de una empresa. Cuando llega una visita, ella decide a qué departamento mandarla. Las rutas hacen exactamente eso con cada petición HTTP.

Aquí tienes una ruta simple:

# config/routes.rb
Rails.application.routes.draw do
  get '/productos', to: 'productos#index'
end

Esta línea dice: "cuando alguien visite /productos, manda la petición al controlador ProductosController, acción index."

La historia de Andrés y su catálogo en línea

Andrés trabaja en una empresa distribuidora en Monterrey. Su jefe le pidió crear una app interna para consultar el inventario de productos. Andrés había aprendido MVC la semana anterior y entendía las capas, pero no sabía cómo hacer que las URLs funcionaran.

Empezó con una sola ruta:

get '/inventario', to: 'inventario#index'

Luego generó el controlador desde la terminal:

rails generate controller Inventario index

Rails creó automáticamente el archivo app/controllers/inventario_controller.rb. Andrés lo abrió y encontró esto:

class InventarioController < ApplicationController
  def index
  end
end

Andrés agregó lógica básica. Definió una variable de instancia con los productos:

def index
  @productos = Producto.all
end

Recordó de la lección anterior que las variables con @ viajan automáticamente a la Vista. Eso le ahorró tiempo. En dos horas tenía su primer catálogo funcionando.

Rutas REST: el estándar que todos usan

En el mundo real, las aplicaciones necesitan más que solo "ver" datos. También necesitan crear, editar y borrar. Para eso existe el estándar REST.

Rails te da un atajo poderoso. En lugar de escribir siete rutas manualmente, escribes una sola línea:

resources :productos

Esa línea genera automáticamente estas rutas:

Siete rutas con una sola palabra. Eso es Rails.

Puedes verificar todas tus rutas con este comando en la terminal:

rails routes

Verás una tabla con cada URL disponible en tu app.

La historia de Valeria y la tienda de Liverpool

Valeria es desarrolladora junior en una agencia que construye apps para retail. Su proyecto actual: una herramienta de gestión de órdenes para una cadena similar a Liverpool.

Su primera versión usaba rutas sueltas para todo. Tenía doce líneas en routes.rb y era difícil de leer. Su compañero senior le mostró resources:

Rails.application.routes.draw do
  resources :ordenes
end

Valeria corrió rails routes y vio todas las rutas generadas. Luego creó su controlador:

rails generate controller Ordenes

Y en el controlador escribió las acciones que necesitaba:

class OrdenesController < ApplicationController

  def index
    @ordenes = Orden.all
  end

  def show
    @orden = Orden.find(params[:id])
  end

  def new
    @orden = Orden.new
  end

  def create
    @orden = Orden.new(orden_params)
    if @orden.save
      redirect_to @orden
    else
      render :new
    end
  end

  private

  def orden_params
    params.require(:orden).permit(:cliente, :total, :estatus)
  end

end

Fíjate en params[:id]. Cuando alguien visita /ordenes/5, Rails captura el 5 automáticamente en params[:id]. Así puedes buscar exactamente la orden que el usuario quiere ver.

Fíjate también en orden_params. Ese método privado es una medida de seguridad llamada "strong parameters". Le dices a Rails exactamente qué campos puede aceptar del formulario. Nada más.

Valeria terminó el proyecto en tres días. Su jefe quedó impresionado.

Parámetros en las rutas: cómo Rails captura información

Cuando un usuario visita /ordenes/42, Rails necesita saber que el 42 es el ID de una orden. Lo hace con los dos puntos en la ruta:

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

Ese :id es un segmento dinámico. Rails lo captura y lo pone en params[:id] dentro del controlador. Tú lo usas así:

def show
  @orden = Orden.find(params[:id])
end

Puedes crear tus propios segmentos dinámicos. Por ejemplo, si tienes una app para FEMSA y quieres buscar productos por categoría:

get '/catalogo/:categoria', to: 'catalogo#por_categoria'

En el controlador:

def por_categoria
  @productos = Producto.where(categoria: params[:categoria])
end

Así, /catalogo/bebidas mostraría solo los productos de bebidas. Limpio y fácil de leer.

Errores comunes que debes evitar

Muchos principiantes cometen los mismos errores con rutas y controladores. Aquí van los más frecuentes.

Error 1: El nombre del controlador no coincide con la ruta.

Si escribes to: 'productos#index' en tus rutas, Rails busca ProductosController. Si tu archivo se llama ProductoController (sin "s"), Rails lanzará un error. El nombre debe coincidir exactamente.

Error 2: Olvidar que las acciones necesitan una vista.

Si defines una acción index en tu controlador pero no creas el archivo app/views/productos/index.html.erb, Rails mostrará un error de plantilla no encontrada. Cada acción necesita su vista, a menos que uses redirect_to o render json:.

Error 3: Rutas duplicadas o en orden incorrecto.

Rails procesa las rutas de arriba hacia abajo. Si tienes dos rutas que podrían coincidir con la misma URL, Rails usará la primera. Revisa siempre con rails routes.

Error 4: No usar strong parameters.

Algunos principiantes pasan params directamente al modelo:

# MAL - nunca hagas esto
@orden = Orden.new(params[:orden])

Eso es un riesgo de seguridad serio. Siempre filtra con un método privado como orden_params.

Error 5: Poner lógica de negocio en el controlador.

Recuerda lo de la lección anterior: el Controlador coordina, no calcula. Si te encuentras haciendo sumas, descuentos o validaciones complejas en el controlador, mueve ese código al Modelo.

Rutas con nombre: más legibles, menos errores

Cuando usas resources, Rails genera automáticamente "helpers" con nombres para cada ruta. Por ejemplo, ordenes_path devuelve /ordenes. Puedes usarlos en tus vistas y controladores:

redirect_to ordenes_path

Eso es mejor que escribir redirect_to '/ordenes'. Si algún día cambias la URL, solo cambias la ruta en routes.rb. Los helpers se actualizan solos.

Lo que aprendiste hoy

Andrés construyó su catálogo de inventario en horas porque entendió cómo conectar URLs con acciones. Valeria simplificó doce rutas en una sola línea y terminó su proyecto antes. Tú puedes hacer lo mismo.

Las rutas son el punto de entrada de toda tu aplicación. Cuando las entiendes bien, el resto fluye con naturalidad.