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
100
101
102
103
104
105
106
107
108
109
110
111
112

use super::OpTrait;
use crate::{
    Action,
    app::{App, State},
    git::diff::{Diff, PatchMode},
    gitu_diff::Status,
    item_data::ItemData,
    term::Term,
};
use std::{ffi::OsString, process::Command, rc::Rc};

pub(crate) struct Stage;
impl OpTrait for Stage {
    fn get_action(&self, target: &ItemData) -> Option<Action> {
        let action = match target {
            ItemData::AllUnstaged(_) => stage_unstaged(),
            ItemData::AllUntracked(untracked) => stage_untracked(untracked.clone()),
            ItemData::Untracked(u) => stage_file(u.into()),
            ItemData::Delta { diff, file_i } => {
                let diff_header = &diff.file_diffs[*file_i].header;
                let file_path = match diff_header.status {
                    Status::Deleted => &diff_header.old_file,
                    _ => &diff_header.new_file,
                };
                stage_file(file_path.fmt(&diff.text).into_owned().into())
            }
            ItemData::Hunk {
                diff,
                file_i,
                hunk_i,
            } => stage_patch(Rc::clone(diff), *file_i, *hunk_i),
            ItemData::HunkLine {
                diff,
                file_i,
                hunk_i,
                line_i,
                ..
            } => stage_line(Rc::clone(diff), *file_i, *hunk_i, *line_i),
            _ => return None,
        };

        Some(action)
    }

    fn is_target_op(&self) -> bool {
        true
    }

    fn display(&self, _state: &State) -> String {
        "Stage".into()
    }
}

fn stage_unstaged() -> Action {
    Rc::new(move |app: &mut App, term: &mut Term| {
        let mut cmd = Command::new("git");
        cmd.args(["add", "-u", "."]);

        app.close_menu();
        app.run_cmd(term, &[], cmd)
    })
}

fn stage_untracked(untracked: Vec<std::path::PathBuf>) -> Action {
    Rc::new(move |app: &mut App, term: &mut Term| {
        let mut cmd = Command::new("git");
        cmd.arg("add");
        cmd.args(untracked.clone());

        app.close_menu();
        app.run_cmd(term, &[], cmd)
    })
}

fn stage_file(file: OsString) -> Action {
    Rc::new(move |app, term| {
        let mut cmd = Command::new("git");
        cmd.args(["add"]);
        cmd.arg(&file);

        app.close_menu();
        app.run_cmd(term, &[], cmd)
    })
}

fn stage_patch(diff: Rc<Diff>, file_i: usize, hunk_i: usize) -> Action {
    Rc::new(move |app, term| {
        let mut cmd = Command::new("git");
        cmd.args(["apply", "--cached"]);

        app.close_menu();
        app.run_cmd(
            term,
            &diff.format_hunk_patch(file_i, hunk_i).into_bytes(),
            cmd,
        )
    })
}

fn stage_line(diff: Rc<Diff>, file_i: usize, hunk_i: usize, line_i: usize) -> Action {
    Rc::new(move |app, term| {
        let mut cmd = Command::new("git");
        cmd.args(["apply", "--cached", "--recount"]);

        let input = diff
            .format_line_patch(file_i, hunk_i, line_i..(line_i + 1), PatchMode::Normal)
            .into_bytes();

        app.close_menu();
        app.run_cmd(term, &input, cmd)
    })
}