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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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 中前置了模块 AB,这样 AB 就插入到 C 的祖先链中了。从 21 和 22 行中的注释中,我们可以看到,在 C 的祖先链中,AB 位于 C 之前。而在 D 的祖先链中,AB 位于 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 函数做了什么。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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 获取 klassorigin 成员,并且把它和 klass 比较。我们不知道 origin 字段有什么作用,我们先假设测试条件为真,即 klassorigin 成员指向自身。我们来分析一下 if 语句中的逻辑:

  1. 19 行为 klass 创建了一个新的包含类,我们把它称为原始类;
  2. 20 ~ 21 行把新创建的包含类插入到 klassklass 的父类中间;
  3. 22 行将 klassorigin 成员指向了新类;
  4. 接下来,23 ~ 24 行把 klass 的方法表转移到新类中,并清空 klass 的方法表;
  5. 最后,25 行又把 klass 原先的方法表中的 Refined 方法移了回来。

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

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

下面这个图描述了文章开头的那个例子中,类 Cprepend 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 之前,DC 的祖先链,第三个是 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 内部是如何实现的。模块前置非常有用,只要明白了它是如何工作的,你一定能想到它的用武之地。