Recursively delete hashes with empty values - ruby

Question

I'd like to delete empty hashes at different nested levels. And once that empty hash is deleted, I'd like to delete it's container hash as well. How would I do this?
Here is the hash I want to work on:
{
"query"=>{"filtered"=>{
"query"=>{"bool"=>{}},
"filter"=>{"query"=>{"query_string"=>{
"fields"=>[["standard_analyzed_name", "standard_analyzed_message"]],
"query"=>"Arnold AND Schwarz"
}}}
}},
"sort"=>[{"total_interactions"=>{"order"=>"desc"}}]
}
Below is the code that I have that does not remove the empty {"query"=>{"bool"=>{}} part:
def compactify_hash(main_hash)
main_hash.each do |key, value|
if(value.class == Hash && !value.empty?)
compactify_hash(value)
elsif(value.class == Hash && value.empty?)
main_hash.delete(key)
end
end
return main_hash
end

Answer 1

You have a few problems here:
You're modifying the hash in-place when you might not mean to, you'd probably want to name your method compactify_hash! if you really want to modify it in-place.
You have Arrays inside your Hash but you don't scan them for empty Hashes.
Most importantly, you never check your recursively compactified hashes to see if compactifying them has also emptied them. in here:
if(value.class == Hash && !value.empty?)
compactify_hash(value)
elsif(value.class == Hash && value.empty?)
main_hash.delete(key)
end
you need to check value.empty? after you compactify_hash(value).
You could do something like this instead:
def compactify_hash(main_hash)
main_hash.each_with_object({}) do |(k, v), h|
if(v.is_a?(Hash))
ch = compactify_hash(v)
h[k] = ch if(!ch.empty?)
elsif(v.is_a?(Array))
h[k] = v.map do |e|
e.is_a?(Hash) ? compactify_hash(e) : e
end
else
h[k] = v
end
end
end

Answer 2

I have assumed that for any hash h, you want to create another hash g which is the same as h except no nested hash in g will have a key-value pair [k,v] for which v.respond_to(:empty?) and v.empty? both return true. For example, if the following nested hash is present in h:
{ a: { b: '', c: {}, d: [] }, e: 3 }
then the corresponding nested hash in g will be:
{ e: 3 }
In effect, we "remove" the key-value pairs :b=> '', :c=> {} and :d=> [] because '', {} and [] all respond to :empty? and all are empty. That reduces the nested hash to:
{ a: {}, e: 3 }
Since the value of a is now empty, we remove that key-value pair, leaving the nested hash in g equal to:
{ e: 3 }
I believe this can be achieved as follows:
def remove(h)
loop do
h_new = remove_empties(h)
break h if h==h_new
h = h_new
end
end
def remove_empties(h)
h.each_with_object({}) do |(k,v),g|
case v
when Hash
g[k] = remove_empties(h[k]) unless v.empty?
else
g[k] = v unless v.respond_to?(:empty?) && v.empty?
end
end
end
For your hash, which I refer to as h:
remove(h)
#=> {:query=>
# {:filtered=>
# {:filter=>
# {:query=>
# {:query_string=>
# {:fields=>
[["standard_analyzed_name", "standard_analyzed_message"]],
# :query=>"Arnold AND Schwarz"
# }
# }
# }
# }
# },
# :sort=>[
# {:total_interactions=>
# {:order=>"desc"}
# }
# ]
# }
Note that the recursion is performed repeatedly until no further modifications of the hash are performed.