klirr-core 0.2.1

Zero-maintenance and smart FOSS generating beautiful invoices for services and expenses.
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

use std::ops::Deref;

use crate::prelude::*;

/// Invoice rate, a fixed price per month, per day or per hour.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
pub enum Rate {
    /// A fixed rate per month, invoiced monthly
    Monthly(UnitPrice),
    /// A fixed rate per fortnight, invoiced bi-weekly
    Fortnight(UnitPrice),
    /// A fixed rate per day, invoice monthly or bi-weekly
    Daily(UnitPrice),
    /// A fixed rate per hour, invoice monthly or bi-weekly
    Hourly(UnitPrice),
}

impl From<(UnitPrice, Granularity)> for Rate {
    fn from((price, granularity): (UnitPrice, Granularity)) -> Self {
        match granularity {
            Granularity::Month => Self::Monthly(price),
            Granularity::Fortnight => Self::Fortnight(price),
            Granularity::Day => Self::Daily(price),
            Granularity::Hour => Self::Hourly(price),
        }
    }
}

impl Rate {
    /// A monthly fixed rate
    pub fn monthly(rate: impl Into<UnitPrice>) -> Self {
        Self::Monthly(rate.into())
    }

    /// A fortnight fixed rate
    pub fn fortnight(rate: impl Into<UnitPrice>) -> Self {
        Self::Fortnight(rate.into())
    }

    /// A daily fixed rate
    pub fn daily(rate: impl Into<UnitPrice>) -> Self {
        Self::Daily(rate.into())
    }

    /// An hourly fixed rate
    pub fn hourly(rate: impl Into<UnitPrice>) -> Self {
        Self::Hourly(rate.into())
    }

    /// Discriminator
    pub fn granularity(&self) -> Granularity {
        match self {
            Self::Monthly(_) => Granularity::Month,
            Self::Fortnight(_) => Granularity::Fortnight,
            Self::Daily(_) => Granularity::Day,
            Self::Hourly(_) => Granularity::Hour,
        }
    }

    /// The inner unit price
    pub fn unit_price(&self) -> UnitPrice {
        *self.deref()
    }
}

impl std::ops::Deref for Rate {
    type Target = UnitPrice;

    fn deref(&self) -> &Self::Target {
        match self {
            Self::Monthly(price) => price,
            Self::Fortnight(price) => price,
            Self::Daily(price) => price,
            Self::Hourly(price) => price,
        }
    }
}

impl HasSample for Rate {
    fn sample() -> Self {
        Self::Monthly(UnitPrice::sample())
    }

    fn sample_other() -> Self {
        Self::Daily(UnitPrice::sample_other())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    type Sut = Rate;

    #[test]
    fn equality() {
        assert_eq!(Sut::sample(), Sut::sample());
        assert_eq!(Sut::sample_other(), Sut::sample_other());
    }

    #[test]
    fn inequality() {
        assert_ne!(Sut::sample(), Sut::sample_other());
    }

    #[test]
    fn unit_price() {
        assert_eq!(**Sut::hourly(150), dec!(150));
        assert_eq!(**Sut::daily(1_000), dec!(1_000));
        assert_eq!(**Sut::fortnight(9_000), dec!(9_000));
        assert_eq!(**Sut::monthly(15_000), dec!(15_000));
    }

    #[test]
    fn granularity() {
        assert_eq!(Sut::hourly(150).granularity(), Granularity::Hour);
        assert_eq!(Sut::daily(1_000).granularity(), Granularity::Day);
        assert_eq!(Sut::fortnight(9_000).granularity(), Granularity::Fortnight);
        assert_eq!(Sut::monthly(15_000).granularity(), Granularity::Month);
    }

    #[test]
    fn from_tuple() {
        assert_eq!(
            Sut::from((UnitPrice::sample(), Granularity::Month)),
            Sut::monthly(UnitPrice::sample())
        );
        assert_eq!(
            Sut::from((UnitPrice::sample(), Granularity::Day)),
            Sut::daily(UnitPrice::sample())
        );
        assert_eq!(
            Sut::from((UnitPrice::sample(), Granularity::Hour)),
            Sut::hourly(UnitPrice::sample())
        );
        assert_eq!(
            Sut::from((UnitPrice::sample(), Granularity::Fortnight)),
            Sut::fortnight(UnitPrice::sample())
        );
    }
}