Посмотрите всех потомков класса в Ruby

Я легко могу подняться на иерархию классов в Ruby:

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

Есть ли способ спуститься вниз по иерархии? Я хотел бы сделать это

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

но, похоже, нет descendantsметода.

(Этот вопрос возникает потому, что я хочу найти все модели в приложении Rails, которые происходят от базового класса, и перечислить их; у меня есть контроллер, который может работать с любой такой моделью, и я хотел бы иметь возможность добавлять новые модели без необходимости изменять контроллер.)

Вот пример:

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

ставит Parent.descendants дает вам:

GrandChild
Child

ставит Child.descendants дает вам:

GrandChild

Если вы используете Rails> = 3, у вас есть два варианта. Используйте, .descendantsесли вы хотите более одного уровня глубины дочерних классов, или используйте .subclassesдля первого уровня дочерних классов.

Пример:

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 (или 1.8.7) с изящными цепочечными итераторами:

#!/usr/bin/env ruby1.9

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

Предварительная версия 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

Используйте это так:

#!/usr/bin/env ruby

p Animal.descendants

Переопределить метод класса с именем унаследованного . Этот метод будет передан подклассу при его создании, который вы можете отслеживать.

Альтернативно (обновлено для ruby ​​1.9+):

ObjectSpace.each_object(YourRootClass.singleton_class)

Ruby 1.8 совместимый способ:

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

Обратите внимание, что это не будет работать для модулей. Также YourRootClass будет включен в ответ. Вы можете использовать Array # - или другой способ удалить его.

Хотя использование ObjectSpace работает, унаследованный метод класса кажется более подходящим здесь унаследованная (подкласс) Ruby документация

Пространство объектов - это, по сути, способ получить доступ ко всему и ко всему, что в настоящее время использует выделенную память, поэтому итерации по каждому из его элементов для проверки того, является ли он подклассом класса Animal, не идеальны.

В приведенном ниже коде унаследованный метод класса Animal реализует обратный вызов, который добавляет любой вновь созданный подкласс в его массив потомков.

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

  def self.descendants
    puts @descendants 
  end
end

Я знаю, что вы спрашиваете, как сделать это в наследовании, но вы можете достичь этого непосредственно в Ruby, указав интервал имен в классе ( Classили 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]

Это намного быстрее, чем по сравнению с каждым классом в ObjectSpace как предлагают другие решения.

Если вам серьезно нужно это в наследство, вы можете сделать что-то вроде этого:

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

тесты здесь: http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives

Обновить

в конце концов, все, что вам нужно сделать, это

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

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

class Foo < DarthVader
end

DarthVader.descendants #=> [Foo]

спасибо @saturnflyer за предложение

(Rails <= 3.0) В качестве альтернативы вы можете использовать ActiveSupport :: DescendantsTracker, чтобы сделать дело. Из источника:

Этот модуль обеспечивает внутреннюю реализацию для отслеживания потомков, что быстрее, чем итерация в ObjectSpace.

Поскольку он хорошо модульный, вы можете просто «выбрать вишню» для этого конкретного модуля для вашего приложения Ruby.

В Ruby Facets есть потомки класса #,

require 'facets/class/descendants'

Он также поддерживает параметр расстояния поколений.

Простая версия, которая дает массив всех потомков класса:

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

Вы можете require 'active_support/core_ext'и использовать descendantsметод. Проверьте документ и сделайте снимок в IRB или pry. Может использоваться без Rails.

Rails предоставляет метод подклассов для каждого объекта, но он плохо документирован, и я не знаю, где он определен. Возвращает массив имен классов в виде строк.

Может помочь использование gem downndants_tracker . Следующий пример скопирован из документа gem:

class Foo
  extend DescendantsTracker
end

class Bar < Foo
end

Foo.descendants # => [Bar]

Этот драгоценный камень используется популярным драгоценным камнем виртус , поэтому я думаю, что он довольно солидный.

Этот метод вернет многомерный хеш всех потомков объекта.

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

{ MasterClass => descendants_mapper(MasterClass) }

Если у вас есть доступ к коду до загрузки какого-либо подкласса, вы можете использовать унаследованный метод.

Если вы этого не сделаете (что не так, но это может быть полезно для всех, кто нашел этот пост), вы можете просто написать:

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

Извините, если я пропустил синтаксис, но идея должна быть ясной (в данный момент у меня нет доступа к ruby).