grit-lib 0.5.18

Core library for the grit Git implementation
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

//! Index-driven path-tree helpers for skipping redundant directory enumeration.
//!
//! When every tracked path under a directory shares the same next component (a linear
//! chain of intermediate directories), status and untracked walks can descend directly
//! without listing the directory on disk.

#[cfg(test)]
use std::collections::BTreeSet;

#[cfg(test)]
/// Prefix for paths strictly under `rel_dir` (`""` when `rel_dir` is empty).
#[must_use]
pub(crate) fn directory_prefix(rel_dir: &str) -> String {
    if rel_dir.is_empty() {
        String::new()
    } else {
        format!("{rel_dir}/")
    }
}

#[cfg(test)]
/// Returns the sole next path component when every indexed path under `rel_dir` continues
/// through the same subdirectory and none of them is a file directly in `rel_dir`.
#[must_use]
pub(crate) fn unique_indexed_subdirectory(
    tracked: &BTreeSet<String>,
    gitlinks: &BTreeSet<String>,
    rel_dir: &str,
) -> Option<String> {
    let prefix = directory_prefix(rel_dir);
    let mut component: Option<String> = None;
    let mut direct_file = false;

    for path in tracked.range(prefix.clone()..) {
        if !path.starts_with(&prefix) {
            break;
        }
        let rest = path.strip_prefix(&prefix).unwrap_or("");
        if rest.is_empty() {
            continue;
        }
        match rest.split_once('/') {
            Some((first, _)) => match &component {
                None => component = Some(first.to_owned()),
                Some(c) if c == first => {}
                _ => return None,
            },
            None => {
                direct_file = true;
            }
        }
    }

    for g in gitlinks {
        if g.as_str() == rel_dir {
            continue;
        }
        if !g.starts_with(&prefix) {
            continue;
        }
        let rest = g.strip_prefix(&prefix).unwrap_or("");
        if rest.is_empty() {
            continue;
        }
        let first = rest.split('/').next().unwrap_or("");
        if first.is_empty() {
            continue;
        }
        match &component {
            None => component = Some(first.to_owned()),
            Some(c) if c == first => {}
            _ => return None,
        }
    }

    if direct_file {
        None
    } else {
        component
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn unique_subdir_for_linear_chain() {
        let tracked: BTreeSet<String> = ["a/b/c/file.txt".to_owned()].into_iter().collect();
        let gitlinks = BTreeSet::new();
        assert_eq!(
            unique_indexed_subdirectory(&tracked, &gitlinks, ""),
            Some("a".to_owned())
        );
        assert_eq!(
            unique_indexed_subdirectory(&tracked, &gitlinks, "a"),
            Some("b".to_owned())
        );
        assert_eq!(
            unique_indexed_subdirectory(&tracked, &gitlinks, "a/b"),
            Some("c".to_owned())
        );
        assert_eq!(
            unique_indexed_subdirectory(&tracked, &gitlinks, "a/b/c"),
            None
        );
    }

    #[test]
    fn unique_subdir_none_when_sibling_files() {
        let tracked: BTreeSet<String> = ["a/x.txt".to_owned(), "a/y.txt".to_owned()]
            .into_iter()
            .collect();
        let gitlinks = BTreeSet::new();
        assert_eq!(unique_indexed_subdirectory(&tracked, &gitlinks, "a"), None);
    }
}