concord 2.4.2

A terminal user interface client for Discord
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

use std::collections::BTreeMap;

use crate::discord::ActivityInfo;

type ActivityKey = (String, i64);

#[derive(Default)]
pub(super) struct ActivityRegistry {
    // BTreeMap keeps broadcast order stable across changes.
    entries: BTreeMap<ActivityKey, ActivityInfo>,
}

impl ActivityRegistry {
    pub(super) fn set(&mut self, client_id: String, pid: i64, activity: ActivityInfo) {
        self.entries.insert((client_id, pid), activity);
    }

    pub(super) fn clear(&mut self, client_id: &str, pid: i64) {
        self.entries.remove(&(client_id.to_owned(), pid));
    }

    pub(super) fn activities(&self) -> Vec<ActivityInfo> {
        self.entries.values().cloned().collect()
    }

    pub(super) fn activity_for_client(&self, client_id: &str) -> Option<ActivityInfo> {
        self.entries
            .iter()
            .find(|((id, _pid), _)| id == client_id)
            .map(|(_, activity)| activity.clone())
    }
}

#[cfg(test)]
mod tests {
    use super::ActivityRegistry;
    use crate::discord::{ActivityInfo, ActivityKind};

    #[test]
    fn registry_aggregates_and_clears_per_app() {
        let mut registry = ActivityRegistry::default();
        registry.set(
            "app-a".to_owned(),
            1,
            ActivityInfo::test(ActivityKind::Playing, "Game A"),
        );
        registry.set(
            "app-b".to_owned(),
            2,
            ActivityInfo::test(ActivityKind::Listening, "Song B"),
        );

        let activities = registry.activities();
        let names: Vec<&str> = activities
            .iter()
            .map(|activity| activity.name.as_str())
            .collect();
        assert_eq!(names, ["Game A", "Song B"]);

        registry.set(
            "app-a".to_owned(),
            1,
            ActivityInfo::test(ActivityKind::Playing, "Game A2"),
        );
        registry.clear("app-b", 2);
        let activities = registry.activities();
        let names: Vec<&str> = activities
            .iter()
            .map(|activity| activity.name.as_str())
            .collect();
        assert_eq!(names, ["Game A2"]);
    }

    #[test]
    fn activity_for_client_returns_latest_by_client_id() {
        let mut registry = ActivityRegistry::default();
        registry.set(
            "vscode".to_owned(),
            1,
            ActivityInfo::test(ActivityKind::Playing, "Editing a.rs"),
        );
        assert_eq!(
            registry
                .activity_for_client("vscode")
                .map(|activity| activity.name),
            Some("Editing a.rs".to_owned())
        );

        registry.set(
            "vscode".to_owned(),
            1,
            ActivityInfo::test(ActivityKind::Playing, "Editing b.rs"),
        );
        assert_eq!(
            registry
                .activity_for_client("vscode")
                .map(|activity| activity.name),
            Some("Editing b.rs".to_owned())
        );

        assert!(registry.activity_for_client("unknown").is_none());
    }
}