Add account hierarchy to balance commands

Expand colon-separated account hierarchies so parent accounts
aggregate their children's balances. Group entries are displayed
after leaf accounts, with children nested below their parent group.
Group labels are styled with a colored background in terminal output.

Author: ad-si

src/lib.rs

@@ -594,14 +594,19 @@ pub fn show_account_aligned(
   width_rec: &WidthRecord,
   account_id: &str,
   map: &CommodityMap,
+  is_group: bool,
 ) -> String {
   let gap = 2;
   let account_width = width_rec.account.max(account_id.len());
   // Right-align (pad on left) to match PureScript Text.Format behavior
   let acc_name = pad_start(account_width, account_id);
 
   let colored_acc = if color {
-    acc_name.blue().to_string()
+    if is_group {
+      acc_name.black().on_cyan().to_string()
+    } else {
+      acc_name.blue().to_string()
+    }
   } else {
     acc_name
   };
@@ -849,6 +854,43 @@ pub enum BalanceFilter {
   All,
 }
 
+/// Normalize account IDs (strip `:_default_`) and create parent entries
+/// that aggregate the balances of all their children.
+///
+/// For example, given leaf accounts `john:visa`, `john:bank:savings`, and
+/// `john:bank:depot`, this produces additional entries for `john:bank`
+/// (sum of savings + depot) and `john` (sum of all three).
+pub fn expand_account_hierarchy(balance_map: BalanceMap) -> BalanceMap {
+  // Step 1: Normalize all keys (remove :_default_ suffix)
+  let mut normalized: BalanceMap = BalanceMap::new();
+  for (acc_id, com_map) in balance_map {
+    let norm_id = norm_acc_id(&acc_id);
+    let entry = normalized.entry(norm_id).or_default();
+    for amount in com_map.into_values() {
+      commodity_map_add(entry, amount);
+    }
+  }
+
+  // Step 2: For each account, add its amounts to all ancestor prefixes
+  let leaves: Vec<(String, CommodityMap)> = normalized
+    .iter()
+    .map(|(k, v)| (k.clone(), v.clone()))
+    .collect();
+
+  for (acc_id, com_map) in &leaves {
+    let parts: Vec<&str> = acc_id.split(':').collect();
+    for i in 1..parts.len() {
+      let ancestor = parts[..i].join(":");
+      let entry = normalized.entry(ancestor).or_default();
+      for amount in com_map.values() {
+        commodity_map_add(entry, amount.clone());
+      }
+    }
+  }
+
+  normalized
+}
+
 pub fn show_balance(
   filter: BalanceFilter,
   color: bool,
@@ -875,6 +917,10 @@ pub fn show_balance(
     }
   }
 
+  // Expand the account hierarchy so that parent accounts
+  // (e.g. "john", "john:bank") aggregate their children.
+  let balance_map = expand_account_hierarchy(balance_map);
+
   // Apply filter and remove zero amounts
   let mut filtered: Vec<(String, CommodityMap)> = balance_map
     .into_iter()
@@ -901,14 +947,64 @@ pub fn show_balance(
     })
     .collect();
 
-  // Sort by account id
+  // Determine which accounts are groups (have children in the list)
+  let account_ids: Vec<String> =
+    filtered.iter().map(|(id, _)| id.clone()).collect();
+  let is_group = |acc_id: &str| -> bool {
+    let prefix = format!("{}:", acc_id);
+    account_ids.iter().any(|id| id.starts_with(&prefix))
+  };
+  // Find the most specific (deepest) parent group for an account
+  let parent_group = |acc_id: &str| -> Option<String> {
+    account_ids
+      .iter()
+      .filter(|g| is_group(g) && acc_id.starts_with(&format!("{}:", g)))
+      .max_by_key(|g| g.len())
+      .cloned()
+  };
+
+  // Sort alphabetically first
   filtered.sort_by(|a, b| a.0.cmp(&b.0));
 
+  // Partition into ungrouped leaves, groups, and their children
+  let mut ungrouped: Vec<(String, CommodityMap)> = Vec::new();
+  let mut groups: std::collections::BTreeMap<
+    String,
+    Vec<(String, CommodityMap)>,
+  > = std::collections::BTreeMap::new();
+  let mut group_entries: std::collections::BTreeMap<String, CommodityMap> =
+    std::collections::BTreeMap::new();
+
+  for (acc_id, com_map) in filtered {
+    if is_group(&acc_id) {
+      groups.entry(acc_id.clone()).or_default();
+      group_entries.insert(acc_id, com_map);
+    } else if let Some(g) = parent_group(&acc_id) {
+      groups.entry(g).or_default().push((acc_id, com_map));
+    } else {
+      ungrouped.push((acc_id, com_map));
+    }
+  }
+
+  // Reassemble: ungrouped leaves, then each group with its children
+  let mut ordered: Vec<(String, CommodityMap, bool)> = Vec::new();
+  for (acc_id, com_map) in ungrouped {
+    ordered.push((acc_id, com_map, false));
+  }
+  for (group_id, children) in &groups {
+    if let Some(com_map) = group_entries.remove(group_id) {
+      ordered.push((group_id.clone(), com_map, true));
+    }
+    for (acc_id, com_map) in children {
+      ordered.push((acc_id.clone(), com_map.clone(), false));
+    }
+  }
+
   // Compute global width record
   let global_wr =
-    filtered
+    ordered
       .iter()
-      .fold(WidthRecord::zero(), |acc, (acc_id, map)| {
+      .fold(WidthRecord::zero(), |acc, (acc_id, map, _)| {
         acc.merge(&account_to_width_record(&norm_acc_id(acc_id), map))
       });
   let margin_left = 2;
@@ -918,12 +1014,13 @@ pub fn show_balance(
   };
 
   let mut result = String::new();
-  for (acc_id, map) in &filtered {
+  for (acc_id, map, group) in &ordered {
+    let norm_id = norm_acc_id(acc_id);
+    if *group {
+      result.push('\n');
+    }
     result.push_str(&show_account_aligned(
-      color,
-      &global_wr,
-      &norm_acc_id(acc_id),
-      map,
+      color, &global_wr, &norm_id, map, *group,
     ));
   }
   result.push('\n');

src/main.rs

@@ -1124,6 +1124,131 @@ transactions:
     assert!(verify_ledger_balances(&ledger).is_ok());
   }
 
+  // ─── expand_account_hierarchy ──────────────────────────────────────────────
+
+  #[test]
+  fn hierarchy_creates_parent_from_single_child() {
+    let mut map = BalanceMap::new();
+    let mut child = CommodityMap::new();
+    commodity_map_add(&mut child, make_amount(100, 1, "€"));
+    map.insert("john:giro".to_string(), child);
+
+    let result = expand_account_hierarchy(map);
+
+    assert!(result.contains_key("john"), "Expected parent 'john'");
+    assert!(
+      result.contains_key("john:giro"),
+      "Expected leaf 'john:giro'"
+    );
+    assert_eq!(
+      result["john"]["€"].quantity, result["john:giro"]["€"].quantity,
+      "Parent should equal child when there's only one child"
+    );
+  }
+
+  #[test]
+  fn hierarchy_aggregates_multiple_children() {
+    let mut map = BalanceMap::new();
+
+    let mut savings = CommodityMap::new();
+    commodity_map_add(&mut savings, make_amount(50, 1, "€"));
+    map.insert("john:bank:savings".to_string(), savings);
+
+    let mut depot = CommodityMap::new();
+    commodity_map_add(&mut depot, make_amount(30, 1, "€"));
+    map.insert("john:bank:depot".to_string(), depot);
+
+    let mut visa = CommodityMap::new();
+    commodity_map_add(&mut visa, make_amount(20, 1, "€"));
+    map.insert("john:visa".to_string(), visa);
+
+    let result = expand_account_hierarchy(map);
+
+    // john:bank = savings + depot = 80
+    assert_eq!(result["john:bank"]["€"], make_amount(80, 1, "€"));
+    // john = visa + savings + depot = 100
+    assert_eq!(result["john"]["€"], make_amount(100, 1, "€"));
+    // Leaves unchanged
+    assert_eq!(result["john:bank:savings"]["€"], make_amount(50, 1, "€"));
+    assert_eq!(result["john:bank:depot"]["€"], make_amount(30, 1, "€"));
+    assert_eq!(result["john:visa"]["€"], make_amount(20, 1, "€"));
+  }
+
+  #[test]
+  fn hierarchy_merges_default_suffix_into_parent() {
+    // A single-segment account like "shop" becomes "shop:_default_"
+    // in the balance map. The hierarchy should normalize it to "shop"
+    // and not create a separate parent.
+    let mut map = BalanceMap::new();
+    let mut entry = CommodityMap::new();
+    commodity_map_add(&mut entry, make_amount(10, 1, "€"));
+    map.insert("shop:_default_".to_string(), entry);
+
+    let result = expand_account_hierarchy(map);
+
+    assert!(result.contains_key("shop"), "Expected normalized 'shop'");
+    assert!(
+      !result.contains_key("shop:_default_"),
+      "_default_ key should be normalized away"
+    );
+    assert_eq!(result["shop"]["€"], make_amount(10, 1, "€"));
+  }
+
+  #[test]
+  fn hierarchy_merges_default_with_explicit_children() {
+    // Direct transfers to "john" (stored as john:_default_) plus
+    // transfers to john:giro should both roll up into "john".
+    let mut map = BalanceMap::new();
+
+    let mut direct = CommodityMap::new();
+    commodity_map_add(&mut direct, make_amount(40, 1, "€"));
+    map.insert("john:_default_".to_string(), direct);
+
+    let mut giro = CommodityMap::new();
+    commodity_map_add(&mut giro, make_amount(60, 1, "€"));
+    map.insert("john:giro".to_string(), giro);
+
+    let result = expand_account_hierarchy(map);
+
+    // john = direct (40) + giro (60) = 100
+    assert_eq!(result["john"]["€"], make_amount(100, 1, "€"));
+    // john:giro is unchanged
+    assert_eq!(result["john:giro"]["€"], make_amount(60, 1, "€"));
+  }
+
+  #[test]
+  fn hierarchy_handles_multiple_commodities() {
+    let mut map = BalanceMap::new();
+
+    let mut giro = CommodityMap::new();
+    commodity_map_add(&mut giro, make_amount(50, 1, "€"));
+    commodity_map_add(&mut giro, make_amount(3, 1, "BTC"));
+    map.insert("john:giro".to_string(), giro);
+
+    let mut wallet = CommodityMap::new();
+    commodity_map_add(&mut wallet, make_amount(20, 1, "€"));
+    map.insert("john:wallet".to_string(), wallet);
+
+    let result = expand_account_hierarchy(map);
+
+    assert_eq!(result["john"]["€"], make_amount(70, 1, "€"));
+    assert_eq!(result["john"]["BTC"], make_amount(3, 1, "BTC"));
+  }
+
+  #[test]
+  fn hierarchy_no_parent_for_top_level_account() {
+    // A top-level account should not create any parents.
+    let mut map = BalanceMap::new();
+    let mut entry = CommodityMap::new();
+    commodity_map_add(&mut entry, make_amount(10, 1, "€"));
+    map.insert("shop".to_string(), entry);
+
+    let result = expand_account_hierarchy(map);
+
+    assert_eq!(result.len(), 1);
+    assert!(result.contains_key("shop"));
+  }
+
   // ─── show_balance ─────────────────────────────────────────────────────────
 
   fn simple_ledger() -> Ledger {

tests/snapshots/cli_snapshots__balance.snap

@@ -2,10 +2,10 @@
 source: tests/cli_snapshots.rs
 expression: output
 ---
-         john  212.19     €
+         john   50        $
+                60.752114 BTC
+               363.24     €
     john:giro   50        $
                 60.752114 BTC
                 85        €
   john:wallet   66.05     €
-
-

tests/snapshots/cli_snapshots__balance_all.snap

@@ -12,10 +12,11 @@ expression: output
                  315        €
       good-inc  -820        €
   grocery-shop    11.97     €
-          john   212.19     €
+
+          john    50        $
+                  60.752114 BTC
+                 363.24     €
      john:giro    50        $
                   60.752114 BTC
                   85        €
    john:wallet    66.05     €
-
-

tests/snapshots/cli_snapshots__balance_multi.snap

@@ -2,11 +2,12 @@
 source: tests/cli_snapshots.rs
 expression: output
 ---
-         john  212.19     €
+         john   50        $
+                60.752114 BTC
+                -7.64     £
+               363.24     €
     john:giro   50        $
                 60.752114 BTC
                 -7.64     £
                 85        €
   john:wallet   66.05     €
-
-