gitaware 1.0.2

Git Aware is a command line tool that aims to make it easier to detect any dirty working copy in projects that uses Git
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129


mod git_actions;
mod params_checker;

use std::{env, process};
use ignore::{WalkBuilder, WalkState};
use std::sync::{Arc, Mutex};
use std::time::Instant;

use params_checker::{params_checker};

/**
 * Walk through the provided path, recursively in parallel detect Git repository.
 * Open them and check their status.
 */
fn get_git_results(path_to_directories: &str) -> Result<i32, String> {
    let mut git_repositories_scanned = 0;
    let entries = Arc::new(Mutex::new(vec![]));
    // Wall through targeted directory in parallel
    let files = WalkBuilder::new(path_to_directories).hidden(false).build_parallel();
    files.run(|| {
        let entries = entries.clone();
        Box::new(move |result| {
            if let Ok(file) = result {
                entries.lock().unwrap().push(file);
            }
            WalkState::Continue
        })
     });
     let entries = entries.lock().unwrap().to_vec();
     if entries.len() == 0 {
        return Err("Error: No files have been detected with the path you provided.".to_string());
     }
     for entry in entries.to_vec() {
        let path = entry.path().display();
        if path.to_string().ends_with(".git") {
            let path_to_open_repo = path.to_string().replace("/.git", "");
            // Get status of git repository.
            let result = git_actions::is_git_working_directory_clean(&path_to_open_repo);
            match result {
                Ok(repo_data) => {
                    if repo_data.is_empty_status {
                        println!("✅ - {}:\n \tWorking directory {} {} clean.", path_to_open_repo, repo_data.branch_name, if repo_data.is_detached {"DETACHED"} else {""});
                    } else {
                        println!("❌ - {}\n \tWorking directory {} {} clean.", path_to_open_repo, repo_data.branch_name, if repo_data.is_detached {"DETACHED"} else {""})
                    }
                    git_repositories_scanned += 1;
                },
                Err(err) => return Err(format!("An Error has been encountered while detecting statuses on git repository: {}\n - {}.", path_to_open_repo, err))
            }
        }
     }
     return Ok(git_repositories_scanned);
}


fn main() {
    let now = Instant::now();
    let argv: Vec<String> = env::args().collect();
    let config = params_checker(&argv);
    match config {
        Ok(config) => {
            if config.default {
                println!("No argument -p passed, taking the current directory as default. ('./')\n");
                match get_git_results(config.path) {
                    Ok(git_repositories_scanned) => {
                        println!("\nRepositories scanned: {:?}", git_repositories_scanned);
                    },
                    Err(msg) => {
                        eprintln!("{}", msg);
                        process::exit(1);
                    }
                };
            }
            match get_git_results(config.path) {
                Ok(git_repositories_scanned) => {
                    println!("\nRepositories scanned: {:?}", git_repositories_scanned);
                },
                Err(msg) => {
                    eprintln!("{}", msg);
                    process::exit(1);
                }
            };
        },
        Err(msg) => {
            eprintln!("{}", msg);
            process::exit(1);
        }
    };
    println!("\nScanned in: {:.2?}", now.elapsed());
}


#[cfg(test)]
mod tests {
    use crate::get_git_results;

    #[test]
    fn test_params_checker_when_invalid_path() {
        let path = "path_that_does_not_exists";
        let result = get_git_results(path);
        match result {
            Ok(_) => todo!(),
            Err(msg) => {
                assert_eq!(msg, "Error: No files have been detected with the path you provided.")
            }
        }
    }

    #[test]
    fn test_params_checker_it_should_not_detect_any_repo() {
        let path = "./src";
        let result = get_git_results(path);
        match result {
            Ok(git_repositories_scanned) => assert_eq!(git_repositories_scanned, 0),
            Err(_) => todo!()
        }
    }

    #[test]
    fn test_params_checker_it_works() {
        let path = "./";
        let result = get_git_results(path);
        match result {
            Ok(git_repositories_scanned) => assert_eq!(git_repositories_scanned, 1),
            Err(_) => todo!()
        }
    }
}