Ruby: Unique array of hashes with respecting the highest version

user_15394986 0
Viewed 104

I'm trying to create a new array of hashes with unique values and with respecting the highest version of repeated hashes. The hash looks like the following:

old_hash = [
{"dependency"=>"websocket", "version"=>"2.8.0", "repo"=>"repo1"},
{"dependency"=>"rails", "version"=>"6.2.0", "repo"=>"repo2"},
{"dependency"=>"httparty", "version"=>"6.0.3.5", "repo"=>"repo2"},
{"dependency"=>"httparty", "version"=>"6.1.0.2", "repo"=>"repo2"},
{"dependency"=>"httparty", "version"=>"6.1.3.2", "repo"=>"repo2"},
{"dependency"=>"rails", "version"=>"6.1.0", "repo"=>"repo3"},
{"dependency"=>"metasploit", "version"=>"2.8.0", "repo"=>"repo3"}
]

As you can see, the third, fourth, and fifth hash has the same value of key dependency which is httparty and also repo which is repo2, but the fifth hash has the highest version of these three. Therefore, I'd like to create a unique hash that has the first, second, fifth, sixth, and seventh hash. So the result I'm trying to have should look like this:

unique_hash = [
{"dependency"=>"websocket", "version"=>"2.8.0", "repo"=>"repo1"},
{"dependency"=>"rails", "version"=>"6.2.0", "repo"=>"repo2"},
{"dependency"=>"httparty", "version"=>"6.1.3.2", "repo"=>"repo2"},
{"dependency"=>"rails", "version"=>"6.1.0", "repo"=>"repo3"},
{"dependency"=>"metasploit", "version"=>"2.8.0", "repo"=>"repo3"}
]

Regarding the version comparison, I'm thinking of using this method to compare them right:

def version_greater? (version1, version2)
  Gem::Version.new(version1) > Gem::Version.new(version2)
end

which returns true in case version1 is greater than version2.

I would appreciate any suggestions that helps to solve this problem.

hash ruby
3 Answers

The problem was solved by using:

old_hash.group_by {|h| h.values_at("dependency","repo")}.map {|_,v| v.max_by {|h| Gem::Version.new(h["version"])}}

Thanks to @engineersmnky.

user_153949860

One approach is to use the form of Hash#update (aka merge!) that takes a block (here { |_,o,n| n["version"] > o["version"] ? n : o }) to determine the values of keys that are present in both hashes being merged.

old_hash = [
  {"dependency"=>"websocket",  "version"=>"2.8.0",   "repo"=>"repo1"},
  {"dependency"=>"rails",      "version"=>"6.2.0",   "repo"=>"repo2"},
  {"dependency"=>"httparty",   "version"=>"6.0.3.5", "repo"=>"repo2"},
  {"dependency"=>"httparty",   "version"=>"6.1.0.2", "repo"=>"repo2"},
  {"dependency"=>"httparty",   "version"=>"6.1.3.2", "repo"=>"repo2"},
  {"dependency"=>"rails",      "version"=>"6.1.0",   "repo"=>"repo3"},
  {"dependency"=>"metasploit", "version"=>"2.8.0",   "repo"=>"repo3"},
  {"dependency"=>"rails",      "version"=>"6.1.9",   "repo"=>"repo2"}
]

Note that I've added a hash to old_hash shown in the question. (Incidentally, "old_hash" is perhaps not the best name for an array.)

old_hash.each_with_object({}) do |g,h|
  h.update([g["dependency"],g["repo"]]=>g) do |_,o,n|
    n["version"] > o["version"] ? n : o
  end
end.values
  #=> [{"dependency"=>"websocket",  "version"=>"2.8.0",   "repo"=>"repo1"},
  #    {"dependency"=>"rails",      "version"=>"6.2.0",   "repo"=>"repo2"},
  #    {"dependency"=>"httparty",   "version"=>"6.1.3.2", "repo"=>"repo2"},
  #    {"dependency"=>"rails",      "version"=>"6.1.0",   "repo"=>"repo3"},  
  #    {"dependency"=>"metasploit", "version"=>"2.8.0",   "repo"=>"repo3"}]

The receiver of values can be seen to be the following.

  {["websocket", "repo1"] =>{"dependency"=>"websocket",  "version"=>  "2.8.0", "repo"=>"repo1"},
   ["rails", "repo2"]     =>{"dependency"=>"rails",      "version"=>  "6.2.0", "repo"=>"repo2"},
   ["httparty", "repo2"]  =>{"dependency"=>"httparty",   "version"=>"6.1.3.2", "repo"=>"repo2"},
   ["rails", "repo3"]     =>{"dependency"=>"rails",      "version"=>  "6.1.0", "repo"=>"repo3"},
   ["metasploit", "repo3"]=>{"dependency"=>"metasploit", "version"=>  "2.8.0", "repo"=>"repo3"}}

Consult the doc for descriptions of the three block variables: _ (the common key, here an underscore to signal that it is not used in the block calculation), o, the value of the common key in the hash being constructed (think "old"), and n, the value of the common key in the hash being merged (think "new").

user_2569700

Sort By Semantic Version, Then by Select by Gem Name

The easiest and most readable (but not necessarily shortest or fastest) way to sort your items that I can think of is:

sorted_array = old_hash.sort_by { Gem::Version.new _1["version"] }
gems = old_hash.map { _1["dependency"] }.uniq.sort
gems.map { |gem| sorted_array.select { _1["dependency"] == gem }.last }

In Ruby 3.0.2, this yields:

[{"dependency"=>"httparty", "version"=>"6.1.3.2", "repo"=>"repo2"},
 {"dependency"=>"metasploit", "version"=>"2.8.0", "repo"=>"repo3"},
 {"dependency"=>"rails", "version"=>"6.2.0", "repo"=>"repo2"},
 {"dependency"=>"websocket", "version"=>"2.8.0", "repo"=>"repo1"}]

Basically, you sort your Array of Hashes by the semantic version, and then rely on your Array's sorted order and the fact that the last Hash for each gem "wins" (because of the duplicate dependency keys) to remove older items.

As a bonus, the gem names also appear in sorted order in your new Array. This makes it a bit easier to visually scan through them, especially as the list gets longer.

user_13019720
Related