Create class inherirance hierarchy using ruby - ruby

Question

I want to using ruby to create class inherirance hierarchy. I have grep the class name and its parent class name like this:
[[B,A], [C,A], [E,D], [F,B] ...]
[B,A] A is B's parent class, and the root class not only one, like A or D.
The elements in the array is just string, like A,B,C...
I want to create a inherirance hierarchy graph like this:
[
A=>[
B=>[F],
C
],
D=>[E]
]
the graph format is not strict, which can demonstrate the hierarchy will be OK.
I have try to using loop to recursively placed the node, but it's too low efficiency. Does anyone can help me or there is some gem to solve this?
All I want to know is the clas inherirance hierarchy, so whatever the way you solve this.
Thanks #Max and #Gabriel de Oliveira for answer my question! I have solve the problem.
It maybe ugly, but it works.
class Node
attr_accessor :name, :parent, :children
def initialize(name)
#name = name
#parent = nil
#children = Set.new
end
def <=>(other)
if other.name == self.name
return 0
end
return nil
end
def ==(other)
if other.name == self.name
return true
end
return false
end
def inspect
desc = ""
desc << "{" if #children.length > 0
desc << %("#{#name}")
if #children.count > 0
desc << ":["
children_arr = #children.to_a
children_arr.to_a.each_index do |index|
desc << ',' if index > 0
desc << children_arr[index].inspect
end
desc << "]"
end
desc << "}" if #children.length > 0
return desc
end
end
str = string_from_file(file_path)
arr = JSON.parse(str)
nodes = {}
# create nodes set
arr.each do |item|
name = item[0]
parent = item[1]
nodes[name] = Node.new(name)
nodes[parent] = Node.new(parent)
end
# bind relationship with nodes
arr.each do |item|
node = nodes[item[0]]
parent = nodes[item[1]]
if !parent.nil?
node.parent = parent
parent.children << node
end
end
# filter the root nodes
roots = []
nodes.each_value do |node|
roots << node if node.parent.nil?
end
puts roots

Answer 1

You can do this with metaprogramming. B = Class.new(A) creates a class B that inherits from A and Object.const_set and Object.const_get can dynamically access constants. The only tricky bit is creating the classes in the right order, but that can be solved with recursion.
# create class klass (and any necessary superclasses) with inheritance specified by tree
def create_class_from_tree(klass, tree)
# nothing to do if the class already exists
return if Object.const_defined? klass
# default superclass
parent = Object
# look for a superclass defined in the tree
if inherit = tree.find { |k, p| k == klass }
# ensure superclass exists
parent = create_class_from_tree(inherit[1], tree)
end
Object.const_set(klass, Class.new(parent))
end
# create all classes with inheritance specified by tree
def create_classes_from_tree(tree)
tree.each { |klass, _| create_class_from_tree(klass, tree) }
end
create_classes_from_tree([['B', 'A'], ['C', 'A'], ['E', 'D'], ['F', 'B']])
('A'..'F').each { |klass| puts "#{klass} < #{Object.const_get(klass).superclass}" }
# A < Object
# B < A
# C < A
# D < Object
# E < D
# F < B

Answer 2

To transform the input array into a nested hash you could implement something along these lines:
def process(input)
return {} if input.empty?
base_classes, rest = input.partition {|value| value.is_a? Class }
ret_val = {}
base_classes.each do |klass|
ret_val[klass], rest = rest.partition {|value| value.last == klass }
ret_val[klass] = ret_val[klass].map(&:first)
end
ret_val.each {|klass, classes| ret_val[klass] = process(classes + rest) }
end
Then given all clases are defined and your data array is sanitized (for example it doesn't contain an invalid element such as [X, Z]):
data = [A, [B, A], [C, A], D, [E, D], [F, B]]
process(data) #=> {A=>{B=>{F=>{}}, C=>{}}, D=>{E=>{}}}