90 lines
3.1 KiB
Ruby
90 lines
3.1 KiB
Ruby
module GroupDescendant
|
|
def hierarchy(hierarchy_top = nil, preloaded = [])
|
|
expand_hierarchy_for_child(self, self, hierarchy_top, preloaded)
|
|
end
|
|
|
|
def self.build_hierarchy(descendants, hierarchy_top = nil)
|
|
descendants = Array.wrap(descendants)
|
|
return if descendants.empty?
|
|
|
|
unless descendants.all? { |hierarchy| hierarchy.is_a?(GroupDescendant) }
|
|
raise ArgumentError.new('element is not a hierarchy')
|
|
end
|
|
|
|
first_descendant, *other_descendants = descendants
|
|
merged = first_descendant.hierarchy(hierarchy_top, descendants)
|
|
|
|
other_descendants.each do |descendant|
|
|
next_descendant = descendant.hierarchy(hierarchy_top, descendants)
|
|
merged = merge_hash_tree(merged, next_descendant)
|
|
end
|
|
|
|
merged
|
|
end
|
|
|
|
private
|
|
|
|
def expand_hierarchy_for_child(child, hierarchy, hierarchy_top, preloaded = [])
|
|
parent = preloaded.detect { |possible_parent| possible_parent.is_a?(Group) && possible_parent.id == child.parent_id }
|
|
parent ||= child.parent
|
|
|
|
if parent.nil? && hierarchy_top.present?
|
|
raise ArgumentError.new('specified base is not part of the tree')
|
|
end
|
|
|
|
if parent && parent != hierarchy_top
|
|
expand_hierarchy_for_child(parent,
|
|
{ parent => hierarchy },
|
|
hierarchy_top,
|
|
preloaded)
|
|
else
|
|
hierarchy
|
|
end
|
|
end
|
|
|
|
private_class_method def self.merge_hash_tree(first_child, second_child)
|
|
# When the first is an array, we need to go over every element to see if
|
|
# we can merge deeper. If no match is found, we add the element to the array
|
|
#
|
|
# Handled cases:
|
|
# [Array, Hash]
|
|
if first_child.is_a?(Array) && second_child.is_a?(Hash)
|
|
merge_hash_into_array(first_child, second_child)
|
|
elsif first_child.is_a?(Hash) && second_child.is_a?(Array)
|
|
merge_hash_into_array(second_child, first_child)
|
|
# If both of them are hashes, we can deep_merge with the same logic
|
|
#
|
|
# Handled cases:
|
|
# [Hash, Hash]
|
|
elsif first_child.is_a?(Hash) && second_child.is_a?(Hash)
|
|
first_child.deep_merge(second_child) { |key, first, second| merge_hash_tree(first, second) }
|
|
# If only one of them is a hash, and one of them is a GroupHierachy-object
|
|
# we can check if its already in the hash. If so, we don't need to do anything
|
|
#
|
|
# Handled cases
|
|
# [Hash, GroupDescendant]
|
|
elsif first_child.is_a?(Hash) && first_child.keys.include?(second_child)
|
|
first_child
|
|
elsif second_child.is_a?(Hash) && second_child.keys.include?(first_child)
|
|
second_child
|
|
# If one or both elements are a GroupDescendant, we wrap create an array
|
|
# combining them.
|
|
#
|
|
# Handled cases:
|
|
# [GroupDescendant, Array], [GroupDescendant, GroupDescendant], [Array, Array]
|
|
else
|
|
Array.wrap(first_child) + Array.wrap(second_child)
|
|
end
|
|
end
|
|
|
|
private_class_method def self.merge_hash_into_array(array, new_hash)
|
|
if mergeable_index = array.index { |element| element.is_a?(Hash) && (element.keys & new_hash.keys).any? }
|
|
array[mergeable_index] = merge_hash_tree(array[mergeable_index], new_hash)
|
|
else
|
|
array << new_hash
|
|
end
|
|
|
|
array
|
|
end
|
|
end
|