ruby on rails - example - Ruby method_added callback not trigger incluyendo Módulos

rails after action

Question

Quería escribir un poco de lib de "Deprecate" y usé la devolución de llamada "method_added" mucho. Pero ahora noté que esta devolución de llamada no se desencadena, cuando se incluye un módulo.

¿Hay devoluciones de llamada o soluciones alternativas para informar a la clase "Foobar" cuando se incluye algo?

Pequeña demostración para demostrar:

# Including Moduls won''t trigger method_added callback

module InvisibleMethod
  def invisible
    "You won''t get a callback from me"
  end
end

class Foobar
  def self.method_added(m)
    puts "InstanceMethod: ''#{m}'' added to ''#{self}''"
  end

  def visible
    "You will get a callback from me"
  end

  include InvisibleMethod
end

[:invisible, :visible, :wont_exist].each do |meth|
  puts "#{meth}: #{Foobar.public_method_defined? meth}"
end

Ese es el resultado:

InstanceMethod: ''visible'' added to ''Foobar''
invisible: true
visible: true
wont_exist: false

Información Adicional:

Realmente necesito usar un gancho como method_added.

ActiveModel está agregando métodos_instancia_pública a la clase durante el tiempo de ejecución mediante módulos anónimos.

Answer 1

Creo que deprecation no es una gran idea para requerir una biblioteca. se implementa así en datamapper . Acerca de hook method_added ; está funcionando como se esperaba porque los métodos ya se han agregado al module no a la class . Solo usted puede obtener su resultado esperado Parche de monos included gancho.

# got from https://github.com/datamapper/dm-core/blob/master/lib/dm-core/support/deprecate.rb
module Deprecate
  def deprecate(old_method, new_method)
    class_eval <<-RUBY, __FILE__, __LINE__ + 1
      def #{old_method}(*args, &block)
        warn "/#{self.class}##{old_method} is deprecated, use /#{self.class}##{new_method} instead (/#{caller.first})"
        send(#{new_method.inspect}, *args, &block)
      end
    RUBY
  end
end # module Deprecate

class MyClass
  extend Deprecate

  def old_method
    p "I am old"
  end
  deprecate :old_method, :new_method

  def new_method
    p "I am new"
  end
end

m = MyClass.new
m.old_method

# MyClass#old_method is deprecated, use MyClass#new_method instead (pinger.rb:27:in `<main>'')
# "I am new"

Answer 2

Tal como lo sugiere uno de los comentarios, puede usar algún otro enlace para obtener el comportamiento que desea. Por ejemplo, intente agregar esto al comienzo de su código:

class Module
  def included(klass)
    if klass.respond_to?(:method_added)
      self.instance_methods.each do |method|
        klass.method_added(method)
      end
    end
  end
end

Cada vez que se incluye un módulo en una clase, todos los métodos de instancia de ese módulo se notificarán a la clase, siempre que defina el método method_added . Al ejecutar su código con el cambio anterior obtengo este resultado:

InstanceMethod: ''visible'' added to ''Foobar''
InstanceMethod: ''invisible'' added to ''Foobar''
invisible: true
visible: true
wont_exist: false

Lo cual creo que es el comportamiento que quieres.

Answer 3

El problema es que incluir módulos no agrega métodos a las clases, solo cambia la cadena de llamadas del método. Esta cadena define qué clases / módulo se buscará para un método, que no está definido para la clase en cuestión. Lo que sucede cuando se incluye un módulo es una adición de una entrada en esa cadena.

Esto es exactamente lo mismo que cuando agrega un método en una superclase; esto no llama a method_added ya que no está definido en la superclase. Sería muy extraño si una subclase pudiera cambiar el comportamiento de una superclase.

Podrías solucionarlo mediante el método de llamada manual agregado para un módulo incluido, al redefinir include para tu clase:

class Foobar
  def self.include(included_module)
    included_module.instance_methods.each{|m| self.method_added(m)}
    super
  end
end

Y es mucho más seguro que redefinir el método included en el Module : el cambio se reduce solo a las clases que usted mismo definió.