Nivel inicial10 min de lectura · Publicado el

Concerns en Ruby on Rails: qué son y cuándo usarlos

Concerns en Ruby on Rails: los módulos Permissions y Authorization se añaden con include a User y a ApplicationController. Concerns: escribe una vezrubentejera.com PermissionsincludeUserAuthorizationincludeApplicationController
Un concern se escribe una vez y se añade con include: Permissions da a User sus métodos de permisos, y Authorization, incluido en ApplicationController, llega a todos los controladores. Si cambias el módulo, cambia en todos.

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.

  1. Crea el módulo en app/models/concerns/ con extend ActiveSupport::Concern.
  2. Inclúyelo en el modelo con include.
  3. 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.

Con un concern, User incluye Permissions y sus métodos editor?, admin? y with_level, la validación y el scope acaban dentro de User: sigue siendo una sola clase. Con un objeto pequeño, User usa PermissionLevel desde su método permissions y conserva el scope y la validación; PermissionLevel tiene at_least?(name), se prueba sin Rails y se encarga de una sola cosa.
Arriba, el concern solo cambia de fichero: sus métodos acaban dentro de 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:

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.