ruby · level 2 check

an expense tracker that saves JSON.

Time to build something you could really use: an expense tracker. You type commands like `add coffee food 3.50`, and it keeps every expense in a file called `expenses.json`, so nothing is lost when the program stops.

It brings the whole level together. Each expense is an `Expense` object with readers, `to_h` and `to_s`. Amounts are kept as whole pence, and categories in small letters, so `Food` and `food` land in one group. Every `add` loads the JSON, adds the new expense and saves it again. `list`, `total` and `report` read the file back, and `json` shows exactly what was saved.

Bad input must never crash it. `Float(text)` works like `Integer`, but for decimals, and raises the same kind of error. A wrong amount, or an `add` with missing pieces, raises your own `BadEntry` error, and the tracker rescues it with a friendly message. Fill in each `____`, run it, then try your own commands, one per line.

Your program

require "json"

FILE = "expenses.json"

class BadEntry < StandardError; end

class Expense
  attr_reader :item, :category, :pence

def initialize(item, category, pence)
    raise BadEntry, "Amount must be more than zero" if pence <= 0
    @item = item
    @category = category.____
    @pence = pence
  end

def to_h = { item: item, category: category, pence: pence }

def to_s = format("%-10s%-10s%8s", item, category, money(pence))
end

def money(pence) = format("£%.2f", pence / 100.0)

def to_pence(text)
  (Float(text) * 100).____
rescue ____
  raise BadEntry, "#{text} is not an amount"
end

def load_expenses
  return [] if !File.exist?(FILE)
  rows = JSON.parse(File.read(FILE), ____: true)
  rows.map { |row| Expense.new(row[:item], row[:category], row[:pence]) }
end

def save_expenses(expenses)
  File.write(FILE, JSON.pretty_generate(expenses.map { |expense| expense.____ }))
end

def add(words)
  raise BadEntry, "Type it as: add ITEM CATEGORY AMOUNT" if words.length != 4
  expense = Expense.new(words[1], words[2], to_pence(words[3]))
  expenses = load_expenses
  expenses << expense
  save_expenses(expenses)
  puts "Saved #{expense.item} for #{money(expense.pence)}. #{expenses.length} in #{FILE}"
end

def list
  expenses = load_expenses
  puts "No expenses yet" if expenses.length == 0
  expenses.each { |expense| puts expense }
end

def total
  pence = load_expenses.____ { |expense| expense.pence }
  puts "Total: #{money(pence)}"
end

def report
  groups = load_expenses.____ { |expense| expense.category }
  groups.sort_by { |category, expenses| category }.each do |category, expenses|
    puts "#{category}: #{money(expenses.sum { |expense| expense.pence })}"
  end
end

def handle(text)
  words = text.split
  return if words.length == 0
  command = words[0]
  if command == "add"
    add(words)
  elsif command == "list"
    list
  elsif command == "total"
    total
  elsif command == "report"
    report
  elsif command == "json"
    puts File.read(FILE) if File.exist?(FILE)
  else
    puts "Unknown command: #{command}"
  end
rescue ____ => error
  puts "Oops: #{error.message}"
end

puts "Commands: add ITEM CATEGORY AMOUNT, list, total, report, json, quit"
line = gets
while line && line.chomp != "quit"
  handle(line.chomp)
  line = gets
end
puts "Bye!"

Fill in every ____ then run the checks.

1 It saves each expense and lists ituses: files
2 It stores the expenses as JSONuses: JSON
3 It totals in pounds and penceuses: formatting
4 It reports each category, whatever the capitalsuses: Enumerable
5 It rescues bad input without crashinguses: errors
6 It skips blank lines and unknown commandsuses: decisions

Take as long as you like and try as many times as you want.

an expense tracker that saves JSON.

level up.

playground