ruby on rails - ¿Cuál es la forma preferida de agregar algún método en la base de registros activa?

ruby-on-rails include

Question

Quiero crear un módulo que proporcione algunos métodos comunes a las clases que se heredan de la base de registros activos.

Lo siguiente es de dos vías que podemos lograr.

1)

module Commentable
def self.extended(base)
base.class_eval do
include InstanceMethods
extend ClassMethods
end
end
module ClassMethods
def test_commentable_classmethod
puts ''test class method''
end
end
module InstanceMethods
def test_commentable_instance_method
puts ''test instance method''
end
end
end
ActiveRecord::Base.extend(Commentable)

2)

module Commentable
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def test_commentable_classmethod
puts ''test class method''
end
end
def test_commentable_instance_method
puts ''test instance methods''
end
end
ActiveRecord::Base.send(:include, Commentable)

¿Cuál es la forma preferida de manejar esto?

Y

¿Qué usar cuando?

Answer 1

refiriendo con la respuesta de Mori ... puedes hacer algo como:

Module ActiveRecordUtilities
class MyBase < ActiveRecord::Base
self.abstract_class = true
def self.a_class_method
end
def an_instance_method
end
end
end##class ends
end##module ends

y puede usarlo ... supongo en user.rb

include ActiveRecordUtilities::MyBase
User.a_class_method
@user.instance_method

========================= O ====================

module MyUtils
def do_something_funky
# Some exciting code
end
end
class Account < ActiveRecord::Base
belongs_to :person, :extend => MyUtils
end
And then call it like this:
@account = Account.first
@account.person.do_something_funky

Answer 2

Otra forma es crear su propia clase base heredando ActiveRecord::Base y luego dejar que sus modelos hereden de esa clase base. Esto tiene la ventaja de dejar en claro que sus modelos no se están ejecutando en ActiveRecord vainilla:

class MyBase < ActiveRecord::Base
self.abstract_class = true
def self.a_class_method
end
def an_instance_method
end
end
class Foo < MyBase
end
Foo.a_class_method
Foo.new.an_instance_method

Answer 3

A partir de Rails 5, la forma recomendada es crear un módulo e incluirlo en los modelos donde sea necesario, o en cualquier lugar utilizando ApplicationRecord, del que heredan todos los modelos. (Puede implementar fácilmente este patrón desde cero en versiones anteriores de Rails).

# app/models/concerns/my_module.rb
module MyModule
extend ActiveSupport::Concern
module ClassMethods
def has_some_new_fancy_feature(options = {})
...
end
end
end
# app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
self.abstract_class = true
include MyModule
end

Los módulos son una forma de herencia múltiple y, a veces, agregan complejidad innecesaria. Verifique si un decorador, servicio u otro tipo de objeto tiene más sentido primero. No todo necesita ser una macro elegante que agrega 50 devoluciones de llamada a su modelo. Odiarás tu vida si haces esto demasiado.

Si quieres un parche de mono (NO HAGAS ESTO), aquí está mi respuesta anterior:

# config/initializers/activerecord_extensions.rb
ActiveRecord::Base.send(:include, MyModule)

O sin parche de mono (ver la respuesta de Mori ):

# app/models/base_model.rb
class BaseModel < ActiveRecord::Base
self.abstract_class = true
include MyModule
end

Editar: Varios meses después, en un proyecto grande, me di cuenta de que es mejor tener todas las modelos heredadas de una nueva clase de modelo base, como explica Mori . El problema de incluir módulos directamente en ActiveRecord :: Base es que esto puede interferir con el código de un tercero que también depende de ActiveRecord. Es mejor no hacer un parche de mono cuando no es necesario. En este caso, crear una nueva clase base puede terminar siendo más simple a largo plazo.