interrogate a Ruby array of hashes - ruby-on-rails

Question

I need to group people by age in Ruby. I have their date of birth, and a method which returns their age in years. So a solution like this works.
case
when (0..15).cover?(age_years)
'child'
when (16..24).cover?(age_years)
'16 to 24'
when (25..34).cover?(age_years)
'25 to 34'
when (35..44).cover?(age_years)
'35 to 44'
when (45..54).cover?(age_years)
'45 to 54'
when (55..64).cover?(age_years)
'55 to 64'
when age_years > 64
'really old'
else
'unknown'
end
However, I am trying to learn Ruby and am looking for a more elegant solution. I thought about putting the age_ranges into an array of hashes like this...
age_ranges = [{ name: 'child', min_age: 0, max_age: 15 },
{ name: '16 to 24', min_age: 16, max_age: 24 }]
but am at a loss as to how to interrogate this data to return the correct name where the age_years is within the appropriate ranges, or even a range like this
age_ranges = [{ name: 'child', age_range: '0..15' },
{ name: '16 to 24', age_range: '16..24' }]
which looks neater but I have no idea if I have written gibberish as I don't know how to extract the name when the age years matches.
Can someone point me in the right direction?

Answer 1

Now that you have an map of age names and ranges (note I used range, not string as a value of age_range), you want to search the age_ranges array of hashes for such, which value of age_range includes the age:
def age_ranges
[
{ name: 'child', age_range: 0..15 },
{ name: '16 to 24', age_range: 16..24 }
]
end
def find_age(age)
age_ranges.find { |hash| hash[:age_range].include?(age) }[:name]
end
find_age(12)
#=> "child"
find_age(17)
#=> "16 to 24"
Note, that [:name] will fail if find returns nil (meaning, no matches found).
To overcome it either add an infinite range as a last one in the array (I'd prefer this one, because it is simpler):
def age_ranges
[
{ name: 'child', age_range: 0..15 },
{ name: '16 to 24', age_range: 16..24 },
{ name: 'unknown', age_range: 25..Float::INFINITY }
]
end
Or handle it while fetching the age in the find_age method:
def find_age(age)
age_ranges.each_with_object('unknown') { |hash, _| break hash[:name] if hash[:age_range].include?(age) }
end
Also, make sure to handle the negative numbers passed to the method (since age_ranges do not cover negatives):
def find_age(age)
return 'Age can not be less than 0' if age.negative?
age_ranges.find { |hash| hash[:age_range].include?(age) }[:name]
end
P.S. After all these "note/make sure" I want to say that #mudasobwa's answer is the simplest way to go about it :)

Answer 2

Use Range#=== triple equal directly, as it is supposed to be used:
case age_years
when 0..15 then 'child'
when 16..24 then '16 to 24'
when 25..34 then '25 to 34'
when 35..44 then '35 to 44'
when 45..54 then '45 to 54'
when 55..64 then '55 to 64'
when 64..Float::INFINITY then 'really old' # or when 64.method(:<).to_proc
else 'unknown'
end
To make case to accept floats, one should use triple-dot ranges:
case age_years
when 0...16 then 'child'
when 16...25 then '16 to 24'
when 25...35 then '25 to 34'
when 35...45 then '35 to 44'
when 45...55 then '45 to 54'
when 55...64 then '55 to 64'
when 64..Float::INFINITY then 'really old' # or when 64.method(:<).to_proc
else 'unknown'
end

Answer 3

Here's how I'd do it, to avoid code repetition between 16 and 64 :
def age_range(age, offset=4, span=10, lowest_age=16)
i = ((age-offset-1)/span).to_i
min = [i*span+offset+1, lowest_age].max
max = (i+1)*span + offset
"#{min} to #{max}"
end
def age_description(age)
case age
when 0...16 then 'child'
when 16..64 then age_range(age)
when 64..999 then 'really old'
else 'unknown'
end
end
(0..99).each do |age|
puts "%s (%s)" % [age_description(age), age]
end
It outputs :
child (0)
child (1)
child (2)
child (3)
child (4)
child (5)
child (6)
child (7)
child (8)
child (9)
child (10)
child (11)
child (12)
child (13)
child (14)
child (15)
16 to 24 (16)
16 to 24 (17)
16 to 24 (18)
16 to 24 (19)
16 to 24 (20)
16 to 24 (21)
16 to 24 (22)
16 to 24 (23)
16 to 24 (24)
25 to 34 (25)
25 to 34 (26)
25 to 34 (27)
25 to 34 (28)
25 to 34 (29)
25 to 34 (30)
25 to 34 (31)
25 to 34 (32)
25 to 34 (33)
25 to 34 (34)
35 to 44 (35)
...
As a bonus, it also works with Floats (e.g. 15.9 and 16.0).