ex-cli 1.20.0

Command line tool to find, filter, sort and list files.
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

use crate::error::MyResult;
use crate::git::cache::TriOption::*;
use crate::git::flags::GitFlags;
use crate::git::repo::GitRepo;
use std::cell::RefCell;
use std::collections::HashMap;
use std::ops::DerefMut;
use std::path::{Path, PathBuf};
use std::rc::Rc;

enum TriOption<T> {
    Yes(T),
    No,
    Maybe,
}

type GitRepoMap = HashMap<PathBuf, Option<Rc<RefCell<GitRepo>>>>;

pub struct GitCache {
    flags: GitFlags,
    repos: RefCell<GitRepoMap>,
}

impl GitCache {
    pub fn new(flags: &GitFlags) -> Self {
        let flags = flags.clone();
        let repos = RefCell::new(HashMap::new());
        Self { flags, repos }
    }

    pub fn test_ignored(&self, path: &Path) -> bool {
        if let Some(parent) = path.parent() {
            if let Some(repo) = self.find_repository(parent) {
                let repo = repo.borrow();
                return repo.test_ignored(path).unwrap_or(true);
            }
        }
        true
    }

    pub fn test_allowed(&self, path: &Path) -> MyResult<Option<GitFlags>> {
        if let Some(parent) = path.parent() {
            if let Some(repo) = self.find_repository(parent) {
                let mut repo = repo.borrow_mut();
                let result = repo.test_allowed(&self.flags, path)?;
                return Ok(result);
            }
        }
        if self.flags.untracked {
            let result = GitFlags::default().with_untracked(true);
            return Ok(Some(result));
        }
        Ok(None)
    }

    fn find_repository(&self, path: &Path) -> Option<Rc<RefCell<GitRepo>>> {
        let mut repos = self.repos.borrow_mut();
        match Self::find_recursive(repos.deref_mut(), path) {
            Yes(repo) => {
                Some(repo)
            }
            No => {
                None
            }
            Maybe => {
                if let Some(repo) = GitRepo::open_repository(path, repos.keys()) {
                    let root = repo.get_root().to_path_buf();
                    let repo = Rc::new(RefCell::new(repo));
                    repos.insert(root, Some(Rc::clone(&repo)));
                    Some(repo)
                } else {
                    let path = PathBuf::from(path);
                    repos.insert(path, None);
                    None
                }
            }
        }
    }

    fn find_recursive(repos: &GitRepoMap, path: &Path) -> TriOption<Rc<RefCell<GitRepo>>> {
        if let Some(repo) = repos.get(path) {
            if let Some(repo) = repo {
                Yes(Rc::clone(repo))
            } else {
                No
            }
        } else if let Some(parent) = path.parent() {
            if let Yes(repo) = Self::find_recursive(repos, parent) {
                Yes(repo)
            } else {
                Maybe
            }
        } else {
            Maybe
        }
    }
}