Find product's frequency in this CashRegister class - ruby

Question

I have 3 simple classes CashRegister, Bill and Position. A CashRegister is composed of Bill objects and a Bill object is composed of Position objects. They're implemented as followed
class CashRegister
def initialize
#bills = []
end
def product_frequency
#???
end
def << bill
#bills << bill
self
end
end
class Bill
attr_reader :positions,:nr
protected :positions
def initialize(nr)
#nr = nr
#positions = []
end
def << pos
#positions << pos
self
end
end
class Position
attr_reader :product,:quantity,:price
def initialize(product,quantity,single_price)
#product = product
#quantity = quantity
#price = single_price * quantity
end
end
I want to write a product_frequency method that calculates how often a product is bought in the CashRegister. This method returns a hash as a result, with the product as key, and the frequency as value.
An example would be:
pos1 = Position.new('Chicken', 5, 12)
pos2 = Position.new('Soup', 6, 24)
pos3 = Position.new('Burger', 3, 19)
pos4 = Position.new('Chicken', 2, 12)
pos5 = Position.new('Soup', 8, 24)
pos6 = Position.new('Burger', 9, 19)
bill1 = Bill.new(1) << pos1 << pos2 << pos3 #Chicken: 5;Soup: 6;Burger: 3
bill2 = Bill.new(2) << pos4 << pos3 << pos2 #Chicken: 2;Soup: 6;Burger: 3
bill3 = Bill.new(3) << pos6 << pos6 << pos6 #Chicken: 0;Soup: 0;Burger: 27
bill4 = Bill.new(4) << pos4 << pos5 << pos4 #Chicken: 4;Soup: 8;Burger: 0
my_cash_register = CashRegister.new << bill1 << bill2 << bill3 << bill4
my_cash_register.product_frequency #{'Chicken' => 11, 'Soup' => 20, 'Burger' => 33}
How can I accomplish that result?

Answer 1

Taken mostly from the solution of Bartosz Bonisławski. But since positionen in bill is protected, we first have to make it accessible by defining an each function in Bill that takes in a block and applies it to every position of positions. We also do the same for CashRegister.
class CashRegister
def initialize
#bills = []
end
def each(&block)
#bills.each(&block)
end
def product_frequency
result = {}
each { |bill|
bill.each { |position|
result[position.product] ||= 0
result[position.product] += position.quantity
}
}
result
end
def << bill
#bills << bill
self
end
end
class Bill
attr_reader :positions,:nr
protected :positions
def initialize(nr)
#nr = nr
#positions = []
end
def each(&block)
#positions.each(&block)
end
def << pos
#positions << pos
self
end
end
class Position
attr_reader :product,:quantity,:price
def initialize(product,quantity,single_price)
#product = product
#quantity = quantity
#price = single_price * quantity
end
end

Answer 2

If you just want to count how many times each product was bought, then here it is:
def product_frequency
product_frequency = {}
#bills.each do |bill|
bill.positionen.each do |position|
#product_frequency[position.product] ||= 0
#product_frequency[position.product] += position.quantity
end
end
product_frequency
end
It's just one way of doing it. Code is pretty easy, so I think you can figure how it works

Answer 3

You could define #frequency for each nested class and then recursively collect hashes.
class Hash
def additive_merge!(hash)
hash.each { |k,v| self[k] ? self[k] += v : self[k] = v }
self
end
end
class CashRegister
def initialize
#bills = []
end
def product_frequency
#bills.map(&:frequency).reduce(&:additive_merge!)
end
def << bill
#bills << bill
self
end
end
class Bill
attr_reader :positionen,:nr
protected :positionen
def initialize(nr)
#nr = nr
#positions = []
end
def << pos
#positions << pos
self
end
def frequency
#positions.map(&:frequency).reduce(&:additive_merge!)
end
end
class Position
attr_reader :product,:quantity,:price
def initialize(product,quantity,single_price)
#product = product
#quantity = quantity
#price = single_price * quantity
end
def frequency
{ product => quantity }
end
end