gitnu 0.0.5

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

use crate::structs::Gitnu;
use log::{info};
use std::collections::LinkedList;
use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use std::process::{Command, Stdio};

enum LineState {
    DualStaged, // both staged and unstaged
    Unstaged,
    Staged,
    Untracked,
    None,
}

fn get_line_state(line: &String) -> LineState {
    if line.len() < 2 {
        return LineState::None;
    }
    if line.starts_with("??") {
        return LineState::Untracked;
    };
    let mut it = line.chars();
    let staged = it.next() != Some(' ');
    let unstaged = it.next() != Some(' ');
    match (staged, unstaged) {
        (true, true) => LineState::DualStaged,
        (true, false) => LineState::Staged,
        (false, true) => LineState::Unstaged,
        (false, false) => LineState::None,
    }
}

/// use `git status --pocelain` to get all files in order of display
/// as in `git status`
///
/// index starts at the front of the linked list
pub fn load_files(gitnu: &mut Gitnu, git_dir: &PathBuf) {
    let mut staged: LinkedList<String> = LinkedList::new();
    let mut unstaged: LinkedList<String> = LinkedList::new();
    let mut untracked: LinkedList<String> = LinkedList::new();

    let handle_line = |line: String| {
        let file = line[3..].to_string();
        match get_line_state(&line) {
            LineState::DualStaged => {
                unstaged.push_back(file.clone());
                staged.push_back(file);
            }
            LineState::Staged => staged.push_back(file),
            LineState::Unstaged => unstaged.push_back(file),
            LineState::Untracked => untracked.push_back(file),
            _ => (),
        }
    };

    info!("loading index at: {:#?}", git_dir);

    // spawn the git status process
    let proc = Command::new("git")
        .arg("-C")
        .arg(git_dir)
        .args(["status", "--porcelain"])
        .stdout(Stdio::piped())
        .spawn()
        .unwrap();

    // return a reader for that process
    // this enables real-time processing of stdout
    BufReader::new(proc.stdout.unwrap())
        .lines()
        .filter_map(|line| line.ok())
        .for_each(handle_line);

    // after this point, the reader has done executing and has closed

    let mut load = |mut q: LinkedList<String>| {
        while !q.is_empty() {
            gitnu.add_file(q.pop_front().unwrap());
        }
    };

    // load all files into gitnu queue
    load(staged);
    load(unstaged);
    load(untracked);
}