Ytukyg

I need to reduce an array of hashes into a single hash if that hash key matches.

my_array is an array of hashes, each of which has two keys: one an active record object, the other an array of different active record objects, similar to:

my_array = [

  {

    first_hash_key: {id: 1, title: "my title"},

    second_hash_key: ["stuff", "more stuff", "more stuff"]

  },

  {

    first_hash_key: {id: 1, title: "my title"},

    second_hash_key: ["stuff 3", "uniq stuff 2"]

  },

  {

    first_hash_key: {id: 2, title: "my other title"},

    second_hash_key: ["interesting stuff", "uniq stuff"]

  }

]

I want to combine hashes by first_hash_key[:id], add each item in hash_key_two to an array, not overwrite them to get:

my_array = [

  {

    first_hash_key: {id: 1, title: "my title"},

    second_hash_key: [

      ["stuff", "more stuff", "more stuff"],

      ["stuff 3", "uniq stuff 2"]

    ]

  },

  {

    first_hash_key: {id: 2, title: "my other title"},

    second_hash_key: ["interesting stuff", "uniq stuff"]

  }

]

I can reduce the top level array and hash, and use merge, but I'm losing the individual arrays inside the hash.

I've also tried grouping by the id of the first_hash_key, and then injecting like this:

my_array.group_by{|h| h[:first_hash_key]}.map{|k,v| v.inject(:merge)}

Again, I'm losing the arrays in the second_hash_key. I only get the last array listed. Without map, I get an array of each hash in the group, but the top level isn't combined.

[

  {

    :first_hash_key=>{:id=>1, :title=>"my title"},

    :second_hash_key=>["stuff 3", "uniq stuff 2"]

  },

  {

    :first_hash_key=>{:id=>2, :title=>"my other title"}, 

    :second_hash_key=>["interesting stuff", "uniq stuff"]

  }

]

Update
As noted by sawa and cary, there is no sense in guessing for the second_hash_key if the data is an array or array or arrays, better to always have an array of arrays. The desired output is:

 [{:first_hash_key=>{:id=>1, :title=>"my title"}, 

   :second_hash_key=>[["stuff", "more stuff", "more stuff"], 

                      ["stuff 3", "uniq stuff 2"]]

 },

 {:first_hash_key=>{:id=>2, :title=>"my other title"}, 

 :second_hash_key=>[["interesting stuff", "uniq stuff"]]

 }]

well it ain't pretty but here you go:

my_array.

  group_by { |elem| elem[:first_hash_key] }.

  transform_values { |vals| vals.map { |val| val[:second_hash_key] } }.

  reduce() do |memo, (key, vals)|

    memo + [{first_hash_key: key, second_hash_key: vals}]

  end

returns:

[

  {

    :first_hash_key=>{:id=>1, :title=>"my title"},

    :second_hash_key=>[

      ["stuff", "more stuff", "more stuff"],

      ["stuff 3", "uniq stuff 2"]

    ]

  }, {

    :first_hash_key=>{:id=>2, :title=>"my other title"},

    :second_hash_key=>[

      ["interesting stuff", "uniq stuff"]

    ]

  }

]

If you're not clear how this works you should inspect the result of each line, but to summarize

1. group by first_hash_key
   



2. call transform_values to get the values at second_hash_key corresponding to each of these first_hash_key values




3. At this point you have a hash mapping first_hash_key value to all of the corresponding values of second_hash_key. Now just have to reduce it to get the final data structure.

This pattern of group_by => transform_values => reduce is something I use all the time and is very useful. transform_values is available in rails as well as ruby 2.5 I believe.

my_array.each_with_object({}) do |g,h|

  h.update(g[:first_hash_key][:id]=>g) { |_,o,n|

    o.merge(second_hash_key: [[*o[:second_hash_key]], n[:second_hash_key]]) }

end.values

  #=> [{:first_hash_key=>{:id=>1, :title=>"my title"},

  #     :second_hash_key=>[["stuff", "more stuff", "more stuff"],

  #                        ["stuff 3", "uniq stuff 2"]]},

  #    {:first_hash_key=>{:id=>2, :title=>"my other title"},

  #     :second_hash_key=>["interesting stuff", "uniq stuff"]}]

The receiver of Hash#values is the hash:

{1=>{:first_hash_key=>{:id=>1, :title=>"my title"},

     :second_hash_key=>[["stuff", "more stuff", "more stuff"],

                        ["stuff 3", "uniq stuff 2"]]},

 2=>{:first_hash_key=>{:id=>2, :title=>"my other title"},

     :second_hash_key=>["interesting stuff", "uniq stuff"]}}

This uses the form of Hash#update (aka merge!) that employs a block to determine the values of keys that are present in both hashes being merged, here the keys being 1 and 2. That block has three block variables: _ equals the common key¹; o ("old") is value of the key _ in the hash being constructed and n ("new") is the value of the key _ in the hash being merged into the hash being constructed.

The expression [*o[:second_hash_key]] converts o[:second_hash_key] to an array of itself if o[:second_hash_key] is not an array and leaves o[:second_hash_key] unchanged if it is already an array. For example, [*1] #=> [1], whereas [*[1,2]] #=> [1,2].

The return value is problematic in that the value of :second_hash_key is in one case an array of arrays and in another it is simply an array. In subsequent calculations it therefore will be necessary to determine if each value is an array of arrays or just an array, and then take action accordingly. That could be done, of course, but it's messy and ugly; better to make all the values arrays of arrays. We could do that as follows.

my_array.each_with_object({}) do |g,h|

  h.update(g[:first_hash_key][:id]=>

    g.merge(second_hash_key: [g[:second_hash_key]])) { |_,o,n|

      o.merge(second_hash_key: o[:second_hash_key] + n[:second_hash_key]) }

end.values

  #=> [{:first_hash_key=>{:id=>1, :title=>"my title"},

  #     :second_hash_key=>[["stuff", "more stuff", "more stuff"],

  #                        ["stuff 3", "uniq stuff 2"]]},

  #    {:first_hash_key=>{:id=>2, :title=>"my other title"},

  #     :second_hash_key=>[["interesting stuff", "uniq stuff"]]}]

^{1 The use of the underscore--a valid local variable--for the common key is to inform the reader that it is not used in the block calculation.}