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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
use std::{borrow::Cow, fs::FileType};
use crate::{walk::ForDeletionMode, Entry, EntryRef};
/// A way of attaching additional information to an [Entry] .
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
pub enum Property {
/// The entry was named `.git`, matched according to the case-sensitivity rules of the repository.
DotGit,
/// The entry is a directory, and that directory is empty.
EmptyDirectory,
/// The entry is a directory, it is empty and the current working directory.
///
/// The caller should pay special attention to this very special case, as it is indeed only possible to run into it
/// while traversing the directory for deletion.
/// Non-empty directory will never be collapsed, hence if they are working directories, they naturally become unobservable.
EmptyDirectoryAndCWD,
/// Always in conjunction with a directory on disk that is also known as cone-mode sparse-checkout exclude marker
/// - i.e. a directory that is excluded, so its whole content is excluded and not checked out nor is part of the index.
///
/// Note that evne if the directory is empty, it will only have this state, not `EmptyDirectory`.
TrackedExcluded,
}
/// The kind of the entry, seated in their kinds available on disk.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
pub enum Kind {
/// Something that is not a regular file, directory, or symbolic link.
///
/// These can only exist in the filesystem,
/// because Git repositories do not support them, thus they cannot be tracked.
/// Hence, they do not appear as blobs in a repository, and their type is not specifiable in a tree object.
/// Examples include named pipes (FIFOs), character devices, block devices, and sockets.
Untrackable,
/// The entry is a blob, representing a regular file, executable or not.
File,
/// The entry is a symlink.
Symlink,
/// The entry is an ordinary directory.
///
/// Note that since we don't check for bare repositories, this could in fact be a collapsed
/// bare repository. To be sure, check it again with [`gix_discover::is_git()`] and act accordingly.
Directory,
/// The entry is a directory which *contains* a `.git` folder, or a submodule entry in the index.
Repository,
}
/// The kind of entry as obtained from a directory.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
pub enum Status {
/// The entry was removed from the walk due to its other properties, like [Property] or [PathspecMatch]
///
/// Note that entries flagged as `DotGit` directory will always be considered `Pruned`, but if they are
/// also ignored, in delete mode, they will be considered `Ignored` instead. This way, it's easier to remove them
/// while they will not be available for any interactions in read-only mode.
Pruned,
/// The entry is tracked in Git.
Tracked,
/// The entry is ignored as per `.gitignore` files and their rules.
///
/// If this is a directory, then its entire contents is ignored. Otherwise, possibly due to configuration, individual ignored files are listed.
Ignored(gix_ignore::Kind),
/// The entry is not tracked by git yet, it was not found in the [index](gix_index::State).
///
/// If it's a directory, the entire directory contents is untracked.
Untracked,
}
/// Describe how a pathspec pattern matched.
#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
pub enum PathspecMatch {
/// The match happened because there wasn't any pattern, which matches all, or because there was a nil pattern or one with an empty path.
/// Thus, this is not a match by merit.
Always,
/// A match happened, but the pattern excludes everything it matches, which means this entry was excluded.
Excluded,
/// The first part of a pathspec matches, like `dir/` that matches `dir/a`.
Prefix,
/// The whole pathspec matched and used a wildcard match, like `a/*` matching `a/file`.
WildcardMatch,
/// The entire pathspec matched, letter by letter, e.g. `a/file` matching `a/file`.
Verbatim,
}
impl PathspecMatch {
pub(crate) fn should_ignore(&self) -> bool {
match self {
PathspecMatch::Always | PathspecMatch::Excluded => true,
PathspecMatch::Prefix | PathspecMatch::WildcardMatch | PathspecMatch::Verbatim => false,
}
}
}
impl From<gix_pathspec::search::MatchKind> for PathspecMatch {
fn from(kind: gix_pathspec::search::MatchKind) -> Self {
match kind {
gix_pathspec::search::MatchKind::Always => Self::Always,
gix_pathspec::search::MatchKind::Prefix => Self::Prefix,
gix_pathspec::search::MatchKind::WildcardMatch => Self::WildcardMatch,
gix_pathspec::search::MatchKind::Verbatim => Self::Verbatim,
}
}
}
impl From<gix_pathspec::search::Match<'_>> for PathspecMatch {
fn from(m: gix_pathspec::search::Match<'_>) -> Self {
if m.is_excluded() {
PathspecMatch::Excluded
} else {
m.kind.into()
}
}
}
/// Conversion
impl EntryRef<'_> {
/// Strip the lifetime to obtain a fully owned copy.
pub fn to_owned(&self) -> Entry {
Entry {
rela_path: self.rela_path.clone().into_owned(),
status: self.status,
property: self.property,
disk_kind: self.disk_kind,
index_kind: self.index_kind,
pathspec_match: self.pathspec_match,
}
}
/// Turn this instance into a fully owned copy.
pub fn into_owned(self) -> Entry {
Entry {
rela_path: self.rela_path.into_owned(),
status: self.status,
property: self.property,
disk_kind: self.disk_kind,
index_kind: self.index_kind,
pathspec_match: self.pathspec_match,
}
}
}
/// Conversion
impl Entry {
/// Obtain an [`EntryRef`] from this instance.
pub fn to_ref(&self) -> EntryRef<'_> {
EntryRef {
rela_path: Cow::Borrowed(self.rela_path.as_ref()),
status: self.status,
property: self.property,
disk_kind: self.disk_kind,
index_kind: self.index_kind,
pathspec_match: self.pathspec_match,
}
}
}
impl From<std::fs::FileType> for Kind {
fn from(value: FileType) -> Self {
if value.is_dir() {
Kind::Directory
} else if value.is_symlink() {
Kind::Symlink
} else if value.is_file() {
Kind::File
} else {
Kind::Untrackable
}
}
}
impl Status {
/// Return true if this status is considered pruned. A pruned entry is typically hidden from view due to a pathspec.
pub fn is_pruned(&self) -> bool {
matches!(&self, Status::Pruned)
}
/// Return `true` if `file_type` is a directory on disk and isn't ignored, and is not a repository.
/// This implements the default rules of `git status`, which is good for a minimal traversal through
/// tracked and non-ignored portions of a worktree.
/// `for_deletion` is used to determine if recursion into a directory is allowed even though it otherwise wouldn't be.
/// If `worktree_root_is_repository` is `true`, then this status is part of the root of an iteration, and the corresponding
/// worktree root is a repository itself. This typically happens for submodules. In this case, recursion rules are relaxed
/// to allow traversing submodule worktrees.
///
/// Use `pathspec_match` to determine if a pathspec matches in any way, affecting the decision to recurse.
pub fn can_recurse(
&self,
file_type: Option<Kind>,
pathspec_match: Option<PathspecMatch>,
for_deletion: Option<ForDeletionMode>,
worktree_root_is_repository: bool,
) -> bool {
let is_dir_on_disk = file_type.is_some_and(|ft| {
if worktree_root_is_repository {
ft.is_dir()
} else {
ft.is_recursable_dir()
}
});
if !is_dir_on_disk {
return false;
}
match self {
Status::Pruned => false,
Status::Ignored(_) => {
for_deletion.is_some_and(|fd| {
matches!(
fd,
ForDeletionMode::FindNonBareRepositoriesInIgnoredDirectories
| ForDeletionMode::FindRepositoriesInIgnoredDirectories
)
}) || pathspec_match.is_some_and(|m| !m.should_ignore())
}
Status::Untracked | Status::Tracked => true,
}
}
}
impl Kind {
pub(super) fn is_recursable_dir(&self) -> bool {
matches!(self, Kind::Directory)
}
/// Return `true` if this is a directory on disk. Note that this is true for repositories as well.
pub fn is_dir(&self) -> bool {
matches!(self, Kind::Directory | Kind::Repository)
}
}