Wyszukaj wszystkich potomków klasy w języku Ruby

Mogę łatwo wspiąć się po hierarchii klas w Rubim:

String.ancestors     # [String, Enumerable, Comparable, Object, Kernel]
Enumerable.ancestors # [Enumerable]
Comparable.ancestors # [Comparable]
Object.ancestors     # [Object, Kernel]
Kernel.ancestors     # [Kernel]

Czy jest jakiś sposób na zejście również z hierarchii? Chciałbym to zrobić

Animal.descendants      # [Dog, Cat, Human, ...]
Dog.descendants         # [Labrador, GreatDane, Airedale, ...]
Enumerable.descendants  # [String, Array, ...]

ale wydaje się, że nie ma descendantsmetody.

(To pytanie pojawia się, ponieważ chcę znaleźć wszystkie modele w aplikacji Railsów, które pochodzą z klasy bazowej i je wyświetlić; Mam kontroler, który może pracować z każdym takim modelem i chciałbym móc dodawać nowe modele bez konieczności modyfikowania kontrolera.)

Oto przykład:

class Parent
  def self.descendants
    ObjectSpace.each_object(Class).select { |klass| klass < self }
  end
end

class Child < Parent
end

class GrandChild < Child
end

puts Parent.descendants
puts Child.descendants

umieszcza Parent.descendants daje:

GrandChild
Child

stawia Child.descendants daje:

GrandChild

Jeśli używasz Rails> = 3, masz dwie opcje. Użyj, .descendantsjeśli chcesz mieć więcej niż jeden poziom głębokości klas podrzędnych lub użyj.subclasses podrzędnych dla pierwszego poziomu klas podrzędnych.

Przykład:

class Animal
end

class Mammal < Animal
end

class Dog < Mammal
end

class Fish < Animal
end

Animal.subclasses #=> [Mammal, Fish] 
Animal.descendants  #=> [Dog, Mammal, Fish]

Ruby 1.9 (lub 1.8.7) ze sprytnymi iteratorami łańcuchowymi:

#!/usr/bin/env ruby1.9

class Class
  def descendants
    ObjectSpace.each_object(::Class).select {|klass| klass < self }
  end
end

Ruby przed 1.8.7:

#!/usr/bin/env ruby

class Class
  def descendants
    result = []
    ObjectSpace.each_object(::Class) {|klass| result << klass if klass < self }
    result
  end
end

Użyj go w ten sposób:

#!/usr/bin/env ruby

p Animal.descendants

Zastąp metodę klasy o nazwie inherited . Ta metoda zostanie przekazana do podklasy podczas jej tworzenia, którą można śledzić.

Alternatywnie (aktualizacja dla Ruby 1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Zgodność z Ruby 1.8:

ObjectSpace.each_object(class<<YourRootClass;self;end)

Pamiętaj, że to nie zadziała dla modułów. W odpowiedzi znajdzie się również YourRootClass. Możesz użyć Array # - lub innego sposobu, aby go usunąć.

Chociaż używanie ObjectSpace działa, dziedziczona metoda klasy wydaje się być lepsza tutaj dziedziczona (podklasa) dokumentacja Rubiego

Przestrzeń obiektów to zasadniczo sposób na uzyskanie dostępu do czegokolwiek i wszystkiego, co aktualnie używa przydzielonej pamięci, więc iterowanie po każdym pojedynczym elemencie w celu sprawdzenia, czy jest to podklasa klasy Animal, nie jest idealne.

W poniższym kodzie odziedziczona metoda klasy Animal implementuje wywołanie zwrotne, które doda każdą nowo utworzoną podklasę do swojej tablicy potomków.

class Animal
  def self.inherited(subclass)
    @descendants = []
    @descendants << subclass
  end

  def self.descendants
    puts @descendants 
  end
end

Wiem, że pytasz, jak to zrobić w dziedziczeniu, ale możesz to osiągnąć bezpośrednio w Rubim, oddzielając klasę ( Classlub Module)

module DarthVader
  module DarkForce
  end

  BlowUpDeathStar = Class.new(StandardError)

  class Luck
  end

  class Lea
  end
end

DarthVader.constants  # => [:DarkForce, :BlowUpDeathStar, :Luck, :Lea]

DarthVader
  .constants
  .map { |class_symbol| DarthVader.const_get(class_symbol) }
  .select { |c| !c.ancestors.include?(StandardError) && c.class != Module }
  # => [DarthVader::Luck, DarthVader::Lea]

W ten sposób jest znacznie szybszy niż w przypadku innych klas w ObjectSpace podobnie jak inne rozwiązania.

Jeśli naprawdę potrzebujesz tego w spadku, możesz zrobić coś takiego:

class DarthVader
  def self.descendants
    DarthVader
      .constants
      .map { |class_symbol| DarthVader.const_get(class_symbol) }
  end

  class Luck < DarthVader
    # ...
  end

  class Lea < DarthVader
    # ...
  end

  def force
    'May the Force be with you'
  end
end

testy porównawcze tutaj: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

aktualizacja

w końcu wszystko, co musisz zrobić, to to

class DarthVader
  def self.inherited(klass)
    @descendants ||= []
    @descendants << klass
  end

  def self.descendants
    @descendants || []
  end
end

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

dziękuję @saturnflyer za sugestie

(Rails <= 3.0) Alternatywnie możesz użyć ActiveSupport :: DescendantsTracker do zrobienia tego. Ze źródła:

Ten moduł zapewnia wewnętrzną implementację do śledzenia potomków, która jest szybsza niż iteracja przez ObjectSpace.

Ponieważ jest ładnie modularyzowany, możesz po prostu wybrać ten konkretny moduł dla swojej aplikacji Ruby.

Aspekty Ruby mają potomków klasy #,

require 'facets/class/descendants'

Obsługuje również parametr odległości pokoleniowej.

Prosta wersja, która podaje tablicę wszystkich potomków klasy:

def descendants(klass)
  all_classes = klass.subclasses
  (all_classes + all_classes.map { |c| descendants(c) }.reject(&:empty?)).flatten
end

Możesz require 'active_support/core_ext'i użyj descendantsmetody. Sprawdź dokument i wypróbuj go w IRB lub podważ. Może być używany bez szyn.

Railsy zapewniają metodę podklas dla każdego obiektu, ale nie jest ona dobrze udokumentowana i nie wiem, gdzie jest zdefiniowana. Zwraca tablicę nazw klas jako ciągi.

Pomocne może być użycie klejnotu descendants_tracker . Poniższy przykład został skopiowany z dokumentu klejnotu:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Ten klejnot jest używany przez popularny klejnot virtus , więc myślę, że jest całkiem solidny.

Ta metoda zwróci wielowymiarowy skrót wszystkich potomków Object.

def descendants_mapper(klass)
  klass.subclasses.reduce({}){ |memo, subclass|
    memo[subclass] = descendants_mapper(subclass); memo
  }
end

{ MasterClass => descendants_mapper(MasterClass) }

Jeśli masz dostęp do kodu przed załadowaniem jakiejkolwiek podklasy, możesz użyć metody dziedziczonej .

Jeśli nie (co nie jest przypadkiem, ale może się przydać każdemu, kto znalazł ten post), możesz po prostu napisać:

x = {}
ObjectSpace.each_object(Class) do |klass|
     x[klass.superclass] ||= []
     x[klass.superclass].push klass
end
x[String]

Przepraszam, jeśli przegapiłem składnię, ale pomysł powinien być jasny (w tej chwili nie mam dostępu do ruby).