Concerns en Ruby on Rails: qué son y cuándo usarlos
Tienes dos o tres modelos que necesitan el mismo método, o varios controladores que comprueban lo mismo antes de cada acción. Copiar y pegar funciona hasta el día en que cambias una copia y te olvidas de la otra.
Los concerns de Rails (Rails concerns) son una forma de abstraer el código que se comparte entre diferentes modelos o diferentes controladores. Se coloca en un módulo y ese módulo se incluye en cada clase que necesita ese código común.
Es como la receta de un sofrito: la escribes una vez y la añades a todos los platos que la llevan. Si un día le quitas el ajo, cambia en todos a la vez. El símil se queda corto en una cosa: el sofrito no necesita saber nada del plato, y un concern a menudo sí depende de la clase donde lo metes (de sus columnas, por ejemplo). Volveremos a eso al final.
Qué es ActiveSupport::Concern
Un concern es un módulo de Ruby normal, el mismo mecanismo que se usa para los mixins: una forma de «mezclar» métodos en una clase sin heredar de ella. La diferencia está en la línea extend ActiveSupport::Concern, que le añade tres bloques muy cómodos:
| Bloque | Qué hace | Para qué lo usas |
|---|---|---|
included do … end |
Ejecuta el código dentro de la clase que incluye el concern | Validaciones, scope, asociaciones, callbacks, before_action |
class_methods do … end |
Define métodos de clase (User.algo) |
Consultas o utilidades de la clase |
prepended do … end |
Igual que included, pero cuando usas prepend en vez de include |
Envolver métodos que ya existen en la clase |
Los métodos que escribes fuera de esos bloques se convierten en métodos de instancia (user.algo), como en cualquier módulo.
La guía oficial de Rails lo resume así: «A Concern is a Ruby module with some syntactic sugar to make using them easier» (un concern es un módulo de Ruby con algo de azúcar sintáctico para que sea más fácil de usar).
Dónde se guardan los concerns
Tanto la carpeta app/models como la de app/controllers traen una carpeta concerns creada por defecto:
app/
├── controllers/
│ ├── concerns/
│ ├── application_controller.rb
│ └── articles_controller.rb
└── models/
├── concerns/
├── application_record.rb
└── article.rb
Rails carga solas esas carpetas, y las trata como raíz: un fichero app/models/concerns/permissions.rb debe definir un módulo Permissions, sin prefijo Concerns::.
Crear un concern de modelo paso a paso
En este ejemplo vamos a controlar qué nivel de permiso tiene un usuario para dejarle o no hacer operaciones en nuestra web. La tabla users tiene una columna numérica permission_level: 1 es un usuario normal, 2 un editor y 3 un administrador.
- Crea el módulo en
app/models/concerns/conextend ActiveSupport::Concern. - Inclúyelo en el modelo con
include. - Usa sus métodos como si fueran del modelo.
1. Crea el módulo
app/models/concerns/permissions.rb
module Permissions
extend ActiveSupport::Concern
LEVELS = { normal: 1, editor: 2, admin: 3 }.freeze
# Se ejecuta dentro de la clase que incluye el concern
included do
validates :permission_level, inclusion: { in: LEVELS.values }
scope :editors, -> { where(permission_level: LEVELS[:editor]..) }
end
# Métodos de clase: User.with_level(:admin)
class_methods do
def with_level(name)
where(permission_level: LEVELS.fetch(name))
end
end
# Métodos de instancia: user.editor?
def normal_user?
permission_level >= LEVELS[:normal]
end
def editor?
permission_level >= LEVELS[:editor]
end
def admin?
permission_level >= LEVELS[:admin]
end
end
Fíjate en los nombres: en Ruby, los métodos que responden sí o no terminan en ? y no empiezan por is_. Por eso admin? en vez de is_admin?. Tampoco hace falta escribir self. delante de permission_level.
2. Inclúyelo en el modelo
app/models/user.rb
class User < ApplicationRecord
include Permissions
end
3. Úsalo
A partir de aquí, la clase User tiene todo lo que declara el módulo: los métodos, el scope y la validación.
ana = User.create!(name: "Ana", permission_level: 3)
luis = User.create!(name: "Luis", permission_level: 2)
eva = User.create!(name: "Eva", permission_level: 1)
p ana.admin?
p luis.admin?
p luis.editor?
p eva.editor?
p User.editors.pluck(:name)
p User.with_level(:admin).pluck(:name)
p User.new(name: "Sin nivel").valid?
p User.new(name: "Nivel 7", permission_level: 7).valid?
Salida real al ejecutarlo con bin/rails runner en una app mínima (rails new demo --minimal y bin/rails g model User name:string permission_level:integer):
true
false
true
false
["Ana", "Luis"]
["Ana"]
false
false
Los dos últimos false vienen de la validación del concern: un usuario sin nivel o con un nivel que no está en LEVELS no se puede guardar. Por eso Eva necesita su permission_level: 1.
Concerns en controladores de Rails (controller concerns)
En los controladores funcionan igual. Vamos a comprobar el tipo de usuario antes de cada acción y, si no tiene permiso, mandarlo a la página de inicio.
app/controllers/concerns/authorization.rb
module Authorization
extend ActiveSupport::Concern
private
def require_editor!
redirect_to root_path unless user_signed_in? && current_user.editor?
end
def require_admin!
redirect_to root_path unless user_signed_in? && current_user.admin?
end
end
Estos métodos verifican si el usuario ha iniciado sesión y si es editor o administrador. Si no lo es, lo redirigen a la página raíz del sitio. user_signed_in? y current_user los aporta la gema Devise; si usas otro sistema de autenticación, cámbialos por los suyos.
Lo incluimos en el ApplicationController, del que heredan todos los controladores:
app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
include Authorization
end
Y en el controlador de artículos llamamos a esos métodos antes de cada acción con before_action:
app/controllers/articles_controller.rb
class ArticlesController < ApplicationController
before_action :require_editor!, only: %i[new create edit update]
before_action :require_admin!, only: :destroy
# …
end
Ojo con la lista de acciones: si proteges update pero no edit, cualquiera puede abrir el formulario de edición aunque luego no pueda guardarlo. Protege siempre las dos parejas: new y create, edit y update.
Salida real de cuatro peticiones de prueba (nivel 0 es un visitante sin sesión):
new con nivel 0: 302 -> http://example.org/
new con nivel 2: 200 Formulario de nuevo artículo
destroy con nivel 2: 302 -> http://example.org/
destroy con nivel 3: 200 Artículo borrado
El 302 es la redirección a la página de inicio; el 200, que la acción se ha ejecutado.
Concern o módulo de Ruby: qué añade ActiveSupport::Concern
Si ya conoces los módulos, puede que te preguntes para qué hace falta ActiveSupport::Concern. Hace tres cosas que con un módulo normal son más incómodas.
Métodos de clase sin trucos
Con un módulo normal, para añadir métodos de clase necesitas un hook (un método que Ruby llama solo al incluir el módulo):
module Greeting
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def greeting = "Hola desde #{name}"
end
end
Con ActiveSupport::Concern, lo mismo queda así:
module Farewell
extend ActiveSupport::Concern
class_methods do
def farewell = "Adiós desde #{name}"
end
end
Los dos hacen lo mismo, pero el segundo se lee de un vistazo.
Dependencias resueltas
Si un concern necesita otro, basta con que lo incluya él mismo. ActiveSupport se encarga de que el bloque included se ejecute en la clase final y no en el módulo intermedio. Con módulos normales, la clase tendría que incluir los dos en el orden correcto.
module Signature
extend ActiveSupport::Concern
include Farewell # Signature depende de Farewell
included do
puts "Signature incluido en #{name}: ya puede usar #{farewell.inspect}"
end
end
Soporte para prepend
Con prepend, el módulo se coloca delante de la clase, así que sus métodos se ejecutan primero y pueden llamar al original con super:
module Loud
extend ActiveSupport::Concern
prepended do
puts "Loud antepuesto a #{name}"
end
def say = super.upcase
end
class Letter
include Greeting
include Signature
def say = "una carta"
prepend Loud
end
puts Letter.greeting
puts Letter.new.say
puts Letter.ancestors.take(4).inspect
Salida real:
Signature incluido en Letter: ya puede usar "Adiós desde Letter"
Loud antepuesto a Letter
Hola desde Letter
UNA CARTA
[Loud, Letter, Signature, Farewell]
Letter solo incluye Signature, pero Farewell aparece en sus ancestros: la dependencia se ha resuelto sola. Y Loud va antes que Letter, por eso say sale en mayúsculas.
Un detalle más: cada concern admite un único bloque included (y uno prepended). Si escribes dos, Rails lanza ActiveSupport::Concern::MultipleIncludedBlocks.
Cuándo usar concerns y cuándo no
Repartir un modelo en cinco ficheros no lo hace más pequeño.
Un concern mueve código de sitio, pero no lo separa: todos sus métodos acaban dentro de la misma clase. Si User incluye seis concerns, sigue siendo una sola clase con todas esas responsabilidades, solo que repartidas en seis ficheros. Es una forma discreta de acabar con un God Object, un objeto que sabe y hace demasiado.
Encaja un concern
- Un comportamiento que se repite de verdad en varios modelos o controladores (etiquetas, borrado lógico, autorización)
- Necesita las herramientas de Rails en la clase: validaciones, scopes, callbacks,
before_action - Depende de poco de la clase anfitriona, y esa dependencia está clara
Mejor otra cosa
- Solo lo usa un modelo y lo extraes para que el fichero «parezca» más corto
- Usa en silencio columnas o métodos de la clase que no se ven desde el concern
- Esconde callbacks que hacen cosas inesperadas al guardar
La alternativa suele ser la composición: en vez de mezclar métodos en la clase, la clase usa un objeto pequeño que se encarga de una sola cosa. En el artículo sobre clases en código limpio lo medíamos así: el tamaño de una clase no se mide en líneas, sino en responsabilidades.
Los permisos del ejemplo se pueden escribir así, sin concern:
class PermissionLevel
LEVELS = { normal: 1, editor: 2, admin: 3 }.freeze
def initialize(value)
@value = Integer(value)
raise ArgumentError, "nivel desconocido: #{value}" unless LEVELS.value?(@value)
end
def at_least?(name) = @value >= LEVELS.fetch(name)
end
class User < ApplicationRecord
def permissions = PermissionLevel.new(permission_level)
end
luis = User.create!(name: "Luis", permission_level: 2)
p luis.permissions.at_least?(:editor)
p luis.permissions.at_least?(:admin)
begin
PermissionLevel.new(7)
rescue ArgumentError => e
p e
end
Salida real, con bin/rails runner en la misma app mínima:
true
false
#<ArgumentError: nivel desconocido: 7>
Un usuario sin nivel (permission_level a nil) haría fallar Integer con un TypeError: si la columna admite nulos, decide antes qué nivel le corresponde. PermissionLevel es una clase de Ruby normal: se prueba sin base de datos ni Rails, se entiende sin abrir User y puede crecer sin engordar el modelo. Lo que pierdes es el scope y la validación de Active Record, que tendrías que dejar en el modelo.
User. Abajo, User usa un objeto aparte, que se prueba solo; el scope y la validación se quedan en el modelo.Ninguna de las dos opciones es siempre la buena. Una regla práctica: si al leer el concern necesitas abrir la clase que lo incluye para entenderlo, probablemente quería ser un objeto propio.
Tu chuleta
| Quiero… | Escribe |
|---|---|
| Crear un concern | module Nombre + extend ActiveSupport::Concern en app/models/concerns/nombre.rb |
| Usarlo en un modelo o controlador | include Nombre |
Añadir validaciones, scopes o before_action |
included do … end |
| Añadir métodos de clase | class_methods do … end |
| Que un concern use otro | include OtroConcern dentro del concern |
| Envolver un método existente | prepend Nombre + prepended do … end y super |
Fuentes
Comprobado en noviembre de 2026 en la documentación oficial de Rails 8.1.4.1, la versión estable más reciente en RubyGems:
- ActiveSupport::Concern (API):
included,class_methods,prepended, resolución de dependencias y error por bloquesincludedrepetidos. - Getting Started with Rails, sección «Extracting a Concern»: definición citada.
- Autoloading and Reloading Constants:
app/models/concernsyapp/controllers/concernscomo rutas de carga automática.
Todos los ejemplos se han ejecutado en Docker con la imagen ruby:3.4 (Ruby 3.4.12). Los de modelos (Permissions y PermissionLevel), en una app Rails 8.1.4.1 mínima con SQLite, con bin/rails runner. El controlador y los módulos de la sección sobre ActiveSupport::Concern, como scripts independientes con activesupport, activerecord y actionpack 8.1.4.1 y sqlite3 2.10.2: el controlador, con peticiones simuladas de Rack y un usuario simulado en lugar de Devise.