Procure todos os descendentes de uma classe em Ruby

Eu posso facilmente subir a hierarquia de classes no Ruby:

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

Existe alguma maneira de descer a hierarquia também? Eu gostaria de fazer isso

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

mas não parece haver um descendantsmétodo.

(Essa pergunta surge porque eu quero encontrar todos os modelos em um aplicativo Rails que descendem de uma classe base e listá-los; eu tenho um controlador que pode trabalhar com qualquer modelo e gostaria de poder adicionar novos modelos sem precisar modificar o controlador.)

Aqui está um exemplo:

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

coloca Parent.descendants fornece:

GrandChild
Child

coloca Child.descendants fornece:

GrandChild

Se você usa Rails> = 3, você tem duas opções. Use .descendantsse você desejar mais de um nível de profundidade de classes para crianças ou use .subclassespara o primeiro nível de classes para crianças.

Exemplo:

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) com iteradores encadeados bacanas:

#!/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

Use-o assim:

#!/usr/bin/env ruby

p Animal.descendants

Substitua o método de classe chamado herdado . Esse método receberia a subclasse quando criada, que você pode rastrear.

Como alternativa (atualizado para o ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Maneira compatível com Ruby 1.8:

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

Observe que isso não funcionará para módulos. Além disso, YourRootClass será incluído na resposta. Você pode usar a Matriz # - ou outra maneira de removê-la.

Embora o uso do ObjectSpace funcione, o método da classe herdada parece ser mais adequado aqui na documentação Ruby herdada (subclasse)

O espaço de objetos é essencialmente uma maneira de acessar tudo e qualquer coisa que esteja usando atualmente a memória alocada, portanto, a iteração sobre cada um de seus elementos para verificar se é uma sublassa da classe Animal não é o ideal.

No código abaixo, o método herdado da classe Animal implementa um retorno de chamada que adicionará qualquer subclasse recém-criada à sua matriz descendente.

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

  def self.descendants
    puts @descendants 
  end
end

Eu sei que você está perguntando como fazer isso na herança, mas você pode conseguir isso diretamente no Ruby espaçando o nome da 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]

É muito mais rápido dessa maneira do que comparar com todas as classes, ObjectSpacecomo as outras soluções propostas.

Se você realmente precisa disso em uma herança, pode fazer algo assim:

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

referências aqui: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

atualizar

no final, tudo o que você precisa fazer é isso

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

obrigado @saturnflyer pela sugestão

(Rails <= 3.0) Como alternativa, você pode usar o ActiveSupport :: DescendantsTracker para executar a ação. Da fonte:

Este módulo fornece uma implementação interna para rastrear descendentes mais rapidamente do que a iteração no ObjectSpace.

Como ele é modularizado de maneira adequada, você pode simplesmente 'escolher' esse módulo específico para o seu aplicativo Ruby.

O Ruby Facets possui descendentes da classe #,

require 'facets/class/descendants'

Ele também suporta um parâmetro de distância geracional.

Uma versão simples que fornece uma matriz de todos os descendentes de uma classe:

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

Você pode require 'active_support/core_ext'e usar o descendantsmétodo Confira o documento e experimente IRB ou alavanca. Pode ser usado sem Rails.

O Rails fornece um método de subclasses para cada objeto, mas não está bem documentado e não sei onde está definido. Retorna uma matriz de nomes de classe como seqüências de caracteres.

O uso da gema descendants_tracker pode ajudar. O exemplo a seguir é copiado do documento da gema:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Esta gema é usada pela joia virtus popular , então acho que é bastante sólida.

Este método retornará um hash multidimensional de todos os descendentes de um objeto.

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

{ MasterClass => descendants_mapper(MasterClass) }

Se você tiver acesso ao código antes do carregamento de qualquer subclasse, poderá usar o método herdado .

Caso contrário (o que não é um caso, mas pode ser útil para quem encontrou este post), basta escrever:

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

Desculpe se perdi a sintaxe, mas a ideia deve estar clara (não tenho acesso ao ruby ​​no momento).