1. Validaciones en el Modelo#

Las validaciones garantizan que los datos sean correctos antes de guardarse en la base de datos. En Rails, se realizan desde el framework, no directamente en la base de datos.

Ejemplo dentro del modelo app/models/product.rb:

1
class Product < ApplicationRecord
2
  validates :name, presence: true, uniqueness: true
3
  validates :price, numericality: { greater_than_or_equal_to: 0 }
4
end

El método validate se usa para personalizar condiciones. En la consola se pueden consultar los errores:

1
product.errors
2
product.errors.full_messages

Rails no permite guardar un registro inválido (product.save devuelve false si falla una validación). Esto centraliza la lógica de negocio dentro del modelo, siguiendo el principio “Don’t Repeat Yourself (DRY)“.

2. Rutas y Peticiones HTTP#

Las rutas (config/routes.rb) definen cómo las peticiones llegan a los controladores y qué acción se ejecuta.

Ejemplo de ruta manual:

1
get "/products", to: "products#index"
2
post "/products", to: "products#create"

Cada ruta relaciona:

• Un método HTTP (GET, POST, PUT, PATCH, DELETE)
• Una ruta URL (ej. /products/:id)
• Un controlador y acción (ej. products#show)

Rails simplifica la creación de rutas con la palabra clave resources, que genera automáticamente todas las rutas CRUD:

1
resources :products

Comando para listar las rutas activas:

1
bin/rails routes

Ejemplo de salida:

1
products     GET     /products(.:format)     products#index
2
product      GET     /products/:id           products#show
3
new_product  GET     /products/new           products#new
4
edit_product GET     /products/:id/edit      products#edit
5
             POST    /products(.:format)     products#create
6
             PATCH   /products/:id           products#update
7
             DELETE  /products/:id           products#destroy

3. Controladores y Acciones#

El controlador conecta las peticiones HTTP con la lógica del modelo y las vistas. Ejemplo básico de ProductsController:

1
class ProductsController < ApplicationController
2
  before_action :set_product, only: %i[ show edit update destroy ]
3

4
  def index
5
    @products = Product.all
6
  end
7

8
  def show; end
9

10
  def new
11
    @product = Product.new
12
  end
13

14
  def create
15
    @product = Product.new(product_params)
16
    if @product.save
17
      redirect_to @product
18
    else
19
      render :new, status: :unprocessable_entity
20
    end
21
  end
22

23
  def edit; end
24

25
  def update
26
    if @product.update(product_params)
27
      redirect_to @product
28
    else
29
      render :edit, status: :unprocessable_entity
30
    end
31
  end
32

33
  def destroy
34
    @product.destroy
35
    redirect_to products_path
36
  end
37

38
  private
39
    def set_product
40
      @product = Product.find(params[:id])
41
    end
42

43
    def product_params
44
      params.require(:product).permit(:name, :price)
45
    end
46
end

4. Vistas y ERB#

Las vistas (.html.erb) contienen código HTML y Ruby embebido (ERB – Embedded Ruby). Ejemplo para listar productos:

1
<h1>Products</h1>
2
<% @products.each do |product| %>
3
  <%= link_to product.name, product %>
4
<% end %>

El helper link_to genera enlaces automáticamente, y product se convierte en /products/:id gracias al sistema de rutas.

5. Formularios y Validaciones Visuales#

Rails facilita la creación de formularios con form_with:

1
<%= form_with model: @product do |form| %>
2
  <%= form.label :name %>
3
  <%= form.text_field :name %>
4

5
  <%= form.label :price %>
6
  <%= form.number_field :price %>
7

8
  <%= form.submit "Guardar" %>
9
<% end %>

Si hay errores en las validaciones, el formulario se recarga mostrando mensajes automáticos. Esto permite validar en el backend (modelo) y en el frontend (vista) sin duplicar lógica.

6. Eliminación de Registros#

Para borrar un producto:

1
<%= button_to "Eliminar", @product, method: :delete, data: { turbo_confirm: "¿Estás seguro?" } %>

Rails usa method: :delete y turbo_confirm para generar un formulario seguro y confirmar antes de eliminar.

Glosario#

Reflexión final#

Ruby on Rails combina estructura, validación y seguridad en un flujo unificado. Las rutas vinculan peticiones con controladores, los modelos validan los datos antes de guardarlos y las vistas muestran resultados dinámicos. Este enfoque permite desarrollar sistemas web coherentes, seguros y fáciles de mantener, aplicando los principios de simplicidad y automatización que caracterizan al framework.