我有以下来自《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
我仍在努力弄清楚它是如何工作的。我希望有人能够确认我的思维过程，因为我想确保我理解这里发生的事情。这些评论是我自己添加的。我真的认为我对方法绑定、单例类和元编程的理解充其量只是新手。
首先，Trace::included 被任何包含它的类调用。这个方法做了两件事，获取该类中现有函数的列表（如果有）并使用注入覆盖它们的方法。然后，它修改包含该模块的类的单例类，并覆盖默认的 method_added 方法，以确保每次添加方法经过附加包含注入都会影响它。此方法使用变量来防止无限递归，因为对inject 的调用本质上会引发method_added。
Trace::的工作原理如下：使用instance_eval将self设置为类定义中存在的上下文。因此scope(?)被修改为它在该类定义中的样子。
然后我们将method_object设置为instance_method(meth)，这将获取要添加的原始方法。自从instance_method 没有显式接收器，它将默认为 self，这与类定义中的上下文相同？
然后我们使用define_method定义一个同名的方法。因为我们处于instance_eval的上下文中，所以这相当于定义了一个实例方法，并且会覆盖现有的方法。我们的方法接受任意数量的参数和一个块（如果存在）。
我们添加一些耀斑来放置“跟踪”，然后我们还调用存储在 method_object 中的原始方法，因为原始方法将被覆盖。这个方法是未绑定，因此我们必须使用bind(self)将其绑定到当前上下文，以便它具有与原来相同的上下文？然后我们使用 call 并传递参数和块，存储其返回值，并在打印后返回其返回值。
我真的希望我能够充分描述这一点。我的描述准确吗？我对粗体内容和以下行特别不确定：
method_object.bind(self).call(*args, &block)
