Cerca tutti i discendenti di una classe in Ruby

Posso facilmente risalire alla gerarchia di classi in Ruby:

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

C'è un modo per discendere anche nella gerarchia? Mi piacerebbe farlo

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

ma non sembra esserci un descendantsmetodo.

(Questa domanda sorge perché voglio trovare tutti i modelli in un'applicazione Rails che discendono da una classe base ed elencarli; ho un controller in grado di funzionare con qualsiasi modello e mi piacerebbe poter aggiungere nuovi modelli senza dover modificare il controller.)

Ecco un esempio:

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

mette Parent.descendants ti dà:

GrandChild
Child

mette Child.descendants ti dà:

GrandChild

Se si utilizza Rails> = 3, sono disponibili due opzioni. Utilizzare .descendantsse si desidera più di un livello di profondità delle classi per bambini o utilizzare .subclassesper il primo livello delle classi per bambini.

Esempio:

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 eleganti iteratori concatenati:

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

Usalo così:

#!/usr/bin/env ruby

p Animal.descendants

Sostituisci il metodo di classe denominato ereditato . Questo metodo verrebbe passato alla sottoclasse al momento della creazione, che è possibile tenere traccia.

In alternativa (aggiornato per ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Modo Ruby 1.8 compatibile:

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

Nota che questo non funzionerà per i moduli. Inoltre, YourRootClass sarà incluso nella risposta. Puoi usare Array # - o un altro modo per rimuoverlo.

Sebbene l'utilizzo di ObjectSpace funzioni, il metodo di classe ereditato sembra essere più adatto qui documentazione Ruby ereditata (sottoclasse)

Lo spazio oggetti è essenzialmente un modo per accedere a tutto e a tutto ciò che attualmente utilizza la memoria allocata, quindi iterare su ciascuno dei suoi elementi per verificare se si tratta di una sottoclasse della classe Animal non è l'ideale.

Nel codice seguente, il metodo della classe Animal ereditato implementa un callback che aggiungerà qualsiasi sottoclasse appena creata alla sua matrice discendente.

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

  def self.descendants
    puts @descendants 
  end
end

So che stai chiedendo come farlo in eredità, ma puoi ottenerlo direttamente in Ruby spaziando il nome della classe ( 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]

È molto più veloce in questo modo rispetto al confronto con ogni classe in ObjectSpace come altre soluzioni propongono.

Se ne hai davvero bisogno in eredità, puoi fare qualcosa del genere:

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

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

aggiornare

alla fine tutto ciò che devi fare è questo

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

grazie @saturnflyer per il suggerimento

(Rails <= 3.0) In alternativa, è possibile utilizzare ActiveSupport :: DescendantsTracker per eseguire l'operazione. Dalla fonte:

Questo modulo fornisce un'implementazione interna per tenere traccia dei discendenti che è più veloce dell'iterazione tramite ObjectSpace.

Dal momento che è modulare bene, potresti semplicemente scegliere "ciliegia" quel particolare modulo per la tua app Ruby.

Ruby Facets ha discendenti di classe #,

require 'facets/class/descendants'

Supporta anche un parametro di distanza generazionale.

Una versione semplice che fornisce una matrice di tutti i discendenti di una classe:

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

È possibile require 'active_support/core_ext'e utilizzare il descendantsmetodo Controlla il documento e provalo in IRB o fai leva. Può essere usato senza binari.

Rails fornisce un metodo di sottoclassi per ogni oggetto, ma non è ben documentato e non so dove sia definito. Restituisce una matrice di nomi di classe come stringhe.

L'uso di descendants_tracker gem può essere d'aiuto. L'esempio seguente viene copiato dal documento della gemma:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Questa gemma viene utilizzata dalla famosa gemma virtus , quindi penso che sia piuttosto solida.

Questo metodo restituirà un hash multidimensionale di tutti i discendenti di un oggetto.

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

{ MasterClass => descendants_mapper(MasterClass) }

Se si ha accesso al codice prima che venga caricata una sottoclasse, è possibile utilizzare il metodo ereditato .

Se non lo fai (il che non è un caso, ma potrebbe essere utile per chiunque abbia trovato questo post) puoi semplicemente scrivere:

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

Scusa se ho perso la sintassi, ma l'idea dovrebbe essere chiara (al momento non ho accesso a ruby).