ex-cli 1.20.1

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

use crate::error::MyResult;
use crate::git::flags::GitFlags;
use git2::{Repository, RepositoryOpenFlags, Status, StatusEntry, StatusOptions};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

type GitStatusMap = HashMap<PathBuf, Status>;

pub struct GitRepo {
    repo: Repository,
    root: PathBuf,
    statuses: Option<GitStatusMap>,
}

impl GitRepo {
    pub fn open_repository<'a, I>(path: &Path, ceiling: I) -> Option<Self> where
        I: IntoIterator<Item = &'a PathBuf>,
    {
        let flags = RepositoryOpenFlags::empty();
        if let Ok(repo) = Repository::open_ext(path, flags, ceiling) {
            if let Some(root) = repo.workdir() {
                let root = root.to_path_buf();
                let repo = Self { repo, root, statuses: None };
                return Some(repo);
            }
        }
        None
    }

    pub fn get_root(&self) -> &Path {
        &self.root
    }

    pub fn test_ignored(&self, path: &Path) -> MyResult<bool> {
        // Check if the directory exists in the .gitignore file.
        let path = path.strip_prefix(&self.root).map_err(|e| (e, path))?;
        let ignored = self.repo.is_path_ignored(path)?;
        Ok(ignored)
    }

    pub fn test_allowed(&mut self, flags: &GitFlags, path: &Path) -> MyResult<Option<GitFlags>> {
        // Test the flags, and return the flags for display purposes.
        let path = path.strip_prefix(&self.root).map_err(|e| (e, path))?;
        let status = self.repo.status_file(path)?;
        if status.is_index_new() {
            let statuses = self.statuses.get_or_insert_with(|| {
                Self::read_statuses(&self.repo)
            });
            if let Some(status) = statuses.get(path) {
                let result = flags.test_allowed(status);
                return Ok(result);
            }
        }
        let result = flags.test_allowed(&status);
        Ok(result)
    }

    fn read_statuses(repo: &Repository) -> GitStatusMap {
        let mut statuses = GitStatusMap::new();
        let mut options = StatusOptions::new();
        options.include_unmodified(true);
        options.include_untracked(true);
        options.include_ignored(true);
        options.renames_head_to_index(true);
        options.renames_index_to_workdir(true);
        options.renames_from_rewrites(true);
        if let Ok(entries) = repo.statuses(Some(&mut options)) {
            for entry in entries.iter() {
                if let Some(path) = Self::read_path(&entry) {
                    statuses.insert(path.to_path_buf(), entry.status());
                }
            }
        }
        statuses
    }

    fn read_path<'a>(entry: &'a StatusEntry) -> Option<&'a Path> {
        let delta = entry.head_to_index()?;
        let old = delta.old_file().path()?;
        let new = delta.new_file().path()?;
        if new != old {
            Some(new)
        } else {
            None
        }
    }
}