Buscar todos los descendientes de una clase en Ruby

Puedo ascender fácilmente la jerarquía de clases en Ruby:

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

¿Hay alguna manera de descender la jerarquía también? Me gustaria hacer esto

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

Pero no parece haber un descendantsmétodo.

(Esta pregunta surge porque quiero encontrar todos los modelos en una aplicación Rails que descienden de una clase base y enumerarlos; tengo un controlador que puede funcionar con cualquier modelo y me gustaría poder agregar nuevos modelos sin tener que modificar el controlador.)

Aquí hay un ejemplo:

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

pone Parent.descendants te da:

GrandChild
Child

pone Child.descendants te da:

GrandChild

Si usa Rails> = 3, tiene dos opciones en su lugar. Úselo .descendantssi desea más de un nivel de profundidad de clases para niños, o úselo .subclassespara el primer nivel de clases para niños.

Ejemplo:

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 (o 1.8.7) con ingeniosos iteradores encadenados:

#!/usr/bin/env ruby1.9

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

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

Úselo así:

#!/usr/bin/env ruby

p Animal.descendants

Reemplazar el método de clase denominado heredado . Este método pasaría a la subclase cuando se crea, lo que puede rastrear.

Alternativamente (actualizado para ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Forma compatible con Ruby 1.8:

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

Tenga en cuenta que esto no funcionará para los módulos. Además, YourRootClass se incluirá en la respuesta. Puede usar Array # u otra forma de eliminarlo.

Aunque el uso de ObjectSpace funciona, el método de clase heredado parece ser más adecuado aquí heredado (subclase) documentación de Ruby

El espacio de objetos es esencialmente una forma de acceder a cualquier cosa y a todo lo que actualmente usa memoria asignada, por lo que iterar sobre cada uno de sus elementos para verificar si es una subclase de la clase Animal no es ideal.

En el siguiente código, el método de clase Animal heredado implementa una devolución de llamada que agregará cualquier subclase recién creada a su matriz de descendientes.

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

  def self.descendants
    puts @descendants 
  end
end

Sé que está preguntando cómo hacer esto en herencia, pero puede lograr esto directamente en Ruby espaciando el nombre de la clase ( Classo 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]

De esta manera, es mucho más rápido que compararlo con cada clase ObjectSpacecomo lo proponen otras soluciones.

Si realmente necesita esto en una herencia, puede hacer algo como esto:

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

puntos de referencia aquí: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

actualizar

al final todo lo que tienes que hacer es esto

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

gracias @saturnflyer por su sugerencia

(Rails <= 3.0) Alternativamente, podría usar ActiveSupport :: DescendantsTracker para hacer la escritura. De la fuente:

Este módulo proporciona una implementación interna para rastrear descendientes que es más rápido que iterar a través de ObjectSpace.

Dado que está bien modularizado, puede simplemente 'seleccionar' ese módulo en particular para su aplicación Ruby.

Ruby Facets tiene descendientes de clase #,

require 'facets/class/descendants'

También es compatible con un parámetro de distancia generacional.

Una versión simple que proporciona una matriz de todos los descendientes de una clase:

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

Puedes require 'active_support/core_ext'y usar el descendantsmétodo. Mira el documento y pruébalo en IRB o en palanca. Se puede usar sin rieles.

Rails proporciona un método de subclases para cada objeto, pero no está bien documentado y no sé dónde está definido. Devuelve una matriz de nombres de clase como cadenas.

Usar descendants_tracker gem puede ayudar. El siguiente ejemplo se copia del documento de la gema:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Esta gema es utilizada por la popular joya virtus , así que creo que es bastante sólida.

Este método devolverá un hash multidimensional de todos los descendientes de un Objeto.

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

{ MasterClass => descendants_mapper(MasterClass) }

Si tiene acceso al código antes de cargar cualquier subclase, puede usar el método heredado .

Si no lo hace (lo cual no es un caso, pero podría ser útil para cualquiera que haya encontrado esta publicación), simplemente puede escribir:

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

Lo siento si me perdí la sintaxis, pero la idea debería ser clara (no tengo acceso a Ruby en este momento).