Ruby 2.0 中模块前置的实现-测试-火龙果软件工程

Ruby 2.0 中模块前置的实现

作者言无不尽，火龙果软件发布于 2014-07-15

2770 次浏览

Ruby 2.0 为模块添加了一个 Module#prepend 方法，根据 API 文档的描述，它以相反的顺序对参数逐一调用 prepend_features 方法。和模块包含类似，会把一个模块的祖先链插入到另一个模块的祖先链中，但跟模块包含把祖先链插到该模块之后不一样，它会把祖先链插到该模块之前。我喜欢把这个特性叫做模块前置。

先举个例子来说明模块前置的作用，并和模块包含作了对比。在这个例子中，类 C 前置了模块 A 和 B；类 D 包含了模块 A 和 B。

module A
def foo; 'A' end
end
module B
def foo; 'B' end
end
class C
prepend A, B   # Prepending is done by this line
def foo; 'C' end
end
class D
include A, B
def foo; 'D' end
end
C.ancestors # => [A, B, C, Object, Kernel, BasicObject]
D.ancestors # => [D, A, B, Object, Kernel, BasicObject]
C.new.foo # => 'A'
D.new.foo # => 'D'

第 10 行，我们在 C 中前置了模块 A 和 B，这样 A 和 B 就插入到 C 的祖先链中了。从 21 和 22 行中的注释中，我们可以看到，在 C 的祖先链中，A 和 B 位于 C 之前。而在 D 的祖先链中，A 和 B 位于 D 之后。

这就是为什么第 24 行，C.new.foo 的返回值是 'A'，因为模块 A 前置于 C，位于祖先链的最前面，方法查找会优先找到 A 中的 foo 方法。

我们看到了模块前置的强大的特性，但疑问也随之而来。最显而易见的问题是，C.ancestors 为什么不是从类 C 开始。要解开这个疑问，首先应该弄清楚 prepend 方法都做了哪些工作。我们跟到源代码中去一探究竟，下面是 prepend 的默认实现 Module#prepend 对应的源代码：

static VALUE
rb_mod_prepend(int argc, VALUE *argv, VALUE module)
{
int i;
ID id_prepend_features, id_prepended;
CONST_ID(id_prepend_features, "prepend_features");
CONST_ID(id_prepended, "prepended");
for (i = 0; i < argc; i++)
Check_Type(argv[i], T_MODULE);
while (argc--) {
rb_funcall(argv[argc], id_prepend_features, 1, module);
rb_funcall(argv[argc], id_prepended, 1, module);
}
return module;
}

可以看到，它的行为和 Module#include 方法几乎一样，只不过回调的方法不一样。这里，它回调了参数模块的 prepend_features 方法和 prepended 方法。同样，Module#prepend_features 才是真正干活的地方，所以跟进去看看。

static VALUE
rb_mod_prepend_features(VALUE module, VALUE prepend)
{
switch (TYPE(prepend)) {
case T_CLASS:
case T_MODULE:
break;
default:
Check_Type(prepend, T_CLASS);
break;
}
rb_prepend_module(prepend, module);
return module;
}
　　它做了一些类型方面的检查，
然后把工作交给了 rb_prepend_module 函数，我们看看 rb_prepend_module 函数做了什么。
void
rb_prepend_module(VALUE klass, VALUE module)
{
void rb_vm_check_redefinition_by_prepend(VALUE klass);
VALUE origin;
int changed = 0;
rb_frozen_class_p(klass);
if (!OBJ_UNTRUSTED(klass)) {
rb_secure(4);
}
Check_Type(module, T_MODULE);
OBJ_INFECT(klass, module);
origin = RCLASS_ORIGIN(klass);
if (origin == klass) {
origin = class_alloc(T_ICLASS, klass);
RCLASS_SUPER(origin) = RCLASS_SUPER(klass);
RCLASS_SUPER(klass) = origin;
RCLASS_ORIGIN(klass) = origin;
RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);
RCLASS_M_TBL(klass) = st_init_numtable();
st_foreach(RCLASS_M_TBL(origin), move_refined_method,
(st_data_t) RCLASS_M_TBL(klass));
}
changed = include_modules_at(klass, klass, module);
if (changed < 0)
rb_raise(rb_eArgError, "cyclic prepend detected");
if (changed) {
rb_clear_cache();
rb_vm_check_redefinition_by_prepend(klass);
}
}

这个函数做了一些工作，我们来分析一下。前 16 行都是在做一些类型检查等工作，我们跳过。从第 17 行开始分析。

首先，宏 RCLASS_ORIGIN 获取 klass 的 origin 成员，并且把它和 klass 比较。我们不知道 origin 字段有什么作用，我们先假设测试条件为真，即 klass 的 origin 成员指向自身。我们来分析一下 if 语句中的逻辑：

19 行为 klass 创建了一个新的包含类，我们把它称为原始类；

20 ~ 21 行把新创建的包含类插入到 klass 和 klass 的父类中间；

22 行将 klass 的 origin 成员指向了新类；

接下来，23 ~ 24 行把 klass 的方法表转移到新类中，并清空 klass 的方法表；

最后，25 行又把 klass 原先的方法表中的 Refined 方法移了回来。

分析完 if 语句，我们继续前进，来到第 28 行。等等，你好像看到了熟悉的东西。没错，那就是 include_modules_at 方法。在前一篇文章中，我们讨论了这个函数，它用来包含某个模块。你简直不敢相信自己的眼睛，明明是在前置模块，怎么突然又变成包含模块了？

是的，没错，它就是在包含模块。被包含的模块的祖先链插入到了 klass 和 klass 的原始类之间。由于 klass 内部的方法表已经转移到上游的原始类中，所以插入的位置正好合适。Ruby 通过这种变换，巧妙地将前置模块转化为包含模块，太棒了。

下面这个图描述了文章开头的那个例子中，类 C 中 prepend A, B 语句执行前后的状态：

　+-----+      +--------+
　　Before:  |  C  |----->| Object |
　　+-----+      +--------+
　　+--------------- klass ----------------+
　　|                                      |
　　v                                      |
　　+-----+      +-----+      +-----+      +-----+      +--------+
　　After:  |  C  |----->|  A  |----->|  B  |----->|  C' |+---->| Object |
　　+-----+      +-----+      +-----+      +-----+      +--------+
　　|                                      ^
　　|                                      |
　　+--------------- origin ---------------+

正如之前分析的那样，C' 就是那个新创建的包含类，它是 C 的原始类。但如果是这样的话，还是无法解释之前的疑问：为什么 C.ancestors 不是从类 C 开始？要搞清楚这个问题，我们来看看 C.ancestors 是如何工作的。

我们找到了 Module#ancestors 的源代码，它看起来比较简单：

VALUE
rb_mod_ancestors(VALUE mod)
{
VALUE p, ary = rb_ary_new();
for (p = mod; p; p = RCLASS_SUPER(p)) {
if (FL_TEST(p, FL_SINGLETON))
continue;
if (BUILTIN_TYPE(p) == T_ICLASS) {
rb_ary_push(ary, RBASIC(p)->klass);
}
else if (p == RCLASS_ORIGIN(p)) {
rb_ary_push(ary, p);
}
}
return ary;
}

该函数首先创建了一个数组，然后对遍历模块的祖先链，对每个祖先，如果是包含类或者原始类指向自身，就放在返回的数组里面。另外，它还会跳过单例类。

至此，之前的疑问也得到了解释，C.ancestors 并没有把 C 自身包含进去，因为它既不是包含类，也不是 origin 指向自身的类。而 C.ancestors 返回的数组中的 C 其实是 C 的原始类，同时也是 C 的包含类，所以它才有 C 这个名字。

模块前置其实也是通过模块包含来完成的，只不过在包含之前做了一些特殊处理：创建了一个原始类，然后在原始类之前包含模块。但由于原始类也是一个包含类，因此被前置模块的某个祖先可能会越过原始类，比如下面这个例子：

A = Module.new
module B
def bar; 'B' end
end
module C
include A, B
end
class D
include A
prepend C
def bar; 'D' end
end
D.new.bar # => 'D'

类 D 在前置模块 C 之前，包含了模块 A。下图中，前两个是 D 前置模块 C 之前，D 和 C 的祖先链，第三个是 D 前置模块 C 之后，D 的祖先链。

+---+    +---+    +--------+
　　| D |--->| A |--->| Object |
　　+---+    +---+    +--------+
　　+---+    +---+    +---+    +--------+
　　| C |--->| A |--->| B |--->| Object |
　　+---+    +---+    +---+    +--------+
　　|
　　+-----------------+  A 使得插入点移到了 D' 的后面
　　|
　　v
　　+---+    +---+    +---+    +---+    +---+    +--------+
　　| D |--->| C |--->| D'|--->| A |--->| B |+-->| Object |
　　+---+    +---+    +---+    +---+    +---+    +--------+

正如图中标注的那样，模块 A 的存在使得插入点移到了 D' 的后面，所以 B 位于 D' 的后面。所以 D.new.bar 的值是 'D' 而不是 'B'。

现在，我们理解了模块前置在 Ruby 内部是如何实现的。模块前置非常有用，只要明白了它是如何工作的，你一定能想到它的用武之地。

2770 次浏览