From: "Student (Nathan Zook)" <blogger@...>
Date: 2013-03-11T02:08:06+09:00
Subject: [ruby-core:53292] [ruby-trunk - Bug #8066] Inconsistency in ancestors chain


Issue #8066 has been updated by Student (Nathan Zook).


This is the behaviour I would expect in all versions of Ruby.  The ancestor chain is set at the time that a class is created, and is updated at the time that a module is included in that class.  What does not happen is that the chain for a class is recomputed when a module is included in an ancestor of the class.

So:

module N ; end
class C ; include N ; end
module M ; end
N.send :include, M
N.ancestors
=> [N, M]
C.ancestors
=> [C, N, Object, Kernel, BasicObject]

Your example is the natural result of this behaviour.  Note, however, that reincluding a module will pick up its current includes:
C.send :include, N
C.ancestors
=> [C, N, M, Object, Kernel, BasicObject]


----------------------------------------
Bug #8066: Inconsistency in ancestors chain
https://bugs.ruby-lang.org/issues/8066#change-37473

Author: prijutme4ty (Ilya Vorontsov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 
ruby -v: 1.9.3p0, 2.0.0p0


Method including have some inconsistencies. Let's define module and include(or prepend) and then include it in classes in different order.

module M; end
Class.send :include, M
Module.send :include, M
Class.ancestors
# => [Class, M, Module, M, Object, Kernel, BasicObject]

module M; end
Module.send :include, M
Class.send :include, M
Class.ancestors
# => [Class, Module, M, Object, Kernel, BasicObject]

We see that ancestor chains are different. Is it a spec(i didn't find it in tests) or a bug?


-- 
http://bugs.ruby-lang.org/