Rechercher tous les descendants d'une classe dans Ruby

Je peux facilement monter dans la hiérarchie des classes dans Ruby:

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

Existe-t-il également un moyen de descendre la hiérarchie? J'aimerais faire ça

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

mais il ne semble pas y avoir de descendantsméthode.

(Cette question se pose parce que je veux trouver tous les modèles dans une application Rails qui descendent d'une classe de base et les lister; j'ai un contrôleur qui peut fonctionner avec n'importe quel modèle de ce type et j'aimerais pouvoir ajouter de nouveaux modèles sans avoir à modifier le contrôleur.)

Voici un exemple:

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

met Parent.descendants vous donne:

GrandChild
Child

met Child.descendants vous donne:

GrandChild

Si vous utilisez Rails> = 3, vous avez deux options en place. À utiliser .descendantssi vous voulez plus d'un niveau de profondeur des classes enfants, ou à utiliser .subclassespour le premier niveau des classes enfants.

Exemple:

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 (ou 1.8.7) avec des itérateurs chaînés astucieux:

#!/usr/bin/env ruby1.9

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

Ruby pré-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

Utilisez-le comme ceci:

#!/usr/bin/env ruby

p Animal.descendants

Remplacez la méthode de classe nommée inherited . Cette méthode serait transmise à la sous-classe lors de sa création que vous pouvez suivre.

Alternativement (mis à jour pour ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Méthode compatible avec Ruby 1.8:

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

Notez que cela ne fonctionnera pas pour les modules. En outre, YourRootClass sera inclus dans la réponse. Vous pouvez utiliser Array # - ou un autre moyen de le supprimer.

Bien que l'utilisation d'ObjectSpace fonctionne, la méthode de classe héritée semble mieux convenir ici documentation Ruby héritée (sous-classe)

Objectspace est essentiellement un moyen d'accéder à tout et à tout ce qui utilise actuellement la mémoire allouée, donc itérer sur chacun de ses éléments pour vérifier s'il s'agit d'une sous-classe de la classe Animal n'est pas idéal.

Dans le code ci-dessous, la méthode héritée de la classe Animal implémente un rappel qui ajoutera toute sous-classe nouvellement créée à son tableau de descendants.

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

  def self.descendants
    puts @descendants 
  end
end

Je sais que vous demandez comment faire cela en héritage mais vous pouvez y parvenir directement dans Ruby en espaçant les noms de la classe ( Classou 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]

C'est beaucoup plus rapide de cette façon que de comparer à toutes les classes ObjectSpacecomme le proposent d'autres solutions.

Si vous en avez vraiment besoin dans un héritage, vous pouvez faire quelque chose comme ceci:

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 ici: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

mettre à jour

à la fin, tout ce que tu as à faire est ceci

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

merci @saturnflyer pour la suggestion

(Rails <= 3.0) Vous pouvez également utiliser ActiveSupport :: DescendantsTracker pour faire l'acte. De la source:

Ce module fournit une implémentation interne pour suivre les descendants qui est plus rapide que l'itération dans ObjectSpace.

Comme il est bien modulaire, vous pouvez simplement choisir ce module particulier pour votre application Ruby.

Ruby Facets a des descendants de classe #,

require 'facets/class/descendants'

Il prend également en charge un paramètre de distance générationnel.

Une version simple qui donne un tableau de tous les descendants d'une classe:

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

Vous pouvez require 'active_support/core_ext'et utilisez la descendantsméthode. Consultez le document et essayez-le en IRB ou en faisant levier. Peut être utilisé sans rails.

Rails fournit une méthode de sous-classes pour chaque objet, mais elle n'est pas bien documentée et je ne sais pas où elle est définie. Il renvoie un tableau de noms de classe sous forme de chaînes.

L'utilisation du gem descendants_tracker peut aider. L'exemple suivant est copié à partir de la documentation du gem:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Cette gemme est utilisée par la gemme virtus populaire , donc je pense qu'elle est assez solide.

Cette méthode retournera un hachage multidimensionnel de tous les descendants d'un Object.

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

{ MasterClass => descendants_mapper(MasterClass) }

Si vous avez accès au code avant le chargement d'une sous-classe, vous pouvez utiliser la méthode héritée .

Si vous ne le faites pas (ce qui n'est pas un cas mais cela pourrait être utile pour quiconque a trouvé ce message), vous pouvez simplement écrire:

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

Désolé si j'ai manqué la syntaxe mais l'idée doit être claire (je n'ai pas accès à ruby ​​pour le moment).