Redmine/body_tracking
Archived
1
0
Fork 0
Code Releases Activity

compute_quantities: allow indirect associations and model dependencies

Browse Source
This commit is contained in:
cryptogopher 2020-05-10 18:06:32 +02:00
parent 9d19890f6f
commit 1f5ea1cfb6
10 changed files with 129 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
app/controllers/meals_controller.rb
View File

@ -94,35 +94,32 @@ class MealsController < ApplicationController
def prepare_meals
@quantities = @project.meal_quantities.includes(:formula)
foods = @project.meal_foods.compute_quantities(@quantities)
ingredients = @project.meal_ingredients
@amount_mfu_unit = ingredients
.each_with_object(Hash.new(0)) { |i, h| h[i.food.ref_unit] += 1 }
.max_by(&:last).try(&:first)
@nutrients = {}
@nutrient_summary = Hash.new { |h,k| h[k] = Hash.new(BigDecimal(0)) }
@quantities.each do |q|
@nutrients[q] = ingredients.find_all { |i| foods[i.food][q] }.map do |i|
n_amount, n_unit = foods[i.food][q]
[i, [n_amount * i.amount / i.food.ref_amount, n_unit]]
end.to_h
mfu_unit = @nutrients[q].each_with_object(Hash.new(0)) { |(i, v), h| h[v.last] += 1 }
.max_by(&:last).try(&:first)
max_value = @nutrients[q].values.max_by { |a, u| a || 0 }.try(&:first) || BigDecimal(0)
precision = [3 - max_value.exponent, 0].max
# TODO: summing up ingredients should take units into account
@nutrients[q].each do |i, (a, v)|
meal = i.composition
@nutrient_summary[q][meal] += a
@nutrient_summary[q][meal.display_date] += a
@ingredients = @project.meal_ingredients.compute_quantities(@quantities) do |q, items|
Hash.new { |h,k| k.composition } if q == Meal
end
@nutrients[q][:mfu_unit] = mfu_unit
@nutrients[q][:precision] = precision
@amount_mfu_unit = @ingredients
.each_with_object(Hash.new(0)) { |(i, qv), h| h[i.food.ref_unit] += 1 }
.max_by(&:last).try(&:first)
@ingredient_summary = Hash.new { |h,k| h[k] = Hash.new(BigDecimal(0)) }
@quantities.each do |q|
@ingredient_summary[:mfu_unit][q] = @ingredients
.each_with_object(Hash.new(0)) { |(i, qv), h| h[qv[q].last] += 1 if qv[q] }
.max_by(&:last).try(&:first)
max_value = @ingredients.max_by { |i, qv| qv[q].try(&:first) || 0 }.last[q].try(&:first)
max_value ||= BigDecimal(0)
@ingredient_summary[:precision][q] = [3 - max_value.exponent, 0].max
end
# TODO: summing up ingredients should take units into account
@ingredients.each do |i, qv|
meal = i.composition
qv.compact.each do |q, (a, u)|
@ingredient_summary[meal][q] += a
@ingredient_summary[meal.display_date][q] += a
end
end
@meals_by_date = @project.meals.reject(&:new_record?)

1
app/models/food.rb
View File

@ -15,6 +15,7 @@ class Food < ActiveRecord::Base
belongs_to :project, required: true
belongs_to :ref_unit, class_name: 'Unit', required: true
belongs_to :source, required: false
has_many :ingredients, dependent: :restrict_with_error
has_many :nutrients, inverse_of: :food, dependent: :destroy, validate: true
validates :nutrients, presence: true

82
app/models/formula.rb
View File

@ -1,7 +1,7 @@
class Formula < ActiveRecord::Base
include BodyTracking::FormulaBuilder
attr_reader :parts, :quantities
attr_reader :parts, :quantity_deps, :model_deps
belongs_to :quantity, inverse_of: :formula, required: true
belongs_to :unit
@ -17,85 +17,29 @@ class Formula < ActiveRecord::Base
end
end
def self.resolve(quantities, items, subitems)
unchecked_q = quantities.map { |q| [q, nil] }
# TODO: jesli wartosci nie ma w subitems to pytac w yield (jesli jest block)
completed_q = {}
# FIXME: loop should finish unless there is circular dependency in formulas
# for now we don't guard against that
while !unchecked_q.empty?
q, deps = unchecked_q.shift
# quantity not computable: no formula/invalid formula (syntax error/runtime error)
# or not requiring calculation/computed
if !q.formula || q.formula.errors.any? || !q.formula.valid? ||
(subitems[q].length == items.count)
completed_q[q] = subitems.delete(q) { {} }
next
end
# quantity with formula requires refresh of dependencies availability
if deps.nil? || !deps.empty?
deps ||= q.formula.quantities.clone
deps.reject! { |d| completed_q.has_key?(d) }
deps.each { |d| unchecked_q << [d, nil] unless unchecked_q.index { |u| u[0] == d } }
end
# quantity with formula has all dependencies satisfied, requires calculation
if deps.empty?
output_items = items.select { |i| subitems[q][i].nil? }
input_q = q.formula.quantities
inputs = input_q.map do |i_q|
values = completed_q[i_q].values_at(*output_items).map { |v| v || [nil, nil] }
values.map! { |v, u| [v || BigDecimal(0), u] } if q.formula.zero_nil
[i_q, values]
end
begin
calculated = q.formula.calculate(inputs.to_h)
rescue Exception => e
output_items.each { |o_i| subitems[q][o_i] = nil }
q.formula.errors.add(
:code, :computation_failed,
{
quantity: q.name,
description: e.message,
count: output_items.size == subitems[q].size ? 'all' : output_items.size
}
)
else
output_items.each_with_index { |o_i, idx| subitems[q][o_i] = calculated[idx] }
end
unchecked_q.unshift([q, deps])
next
end
# quantity still has unsatisfied dependencies, move to the end of queue
unchecked_q << [q, deps]
end
completed_q
end
def calculate(inputs)
raise(InvalidInputs, 'No inputs') if inputs.empty?
quantities = inputs.map { |q, v| [q.name, v.transpose[0]] }.to_h
length = quantities.values.first.length
deps = inputs.map { |q, v| [q.name, v.transpose[0]] }.to_h
length = deps.values.first.length
raise(InvalidFormula, 'Invalid formula') unless self.valid?
raise(InvalidInputs, 'Inputs lengths differ') unless
quantities.values.all? { |v| v.length == length }
deps.values.all? { |v| v.length == length }
args = []
@parts.each do |p|
code = p[:type] == :indexed ?
"length.times.map { |_index| #{p[:content]} }" : p[:content]
args << get_binding(quantities, args, length).eval(code)
args << get_binding(deps, args, length).eval(code)
end
args.last.map { |v| [v, self.unit] }
end
def dependencies
@quantity_deps + @model_deps
end
private
def parse
@ -108,11 +52,13 @@ class Formula < ActiveRecord::Base
errors = parser.errors
quantities = Quantity.where(project: self.quantity.project, name: identifiers.to_a)
(identifiers - quantities.map(&:name) - q_methods.keys).each do |q|
errors << [:unknown_quantity, {quantity: q}]
identifiers -= quantities.map(&:name)
models = identifiers.map(&:safe_constantize).compact || []
(identifiers - models.map(&:class_name)).each do |i|
errors << [:unknown_dependency, {identifier: i}]
end
@parts, @quantities = parts, quantities.to_a if errors.empty?
@parts, @quantity_deps, @model_deps = parts, quantities.to_a, models if errors.empty?
errors
end

2
app/views/meals/_index.html.erb
View File

@ -27,7 +27,7 @@
<tr class="header">
<td class="quantityhead"><%= "[#{@amount_mfu_unit.shortname}]" %></td>
<% @quantities.each do |q| %>
<% mfu_unit = @nutrients[q][:mfu_unit] %>
<% mfu_unit = @ingredient_summary[:mfu_unit][q] %>
<td class="quantityhead"><%= "[#{mfu_unit ? mfu_unit.shortname : '-'}]" %></td>
<% end %>
</tr>

2
app/views/meals/_show.html.erb
View File

@ -37,7 +37,7 @@
<td class="value ellipsible" style="border-left: none;"></td>
<% @quantities.each do |q| %>
<td class="value ellipsible">
<%= format_value(@nutrient_summary[q][m], @nutrients[q][:precision]) %>
<%= format_value(@ingredient_summary[m][q], @ingredient_summary[:precision][q]) %>
</td>
<% end %>

2
app/views/meals/_show_date.html.erb
View File

@ -7,7 +7,7 @@
<td class="value ellipsible" style="border-left: none;"></td>
<% @quantities.each do |q| %>
<td class="value ellipsible">
<%= format_value(@nutrient_summary[q][date], @nutrients[q][:precision]) %>
<%= format_value(@ingredient_summary[date][q], @ingredient_summary[:precision][q]) %>
</td>
<% end %>
<td></td>

3
app/views/meals/_show_ingredient.html.erb
View File

@ -6,7 +6,8 @@
</td>
<% @quantities.each do |q| %>
<td class="value ellipsible">
<%= format_value(*@nutrients[q].values_at(i, :precision, :mfu_unit)) %>
<%= format_value(@ingredients[i][q], @ingredient_summary[:precision][q],
@ingredient_summary[:mfu_unit][q]) %>
</td>
<% end %>
<td class="action unwrappable" style="width: 1%; text-align: right;">

2
config/locales/en.yml
View File

@ -51,7 +51,7 @@ en:
disallowed_token: 'includes disallowed token: "%{token}"'
disallowed_keyword: 'includes disallowed keyword: "%{keyword}"'
disallowed_method: 'includes disallowed method call: "%{method}"'
unknown_quantity: 'contains undefined quantity: %{quantity}'
unknown_dependency: 'contains undefined dependency: %{identifier}'
computation_failed: 'computation failed for "%{quantity}": %{description}
(%{count} values missing)'
body_trackers:

103
lib/body_tracking/items_with_quantities.rb
View File

@ -1,16 +1,19 @@
module BodyTracking
module ItemsWithQuantities
RELATIONS = {
ITEM_TYPES = {
'Ingredient' => {
domain: :diet,
associations: [:food, :nutrients],
value_field: :amount
},
'Food' => {
domain: :diet,
subitem_class: Nutrient,
association: :food,
associations: [:nutrients],
value_field: :amount
},
'Measurement' => {
domain: :measurement,
subitem_class: Readout,
association: :measurement,
associations: [:readouts],
value_field: :value
}
}
@ -30,7 +33,7 @@ module BodyTracking
if filters[:formula][:code].present?
owner = proxy_association.owner
project = owner.is_a?(Project) ? owner : owner.project
domain = RELATIONS[proxy_association.klass.name][:domain]
domain = ITEM_TYPES[proxy_association.klass.name][:domain]
filter_q_attrs = {
name: 'Filter formula',
formula_attributes: filters[:formula],
@ -53,23 +56,91 @@ module BodyTracking
def compute_quantities(requested_q, filter_q = nil)
items = all
relations = RELATIONS[proxy_association.klass.name]
item_type = ITEM_TYPES[proxy_association.klass.name]
subitems = Hash.new { |h,k| h[k] = {} }
relations[:subitem_class].where(relations[:association] => items)
.includes(:quantity, :unit).order('quantities.lft').each do |s|
item = s.send(relations[:association])
subitem_value = s.send(relations[:value_field])
subitems[s.quantity][item] = [subitem_value, s.unit]
# Ingredient.includes(food: {nutrients: [:quantity, :unit]}).order('quantities.lft')
# Food.includes(nutrients: [:quantity, :unit]).order('quantities.lft')
includes = item_type[:associations].reverse
.inject([:quantity, :unit]) { |relation, assoc| {assoc => relation} }
all.includes(includes).order('quantities.lft').each do |i|
item_type[:associations].inject(i) { |o, m| o.send(m) }.each do |s|
subitem_value =
if i.respond_to?(item_type[:value_field])
s_value = s.send(item_type[:value_field])
i_value = i.send(item_type[:value_field])
# NOTE: for now scaling is designed only for Ingredients
s_value * i_value / i.food.ref_amount
else
s.send(item_type[:value_field])
end
subitems[s.quantity][i] = [subitem_value, s.unit]
end
end
quantities = (requested_q || Quantity.none) + Array(filter_q)
completed_q = Formula.resolve(quantities, items, subitems)
unchecked_q = requested_q.map { |q| [q, nil] }
unchecked_q << [filter_q, nil] if filter_q
completed_q = {}
# FIXME: loop should finish unless there is circular dependency in formulas
# for now we don't guard against that
while !unchecked_q.empty?
q, deps = unchecked_q.shift
# quantity not computable: no formula/invalid formula (syntax error/runtime error)
# or not requiring calculation/computed
if !q.formula || q.formula.errors.any? || !q.formula.valid? ||
(subitems[q].length == items.count)
completed_q[q] = subitems.delete(q) { {} }
next
end
# quantity with formula requires refresh of dependencies availability
if deps.nil? || !deps.empty?
deps ||= q.formula.quantity_deps.clone
deps.reject! { |d| completed_q.has_key?(d) }
deps.each { |d| unchecked_q << [d, nil] unless unchecked_q.index { |u| u[0] == d } }
end
# quantity with formula has all dependencies satisfied, requires calculation
if deps.empty?
output_items = items.select { |i| subitems[q][i].nil? }
input_q = q.formula.dependencies
inputs = input_q.map do |i_q|
# Yielding for all 'items', not only 'output_items' as completed_q may
# be used for multiple formulas with different unknowns item sets
completed_q[i_q] ||= yield(i_q, items) unless i_q.class == Quantity
values = completed_q[i_q].values_at(*output_items).map { |v| v || [nil, nil] }
values.map! { |v, u| [v || BigDecimal(0), u] } if q.formula.zero_nil
[i_q, values]
end
begin
calculated = q.formula.calculate(inputs.to_h)
rescue Exception => e
output_items.each { |o_i| subitems[q][o_i] = nil }
q.formula.errors.add(
:code, :computation_failed,
{
quantity: q.name,
description: e.message,
count: output_items.size == subitems[q].size ? 'all' : output_items.size
}
)
else
output_items.each_with_index { |o_i, idx| subitems[q][o_i] = calculated[idx] }
end
unchecked_q.unshift([q, deps])
next
end
# quantity still has unsatisfied dependencies, move to the end of queue
unchecked_q << [q, deps]
end
filter_values = completed_q.delete(filter_q)
items.to_a.keep_if { |i| filter_values[i][0] } if filter_values
subitems.merge!(completed_q)
subitem_keys = subitems.keys.sort_by { |q| q.lft }
subitem_keys = subitems.keys.select { |k| k.class == Quantity }.sort_by { |q| q.lft }
items.map { |i| [i, subitem_keys.map { |q| [q, subitems[q][i]] }.to_h] }.to_h
end
end

3
lib/body_tracking/project_patch.rb
View File

@ -17,7 +17,8 @@ module BodyTracking::ProjectPatch
extend: BodyTracking::ItemsWithQuantities, through: :measurement_routines
has_many :meals, -> { order "eaten_at DESC" }, dependent: :destroy
has_many :meal_ingredients, through: :meals, source: 'ingredients'
has_many :meal_ingredients, through: :meals, source: 'ingredients',
extend: BodyTracking::ItemsWithQuantities
has_many :meal_foods, through: :meal_ingredients, source: 'food',
extend: BodyTracking::ItemsWithQuantities
has_many :meal_exposures, -> { where view_type: "Meal" }, dependent: :destroy,