Наиболее эффективный способ рекурсивного выравнивания вложенного массива в строку, разделенную точками, в Ruby?

Question

Я хочу преобразовать что-то вроде этого:

class NestedItem
  attr_accessor :key, :children
  def initialize(key, &block)
    self.key = key
    self.children = []
    self.instance_eval(&block) if block_given?
  end

  def keys
    [key] + children.keys
  end
end

root = NestedItem.new("root") do
  children << NestedItem.new("parent_a") do
    children << NestedItem.new("child_a")
    children << NestedItem.new("child_c")
  end
  children << NestedItem.new("parent_b") do
    children << NestedItem.new("child_y")
    children << NestedItem.new("child_z")
  end
end

require 'pp'
pp root
#=>
# #<NestedItem:0x1298a0
#  @children=
#   [#<NestedItem:0x129814
#     @children=
#      [#<NestedItem:0x129788 @children=[], @key="child_a">,
#       #<NestedItem:0x12974c @children=[], @key="child_c">],
#     @key="parent_a">,
#    #<NestedItem:0x129738
#     @children=
#      [#<NestedItem:0x129698 @children=[], @key="child_y">,
#       #<NestedItem:0x12965c @children=[], @key="child_z">],
#     @key="parent_b">],
#  @key="root">

В это:

root.keys #=>
[
  "root",
  "root.parent_a",
  "root.parent_a.child_a",
  "root.parent_a.child_c",
  "root.parent_b",
  "root.parent_b.child_y",
  "root.parent_b.child_z",
]

... используя рекурсивный метод.

Какой самый простой способ это сделать?

Обновление

Я сделал это:

def keys
  [key] + children.map(&:keys).flatten.map do |node|
    "#{key}.#{node}"
  end
end

Что-нибудь лучше?

Answer 1

Будет ли Array.flatten работать на вас?

self.children.flatten должен вернуть сглаженные результаты.

Answer 2

Да, .flatten выдаст то, что, я думаю, вы действительно хотите.

Но если вы хотите получить именно тот вывод строки, который вы ввели, это будет сделано:в качестве альтернативы замените последнюю строку в #keys на:

([ here ] + children.map { |o| o.keys here }).flatten