limabean-booking 0.10.5

Beancount booking algorithms for limabean
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

use std::{
    error::Error,
    fmt::{Debug, Display},
};

use super::Booking;

/// A booking error, either for an individual posting or for the transaction as a whole.
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum BookingError {
    Transaction(TransactionBookingError),
    Posting(usize, PostingBookingError),
}

impl Display for BookingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use BookingError::*;

        match self {
            Transaction(e) => write!(f, "{e}"),
            Posting(idx, e) => write!(f, "posting {idx} {e}"),
        }
    }
}

/// A booking error for the transaction as a whole.
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum TransactionBookingError {
    UnsupportedBookingMethod(Booking, String),
    TooManyMissingNumbers,
    Unbalanced(String),
    CannotDetermineCurrencyForBalancing,
    AutoPostMultipleBuckets(Vec<String>),
}

impl Display for TransactionBookingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use TransactionBookingError::*;

        match self {
            UnsupportedBookingMethod(booking, account) => {
                write!(f, "unsupported booking method {booking} for {account}")
            }
            TooManyMissingNumbers => f.write_str("too many missing numbers for interpolation"),
            Unbalanced(residual) => write!(f, "unbalanced transaction with residual {residual}"),
            CannotDetermineCurrencyForBalancing => {
                f.write_str("can't determine currency for balancing transaction")
            }
            AutoPostMultipleBuckets(buckets) => write!(
                f,
                "can't have auto-post with multiple currencies {}",
                buckets.join(","),
            ),
        }
    }
}

impl Error for TransactionBookingError {}

/// A booking error for an individual posting.
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum PostingBookingError {
    AmbiguousAutoPost,
    AmbiguousMatches,
    MultipleCostCurrenciesMatch,
    CannotInferUnits,
    CannotInferCurrency,
    CannotInferAnything,
    CannotInferPricePerUnit,
    CannotInferPriceCurrency,
    CannotInferPrice,
    NotEnoughLotsToReduce,
    NoPositionMatches,
    InferredNegativeCostPerUnit,
    InferredNegativePricePerUnit,
}

impl Display for PostingBookingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use PostingBookingError::*;

        match self {
            AmbiguousAutoPost => f.write_str("ambiguous auto-post"),
            AmbiguousMatches => f.write_str("ambiguous matches"),
            MultipleCostCurrenciesMatch => {
                f.write_str("multiple currencies in cost spec matches against inventory")
            }
            CannotInferUnits => f.write_str("cannot infer units"),
            CannotInferCurrency => f.write_str("cannot infer currency"),
            CannotInferAnything => f.write_str("cannot infer anything"),
            CannotInferPricePerUnit => f.write_str("cannot infer price per-unit"),
            CannotInferPriceCurrency => f.write_str("cannot infer price currency"),
            CannotInferPrice => f.write_str("cannot infer price"),
            NotEnoughLotsToReduce => f.write_str("not enough lots to reduce"),
            NoPositionMatches => f.write_str("no position matches"),
            InferredNegativeCostPerUnit => f.write_str("inferred negative cost per-unit"),
            InferredNegativePricePerUnit => f.write_str("inferred negative price per-unit"),
        }
    }
}