Zastąp metoda moduł z innego modułu

Question

Chcę przesłonić metodę z modułu A z innego modułu B, która będzie małpa-Patch A.
http://codepad.org/LPMCuszt

module A 
    def foo; puts 'A' end 
end 

module B 
    def foo; puts 'B'; super; end 
end 

A.module_eval { include B } # why no override ??? 

class C 
    include A 
end 

# must print 'A B', but only prints 'A' :(
C.new.foo 

Answer 1

module A 
    def foo 
    puts 'A' 
    end 
end 

module B 
    def foo 
    puts 'B' 
    super 
    end 
end 

include A # you need to include module A befor you can override method 

A.module_eval { include B } 

class C 
    include A 
end 

C.new.foo # => B A 

Answer 2

tym module umieszcza go powyżej moduł/klasa, która jest uwzględniana w hierarchii klas. Innymi słowy, A # foo nie jest super od B # foo, ale raczej odwrotnie.

Jeśli myślisz o włączeniu modułu jako sposobie dziedziczenia wielokrotnego, ma to sens, include SomeModule to sposób na powiedzenie: "Traktuj SomeModule tak, jakby to była dla mnie klasa rodzicielska".

Aby uzyskać wyjście chciałeś trzeba odwrócić włączenia tak że B zawiera:

module A 
    def foo; puts 'A' end 
end 

module B 
    def foo; puts 'B'; super; end 
end 

B.module_eval { include A } # Reversing the inclusion 

class C 
    include B # not include A 
end 

puts C.new.foo 

---

Edytowanie w odpowiedzi na komentarz:

wówczas obejmować zarówno A i B C z B zawarta po A:

# A and B as before without including B in A. 

class C 
    include A 
    include B 
end 

lub łatka A w C i nie przejmuj się B.

# A as before, no B. 

class C 
    include A 

    def foo; puts 'B'; super; end 
end 

Jedynym sposobem pracy jest to, że w sposób odnośników C oznacza grupę -> B -> A i nie ma sposobu, aby to zrobić bez włączenia B do C

Answer 3

Innym sposobem w tym celu należy uwzględnić moduł B, gdy moduł A jest zawarty.

module A 
    def foo 
    puts "this should never be called!" 
    "a" 
    end 
end 

module B 
    def foo 
    "b" 
    end 
end 

module A 
    def self.included(base) 
    base.class_eval do 
     include B 
    end 
    end 
end 

class C 
    include A 
end 

C.new.foo # "b"