Calculations in Ruby

class Conditions < Reckoning::RuleSet
  pick :all
  rule 'Major wound', condition: 'damage >= max_hp / 2', value: '"major_wound"'
  rule 'Down', condition: 'hp_after = 0'
end

class Wound < Reckoning::Calculation
  step :hp_after, formula('MAX(0, hp - damage)')
  step :conditions, Conditions.new
end

result = Wound.call(hp: 12, max_hp: 12, damage: 7)
result[:hp_after]                          # => 5
result[:conditions]                        # => {"Major wound" => "major_wound"}
result.slice(:hp_after, :conditions)       # => {hp_after: 5, conditions: {"Major wound" => "major_wound"}}

conditions = Reckoning::RuleSet.new(pick: :all) do |rules|
  house_rules.each { |house_rule| rules.rule house_rule.name, condition: house_rule.condition, value: house_rule.label }
end
conditions.call(damage: 7).value           # => {"Bleeding" => "bleeding"}

line = Reckoning::Calculation.new do |c|
  c.step :total, c.formula('price * qty')
end

order = Reckoning::Calculation.new do |c|
  c.step :price, c.lookup(prices, where: {plan: :plan}, value: :price, on: :renews_on)
  c.step :lines, c.run(line, over: :items)
  c.step :sum_of_lines, c.sum(:total, of: :lines)
  c.step :best, c.compare(:price, :sum_of_lines, pick: :highest)
end

result = order.call(plan: 'basic', renews_on: Date.new(2026, 11, 2), items: [{qty: 2}, {qty: 3}])
result[:price]                             # => 12.5
result[:sum_of_lines]                      # => 62.5
result[:lines].map { _1[:total] }          # => [25.0, 37.5]

result = Wound.call(hp: 12, max_hp: 12, damage: 7)
result.trace.each { |entry| puts "#{entry.step}: #{entry.value.inspect} (#{entry.detail.class})" }
# hp_after: 5 (String)
# conditions: {"Major wound" => "major_wound"} (Reckoning::Pick::Choice)
result.trace.last.detail.chosen            # => ["Major wound"]

blueprint = Reckoning::Blueprint.load(<<~YAML)
  calculations:
    double:
      inputs: {x: {type: number}}
      steps:
        - {name: y, formula: x * 2}
      outputs: [y]
YAML

blueprint.call({x: 2.5})                   # => {y: 5.0}
blueprint.explain({x: 2.5})                # => {outputs: {y: 5.0}, steps: [{step: :y, value: 5.0, formula: "x * 2"}]}
blueprint.inputs                           # => {"double" => {"x" => {type: "number"}}}
blueprint.fact_problems({x: 'two'})        # => ["fact x should be a number, not \"two\""]

begin
  blueprint.call({x: 'two'})
rescue Reckoning::Blueprint::Failure => e
  e.class      # => Reckoning::Blueprint::Refused
  e.problems   # => ["fact x should be a number, not \"two\""]
end

at = -> (hour, minute = 0) { Time.new(2026, 7, 1, hour, minute, 0, '+10:00') }

Reckoning::Interval.new(at.call(16), at.call(22)).split_daily_at([0, 7, 18, 21])
# 16:00-18:00 120m, 18:00-21:00 180m, 21:00-22:00 60m

Reckoning::Interval.new(at.call(11), at.call(21)).without([Reckoning::Interval.new(at.call(13), at.call(13, 30))])
# 11:00-13:00, 13:30-21:00

before, after = Reckoning::Interval.split_after(
  [Reckoning::Interval.new(at.call(7), at.call(9)), Reckoning::Interval.new(at.call(9), at.call(18)), Reckoning::Interval.new(at.call(18), at.call(20))],
  9 * 60
)
# before: 07:00-09:00, 09:00-16:00
# after: 16:00-18:00, 18:00-20:00

begin
  blueprint.call(facts)
rescue Reckoning::Blueprint::Failure => e
  e.problems
end

it 'passes its check and every worked example' do
  directory = Reckoning::Blueprint.shipped_directory('sales_commission')
  path = File.join(directory, 'blueprint.yml')
  cases = Reckoning::Blueprint.read(File.read(File.join(directory, 'cases.yml')))

  expect(Reckoning::Blueprint.check_file(path)).to eq([])
  expect(Reckoning::Blueprint::Tester.new(Reckoning::Blueprint.load_file(path)).call(cases)).to include(failed: 0)
end