gitnu 0.1.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

// gitnu add 2-4
// gitnu reset 7
use crate::opts::Opts;
use std::collections::HashMap;

#[derive(Debug)]
struct Files {
    data2: HashMap<u16, String>,
    count: u16,
}

impl Files {
    pub fn new(data2: HashMap<u16, String>) -> Files {
        Files { data2, count: 0 }
    }
    fn get(&mut self, query: &str) -> Option<String> {
        let index: u16 = match query.parse() {
            Ok(0) => return None,
            Ok(v) => v,
            Err(_) => return None,
        };
        self.data2.remove(&index)
    }
    pub fn apply(&mut self, args: &mut Vec<String>) {
        fn is_flag(flag: &str) -> bool {
            flag.starts_with("-") && flag.to_ascii_lowercase().eq(flag)
        }
        let mut it = args.iter_mut();
        while let Some(arg) = it.next() {
            // don't parse things like the 15 in `gitnu log -n 15`
            // once a flag is seen, skip both the flag and the next arg
            if is_flag(arg) {
                it.next();
                continue;
            }
            if let Some(res) = self.get(arg) {
                *arg = res;
                self.count += 1;
            }
        }
    }
    pub fn count(&self) -> u16 {
        return self.count;
    }
}

/// replace numbers with filenames
/// mutates the vector passed in, since the result has the same length
pub fn load(args: &mut Vec<String>, opts: &Opts) {
    // read cache
    let cache = opts.read_cache2().unwrap_or(HashMap::new());

    // make a wrapper to safely apply to args
    let mut files = Files::new(cache);
    files.apply(args);

    log::info!("made {} replacements", files.count());
    log::info!("files::load {:?}", args);
}