Count nested item before save - ruby-on-rails

Question

Let have Order and Item models.
class Order < ApplicationRecord
has_many :items, inverse_of: :order, dependent: :delete_all
before_save do
self.packed_volume = compute_packed_volume
end
private
def compute_packed_volume
items.count * 0.1O
end
end
And
class Item < ApplicationRecord
belongs_to :order, inverse_of: :items
end
The problem is that items.count is equals to 0 since items are not yet created.
How can we get the number of items that will be created to used it when we create an order?

Answer 1

Try size instead, it won't run a query
items.size * 0.1O
Hope that helps!

Answer 2

What you're looking for is a "counter cache". It implements exactly what you're trying to do. ActiveRecord can do this for you:
belongs_to :post, :counter_cache => true
There are a couple of gems that do this, updating a count field in the parent record whenever a child record is created or deleted.
Gem counter-cache does the job simply. Another, counter-culture takes it a bit further, including support for counting children in has_many :through relationships.
Your example is a little more interesting, as you're not looking for the count, but a computation on the count. So, you could either just roll with that and use it to compute the packed_volume on the fly, probably in a method on the model very similar to your compute_packed_volume() method.
If you wanted to store the actual volume in your parent record (perhaps it is very expensive to compute), you need to shift from putting callbacks on the parent model to putting them on the child model. The counter_culture gem supports that with its "Delta Magnitude". Something like this:
class Item < ActiveRecord::Base
belongs_to :order
counter_culture :order, column_name: :packed_volume, delta_magnitude: 0.1
end
class Order < ActiveRecord::Base
has_many :items
end
The delta_magnitude parameter can take a proc, so you can do more complicated things. Perhaps something like this:
counter_culture :order, column_name: :packed_volume, delta_magnitude: -> {|item| item.length * item.width * item.height }
You could roll your own solution along these lines if you have other requirements that preclude using a gem. You'll need to add callbacks to Item for after_create and before_destroy to increment/decrement the parent record. You may also need to update the order when the record is changed, if your volume computation becomes more complicated.