def result_to_array(result, options = {}, &block)
array = []
inner_recursion = options.delete(:inner_recursion)
result_set = inner_recursion ? result : result.dup
parent_id = (options.delete(:parent_id) || result_set.first[result_set.first.parent_col_name]) rescue nil
level = options[:level] || 0
options[:children] ||= 'children'
options[:methods] ||= []
options[:nested] = true unless options.key?(:nested)
options[:symbolize_keys] = true unless options.key?(:symbolize_keys)
if options[:only].blank? && options[:except].blank?
options[:except] = [:left_column, :right_column, :parent_column].inject([]) do |ex, opt|
column = acts_as_nested_set_options[opt].to_sym
ex << column unless ex.include?(column)
ex
end
end
siblings = options[:nested] ? result_set.select { |s| s.parent_id == parent_id } : result_set
siblings.each do |sibling|
result_set.delete(sibling)
node = block_given? ? block.call(sibling, level) : sibling.attributes(:only => options[:only], :except => options[:except])
options[:methods].inject(node) { |enum, m| enum[m.to_s] = sibling.send(m) if sibling.respond_to?(m); enum }
if options[:nested]
opts = options.merge(:parent_id => sibling.id, :level => level + 1, :inner_recursion => true)
childnodes = result_to_array(result_set, opts, &block)
node[ options[:children] ] = childnodes if !childnodes.empty? && node.respond_to?(:[]=)
end
array << (options[:symbolize_keys] && node.respond_to?(:symbolize_keys) ? node.symbolize_keys : node)
end
unless inner_recursion
result_set.each do |orphan|
node = (block_given? ? block.call(orphan, level) : orphan.attributes(:only => options[:only], :except => options[:except]))
options[:methods].inject(node) { |enum, m| enum[m.to_s] = orphan.send(m) if orphan.respond_to?(m); enum }
array << (options[:symbolize_keys] && node.respond_to?(:symbolize_keys) ? node.symbolize_keys : node)
end
end
array
end