What is the cleanest way to calculate instance variables in initialize? - ruby

Question

Say I have a class that defines a collection of my days and how wacky they are. Is it better to initialize my #scores variable in the initialize function like so:
class WackyDayScorer
attr_reader :scores
def initialize(start = Time.now, max = 90.days)
#start = start
#limit = start - max
#scores = get_scores
end
private
def get_scores
result = []
t = #start.clone
until t < max
result << score_wackiness(t)
t -= 1.day
end
result
end
end
or initialize it in the get_scores method like so:
class WackyDayScorer
attr_reader :scores
def initialize(start = Time.now, max = 90.days)
#start = start
#limit = start - max
get_scores
end
private
def get_scores
#scores = []
t = #start.clone
until t < max
#scores << score_wackiness(t)
t -= 1.day
end
end
end

Answer 1

The first one is just plain wrong. You are saying
#scores = get_scores
But get_scores does not return a useful value, so this is nuts. Instead, get_scores sets #scores directly and internally as a side effect.
The second one is at least coherent.
Personally, though, I would not do either of the things you do. I would say what you say the first time:
#scores = get_scores
But my implementation of get_scores would not touch any ivar. It would return an actual value:
def get_scores
scores = []
# do stuff to scores
return scores # or simply, scores
end

Answer 2

If you want to handle something in initialization, create a private method to handle the calculation and then set the instance variable in #initialize. I wouldn't set it in the method in case you want to reuse that calculation elsewhere in the class without wiping out your instance variable.
class WackyDayScorer
attr_accessor :scores
def initialize(start = DateTime.now, max = 90.days)
#start = start
#limit = start - max
#scores = calculate_scores
end
private
def calculate_scores
(#limit..#start).to_a.map { |date_time| score_wackiness(date_time) }
end
end
In #calculate_scores, we are creating a range between the limit date and the start (counting backwards, as you were doing) and sending each result to the #score_wackiness method.

Answer 3

I'd recommend explicitly defining the getter for scores, memoizing the calculation and skipping all the ceremony:
class WackyDayScorer
def initialize(start = Time.now, max = 90.days)
#start = start
#limit = start - max
end
def scores
#scores ||= begin
result = []
t = #start.clone
until t < max
result << score_wackiness(t)
t -= 1.day
end
result
end
end
end
This is basically what you are doing anyway, but it's more direct.