limabean 0.4.1

Beancount frontend using Rust and Clojure and the Lima parser
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

use limabean_booking::LimaParserBookingTypes;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use std::{
    borrow::Cow,
    collections::{HashMap, HashSet},
};
use time::Date;

use crate::api::types::{iso8601date, raw};

/// A Beancount directive of a particular [DirectiveVariant].
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct Directive<'a> {
    pub(crate) raw_idx: usize,
    #[serde(with = "iso8601date")]
    pub(crate) date: Date,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) tags: Option<HashSet<&'a str>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) links: Option<HashSet<&'a str>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) metadata: Option<HashMap<&'a str, raw::MetaValue<'a>>>,
    #[serde(borrow)]
    #[serde(flatten)]
    pub(crate) variant: DirectiveVariant<'a>,
}

/// A Beancount directive, without the fields common to all, which belong to [Directive].
#[derive(Serialize, Deserialize, PartialEq, Eq, strum_macros::IntoStaticStr, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
#[serde(tag = "dct")]
#[strum(serialize_all = "kebab-case")]
pub enum DirectiveVariant<'a> {
    #[serde(rename = "txn")]
    Transaction(Transaction<'a>),
    Price(raw::PriceDct<'a>),
    Balance(raw::Balance<'a>),
    #[serde(borrow)]
    Open(raw::Open<'a>),
    Close(raw::Close<'a>),
    Commodity(raw::Commodity<'a>),
    Pad(raw::Pad<'a>),
    Document(raw::Document<'a>),
    Note(raw::Note<'a>),
    Event(raw::Event<'a>),
    Query(raw::Query<'a>),
    Custom(raw::Custom<'a>),
}

/// A Beancount transaction directive, without the common [Directive] fields.
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct Transaction<'a> {
    pub(crate) flag: Cow<'static, str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) payee: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) narration: Option<&'a str>,
    pub(crate) postings: Vec<Posting<'a>>,
}

/// A complete posting.
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub(crate) struct Posting<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) raw_idx: Option<usize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) flag: Option<Cow<'static, str>>,
    pub(crate) acc: &'a str,
    pub(crate) units: Decimal,
    pub(crate) cur: &'a str,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) cost: Option<Cost<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) price: Option<Price<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) tags: Option<HashSet<&'a str>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) links: Option<HashSet<&'a str>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) metadata: Option<HashMap<&'a str, raw::MetaValue<'a>>>,
}

/// A cost complete with any fields which were missing from its [CostSpec].
///
/// In addition to `per-unit` which is the natural representation, the `total`
/// is also exposed, since this may be what the user originally specified in the
/// beanfile, and ought to be preserved at its original precision.
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub(crate) struct Cost<'a> {
    #[serde(with = "iso8601date")]
    pub(crate) date: Date,
    pub(crate) per_unit: Decimal,
    pub(crate) total: Decimal,
    pub(crate) cur: &'a str,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) label: Option<Cow<'a, str>>,
    #[serde(skip_serializing_if = "std::ops::Not::not")]
    #[serde(default)]
    pub(crate) merge: bool,
}

impl<'a> From<&'a limabean_booking::Cost<LimaParserBookingTypes<'a>>> for Cost<'a> {
    fn from(value: &'a limabean_booking::Cost<LimaParserBookingTypes>) -> Self {
        Cost {
            date: value.date,
            per_unit: value.per_unit,
            total: value.total,
            cur: value.currency,
            label: value.label.clone(),
            merge: value.merge,
        }
    }
}
///
/// A price complete with any fields which were missing from its [PriceSpec].
///
/// In addition to `per-unit` which is the natural representation, the `total`
/// is also exposed, since this may be what the user originally specified in the
/// beanfile, and ought to be preserved at its original precision.
#[derive(Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug)]
#[serde(rename_all = "kebab-case")]
pub(crate) struct Price<'a> {
    pub(crate) per_unit: Decimal,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) total: Option<Decimal>,
    pub(crate) cur: &'a str,
}