shellist 0.1.2

Shell history analysis. Parses .bash_history, counts commands, and ranks by frequency.
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

use std::collections::HashMap;

/// Sort commands by frequency descending, with alphabetical tie-breaking.
///
/// ```rust
/// let mut map = std::collections::HashMap::new();
/// map.insert("git".into(), 3);
/// map.insert("ls".into(), 5);
/// map.insert("cd".into(), 1);
/// let ranked = shellist::rank_commands(map);
/// assert_eq!(ranked[0], ("ls".to_string(), 5));
/// assert_eq!(ranked[1], ("git".to_string(), 3));
/// assert_eq!(ranked[2], ("cd".to_string(), 1));
/// ```
pub fn rank_commands(map: HashMap<String, usize>) -> Vec<(String, usize)> {
    let mut ranked: Vec<(String, usize)> = map.into_iter().collect();

    ranked.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));

    ranked
}

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

    #[test]
    fn ranks_by_frequency_descending() {
        let mut map = HashMap::new();
        map.insert("git".to_string(), 3);
        map.insert("ls".to_string(), 5);
        map.insert("cd".to_string(), 1);

        let ranked = rank_commands(map);

        assert_eq!(ranked[0], ("ls".to_string(), 5));
        assert_eq!(ranked[1], ("git".to_string(), 3));
        assert_eq!(ranked[2], ("cd".to_string(), 1));
    }

    #[test]
    fn tie_breaks_alphabetically() {
        let mut map = HashMap::new();
        map.insert("zebra".to_string(), 2);
        map.insert("alpha".to_string(), 2);
        map.insert("middle".to_string(), 2);

        let ranked = rank_commands(map);

        assert_eq!(ranked[0], ("alpha".to_string(), 2));
        assert_eq!(ranked[1], ("middle".to_string(), 2));
        assert_eq!(ranked[2], ("zebra".to_string(), 2));
    }

    #[test]
    fn handles_single_command() {
        let mut map = HashMap::new();
        map.insert("ls".to_string(), 42);

        let ranked = rank_commands(map);

        assert_eq!(ranked.len(), 1);
        assert_eq!(ranked[0], ("ls".to_string(), 42));
    }

    #[test]
    fn handles_empty_map() {
        let map: HashMap<String, usize> = HashMap::new();
        let ranked = rank_commands(map);
        assert!(ranked.is_empty());
    }

    #[test]
    fn mixed_frequencies_and_ties() {
        let mut map = HashMap::new();
        map.insert("vim".to_string(), 10);
        map.insert("emacs".to_string(), 10);
        map.insert("nano".to_string(), 5);
        map.insert("cat".to_string(), 20);

        let ranked = rank_commands(map);

        assert_eq!(ranked[0], ("cat".to_string(), 20));
        assert_eq!(ranked[1], ("emacs".to_string(), 10));
        assert_eq!(ranked[2], ("vim".to_string(), 10));
        assert_eq!(ranked[3], ("nano".to_string(), 5));
    }
}