rustledger-core 0.13.0

Core types for rustledger: Amount, Position, Inventory, and all directive types
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
137
138
139
140
141
142
143
144
145
146

//! Directive formatting for balance, open, close, etc.

use super::{FormatConfig, escape_string, format_amount, format_meta_value};
use crate::{
    Balance, Close, Commodity, Custom, Document, Event, Metadata, Note, Open, Pad, Price, Query,
};
use std::fmt::Write;

/// Format metadata entries in deterministic (sorted) order.
pub(super) fn format_metadata(meta: &Metadata, indent: &str, out: &mut String) {
    // Sort keys for deterministic output order
    let mut keys: Vec<_> = meta.keys().collect();
    keys.sort();

    for key in keys {
        let value = &meta[key];
        writeln!(out, "{indent}{}: {}", key, format_meta_value(value))
            .expect("write to String is infallible");
    }
}

/// Format a balance directive.
pub fn format_balance(bal: &Balance, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} balance {} {}",
        bal.date,
        bal.account,
        format_amount(&bal.amount)
    );
    if let Some(tol) = &bal.tolerance {
        write!(out, " ~ {tol}").expect("write to String is infallible");
    }
    out.push('\n');
    format_metadata(&bal.meta, &config.indent, &mut out);
    out
}

/// Format an open directive.
pub fn format_open(open: &Open, config: &FormatConfig) -> String {
    let mut out = format!("{} open {}", open.date, open.account);
    if !open.currencies.is_empty() {
        write!(out, " {}", open.currencies.join(",")).expect("write to String is infallible");
    }
    if let Some(booking) = &open.booking {
        write!(out, " \"{booking}\"").expect("write to String is infallible");
    }
    out.push('\n');
    format_metadata(&open.meta, &config.indent, &mut out);
    out
}

/// Format a close directive.
pub fn format_close(close: &Close, config: &FormatConfig) -> String {
    let mut out = format!("{} close {}\n", close.date, close.account);
    format_metadata(&close.meta, &config.indent, &mut out);
    out
}

/// Format a commodity directive.
pub fn format_commodity(comm: &Commodity, config: &FormatConfig) -> String {
    let mut out = format!("{} commodity {}\n", comm.date, comm.currency);
    format_metadata(&comm.meta, &config.indent, &mut out);
    out
}

/// Format a pad directive.
pub fn format_pad(pad: &Pad, config: &FormatConfig) -> String {
    let mut out = format!("{} pad {} {}\n", pad.date, pad.account, pad.source_account);
    format_metadata(&pad.meta, &config.indent, &mut out);
    out
}

/// Format an event directive.
pub fn format_event(event: &Event, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} event \"{}\" \"{}\"\n",
        event.date,
        escape_string(&event.event_type),
        escape_string(&event.value)
    );
    format_metadata(&event.meta, &config.indent, &mut out);
    out
}

/// Format a query directive.
pub fn format_query(query: &Query, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} query \"{}\" \"{}\"\n",
        query.date,
        escape_string(&query.name),
        escape_string(&query.query)
    );
    format_metadata(&query.meta, &config.indent, &mut out);
    out
}

/// Format a note directive.
pub fn format_note(note: &Note, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} note {} \"{}\"\n",
        note.date,
        note.account,
        escape_string(&note.comment)
    );
    format_metadata(&note.meta, &config.indent, &mut out);
    out
}

/// Format a document directive.
pub fn format_document(doc: &Document, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} document {} \"{}\"\n",
        doc.date,
        doc.account,
        escape_string(&doc.path)
    );
    format_metadata(&doc.meta, &config.indent, &mut out);
    out
}

/// Format a price directive.
pub fn format_price(price: &Price, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} price {} {}\n",
        price.date,
        price.currency,
        format_amount(&price.amount)
    );
    format_metadata(&price.meta, &config.indent, &mut out);
    out
}

/// Format a custom directive.
pub fn format_custom(custom: &Custom, config: &FormatConfig) -> String {
    let mut out = format!(
        "{} custom \"{}\"",
        custom.date,
        escape_string(&custom.custom_type)
    );
    for value in &custom.values {
        write!(out, " {}", format_meta_value(value)).expect("write to String is infallible");
    }
    out.push('\n');
    format_metadata(&custom.meta, &config.indent, &mut out);
    out
}