manejo - Busca a todos los descendientes de una clase en Ruby

objetos y clases en ruby

Question

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 forma de descender también de la jerarquía? Me gustaría hacer esto

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

pero no parece haber un método de descendants .

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

Answer 1

(Rails <= 3.0) Alternativamente, podría usar ActiveSupport :: DescendantsTracker para realizar 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 se modulariza muy bien, puede simplemente ''seleccionar'' ese módulo en particular para su aplicación Ruby.

Answer 2

Alternativamente (actualizado para ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Manera 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.

Answer 3

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

Answer 4

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

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

En el siguiente código, el método heredado de clase Animal 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

Answer 5

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) }

Answer 6

Puede require ''active_support/core_ext'' y usar el método de descendants . Mira el documento y pruébalo en IRB o haz palanca. Se puede usar sin rieles.

Answer 7

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.

Answer 8

Reemplaza el método de clase llamado inherited . A este método se le pasará la subclase cuando se crea y se puede seguir.

Answer 9

Ruby Facets tiene descendientes de clase #,

require ''facets/class/descendants''

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

Answer 10

Sé que estás preguntando cómo hacer esto en herencia, pero puedes lograrlo directamente en Ruby separando los nombres de la clase ( Class o 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]

Es mucho más rápido de esta manera que la comparación con todas las clases en ObjectSpace como 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 sugerencia

Answer 11

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

Si no lo hace (que no es un caso pero puede ser útil para cualquier persona que encuentre esta publicación) 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).

Answer 12

Si usa Rails> = 3, tiene dos opciones en su lugar. Utilice apidock.com/rails/Class/descendants si desea más de una profundidad de nivel de clases de niños, o use .subclasses para el primer nivel de clases de 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]

Answer 13

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

Answer 14

Usar la gema descenddants_tracker puede ayudar. El siguiente ejemplo se copia del documento de la joya:

class Foo
extend DescendantsTracker
end
class Bar < Foo
end
Foo.descendants # => [Bar]

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

Answer 15

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