gitnu 0.4.2

gitnu indexes your git status so you can use numbers instead of filenames.
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

use crate::{git_cmd, Op, Opts};
use std::collections::HashSet;
use std::iter::Peekable;
use std::{path::PathBuf, process::Command};

fn parse_range(arg: &str) -> Option<[usize; 2]> {
    arg.parse().map(|v| Some([v, v])).unwrap_or_else(|_| {
        let (a, b) = arg.split_once("-")?;
        let a: usize = a.parse().ok()?;
        Some(b.parse().map(|b| [a.min(b), a.max(b)]).unwrap_or([a, a]))
    })
}

/// parse arguments before the git command
/// for a list of all git commands, see ./git_cmd.rs
fn pre_cmd(
    args: &mut Peekable<impl Iterator<Item = String>>,
    opts: &mut Opts,
) -> Vec<String> {
    let git_cmd = HashSet::from(git_cmd::GIT_CMD);
    let mut cache: Vec<String> = Vec::new();
    while let Some(arg) = args.next() {
        let arg = arg.as_str();
        // set git sub-cmd
        if git_cmd.contains(arg) {
            if arg.eq("status") {
                opts.set_once(Op::Status(true));
            } else {
                opts.set_once(Op::Number);
                cache = opts.read_cache().unwrap_or(cache);
            }
            opts.cmd.arg(arg);
            break;
        }
        // set cwd using git's -C flag
        if arg.eq("-C") {
            if let Some(cwd) = args.peek() {
                opts.cwd = PathBuf::from(cwd);
                opts.cmd.current_dir(cwd);
            }
        }
        // cut to displaying version
        if arg.eq("--version") {
            opts.op = Op::Version;
            opts.cmd = Command::new("git");
            opts.cmd.arg("--version");
            return Vec::new();
        }
        opts.pargs.push(arg.to_string());
        opts.cmd.arg(arg);
    }
    cache
}

/// parse arguments after the git command
/// for a list of all git commands, see ./git_cmd.rs
fn post_cmd(
    args: &mut Peekable<impl Iterator<Item = String>>,
    opts: &mut Opts,
    cache: Vec<String>,
) {
    let mut skip = false;
    while let Some(arg) = args.next() {
        let arg = arg.as_str();
        if arg.eq("--") {
            opts.cmd.arg(arg);
            break;
        }
        if ["--short", "-s", "--porcelain"].contains(&arg) {
            opts.set_once(Op::Status(false));
        }
        // try to parse argument as a range
        let isf = arg.starts_with('-') && !arg.starts_with("--"); // is short flag
        match (!skip && !isf, parse_range(arg)) {
            (true, Some([s, e])) => (s..e + 1).for_each(|n| {
                opts.cmd.arg(cache.get(n).unwrap_or(&n.to_string()));
            }),
            _ => {
                opts.cmd.arg(arg);
            }
        }
        skip = isf;
    }
    opts.cmd.args(args);
}

pub fn parse(args: impl Iterator<Item = String>, cwd: PathBuf) -> Opts {
    let mut opts = Opts {
        op: Op::Unset,
        cmd: Command::new("git"),
        pargs: Vec::new(),
        cwd,
    };
    if atty::is(atty::Stream::Stdout) {
        opts.cmd.args(["-c", "color.ui=always"]);
    }
    opts.cmd.current_dir(&opts.cwd);
    let mut args = args.skip(1).peekable();
    let cache = pre_cmd(&mut args, &mut opts);
    match opts.op {
        Op::Status(_) | Op::Number => post_cmd(&mut args, &mut opts, cache),
        Op::Unset | Op::Version => (),
    }
    opts
}