W tym moduł w innym module

Question

module A; def a; end; end 
module B; def b; end; end 

class C; include A; end 

module A; include B; end 
class D; include A; end 

C.new.b # undefined method error 
D.new.b # nil 

C.ancestors # [C, A, Object...] 
D.ancestors # [D, A, B, Object...] 

Jak dołączyć moduł B do wnętrza A, aby klasy, które zawierają już moduł A, otrzymają również metody z modułu B?

Answer 1

Nie możesz.

Kiedy include wstawką M do klasy C, Ruby tworzy nową klasę ⟦M′⟧ którego metoda tabela wskazuje na stole Sposób wstawek M i którego nadklasą jest nadklasą C, to sprawia, że ​​tej klasy nowy nadklasą C. Powtarza się to dla każdego miksu, który został zmieszany z M.

Należy zauważyć, że ten algorytm jest uruchamiany tylko raz, po połączeniu M z C. Moduły, które później uzyskają include, nie zostaną uwzględnione.

Answer 2

Powinieneś zawrzeć B w A przed klasa C; włącz A; koniec.

module A; def a; end; end 
module B; def b; end; end 


module A; include B; end 

class C; include A; end 
class D; include A; end 

p C.new.b # nil 
p D.new.b # nil 

p C.ancestors # [C, A, B, Object, Kernel, BasicObject] 
p D.ancestors # [D, A, B, Object, Kernel, BasicObject] 

Edit

module A; def a; end; end 
module B; def b; end; end 

class C; include A; end 

module A; include B; end 
class D; include A; end 

C.send(:include, A) 

p C.new.b # nil 
p D.new.b # nil 

p C.ancestors # [C, A, Object...] 
p D.ancestors # [D, A, B, Object...] 

Answer 3

Jak już powiedziano, Ruby nie działa w ten sposób - gdy klasa zawiera moduł, nie ma żadnego odniesienia do instancji tego modułu, więc jeśli moduł zawiera inne moduły, klasy, które mają już uwzględnione nie będzie wiedzieć o zmianie.

Można obejść ten problem poprzez przechowywanie klas, które zawierają moduł w samym module - w ten sposób można aktualizować je, gdy moduł zawiera inny moduł, czyli mniej więcej tak:

module A 

    class<<self 
    attr_accessor :observers 
    end 

    self.observers = [] 

    def a 
    "#{self} successfully called a" 
    end 

    def self.included(base) 
    self.observers << base unless self.observers.include?(base) 
    end 

    def self.include(mod) 
    observers.each {|o| o.send(:include,mod) } 
    super 
    end 

end 

module B 
    def b 
    "#{self} successfully called b" 
    end 
end 

class C 
    include A 
end 

module A 
    include B 
end 

class D 
    include A 
end 

module E 
    def e 
    "#{self} successfully called e" 
    end 
end 

module A 
    include E 
end 

puts C.new.b 
puts D.new.b 
puts C.new.e 
puts D.new.e 

Nie wiesz to jest kierunkiem, który chcesz wybrać, ale pokazuje, że można to zrobić w zasadzie.