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

use crate::close::close;
use crate::open::open;
use crate::price::{price, Price};
use crate::{Close, Date, Open};
use nom::branch::alt;
use nom::{combinator::map, IResult};

use crate::transaction::{transaction, Transaction};

/// A directive
///
/// A beancount file is made of directives.
///
/// By far the the most common directive is the [`Transaction`].
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Directive<'a> {
    /// The [`Transaction`](crate::Transaction) directive
    Transaction(Transaction<'a>),
    /// The [`Price`](crate::Price) directive
    Price(Price<'a>),
    /// The [`Open`](crate::Open) account directive
    Open(Open<'a>),
    /// The [`Close`](crate::Close) account directive
    Close(Close<'a>),
}

impl<'a> Directive<'a> {
    /// Returns the [`Transaction`] reference if this directive is a transaction
    ///
    /// See also [`Directive::into_transaction`]
    #[must_use]
    pub fn as_transaction(&self) -> Option<&Transaction<'a>> {
        match self {
            Directive::Transaction(trx) => Some(trx),
            _ => None,
        }
    }

    /// Convert into a [`Transaction`] if this directive is a transaction
    ///
    /// See also [`Directive::as_transaction`]
    #[must_use]
    pub fn into_transaction(self) -> Option<Transaction<'a>> {
        match self {
            Directive::Transaction(trx) => Some(trx),
            _ => None,
        }
    }

    /// Returns the date of the directive (if there is one)
    #[must_use]
    pub fn date(&self) -> Option<Date> {
        Some(match self {
            Directive::Transaction(t) => t.date(),
            Directive::Open(o) => o.date(),
            Directive::Close(c) => c.date(),
            Directive::Price(p) => p.date(),
        })
    }
}

pub(crate) fn directive(input: &str) -> IResult<&str, Directive<'_>> {
    alt((
        map(transaction, Directive::Transaction),
        map(price, Directive::Price),
        map(open, Directive::Open),
        map(close, Directive::Close),
    ))(input)
}

#[cfg(test)]
mod tests {
    use crate::account;

    use super::*;

    #[test]
    fn transaction() {
        let input = r#"2022-09-10 txn "My transaction""#;
        let transaction = directive(input).unwrap().1.into_transaction().unwrap();
        assert_eq!(transaction.narration(), Some("My transaction"));
    }

    #[test]
    fn price() {
        let result = directive("2014-07-09 price CHF  5 PLN");
        let Ok((_, Directive::Price(price))) = result else {
            panic!("Expected a price directive but was: {result:?}")
        };
        assert_eq!(price.commodity(), "CHF");
        assert_eq!(price.price().currency(), "PLN");
    }

    #[test]
    fn simple_open_directive() {
        let result = directive("2014-05-01 open Liabilities:CreditCard:CapitalOne");
        let Ok((_, Directive::Open(directive))) = result else {
          panic!("Expected an open directive but was: {result:?}")
        };
        assert_eq!(directive.account().type_(), account::Type::Liabilities);
    }

    #[test]
    fn close_directive() {
        let result = directive("2016-11-28 close Liabilities:CreditCard:CapitalOne");
        let Ok((_, Directive::Close(directive))) = result else {
            panic!("Expected a close directive but was: {result:?}")
        };
        assert_eq!(directive.date(), Date::new(2016, 11, 28));
        assert_eq!(
            directive.account().components(),
            &["CreditCard", "CapitalOne"]
        );
    }

    #[rstest]
    fn invalid(
        #[values(
            "2022-09-11 txn that is incorrect",
            "2022-09-11 * that is incorrect",
            "2022-09-11 ! that is incorrect"
        )]
        input: &str,
    ) {
        assert!(matches!(directive(input), Err(nom::Err::Failure(_))));
    }

    #[rstest]
    fn not_matching(#[values(" ")] input: &str) {
        assert!(matches!(directive(input), Err(nom::Err::Error(_))));
    }

    #[rstest]
    #[case("2022-11-06 txn", Date::new(2022, 11, 6))]
    #[case("2021-02-26 open Liabilities:Debt", Date::new(2021, 2, 26))]
    #[case("2021-02-26 close Liabilities:Debt", Date::new(2021, 2, 26))]
    #[case("2014-07-09 price HOOL  600 USD", Date::new(2014, 7, 9))]
    fn date(#[case] input: &str, #[case] expected_date: Date) {
        let (_, directive) = directive(input).expect("should successfully parse directive");
        let date = directive.date().expect("directive should have a date");
        assert_eq!(date, expected_date);
    }
}