gitu 0.41.0

A git client inspired by Magit
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

use std::borrow::Cow;
use std::collections::BTreeMap;
use std::ffi::OsString;

use serde::{Deserialize, Serialize};

use crate::ops;

pub(crate) mod arg;

#[derive(
    Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Debug, Serialize, Deserialize, strum::AsRefStr,
)]
#[serde(rename_all = "snake_case")]
pub(crate) enum Menu {
    #[serde(rename = "root")]
    #[strum(serialize = "root")]
    Root,
    #[serde(rename = "branch_menu")]
    #[strum(serialize = "branch_menu")]
    Branch,
    #[serde(rename = "commit_menu")]
    #[strum(serialize = "commit_menu")]
    Commit,
    #[serde(rename = "fetch_menu")]
    #[strum(serialize = "fetch_menu")]
    Fetch,
    #[serde(rename = "help_menu")]
    #[strum(serialize = "help_menu")]
    Help,
    #[serde(rename = "log_menu")]
    #[strum(serialize = "log_menu")]
    Log,
    #[serde(rename = "merge_menu")]
    Merge,
    #[serde(rename = "remote_menu")]
    #[strum(serialize = "remote_menu")]
    Remote,
    #[serde(rename = "pull_menu")]
    #[strum(serialize = "pull_menu")]
    Pull,
    #[serde(rename = "push_menu")]
    #[strum(serialize = "push_menu")]
    Push,
    #[serde(rename = "rebase_menu")]
    #[strum(serialize = "rebase_menu")]
    Rebase,
    #[serde(rename = "reset_menu")]
    #[strum(serialize = "reset_menu")]
    Reset,
    #[serde(rename = "revert_menu")]
    #[strum(serialize = "revert_menu")]
    Revert,
    #[serde(rename = "stash_menu")]
    #[strum(serialize = "stash_menu")]
    Stash,
}

pub(crate) struct PendingMenu {
    pub menu: Menu,
    pub is_hidden: bool,
    pub(crate) args: BTreeMap<Cow<'static, str>, arg::Arg>,
}

impl PendingMenu {
    pub fn init(menu: Menu) -> Self {
        Self {
            menu,
            is_hidden: false,
            args: match menu {
                Menu::Root => vec![],
                Menu::Branch => ops::branch::init_args(),
                Menu::Commit => ops::commit::init_args(),
                Menu::Fetch => ops::fetch::init_args(),
                Menu::Help => vec![],
                Menu::Log => ops::log::init_args(),
                Menu::Merge => ops::merge::init_args(),
                Menu::Pull => ops::pull::init_args(),
                Menu::Push => ops::push::init_args(),
                Menu::Rebase => ops::rebase::init_args(),
                Menu::Remote => vec![],
                Menu::Reset => ops::reset::init_args(),
                Menu::Revert => ops::revert::init_args(),
                Menu::Stash => ops::stash::init_args(),
            }
            .into_iter()
            .map(|arg| (Cow::from(arg.arg), arg))
            .collect(),
        }
    }

    pub fn args(&self) -> Vec<OsString> {
        self.args
            .iter()
            .filter(|&(_k, arg)| arg.is_active())
            .map(|(_, v)| v.get_cli_token().into())
            .collect()
    }
}