Bug #9573 » include-future-ancestors-9573.patch
class.c | ||
---|---|---|
changed = include_modules_at(klass, RCLASS_ORIGIN(klass), module, TRUE);
|
||
if (changed < 0)
|
||
rb_raise(rb_eArgError, "cyclic include detected");
|
||
if (RB_TYPE_P(klass, T_MODULE)) {
|
||
rb_subclass_entry_t *iclass = RCLASS_EXT(klass)->subclasses;
|
||
int do_include = 1;
|
||
while (iclass) {
|
||
VALUE check_class = iclass->klass;
|
||
while (check_class) {
|
||
if (RB_TYPE_P(check_class, T_ICLASS) &&
|
||
(RBASIC(check_class)->klass == module)) {
|
||
do_include = 0;
|
||
}
|
||
check_class = RCLASS_SUPER(check_class);
|
||
}
|
||
if (do_include) {
|
||
include_modules_at(iclass->klass, RCLASS_ORIGIN(iclass->klass), module, TRUE);
|
||
}
|
||
iclass = iclass->next;
|
||
}
|
||
}
|
||
}
|
||
static enum rb_id_table_iterator_result
|
test/ruby/test_module.rb | ||
---|---|---|
assert_raise(ArgumentError) { Module.new { include } }
|
||
end
|
||
def test_include_into_module_already_included
|
||
c = Class.new{def foo; [:c] end}
|
||
modules = lambda do ||
|
||
sub = Class.new(c){def foo; [:sc] + super end}
|
||
[
|
||
Module.new{def foo; [:m1] + super end},
|
||
Module.new{def foo; [:m2] + super end},
|
||
Module.new{def foo; [:m3] + super end},
|
||
sub,
|
||
sub.new
|
||
]
|
||
end
|
||
m1, m2, m3, sc, o = modules.call
|
||
assert_equal([:sc, :c], o.foo)
|
||
sc.include m1
|
||
assert_equal([:sc, :m1, :c], o.foo)
|
||
m1.include m2
|
||
assert_equal([:sc, :m1, :m2, :c], o.foo)
|
||
m2.include m3
|
||
assert_equal([:sc, :m1, :m2, :m3, :c], o.foo)
|
||
m1, m2, m3, sc, o = modules.call
|
||
sc.prepend m1
|
||
assert_equal([:m1, :sc, :c], o.foo)
|
||
m1.include m2
|
||
assert_equal([:m1, :m2, :sc, :c], o.foo)
|
||
m2.include m3
|
||
assert_equal([:m1, :m2, :m3, :sc, :c], o.foo)
|
||
m1, m2, m3, sc, o = modules.call
|
||
sc.include m2
|
||
assert_equal([:sc, :m2, :c], o.foo)
|
||
sc.prepend m1
|
||
assert_equal([:m1, :sc, :m2, :c], o.foo)
|
||
m1.include m2
|
||
assert_equal([:m1, :sc, :m2, :c], o.foo)
|
||
m1.include m3
|
||
assert_equal([:m1, :m3, :sc, :m2, :c], o.foo)
|
||
m1, m2, m3, sc, o = modules.call
|
||
sc.include m3
|
||
sc.include m2
|
||
assert_equal([:sc, :m2, :m3, :c], o.foo)
|
||
sc.prepend m1
|
||
assert_equal([:m1, :sc, :m2, :m3, :c], o.foo)
|
||
m1.include m2
|
||
m1.include m3
|
||
assert_equal([:m1, :sc, :m2, :m3, :c], o.foo)
|
||
end
|
||
def test_included_modules
|
||
assert_equal([], Mixin.included_modules)
|
||
assert_equal([Mixin], User.included_modules)
|