nyandere 0.1.2

i help with keeping track of purchases. meow
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

use std::collections::btree_map::Entry;

use super::prelude::*;

/// Move money from *source* to *target*.
///
/// This modifies the [`super::Balance`] ***negatively***!
/// The balance denotes how much *source* owes the *target*,
/// which is how much *source* would need to pay *target*
/// to be on 0 again.
///
/// For example, `A` paying 1€ to `B` means
/// the balance from `A` to `B` will be -1€.
#[apply(cmd_args!)]
pub struct Pay {
    #[pos]
    pub amount: Money,
    #[named]
    pub who: Dir,
}

impl Command for Pay {
    type Args = Self;
}

impl Run for Pay {
    fn run(self: Box<Self>, ctx: &mut State) -> Output {
        let mut difference: Value = self.amount.into();
        difference.align_to(&self.who);

        match ctx.balances.entry(self.who.into()) {
            Entry::Occupied(mut entry) => *entry.get_mut() += difference,
            Entry::Vacant(entry) => {
                entry.insert(difference);
            }
        }

        None
    }
}

#[cfg(test)]
mod tests {
    use crate::{Set, eval, ext::math::Integer};

    #[test]
    fn basic() {
        let rt = eval(
            "
            create entity A
            create entity B
            create entity C

            pay 1€ from=A to=B
            pay 5€ from=B to=A
            pay 3€ from=A to=C
            ",
        )
        .unwrap();

        let s = |lit: &str| lit.to_string();
        let i = Integer::from;

        assert_eq!(
            rt.to_state()
                .balances
                .into_iter()
                .map(|(pair, bal)| {
                    (
                        pair.into_iter()
                            .map(|e| e.name().to_owned())
                            .collect::<Vec<_>>(),
                        bal.0,
                    )
                })
                .collect::<Set<_>>(),
            [
                (vec![s("A"), s("B")], i(-400)),
                (vec![s("A"), s("C")], i(300))
            ]
            .into_iter()
            .collect::<Set<_>>(),
        );
    }
}