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
use std::path::{Path, PathBuf};
use gix_features::fs::walkdir::DirEntryIter;
use gix_object::bstr::ByteSlice;
use gix_path::RelativePath;
use crate::{file::iter::LooseThenPacked, store_impl::file, BString, FullName};
/// An iterator over all valid loose reference paths as seen from a particular base directory.
pub(in crate::store_impl::file) struct SortedLoosePaths {
pub(crate) base: PathBuf,
/// An prefix like `refs/heads/foo/` or `refs/heads/prefix` that a returned reference must match against..
prefix: Option<BString>,
/// A suffix like `HEAD` that a returned reference must match against..
suffix: Option<BString>,
file_walk: Option<DirEntryIter>,
}
impl SortedLoosePaths {
pub fn at(
path: &Path,
base: PathBuf,
prefix: Option<BString>,
suffix: Option<BString>,
precompose_unicode: bool,
) -> Self {
let depth = if suffix.is_some() { 1 } else { usize::MAX };
SortedLoosePaths {
base,
prefix,
suffix,
file_walk: path.is_dir().then(|| {
// serial iteration as we expect most refs in packed-refs anyway.
gix_features::fs::walkdir_sorted_new(
path,
gix_features::fs::walkdir::Parallelism::Serial,
depth,
precompose_unicode,
)
.into_iter()
}),
}
}
}
impl Iterator for SortedLoosePaths {
type Item = std::io::Result<(PathBuf, FullName)>;
fn next(&mut self) -> Option<Self::Item> {
for entry in self.file_walk.as_mut()?.by_ref() {
match entry {
Ok(entry) => {
if !entry.file_type().is_ok_and(|ft| ft.is_file()) {
continue;
}
let full_path = entry.path().into_owned();
let full_name = full_path
.strip_prefix(&self.base)
.expect("prefix-stripping cannot fail as base is within our root");
let Ok(full_name) = gix_path::try_into_bstr(full_name)
.map(|name| gix_path::to_unix_separators_on_windows(name).into_owned())
else {
continue;
};
if let Some(prefix) = &self.prefix {
if !full_name.starts_with(prefix) {
continue;
}
}
if let Some(suffix) = &self.suffix {
if !full_name.ends_with(suffix) {
continue;
}
}
if gix_validate::reference::name_partial(full_name.as_bstr()).is_ok() {
let name = FullName(full_name);
return Some(Ok((full_path, name)));
} else {
continue;
}
}
Err(err) => return Some(Err(err.into_io_error().expect("no symlink related errors"))),
}
}
None
}
}
impl file::Store {
/// Return an iterator over all loose references, notably not including any packed ones, in lexical order.
/// Each of the references may fail to parse and the iterator will not stop if parsing fails, allowing the caller
/// to see all files that look like references whether valid or not.
///
/// Reference files that do not constitute valid names will be silently ignored.
pub fn loose_iter(&self) -> std::io::Result<LooseThenPacked<'_, '_>> {
self.iter_packed(None)
}
/// Return an iterator over all loose references that start with the given `prefix`.
///
/// Otherwise, it's similar to [`loose_iter()`](file::Store::loose_iter()).
///
/// Note that if a prefix isn't using a trailing `/`, like in `refs/heads/foo`, it will effectively
/// start the traversal in the parent directory, e.g. `refs/heads/` and list everything inside that
/// starts with `foo`, like `refs/heads/foo` and `refs/heads/foobar`.
///
/// Prefixes are relative paths with slash-separated components.
pub fn loose_iter_prefixed(&self, prefix: &RelativePath) -> std::io::Result<LooseThenPacked<'_, '_>> {
self.iter_prefixed_packed(prefix, None)
}
}