Rails desde cero (I): Los fundamentos que todo desarrollador debería conocer

Primera entrega de la serie Rails desde cero. Tiempo de lectura estimado: 10 minutos.

Ruby on Rails cumplió veinte años en 2024 y sigue siendo uno de los frameworks más productivos que existen. Startups como GitHub, Shopify o Basecamp se construyeron sobre él, y todavía hoy impulsan negocios con millones de usuarios. Si estás empezando con Rails, o quieres consolidar tus bases antes de avanzar hacia temas más complejos, este artículo es para ti.

Vamos a ver qué es Rails, cómo piensa, y cómo están estructurados sus componentes fundamentales.

Qué es Rails y por qué importa

Rails es un framework web escrito en Ruby que sigue la filosofía de que las decisiones ya tomadas no deberían volverte a costar tiempo. En lugar de configurar desde cero dónde van los modelos, cómo se conectan con la base de datos o cómo se nombran las rutas, Rails lo decide por ti mediante convenciones.

Esto se resume en dos principios que deberías grabarte a fuego:

Convention over Configuration (CoC). Si sigues las convenciones del framework, apenas necesitas configuración. Un modelo llamado Article se mapeará automáticamente a una tabla articles, y Rails sabrá dónde encontrar sus vistas, sus controladores y sus tests sin que le digas nada más.

Don’t Repeat Yourself (DRY). Cada pieza de conocimiento debe tener una única representación en el sistema. Rails te da las herramientas para evitar duplicar lógica, y te penaliza (suavemente) cuando ignoras este principio.

Estos dos principios no son decorativos. Son los que hacen que una aplicación Rails sea predecible: cualquier desarrollador que conozca el framework puede navegar un proyecto que no ha visto nunca y orientarse en minutos.

La arquitectura MVC

Rails implementa el patrón Model-View-Controller (MVC), que divide la aplicación en tres capas con responsabilidades bien diferenciadas.

El Modelo

El modelo representa los datos y las reglas de negocio. En Rails, los modelos son clases Ruby que heredan de ApplicationRecord (que a su vez hereda de ActiveRecord::Base), y cada uno se corresponde con una tabla en la base de datos.

class Article < ApplicationRecord
  validates :title, presence: true, length: { minimum: 5 }
  validates :body, presence: true

  belongs_to :author, class_name: "User"
  has_many :comments, dependent: :destroy
end

ActiveRecord es el ORM de Rails. Traduce objetos Ruby a filas de base de datos y viceversa, y te da una API en Ruby para hacer consultas sin escribir SQL directamente:

# Todos los artículos publicados, ordenados por fecha
Article.where(published: true).order(created_at: :desc)

# El artículo con id 42
Article.find(42)

# Crear y persistir un artículo en una línea
Article.create!(title: "Hola Rails", body: "Primer artículo", published: true)

La Vista

Las vistas son las plantillas que generan la respuesta que el usuario recibe. En Rails se usan por defecto archivos .html.erb (Embedded Ruby), aunque puedes usar otros motores como Haml o Slim.

<!-- app/views/articles/index.html.erb -->
<h1>Artículos</h1>

<% @articles.each do |article| %>
  <article>
    <h2><%= link_to article.title, article_path(article) %></h2>
    <p><%= article.body.truncate(200) %></p>
    <small>Por <%= article.author.name %></small>
  </article>
<% end %>

La diferencia entre <% %> y <%= %> es importante: el primero ejecuta código Ruby sin imprimir nada; el segundo ejecuta e imprime el resultado en el HTML.

Las vistas no deberían contener lógica compleja. Si una vista empieza a llenarse de condicionales y bucles enrevesados, es una señal de que esa lógica pertenece al modelo o a un helper.

El Controlador

El controlador es el intermediario. Recibe la petición HTTP, consulta los modelos que necesita, y escoge qué vista renderizar.

class ArticlesController < ApplicationController
  before_action :set_article, only: [:show, :edit, :update, :destroy]

  def index
    @articles = Article.where(published: true).order(created_at: :desc)
  end

  def show
    # @article ya está disponible gracias al before_action
  end

  def create
    @article = Article.new(article_params)

    if @article.save
      redirect_to @article, notice: "Artículo creado correctamente."
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def set_article
    @article = Article.find(params[:id])
  end

  def article_params
    params.require(:article).permit(:title, :body, :published)
  end
end

Fíjate en article_params: esto es Strong Parameters, el mecanismo de Rails para evitar que un usuario malintencionado envíe campos que no debería poder modificar. Siempre debes usar permit para declarar explícitamente qué atributos acepta el controlador.

El router: el mapa de tu aplicación

El router de Rails (config/routes.rb) define qué URL corresponde a qué acción de qué controlador. La forma más común de declarar rutas es con resources:

Rails.application.routes.draw do
  resources :articles do
    resources :comments, only: [:create, :destroy]
  end

  root "articles#index"
end

Una sola línea resources :articles genera automáticamente siete rutas RESTful:

Puedes ver todas las rutas de tu aplicación en cualquier momento con:

bin/rails routes

Migraciones: el control de versiones de tu base de datos

Las migraciones son archivos Ruby que describen cambios en el esquema de la base de datos. En lugar de ejecutar SQL directamente, escribes migraciones que Rails puede aplicar, revertir y compartir con el resto del equipo.

# db/migrate/20240315120000_create_articles.rb
class CreateArticles < ActiveRecord::Migration[7.1]
  def change
    create_table :articles do |t|
      t.string :title, null: false
      t.text :body, null: false
      t.boolean :published, default: false, null: false
      t.references :author, null: false, foreign_key: { to_table: :users }

      t.timestamps
    end

    add_index :articles, :published
  end
end

t.timestamps añade automáticamente las columnas created_at y updated_at, que Rails gestiona solo. t.references crea la columna author_id y, con foreign_key: true, la restricción en base de datos.

Para aplicar la migración:

bin/rails db:migrate

Para revertirla:

bin/rails db:rollback

El estado actual del esquema siempre queda reflejado en db/schema.rb, que es la fuente de verdad sobre cómo está la base de datos.

La consola de Rails: tu mejor aliada

Una de las herramientas más útiles de Rails es su consola interactiva, que carga toda la aplicación y te permite ejecutar código Ruby contra ella en tiempo real:

bin/rails console

Desde ahí puedes hacer consultas, probar validaciones, crear registros de prueba o depurar lógica de negocio sin necesidad de pasar por el navegador:

# En la consola
article = Article.new(title: "Test")
article.valid?       # => false
article.errors.full_messages  # => ["Body can't be blank"]

Article.count        # => 42
Article.last.title   # => "Rails desde cero (I): Los fundamentos..."

En desarrollo es habitual usar bin/rails console --sandbox, que ejecuta todo en una transacción que se revierte al salir, sin tocar los datos reales.

Estructura de directorios

Una aplicación Rails tiene una estructura de carpetas estándar que merece la pena conocer desde el principio:

app/
  models/          # Lógica de negocio y datos
  controllers/     # Controladores HTTP
  views/           # Plantillas HTML
  helpers/         # Helpers para las vistas
  jobs/            # Trabajos en segundo plano
  mailers/         # Envío de emails
  channels/        # ActionCable (WebSockets)
config/
  routes.rb        # Definición de rutas
  database.yml     # Configuración de base de datos
  application.rb   # Configuración de la aplicación
db/
  migrate/         # Migraciones
  schema.rb        # Estado actual del esquema
  seeds.rb         # Datos iniciales
test/ (o spec/)    # Tests
Gemfile            # Dependencias Ruby

Todo tiene su lugar. Cuando dudes dónde poner algo, la respuesta suele estar en esta estructura.

Generadores: andamiaje automático

Rails incluye generadores que crean los archivos necesarios por ti, siguiendo todas las convenciones:

# Genera modelo + migración
bin/rails generate model Article title:string body:text published:boolean

# Genera controlador con acciones
bin/rails generate controller Articles index show new create edit update destroy

# Genera modelo + migración + controlador + vistas + rutas (scaffold completo)
bin/rails generate scaffold Article title:string body:text published:boolean

El scaffold es útil para aprender o para prototipar rápido, pero en proyectos reales rara vez querrás usarlo tal cual, porque genera código genérico que casi siempre necesitarás personalizar.

Por dónde seguir

En este artículo hemos visto los cimientos: MVC, ActiveRecord, el router, las migraciones y la estructura de la aplicación. Con estos conceptos ya puedes leer código Rails real y entender lo que hace.

En los próximos artículos de la serie profundizaremos en:

• ActiveRecord avanzado: asociaciones, scopes, callbacks y consultas complejas.
• Testing en Rails: RSpec, fixtures, factories y la pirámide de tests.
• Background jobs: Solid Queue, Active Job y cuándo procesar en segundo plano.
• Autenticación: desde cero con has_secure_password y con Authentication Generator.
• APIs con Rails: modo API, serialización y versionado.

Si tienes preguntas o quieres que profundice en algún aspecto concreto, déjalo en los comentarios.

¿Te ha resultado útil? Comparte el artículo con alguien que esté aprendiendo Rails.