ghtui 0.2.6

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
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

//! A repository's Settings tab, at one of its pages ([`crate::settings`]),
//! and the two pages kept as settings are outside it: Actions' caches and
//! the custom properties.

use super::{Family, Route, Target, Url};
use crate::api::model::RepoId;
use crate::api::settings::SettingsPage;
use crate::browse::Build;
use crate::chrome::Section;
use crate::data::DataKey;
use crate::state::State;
use crate::ui::pages::url as links;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Page {
    pub repo: RepoId,
    pub page: SettingsPage,
}

impl Family for Page {
    fn url(&self) -> String {
        format!("{}{}", links::repo(&self.repo), self.page.slug())
    }

    fn title(&self) -> String {
        let repo = &self.repo;
        match self.page {
            SettingsPage::Hook(id) => format!("{repo} · Webhook {id}"),
            SettingsPage::Caches => format!("{repo} · Actions · Caches"),
            SettingsPage::Properties => format!("{repo} · Custom properties"),
            page => format!("{repo} · Settings · {}", page.name()),
        }
    }

    fn repo(&self) -> Option<&RepoId> {
        Some(&self.repo)
    }

    fn up(&self, _: &State) -> Option<Route> {
        let repo = self.repo.clone();
        Some(match self.page {
            SettingsPage::Hook(_) => Route::Settings(Page {
                repo,
                page: SettingsPage::Hooks,
            }),
            SettingsPage::Caches => Route::Runs(super::runs::Page::Actions {
                repo,
                query: String::new(),
            }),
            _ => Route::code(repo),
        })
    }

    fn needs(&self) -> Vec<DataKey> {
        let repo = self.repo.clone();
        vec![
            DataKey::Repo(repo.clone()),
            DataKey::Settings(repo, self.page),
        ]
    }

    fn section(&self) -> Section {
        match self.page {
            SettingsPage::Caches => Section::Actions,
            SettingsPage::Properties => Section::Code,
            _ => Section::Settings,
        }
    }

    fn build(&self, b: Build<'_>, page: &mut crate::ui::page::Page) {
        let settings = b.get(&DataKey::Settings(self.repo.clone(), self.page));
        crate::settings::build(b.state, page, &self.repo, self.page, settings, b.cx.now);
    }
}

/// The Settings tab's pages ghtui has (the rest are on GitHub), and
/// Actions' caches and the custom properties.
pub(super) fn parse_repo(repo: &RepoId, rest: &[&str], _: &Url<'_>) -> Option<Target> {
    use SettingsPage as P;
    let page = match rest {
        ["actions", "caches"] => P::Caches,
        ["custom-properties"] => P::Properties,
        ["settings", rest @ ..] => match rest {
            [] => P::General,
            ["branches" | "branch_protection_rules" | "rules", ..] => P::Branches,
            ["access" | "collaboration"] => P::Access,
            ["hooks"] | ["hooks", "new"] => P::Hooks,
            ["hooks", id] => P::Hook(id.parse().ok().filter(|&n| n > 0)?),
            ["keys", ..] => P::Keys,
            ["secrets", "actions", ..] => P::Secrets,
            ["variables", "actions", ..] => P::Variables,
            ["pages"] => P::Pages,
            _ => return None,
        },
        _ => return None,
    };
    let repo = repo.clone();
    Some(Target::Page(Route::Settings(Page { repo, page })))
}

#[cfg(test)]
pub(crate) fn arb() -> impl proptest::strategy::Strategy<Value = Route> {
    use crate::route::arb::repo;
    use proptest::prelude::*;
    let page = prop_oneof![
        Just(SettingsPage::General),
        Just(SettingsPage::Branches),
        Just(SettingsPage::Access),
        Just(SettingsPage::Hooks),
        Just(SettingsPage::Keys),
        Just(SettingsPage::Secrets),
        Just(SettingsPage::Variables),
        Just(SettingsPage::Pages),
        Just(SettingsPage::Caches),
        Just(SettingsPage::Properties),
        (1..u64::MAX).prop_map(SettingsPage::Hook),
    ];
    (repo(), page).prop_map(|(repo, page)| Route::Settings(Page { repo, page }))
}