ghtui 0.2.0

A keyboard-driven terminal client for GitHub, with a pull request diff viewer that goes further than GitHub's
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

//! Whose cache and drafts these are: one account on one GitHub. The cache
//! and the drafts keep each account's apart, under `<host>/<login>/`. Until
//! GitHub says whose the token is (on its first use), it's
//! `<host>/token-<fingerprint>/`, and the store remembers the login for
//! that fingerprint next time.

use std::sync::{Arc, PoisonError, RwLock};

/// Cheap to clone; all clones follow the same account.
#[derive(Debug, Clone, Default)]
pub struct Account(Arc<RwLock<Who>>);

#[derive(Debug, Default)]
struct Who {
    host: String,
    /// The token's fingerprint (never the token).
    fingerprint: String,
    login: Option<String>,
}

impl Account {
    pub fn new(host: &str, fingerprint: &str, login: Option<String>) -> Self {
        Self(Arc::new(RwLock::new(Who {
            host: host.to_owned(),
            fingerprint: fingerprint.to_owned(),
            login,
        })))
    }

    /// What the account's keys and paths start with: `<host>/<login>/`,
    /// or nothing for a store that isn't anyone's (in tests).
    pub fn scope(&self) -> String {
        let who = self.0.read().unwrap_or_else(PoisonError::into_inner);
        match &who.login {
            _ if who.host.is_empty() => String::new(),
            Some(login) => format!("{}/{login}/", who.host),
            None => format!("{}/token-{}/", who.host, who.fingerprint),
        }
    }

    /// Whose token it is, as last seen: known before GitHub answers, from
    /// the last time it did.
    pub fn login(&self) -> Option<String> {
        let who = self.0.read().unwrap_or_else(PoisonError::into_inner);
        who.login.clone()
    }

    /// Where the login for this token is remembered.
    pub(crate) fn token_key(&self) -> Option<String> {
        let who = self.0.read().unwrap_or_else(PoisonError::into_inner);
        (!who.host.is_empty()).then(|| format!("{}/{}", who.host, who.fingerprint))
    }

    /// The token is `login`'s: from now on, its scope. Whether that's new.
    pub(crate) fn sign_in(&self, login: &str) -> bool {
        let mut who = self.0.write().unwrap_or_else(PoisonError::into_inner);
        if who.host.is_empty() || who.login.as_deref() == Some(login) {
            return false;
        }
        who.login = Some(login.to_owned());
        true
    }
}