ruby-on-rails - queries - rails where

Rieles que extienden ActiveRecord:: Base

Question

He leído algo sobre cómo extender ActiveRecord: clase base para que mis modelos tengan algunos métodos especiales. ¿Cuál es la manera más fácil de ampliarlo (tutorial paso a paso)?

Answer 1

Con Rails 4, el concepto de utilizar las preocupaciones para modularizar y DRY hasta sus modelos ha estado en lo más destacado.

Las preocupaciones básicamente le permiten agrupar códigos similares de un modelo o en varios modelos en un solo módulo y luego usar este módulo en los modelos. Aquí hay un ejemplo:

Considere un modelo de artículo, un modelo de evento y un modelo de comentario. Un artículo o un evento tiene muchos comentarios. Un comentario pertenece a cualquier artículo o evento.

Tradicionalmente, los modelos pueden verse así:

Modelo de comentario:

class Comment < ActiveRecord::Base
  belongs_to :commentable, polymorphic: true
end

Modelo del artículo:

class Article < ActiveRecord::Base
  has_many :comments, as: :commentable 

  def find_first_comment
    comments.first(created_at DESC)
  end

  def self.least_commented
   #return the article with least number of comments
  end
end

Modelo de evento

class Event < ActiveRecord::Base
  has_many :comments, as: :commentable 

  def find_first_comment
    comments.first(created_at DESC)
  end

  def self.least_commented
   #returns the event with least number of comments
  end
end

Como podemos observar, hay un fragmento significativo de código común para el modelo de evento y artículo. Usando las preocupaciones, podemos extraer este código común en un módulo separado Commentable.

Para esto crea un archivo commentable.rb en la aplicación / modelo / inquietudes.

module Commentable
    extend ActiveSupport::Concern

    included do 
        has_many :comments, as: :commentable 
    end

    # for the given article/event returns the first comment
    def find_first_comment
        comments.first(created_at DESC)
    end

    module ClassMethods     
        def least_commented
           #returns the article/event which has the least number of comments
        end
    end 
end

Y ahora tus modelos se ven así:

Modelo de comentario:

    class Comment < ActiveRecord::Base
      belongs_to :commentable, polymorphic: true
    end

Modelo del artículo:

class Article < ActiveRecord::Base
    include Commentable
end

Modelo de evento

class Event < ActiveRecord::Base    
    include Commentable
end

Un punto que me gustaría resaltar al usar Preocupaciones es que las Preocupaciones deberían usarse para la agrupación ''basada en dominio'' en lugar de la agrupación ''técnica''. Por ejemplo, una agrupación de dominios es como ''Commentable'', ''Etiquetable'', etc. Una agrupación basada en tecnología será como ''FinderMethods'', ''ValidationMethods''.

Aquí hay un enlace a una publicación que encontré muy útil para entender las preocupaciones en los Modelos.

Espero que la crítica ayude :)

Answer 2

Con Rails 5, todos los modelos se heredan de ApplicationRecord y ofrece una forma agradable de incluir o ampliar otras bibliotecas de extensión.

# app/models/concerns/special_methods.rb
module SpecialMethods
  extend ActiveSupport::Concern

  scope :this_month, -> { 
    where("date_trunc(''month'',created_at) = date_trunc(''month'',now())")
  }

  def foo
    # Code
  end
end

Supongamos que el módulo de métodos especiales debe estar disponible en todos los modelos, inclúyalo en el archivo application_record.rb. Si queremos aplicar esto para un conjunto particular de modelos, luego incluirlo en las respectivas clases modelo.

# app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true
  include SpecialMethods
end

# app/models/user.rb
class User < ApplicationRecord
  include SpecialMethods

  # Code
end

Si desea tener los métodos definidos en el módulo como métodos de clase, amplíe el módulo a ApplicationRecord.

# app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true
  extend SpecialMethods
end

Espero que ayude a los demás!

Answer 3

Hay varios enfoques:

Uso de ActiveSupport :: Preocupación (Preferido)

Lea la documentación de ActiveSupport::Concern para más detalles.

Cree un archivo llamado active_record_extension.rb en el directorio lib .

module ActiveRecordExtension

  extend ActiveSupport::Concern

  # add your instance methods here
  def foo
     "foo"
  end

  # add your static(class) methods here
  class_methods do
    #E.g: Order.top_ten        
    def top_ten
      limit(10)
    end
  end
end

# include the extension 
ActiveRecord::Base.send(:include, ActiveRecordExtension)

Cree un archivo en el directorio config/initializers llamado extensions.rb y agregue la siguiente línea al archivo:

require "active_record_extension"

Herencia (Preferido)

Consulte la answer de Toby.

Parche de mono (debe evitarse)

Cree un archivo en el directorio config/initializers llamado active_record_monkey_patch.rb .

class ActiveRecord::Base     
  #instance method, E.g: Order.new.foo       
  def foo
   "foo"
  end

  #class method, E.g: Order.top_ten        
  def self.top_ten
    limit(10)
  end
end

La famosa cita sobre expresiones regulares de Jamie Zawinski se puede reutilizar para ilustrar los problemas asociados con el parche de monos.

Algunas personas, cuando se enfrentan con un problema, piensan "Lo sé, utilizaré el parche de monos". Ahora tienen dos problemas.

El parche de mono es fácil y rápido. Pero, el tiempo y el esfuerzo ahorrado siempre se extraen en el futuro; con interés compuesto. En estos días, limito el parche de mono para prototipar rápidamente una solución en la consola de rieles.

Answer 4

Puedes extender la clase y simplemente usar herencia.

class AbstractModel < ActiveRecord::Base  
  self.abstract_class = true
end

class Foo < AbstractModel
end

class Bar < AbstractModel
end

Answer 5

Rails 5 proporciona un mecanismo integrado para extender ActiveRecord::Base .

Esto se logra proporcionando capa adicional:

# app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true
  # put your extensions here
end

y todos los modelos heredan de ese:

class Post < ApplicationRecord
end

Ver, por ejemplo, este blogpost .

Answer 6

Solo para agregar a este tema, pasé un tiempo trabajando en cómo probar tales extensiones (bajé por la ruta ActiveSupport::Concern ).

Así es como configuré un modelo para probar mis extensiones.

describe ModelExtensions do
  describe :some_method do
    it ''should return the value of foo'' do
      ActiveRecord::Migration.create_table :test_models do |t|
        t.string :foo
      end

      test_model_class = Class.new(ActiveRecord::Base) do
        def self.name
          ''TestModel''
        end

        attr_accessible :foo
      end

      model = test_model_class.new(:foo => ''bar'')

      model.some_method.should == ''bar''
    end
  end
end

Answer 7

También puede usar ActiveSupport::Concern y tener más Core Rails Idiomatic como:

module MyExtension
  extend ActiveSupport::Concern

  def foo
  end

  module ClassMethods
    def bar
    end
  end
end

ActiveRecord::Base.send(:include, MyExtension)

[Editar] siguiendo el comentario de @daniel

Entonces todos sus modelos tendrán el método foo incluido como método de instancia y los métodos en ClassMethods incluidos como métodos de clase. Por ejemplo, en FooBar < ActiveRecord::Base tendrás: FooBar.bar y FooBar#foo

ActiveSupport::Concern

Answer 8

yo tengo

ActiveRecord::Base.extend Foo::Bar

en un inicializador

Para un módulo como a continuación

module Foo
  module Bar
  end
end

Answer 9

Paso 1

module FooExtension
  def foo
    puts "bar :)"
  end
end
ActiveRecord::Base.send :include, FooExtension

Paso 2

# Require the above file in an initializer (in config/initializers)
require ''lib/foo_extension.rb''

Paso 3

There is no step 3 :)