Creating objects/hashes and storing them in an array - ruby-on-rails

Question

I'm trying to create a function that validates data stored in my database. Say I have a table Foo. For each item in Foo i call a function say Bar which validates it by using a set of checks. If the data is not correct, I store the item id along with a description of the reason of failure in a hash. The hash is pushed on to an array.
ErrorList = []
MyHash = Hash.new {|h,k| h[k]=[]}
Foo.each do |f|
unless f.valid?
MyHash["foo_id"] = f.id
MyHash["description"] = "blah blah blah"
ErrorList.push MyHash
end
end
At the end of execution, all entries in the array are the same since the hash entries are overwritten. Is there a way I can use this hash to store different id's and description in my array. Otherwise, is there a way to use objects instead to overcome this issue?
I'm using rails version 2.3.5

Answer 1

First MyHash shouldn't be camel case, but you can just do...
myhash = {}
Foo.each do |f|
unless f.valid?
myhash[f.id] = "blah blah blah"
end
end
Assuming all the id's are unique, you only need this hash. This will set the key value pair to: id: blah blah blah

Answer 2

I believe you could write the above using reject and map:
error_list = foos.reject(&:valid?).map do |f|
{ "foo_id" => f.id, "description" => "blah blah blah" }
end
This will create a list of hashes, each with a "foo_id" and "description" of all the invalid foos.
To make your code work, you need to make sure you are creating a new hash for each element in the list, and not re-using the hash you already created:
ErrorList = []
Foo.each do |f|
unless f.valid?
my_hash = Hash.new {|h,k| h[k]=[]}
my_hash["foo_id"] = f.id
my_hash["description"] = "blah blah blah"
ErrorList.push my_hash
end
end

Answer 3

It was Matz himself who pointed out that, over time, "object-oriented" became such a common term, that we tend to underestimate its power. However old-fashioned it may sound, Ruby is an OO language, and you should write OO programs with it. There are many possible approaches. One possible example would be
class ValidatedTable < Array
def self.new array=[]
array.each_with_object new do |e, o| o << e end unless array.empty?
super
end
def << element
fail TypeError, "blah blah blah" unless element.valid?
super
end
end
And now, with this ValidatedTable whose #<< method complains about invalid inputs, we can easily achieve your objective:
validated_table, error_list = Foo.each_with_object [ ValidatedTable.new, [] ] do |e, o|
begin
o[0] << e
rescue TypeError => msg
e[1] << { id: e.id, description: msg.to_s }
end
end
The distinctive aspect of this solution is that it creates a special subclass of array, ValidatedTable, which, at any moment, is guaranteed to only contain valid elements. Attempts to push invalid elements into it raise an error, which can be rescued and used to produce an error list.