How to sort hash in ruby recursively - json

Question

I have a huge hash/json in below format. Sample is given.
How we can sort this result hash based on the "total" key in descending order?
Nb: The last level nested node will not have have response and total keys. They will have metrics as keys.
result = {
"account_id_1": {
"total": 1000,
"response": {
"location_1": {
"total": 300,
"response": {
"service_1": { "metrics": { "cost": 100} },
"service_2": { "metrics": { "cost": 100 } },
"service_3": { "metrics": { "cost": 100 } },
}
},
"location_2": {
"total": 500,
"response": {
"service_1": { "metrics": { "cost": 300 } },
"service_2": { "metrics": { "cost": 150 } },
"service_3": { "metrics": { "cost": 50 } },
}
},
"location_3": {
"total": 200,
"response": {
"service_1": { "metrics": { "cost": 75 } },
"service_2": { "metrics": { "cost": 75 } },
"service_3": { "metrics": { "cost": 50 } },
}
}
}
},
"account_id_2": {
"total": 2000,
"response": {
"location_1": {
"total": 300,
"response": {
"service_1": { "metrics": { "cost": 100 } },
"service_2": { "metrics": { "cost": 100 } },
"service_3": { "metrics": { "cost": 100 } },
}
},
"location_2": {
"total": 500,
"response": {
"service_1": { "metrics": { "cost": 300 } },
"service_2": { "metrics": { "cost": 150 } },
"service_3": { "metrics": { "cost": 50 } },
}
},
"location_3": {
"total": 1200,
"response": {
"service_1": { "metrics": { "cost": 1075 } },
"service_2": { "metrics": { "cost": 75 } },
"service_3": { "metrics": { "cost": 50 } },
}
}
}
}
}
Expected result:
result = {
"account_id_2": {
"total": 2000,
"response": {
"location_3": {
"total": 1200,
"response": {
"service_1": { "metrics": { "cost": 1075 } },
"service_2": { "metrics": { "cost": 75 } },
"service_3": { "metrics": { "cost": 50 } },
}
},
"location_2": {
"total": 500,
"response": {
"service_1": { "metrics": { "cost": 300 } },
"service_2": { "metrics": { "cost": 150 } },
"service_3": { "metrics": { "cost": 50 } },
}
},
"location_1": {
"total": 300,
"response": {
"service_1": { "metrics": { "cost": 100 } },
"service_2": { "metrics": { "cost": 100 } },
"service_3": { "metrics": { "cost": 100 } },
}
}
}
},
"account_id_1": {
"total": 1000,
"response": {
"location_2": {
"total": 500,
"response": {
"service_1": { "metrics": { "cost": 300 } },
"service_2": { "metrics": { "cost": 150 } },
"service_3": { "metrics": { "cost": 50 } },
}
},
"location_1": {
"total": 300,
"response": {
"service_1": { "metrics": { "cost": 100} },
"service_2": { "metrics": { "cost": 100 } },
"service_3": { "metrics": { "cost": 100 } },
}
},
"location_3": {
"total": 200,
"response": {
"service_1": { "metrics": { "cost": 75 } },
"service_2": { "metrics": { "cost": 75 } },
"service_3": { "metrics": { "cost": 50 } },
}
}
}
}
}

Answer 1

Personally I would create a class to handle the custom sorting so that we can implement our own <=> (Spaceship Operator)
Something like: (Working Example: https://replit.com/#engineersmnky/ThankfulAutomaticRam#main.rb)
class AccountLocaleMetricSorter
include Comparable
def self.sort(h)
h.map do |name,values|
new(name: name, data: values)
end.sort.reduce({}) {|m,o| m.merge(o.to_h)}
end
attr_reader :name, :data, :o_data
def initialize(name: , data: )
#name = name
#o_data = data
#data = parse_response(data)
end
def to_h
return {name.to_sym => o_data} unless o_data.key?(:total)
{name.to_sym => {
total: o_data[:total],
response: data.to_h
}
}
end
def <=>(other)
if o_data.key?(:total) && o_data.key?(:total)
other.o_data[:total] <=> o_data[:total]
elsif other.o_data.key?(:metrics) && o_data.key?(:metrics)
other.o_data.dig(:metrics,:cost) <=> o_data.dig(:metrics,:cost)
else
0
end
end
private
def parse_response(response)
return response unless response.key?(:response)
self.class.sort(response[:response])
end
end
Usage as:
pp AccountLocaleMetricSorter.sort(result)
Output:
{:account_id_2=>
{:total=>2000,
:response=>
{:location_3=>
{:total=>1200,
:response=>
{:service_1=>{:metrics=>{:cost=>1075}},
:service_2=>{:metrics=>{:cost=>75}},
:service_3=>{:metrics=>{:cost=>50}}}},
:location_2=>
{:total=>500,
:response=>
{:service_1=>{:metrics=>{:cost=>300}},
:service_2=>{:metrics=>{:cost=>150}},
:service_3=>{:metrics=>{:cost=>50}}}},
:location_1=>
{:total=>300,
:response=>
{:service_1=>{:metrics=>{:cost=>100}},
:service_2=>{:metrics=>{:cost=>100}},
:service_3=>{:metrics=>{:cost=>100}}}}}},
:account_id_1=>
{:total=>1000,
:response=>
{:location_2=>
{:total=>500,
:response=>
{:service_3=>{:metrics=>{:cost=>300}},
:service_2=>{:metrics=>{:cost=>150}},
:service_1=>{:metrics=>{:cost=>50}}}},
:location_1=>
{:total=>300,
:response=>
{:service_1=>{:metrics=>{:cost=>100}},
:service_2=>{:metrics=>{:cost=>100}},
:service_3=>{:metrics=>{:cost=>100}}}},
:location_3=>
{:total=>200,
:response=>
{:service_1=>{:metrics=>{:cost=>75}},
:service_2=>{:metrics=>{:cost=>75}},
:service_3=>{:metrics=>{:cost=>50}}}}}}}

Answer 2

Let's first simplify your example.
result = {
"account_id_1": {
"total": 1000,
"response": {
"location_1": { "total": 300, "response": 1 },
"location_2": { "total": 500, "response": 2 },
"location_3": { "total": 200, "response": 3 }
}
},
"account_id_2": {
"total": 2000,
"response": {
"location_1": { "total": 300, "response": 1 },
"location_2": { "total": 500, "response": 2 },
"location_3": { "total": 1200, "response": 3 }
}
}
}
In your example,
result[:account_id_1][:response][:location_1][:response]
#=> { "service_1": { "metrics": { "cost": 100} },
# "service_2": { "metrics": { "cost": 100 } },
# "service_3": { "metrics": { "cost": 100 } } }
This value, and others like it, will remain unchanged, so I've replaced it with a placeholder, an arbitrary integer:
result[:account_id_1][:response][:location_1][:response]
#=> 1
result[:account_id_1][:response][:location_2][:response]
#=> 2
and so on.
I found it useful to create a helper method:
def sort_by_total_desc(h)
h.sort_by { |_,g| -g[:total] }.to_h
end
The desired hash can then be computed as follows.
sort_by_total_desc(result.transform_values do |v|
v.merge(response: sort_by_total_desc(v[:response]))
end)
#=> {:account_id_2=>{
# :total=>2000,
# :response=>{
# :location_3=>{:total=>1200, :response=>3},
# :location_2=>{:total=>500, :response=>2},
# :location_1=>{:total=>300, :response=>1}
# }
# },
# :account_id_1=>{
# :total=>1000,
# :response=>{
# :location_2=>{:total=>500, :response=>2},
# :location_1=>{:total=>300, :response=>1},
# :location_3=>{:total=>200, :response=>3}
# }
# }
# }
Regarding the helper method, here is an example.
h = { "location_1": { "total": 300, "response": 1 },
"location_2": { "total": 500, "response": 2 },
"location_3": { "total": 200, "response": 3 } }
sort_by_total_desc(h)
#=> {:location_2=>{:total=>500, :response=>2},
# :location_1=>{:total=>300, :response=>1},
# :location_3=>{:total=>200, :response=>3}}
which requires two steps:
a = h.sort_by { |_,g| -g[:total] }
#=> [[:location_2, {:total=>500, :response=>2}],
# [:location_1, {:total=>300, :response=>1}],
# [:location_3, {:total=>200, :response=>3}]]
a.to_h
#=> as above
The main method has two main steps. First perform the "inner" sorting.
h = result.transform_values do |v|
v.merge(response: sort_by_total_desc(v[:response]))
end
#=> {:account_id_1=>{
# :total=>1000,
# :response=>{
# :location_2=>{:total=>500, :response=>2},
# :location_1=>{:total=>300, :response=>1},
# :location_3=>{:total=>200, :response=>3}
# }
# },
# :account_id_2=>{
# :total=>2000,
# :response=>{
# :location_3=>{:total=>1200, :response=>3},
# :location_2=>{:total=>500, :response=>2},
# :location_1=>{:total=>300, :response=>1}
# }
# }
# }
Then do the "outer" sorting to return the desired result:
sort_by_total_desc(h)
#=> as above
See Enumerable#sort_by, Hash#transform_values and Hash#merge.