gitu 0.42.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

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

pub(crate) struct Apply;
impl OpTrait for Apply {
    fn get_action(&self, target: &ItemData) -> Option<Action> {
        let action = match target {
            ItemData::Stash { stash_ref, .. } => apply_stash(stash_ref.clone()),
            ItemData::Delta { diff, file_i, .. } => apply_patch(diff.format_file_patch(*file_i)),
            ItemData::Hunk {
                diff,
                file_i,
                hunk_i,
            } => apply_patch(diff.format_hunk_patch(*file_i, *hunk_i)),
            ItemData::HunkLine {
                diff,
                file_i,
                hunk_i,
                line_i,
                ..
            } => apply_line(diff, *file_i, *hunk_i, *line_i),
            _ => return None,
        };

        Some(action)
    }

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

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

fn apply_stash(stash_ref: String) -> Action {
    Rc::new(move |app: &mut App, term: &mut Term| {
        let mut cmd = Command::new("git");
        cmd.args(["stash", "apply", "-q"]);
        cmd.arg(&stash_ref);
        app.run_cmd(term, &[], cmd)
    })
}

fn apply_line(diff: &Rc<Diff>, file_i: usize, hunk_i: usize, line_i: usize) -> Action {
    let patch = diff
        .format_line_patch(file_i, hunk_i, line_i..(line_i + 1), PatchMode::Normal)
        .into_bytes();

    Rc::new(move |app: &mut App, term: &mut Term| {
        let mut cmd = Command::new("git");
        cmd.args(["apply", "--recount"]);
        app.run_cmd(term, &patch, cmd)
    })
}

fn apply_patch(patch: String) -> Action {
    let patch = patch.into_bytes();

    Rc::new(move |app: &mut App, term: &mut Term| {
        let mut cmd = Command::new("git");
        cmd.arg("apply");
        app.run_cmd(term, &patch, cmd)
    })
}