Bug #8066

Inconsistency in ancestors chain

Added by Ilya Vorontsov over 2 years ago. Updated over 2 years ago.

ruby -v:1.9.3p0, 2.0.0p0 Backport:


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, M, Module, M, Object, Kernel, BasicObject]

module M; end
Module.send :include, M
Class.send :include, M

=> [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?

Related issues

Duplicates Ruby trunk - Feature #1586: Including a module already present in ancestors should not be ignored Assigned 06/07/2009


#1 Updated by Nathan Zook over 2 years ago

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.


module N ; end
class C ; include N ; end
module M ; end
N.send :include, M
=> [N, M]
=> [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, N, M, Object, Kernel, BasicObject]

#2 Updated by Ilya Vorontsov over 2 years ago

Isn't it just a conseqency of the fact that module can't be included twice and because of that including a module in parent class prevents including module into a child class.
This behavior disallows for example creating decorators by prepending named modules.

Also available in: Atom PDF