ruby-on-rails - 了解使用 method_added 动态覆盖实例方法的 ruby​​ 元编程

Question

我有以下来自 Programming Ruby 1.9 的代码(稍微改编)我只是想确保我的思维过程是准确的

module Trace
  def self.included(culprit)
    #Inject existing methods with tracing code:
    culprit.instance_methods(false).each do |func|
      inject(culprit, func)
    end

    #Override the singletons method_added to ensure all future methods are injected.
    def culprit.method_added(meth)
      unless @trace_calls_internal
        @trace_calls_internal = true
        Trace.inject(self, meth) #This will call method_added itself, the condition prevents infinite recursion.
        @trace_calls_internal = false
      end
    end
  end

  def self.inject(target, meth)
    target.instance_eval do
      #Get the method
      method_object = instance_method(meth)
      #Rewrite dat sheet
      define_method(meth) do |*args, &block|
        puts "==> Called #{meth} with #{args.inspect}"
        #the bind to self will put the context back to the class.
        result = method_object.bind(self).call(*args, &block)
        puts "<== #{meth} returned #{result.inspect}"
        result
      end
    end
  end
end

class Example
  def one(arg)
    puts "One called with #{arg}"
  end
end
#No tracing for the above.
ex1 = Example.new
ex1.one("Sup") #Not affected by Trace::inject

class Example #extend the class to include tracing.
  include Trace #calls Trace::inject on existing methods via Trace::included
  def two(a1, a2) #triggers Example::method_added(two) and by extension Trace::inject
    a1 + a2
  end
end

ex1.one("Sup again") #Affected by Trace::inject
puts ex1.two(5, 4) #Affected by Trace::inject

我仍在努力思考它是如何工作的。我希望是否有人可以确认我的思维过程，因为我想确保我了解这里发生的事情。评论是我自己加的。我真的认为我对方法绑定(bind)、单例类和元编程的理解充其量是新手。

首先，Trace::included 被任何包含它的类调用。这个方法做了两件事，获取该类中现有函数的列表(如果有的话)并使用 inject 覆盖它们的方法。然后它修改包含该模块的类的单例类，并覆盖默认的 method_added 方法，以确保每次添加方法时，额外的 include 注入(inject)都会影响它。此方法使用一个变量来防止无限递归，因为对 inject 的调用本质上会调用 method_added。

Trace::works 如下:使用 instance_eval 将 self 设置为存在于类定义中的上下文。因此，scope(?) 被修改为它在该类定义中的样子。

然后我们将 method_object 设置为 instance_method(meth) ，这将获得将要添加的原始方法。由于 instance_method 没有明确的接收者，它会默认为 self，这与类定义中的上下文相同？

然后我们使用define_method定义一个同名的方法。因为我们是在instance_eval的上下文中，这相当于定义了一个实例方法，会覆盖已有的方法。我们的方法接受任意数量的参数和一个 block (如果存在的话)。

我们添加一些光晕来放置我们的“Tracing”，然后我们还调用存储在 method_object 中的原始方法，因为原始方法正在被覆盖。此方法是未绑定(bind)的，因此我们必须使用 bind(self) 将其绑定(bind)到当前上下文，以便它具有与最初相同的上下文？然后我们使用 call 并传递参数和 block ，存储它的返回值，打印后返回它的返回值。

---

我真的希望我能充分描述这一点。我的描述准确吗？我特别不确定粗体内容和以下行:

method_object.bind(self).call(*args, &block)

Answer 1

Trace::works as follows: set self to the context that exists within the class definition using instance_eval. Therefore the scope(?) is modified to how it would be within that class definition.

使用 instance eval，您可以评估自身绑定(bind)到对象的 block ，在这种情况下，对象将是包含模块的类。 (即罪魁祸首)。为清楚起见，以下之间存在差异:

o = Object.new
o.instance_eval do
  puts self
end

和

class Foo < Object end
Foo.instance_eval do  puts self end

回答:是的，您的这个假设是正确的!

---

Then we set method_object to instance_method(meth) which will get the original method that will added. Since instance_method does not have an explicit receiver, it will default to self which will be the same as the context of being within the class definition?

是的，您的假设是正确的。请注意，询问:

culprit.instance_methods(false) => [:someselector, :someotherselector]

并且在这个context中调用实例方法确实和调用self.instance_method是一样的。

---

This method is unbound, so we must bind it to the current context using bind(self) so it has the same context as it would originally?

是的。当您以跟踪模块中定义的方式获取方法时，您将获得一个未绑定(bind)的方法对象，该对象可以按照描述再次绑定(bind)。

---

如果您想深入了解 Ruby 的元编程，我推荐以下书籍:http://pragprog.com/book/ppmetr/metaprogramming-ruby它解释了 Ruby 的对象系统、mixins、 block 和任何你能想象到的东西背后的所有细节。