rtimelog 1.1.1

System for tracking time in a text-log-based format.
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

//! The [`PieData`] type represents the data in a pie chart.
//!
//! # Examples
//!
//! # Description
//!
//! The [`PieData`] holds the data used to construct a pie chart. It supports
//! adding data to build up the data set.

use std::collections::HashMap;

#[doc(inline)]
use crate::chart::{Percentages, TagPercent};

/// Representation of the data used to construct the pie chart.
#[derive(Debug)]
pub struct PieData {
    total: f32,
    data:  HashMap<String, f32>
}

impl PieData {
    /// Add the supplied number of seconds to the supplied label.
    pub fn add_secs(&mut self, label: &str, secs: u64) {
        #![allow(clippy::cast_precision_loss)]
        let secs = secs as f32;
        self.total += secs;
        let entry = self.data.entry(label.to_string()).or_insert(0.0);
        *entry += secs;
    }

    /// Return the percentage associated with the supplied label, if any.
    pub fn get_percent(&self, label: &str) -> Option<f32> {
        self.data.get(label).map(|&s| self.cent(s))
    }

    /// Return `true` if no data has been added to the [`PieData`]
    pub fn is_empty(&self) -> bool { self.data.is_empty() }

    /// Return the total sum of the values in the data
    pub fn total(&self) -> f32 { self.total }

    /// Return a sorted list of the labels in the [`PieData`].
    pub fn labels(&self) -> Vec<&str> {
        let mut labels: Vec<&str> = self.data.keys().map(String::as_str).collect();
        labels.sort();
        labels
    }

    /// Return list of [`TagPercent`] objects sorted by descending percentage
    /// and ascending label.
    pub fn percentages(&self) -> Percentages {
        let mut percents: Percentages = self
            .data
            .iter()
            .filter_map(|(l, p)| TagPercent::new(l, self.cent(*p)))
            .collect();

        percents.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
        percents
    }

    // Utility method for converting a stored value into a percentage.
    fn cent(&self, val: f32) -> f32 { 100.0 * val / self.total }
}

impl Default for PieData {
    /// Create a brand-new [`PieData`] object with no data.
    fn default() -> Self { Self { total: 0.0, data: HashMap::new() } }
}

#[cfg(test)]
mod tests {
    use assert2::{assert, let_assert};

    use super::*;

    #[test]
    fn test_default() {
        let pd = PieData::default();

        assert!(pd.is_empty());
        assert!(pd.total() == 0.0);
        assert!(pd.labels().len() == 0);
        assert!(pd.percentages().len() == 0);
    }

    #[test]
    fn test_add_secs() {
        let mut pd = PieData::default();

        pd.add_secs("foo", 300);

        assert!(!pd.is_empty());
        assert!(pd.total() == 300.0);
        assert!(pd.labels().len() == 1);
        assert!(pd.labels() == vec!["foo"]);
        let_assert!(Some(expected_pcnt) = TagPercent::new("foo", 100.0));
        assert!(pd.percentages() == vec![expected_pcnt]);
    }

    #[test]
    fn test_add_secs_multiple() {
        let mut pd = PieData::default();

        #[rustfmt::skip]
        let input = [
            ("david",   400),
            ("kirsten", 300),
            ("mark",    200),
            ("connie",  100)
        ];
        for (label, secs) in &input {
            pd.add_secs(label, *secs);
        }

        assert!(pd.total() == 1000.0);
        let expect: Vec<&str> = vec!["connie", "david", "kirsten", "mark"];

        assert!(pd.labels() == expect);
        let expect: Vec<TagPercent> = input
            .iter()
            .map(|(l, s)| TagPercent::new(l, *s as f32 / 10.0).expect("Hardcoded value"))
            .collect();
        assert!(pd.percentages() == expect);
    }
}