Suchen Sie in Ruby nach allen Nachkommen einer Klasse

Ich kann die Klassenhierarchie in Ruby leicht aufsteigen lassen:

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

Gibt es eine Möglichkeit, die Hierarchie ebenfalls abzusteigen? Ich würde das gerne machen

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

aber es scheint keine descendantsMethode zu geben.

(Diese Frage wird gestellt, weil ich alle Modelle in einer Rails-Anwendung finden möchte, die von einer Basisklasse abstammen, und sie auflisten möchte. Ich habe einen Controller, der mit jedem solchen Modell arbeiten kann, und ich möchte neue Modelle hinzufügen können ohne den Controller ändern zu müssen.)

Hier ist ein Beispiel:

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

setzt Parent.descendants gibt Ihnen:

GrandChild
Child

setzt Child.descendants gibt Ihnen:

GrandChild

Wenn Sie Rails> = 3 verwenden, haben Sie zwei Möglichkeiten. Verwenden .descendantsSie diese Option, wenn Sie mehr als eine Ebenentiefe für untergeordnete Klassen oder .subclassesfür die erste Ebene von untergeordneten Klassen verwenden möchten .

Beispiel:

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 (oder 1.8.7) mit raffinierten verketteten Iteratoren:

#!/usr/bin/env ruby1.9

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

Ruby vor 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

Verwenden Sie es so:

#!/usr/bin/env ruby

p Animal.descendants

Überschreiben Sie die Klassenmethode mit dem Namen geerbt . Diese Methode wird beim Erstellen der Unterklasse übergeben, die Sie verfolgen können.

Alternativ (aktualisiert für Ruby 1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Ruby 1.8 kompatibler Weg:

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

Beachten Sie, dass dies für Module nicht funktioniert. Außerdem wird YourRootClass in die Antwort aufgenommen. Sie können Array # - oder eine andere Methode zum Entfernen verwenden.

Obwohl die Verwendung von ObjectSpace funktioniert, scheint die geerbte Klassenmethode hier besser für die geerbte Ruby-Dokumentation (Unterklasse) geeignet zu sein

Objectspace ist im Wesentlichen eine Möglichkeit, auf alles zuzugreifen, was derzeit den zugewiesenen Speicher verwendet. Daher ist es nicht ideal, jedes einzelne seiner Elemente zu durchlaufen, um zu überprüfen, ob es sich um eine Unterklasse der Animal-Klasse handelt.

Im folgenden Code implementiert die geerbte Animal-Klassenmethode einen Rückruf, der alle neu erstellten Unterklassen zu ihrem Nachkommen-Array hinzufügt.

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

  def self.descendants
    puts @descendants 
  end
end

Ich weiß, dass Sie fragen, wie dies bei der Vererbung zu tun ist, aber Sie können dies direkt in Ruby erreichen, indem Sie die Klasse ( Classoder Module) mit einem Namensabstand versehen.

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]

Auf diese Weise ist es viel schneller als im Vergleich zu jeder Klasse in ObjectSpace wie es andere Lösungen vorschlagen.

Wenn Sie dies in einer Erbschaft ernsthaft benötigen, können Sie Folgendes tun:

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

Benchmarks hier: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

aktualisieren

Am Ende müssen Sie nur noch Folgendes tun

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

danke @saturnflyer für den vorschlag

(Rails <= 3.0) Alternativ können Sie ActiveSupport :: DescendantsTracker verwenden, um die Tat auszuführen. Aus der Quelle:

Dieses Modul bietet eine interne Implementierung zum Verfolgen von Nachkommen, die schneller ist als das Durchlaufen von ObjectSpace.

Da es gut modularisiert ist, können Sie einfach das jeweilige Modul für Ihre Ruby-App auswählen.

Ruby Facets hat Nachkommen der Klasse #,

require 'facets/class/descendants'

Es unterstützt auch einen Generationsabstandsparameter.

Eine einfache Version, die ein Array aller Nachkommen einer Klasse enthält:

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

Sie können require 'active_support/core_ext'und verwenden die descendantsMethode. Schauen Sie sich das Dokument an und probieren Sie es in IRB oder Pry aus. Kann ohne Schienen verwendet werden.

Rails bietet für jedes Objekt eine Unterklassenmethode, die jedoch nicht gut dokumentiert ist, und ich weiß nicht, wo sie definiert ist. Es gibt ein Array von Klassennamen als Zeichenfolgen zurück.

Die Verwendung von descants_tracker gem kann helfen. Das folgende Beispiel wurde aus dem Dokument des Edelsteins kopiert:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Dieser Edelstein wird von dem beliebten Virtus-Edelstein verwendet , daher finde ich ihn ziemlich solide.

Diese Methode gibt einen mehrdimensionalen Hash aller Nachkommen eines Objekts zurück.

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

{ MasterClass => descendants_mapper(MasterClass) }

Wenn Sie Zugriff auf Code haben, bevor eine Unterklasse geladen wird, können Sie geerbt verwenden Methode verwenden.

Wenn Sie dies nicht tun (was kein Fall ist, aber für jeden, der diesen Beitrag gefunden hat, nützlich sein könnte), können Sie einfach schreiben:

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

Es tut mir leid, wenn ich die Syntax verpasst habe, aber die Idee sollte klar sein (ich habe momentan keinen Zugriff auf Ruby).