acc 0.4.1

plaintext double-entry accounting command line tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! `print` command — write each booked transaction back in canonical,
//! colorized ledger format.
//!
//! Layout per transaction:
//!
//! ```text
//! DATE [STATE] [(CODE)] DESCRIPTION
//!     ; transaction comment
//!     ACCOUNT              COMMODITY VALUE
//!     ; posting comment
//! ```
//!
//! Every indent and gap is emitted via `print_spaces(GAP)` so column
//! alignment is consistent across rows. Accounts and amounts have
//! global max-widths: the account column is left-aligned within
//! `account_max`, the amount column right-aligned within `amount_max`.
//!
//! Runs after the filter phase — the journal is already scoped.

use colored::Colorize;

use super::util::{format_amount, print_spaces};
use crate::loader::Journal;
use crate::parser::posting::Posting;
use crate::parser::transaction::{State, Transaction};

const GAP: usize = 4;

pub fn run(journal: &Journal) {
    let account_max = max_account_width(journal);
    let amount_max = max_amount_width(journal);
    let mut iter = journal.transactions.iter().peekable();

    while let Some(lt) = iter.next() {
        let tx = &lt.value;
        print_header(tx);
        for lp in &tx.postings {
            print_posting(&lp.value, account_max, amount_max, &journal.precisions);
        }
        if iter.peek().is_some() {
            println!();
        }
    }
}

fn print_header(tx: &Transaction) {
    // Uniform 3-char state marker keeps the description column stable.
    let marker = match tx.state {
        State::Cleared => " * ".green().to_string(),
        State::Uncleared => "   ".to_string(),
        State::Pending => " ! ".yellow().to_string(),
    };
    let code = tx
        .code
        .as_deref()
        .map(|c| format!("({}) ", c).yellow().to_string())
        .unwrap_or_default();
    println!("{}{}{}{}", tx.date, marker, code, tx.description.bold());
    for comment in &tx.comments {
        print_spaces(GAP);
        println!("{}", format!("; {}", comment.value.text).dimmed());
    }
}

fn print_posting(
    p: &Posting,
    account_max: usize,
    amount_max: usize,
    precisions: &std::collections::HashMap<String, usize>,
) {
    let display = render_account(p);
    let display_width = display.chars().count();

    print_spaces(GAP);
    print!("{}", display.blue());

    if let Some(amount) = &p.amount {
        print_spaces(account_max.saturating_sub(display_width) + GAP);
        let formatted = format_amount(&amount.commodity, &amount.value, precisions);
        print_spaces(amount_max.saturating_sub(formatted.chars().count()));
        if amount.value.is_negative() {
            print!("{}", formatted.red());
        } else {
            print!("{}", formatted);
        }
    }

    // `@` / `@@` cost annotations and `=` balance assertions are
    // internal to the booker and not rendered here: costs drive the
    // balance math, assertions are verified during load, neither
    // carries new information for the reader.

    println!();

    for comment in &p.comments {
        print_spaces(GAP);
        println!("{}", format!("; {}", comment.value.text).dimmed());
    }
}

/// Virtual postings are wrapped in `(...)`. The parser distinguishes
/// `[balanced]` vs `(unbalanced)`, but print collapses both to `(...)`
/// following the old reference output.
fn render_account(p: &Posting) -> String {
    if p.is_virtual {
        format!("({})", p.account)
    } else {
        p.account.clone()
    }
}

fn max_account_width(journal: &Journal) -> usize {
    journal
        .transactions
        .iter()
        .flat_map(|tx| tx.value.postings.iter())
        .map(|lp| render_account(&lp.value).chars().count())
        .max()
        .unwrap_or(0)
}

fn max_amount_width(journal: &Journal) -> usize {
    journal
        .transactions
        .iter()
        .flat_map(|tx| tx.value.postings.iter())
        .filter_map(|lp| {
            lp.value.amount.as_ref().map(|a| {
                format_amount(&a.commodity, &a.value, &journal.precisions)
                    .chars()
                    .count()
            })
        })
        .max()
        .unwrap_or(0)
}