我真的不知道下面是不是你正在寻找的，但如果不是，也许你可以调整它以适应你的需要。

str =<<~END
Parent 1
 |
 |-Child 1
 |- - Child 1_GrandChild1
 |
 |-Child 2
 |
Parent 2
 |
 |-Child 1
 |- - Child 1_GrandChild1
 |- - Child 1_GrandChild2
 |
 |-Child 2
 |
 |-Child 3
 |- - Child 3_GrandChild1
 |
Parent 3
END

字符串

str.each_line.with_object([]) do |s,arr|
  s.chomp!
  case s
  when /\A\p{Alpha}+\s+\d+\z/
    arr << [0,s]
  when /\A \|\-\p{Alpha}+\s+\d+\z/
    arr << [1,s[/[A-Z].*/]]
  when /\A \|\- \- \p{Alpha}+ \d+\_\p{Alpha}+\d+\z/
    arr << [2,s[/\d.*/]]
  end
end.sort.map(&:last)
  #=> ["Parent 1", "Parent 2", "Parent 3", "Child 1", "Child 1", "Child 2",
  #    "Child 2", "Child 3", "1_GrandChild1", "1_GrandChild1", "1_GrandChild2",
  #    "3_GrandChild1"]

型
注意

a = str.each_line.with_object([]) do |s,arr|
  s.chomp!
  case s
  when /\A\p{Alpha}+\s+\d+\z/
    arr << [0,s]
  when /\A \|\-\p{Alpha}+\s+\d+\z/
    arr << [1,s[/[A-Z].*/]]
  when /\A \|\- \- \p{Alpha}+ \d+\_\p{Alpha}+\d+\z/
    arr << [2,s[/\d.*/]]
  end
end
  #=> [[0, "Parent 1"], [1, "Child 1"], [2, "1_GrandChild1"],
  #    [1, "Child 2"], [0, "Parent 2"], [1, "Child 1"],
  #    [2, "1_GrandChild1"], [2, "1_GrandChild2"], [1, "Child 2"],
  #    [1, "Child 3"], [2, "3_GrandChild1"], [0, "Parent 3"]]

型
因此，sort首先对每个两元素数组的第一个元素进行排序，然后对第二个元素进行排序以打破平局：

b = a.sort
  #=> [[0, "Parent 1"], [0, "Parent 2"], [0, "Parent 3"],
  #    [1, "Child 1"], [1, "Child 1"], [1, "Child 2"], [1, "Child 2"],
  #    [1, "Child 3"],
  #    [2, "1_GrandChild1"], [2, "1_GrandChild1"], [2, "1_GrandChild2"],
  #    [2, "3_GrandChild1"]]

型
最后，b.map(&:last)将每个两元素数组Map到数组的最后一个元素。

我试着回答了这个问题here。我认为解决方案通过将以下内容添加到acts_as_nested_set的模型中来实现您想要的功能：

def sorted_heir_list(target = self, set = self.descendants)
    sorted_list = [target]
    kids = set.select{|i| i.parent_id == target.id}.sort_by{|j| j.name}
    kids.each do |k|
      sorted_list.concat(sorted_heir_list(k, set))
    end
    sorted_list
  end

字符串
因此，调用category.sorted_heir_list给出了一个按名称排序的平面对象数组，同时保留了层次结构，并且只会导致一次DB命中。