[ruby-core:83903] [Ruby trunk Feature#1586] Including a module already present in ancestors should not be ignored

Issue #1586 has been updated by marcandre (Marc-Andre Lafortune).



matz (Yukihiro Matsumoto) wrote:
> So I think this change is good but we need to make it in proper timing.

mame (Yusuke Endoh) wrote:
> When is proper time?  Ruby 3.0? :-)

As soon as Nobu can code it?

I'll note that we can already `prepend` a module more than once:

```
Base = Class.new
Foo = Class.new(Base)
M = Module.new; N = M.dup
Base.prepend M; Base.include N
Foo.prepend M; Foo.include N
Foo.ancestors # => [M, Foo, M, Base, N, Object, Kernel, BasicObject] 
```

----------------------------------------
Feature #1586: Including a module already present in ancestors should not be ignored
https://bugs.ruby-lang.org/issues/1586#change-67953

* Author: bitsweat (Jeremy Daer)
* Status: Assigned
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: Next Major
----------------------------------------
=begin
 The scenario:
 * I include Foo in Numeric to provide #bar
 * Some other library includes a module in Float to provide #bar
 * So I include Foo in Float to use my #bar
 * But including Foo in Float is ignored since it's already in the ancestor chain
 
 I think it should be added to the ancestor chain, even if it's already present, since I may want to override some other method earlier in the ancestor chain.
 
 # Including a module already included in a superclass is ignored
 >> module Foo; end
 => nil
 >> class Numeric; include Foo; end
 => Numeric
 >> Float.ancestors
 => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel]
 >> class Float; include Foo; end
 => Float
 >> Float.ancestors
 => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel]
  
 # Reversing the order of inclusion works as expected
 >> module Foo; end
 => nil
 >> class Float; include Foo; end
 => Float
 >> Float.ancestors
 => [Float, Foo, Precision, Numeric, Comparable, Object, Kernel]
 >> class Numeric; include Foo; end
 => Numeric
 >> Float.ancestors
 => [Float, Foo, Precision, Numeric, Foo, Comparable, Object, Kernel]
  
 # And so does including a dupe of the existing module in the subclass
 >> module Foo; end
 => nil
 >> class Numeric; include Foo; end
 => Numeric
 >> Float.ancestors
 => [Float, Precision, Numeric, Foo, Comparable, Object, Kernel]
 >> class Float; include Foo.dup; end
 => Float
 >> Float.ancestors
 => [Float, #<Module:0x19bcd40>, Precision, Numeric, Foo, Comparable, Object, Kernel]
=end


---Files--------------------------------
inclusion.pdf (56.4 KB)


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

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>