laziergit 1.0.0

an even lazier git implementation than lazygit
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

use color_eyre::eyre::{Result, bail};
use std::process::Command;

fn run(args: &[&str]) -> Result<Vec<u8>> {
    let out = Command::new("git").args(args).output()?;
    if !out.status.success() {
        bail!("{}", String::from_utf8_lossy(&out.stderr).trim());
    }
    Ok(out.stdout)
}

fn capture(args: &[&str]) -> String {
    Command::new("git")
        .args(args)
        .output()
        .map(|o| String::from_utf8_lossy(&o.stdout).into_owned())
        .unwrap_or_default()
}

pub fn status_raw() -> Result<Vec<u8>> {
    run(&["status", "--porcelain=v2", "--branch", "-z", "-uall"])
}

pub fn diff(path: &str, staged: bool) -> String {
    if staged {
        capture(&["diff", "--no-color", "--cached", "--", path])
    } else {
        capture(&["diff", "--no-color", "--", path])
    }
}

pub fn diff_untracked(path: &str) -> String {
    capture(&["diff", "--no-color", "--no-index", "--", "/dev/null", path])
}

pub fn stage(pathspec: &str) -> Result<()> {
    run(&["add", "--", pathspec]).map(drop)
}

pub fn unstage(pathspec: &str) -> Result<()> {
    if run(&["restore", "--staged", "--", pathspec]).is_ok() {
        return Ok(());
    }
    run(&["rm", "--cached", "-r", "-q", "--", pathspec]).map(drop)
}

pub fn commit(message: &str) -> Result<()> {
    run(&["commit", "-m", message]).map(drop)
}

pub fn checkout(name: &str) -> Result<()> {
    if run(&["checkout", name]).is_ok() {
        return Ok(());
    }
    run(&["checkout", "-b", name]).map(drop)
}

pub fn reset_hard_clean() -> Result<()> {
    run(&["reset", "--hard"])?;
    run(&["clean", "-fd"])?;
    Ok(())
}

pub fn pull() -> Result<String> {
    remote(&["pull"])
}

pub fn push() -> Result<String> {
    remote(&["push"])
}

fn remote(args: &[&str]) -> Result<String> {
    let out = Command::new("git").args(args).output()?;
    let mut text = String::from_utf8_lossy(&out.stdout).into_owned();
    text.push_str(&String::from_utf8_lossy(&out.stderr));
    let last = text
        .lines()
        .rev()
        .find(|l| !l.trim().is_empty())
        .unwrap_or("done")
        .trim()
        .to_string();
    if out.status.success() {
        Ok(last)
    } else {
        bail!("{last}");
    }
}