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
use gix_dir::walk::{CollapsedEntriesEmissionMode, EmissionMode, ForDeletionMode};
use crate::dirwalk::Options;
/// Construction
impl Options {
pub(crate) fn from_fs_caps(caps: gix_fs::Capabilities) -> Self {
Self {
precompose_unicode: caps.precompose_unicode,
ignore_case: caps.ignore_case,
recurse_repositories: false,
emit_pruned: false,
emit_ignored: None,
for_deletion: None,
emit_tracked: false,
emit_untracked: Default::default(),
emit_empty_directories: false,
classify_untracked_bare_repositories: false,
emit_collapsed: None,
empty_patterns_match_prefix: false,
symlinks_to_directories_are_ignored_like_directories: false,
}
}
}
impl From<Options> for gix_dir::walk::Options<'static> {
fn from(v: Options) -> Self {
gix_dir::walk::Options {
precompose_unicode: v.precompose_unicode,
ignore_case: v.ignore_case,
recurse_repositories: v.recurse_repositories,
emit_pruned: v.emit_pruned,
emit_ignored: v.emit_ignored,
for_deletion: v.for_deletion,
emit_tracked: v.emit_tracked,
emit_untracked: v.emit_untracked,
emit_empty_directories: v.emit_empty_directories,
classify_untracked_bare_repositories: v.classify_untracked_bare_repositories,
emit_collapsed: v.emit_collapsed,
symlinks_to_directories_are_ignored_like_directories: v
.symlinks_to_directories_are_ignored_like_directories,
worktree_relative_worktree_dirs: None,
}
}
}
impl Options {
/// If `true`, default `false`, pathspecs and the directory walk itself will be setup to use the [prefix](crate::Repository::prefix)
/// if patterns are empty.
///
/// This means that the directory walk will be limited to only what's inside the [repository prefix](crate::Repository::prefix).
/// By default, the directory walk will see everything.
pub fn empty_patterns_match_prefix(mut self, toggle: bool) -> Self {
self.empty_patterns_match_prefix = toggle;
self
}
/// Like [`empty_patterns_match_prefix()`](Self::empty_patterns_match_prefix), but only requires a mutably borrowed instance.
pub fn set_empty_patterns_match_prefix(&mut self, toggle: bool) -> &mut Self {
self.empty_patterns_match_prefix = toggle;
self
}
/// If `toggle` is `true`, we will stop figuring out if any directory that is a candidate for recursion is also a nested repository,
/// which saves time but leads to recurse into it. If `false`, nested repositories will not be traversed.
pub fn recurse_repositories(mut self, toggle: bool) -> Self {
self.recurse_repositories = toggle;
self
}
/// Like [`recurse_repositories()`](Self::recurse_repositories), but only requires a mutably borrowed instance.
pub fn set_recurse_repositories(&mut self, toggle: bool) -> &mut Self {
self.recurse_repositories = toggle;
self
}
/// If `toggle` is `true`, entries that are pruned and whose [Kind](gix_dir::entry::Kind) is known will be emitted.
pub fn emit_pruned(mut self, toggle: bool) -> Self {
self.emit_pruned = toggle;
self
}
/// Like [`emit_pruned()`](Self::emit_pruned), but only requires a mutably borrowed instance.
pub fn set_emit_pruned(&mut self, toggle: bool) -> &mut Self {
self.emit_pruned = toggle;
self
}
/// If `value` is `Some(mode)`, entries that are ignored will be emitted according to the given `mode`.
/// If `None`, ignored entries will not be emitted at all.
pub fn emit_ignored(mut self, value: Option<EmissionMode>) -> Self {
self.emit_ignored = value;
self
}
/// Like [`emit_ignored()`](Self::emit_ignored), but only requires a mutably borrowed instance.
pub fn set_emit_ignored(&mut self, value: Option<EmissionMode>) -> &mut Self {
self.emit_ignored = value;
self
}
/// When the walk is for deletion, `value` must be `Some(_)` to assure we don't collapse directories that have precious files in
/// them, and otherwise assure that no entries are observable that shouldn't be deleted.
/// If `None`, precious files are treated like expendable files, which is usually what you want when displaying them
/// for addition to the repository, and the collapse of folders can be more generous in relation to ignored files.
pub fn for_deletion(mut self, value: Option<ForDeletionMode>) -> Self {
self.for_deletion = value;
self
}
/// Like [`for_deletion()`](Self::for_deletion), but only requires a mutably borrowed instance.
pub fn set_for_deletion(&mut self, value: Option<ForDeletionMode>) -> &mut Self {
self.for_deletion = value;
self
}
/// If `toggle` is `true`, we will also emit entries for tracked items. Otherwise these will remain 'hidden',
/// even if a pathspec directly refers to it.
pub fn emit_tracked(mut self, toggle: bool) -> Self {
self.emit_tracked = toggle;
self
}
/// Like [`emit_tracked()`](Self::emit_tracked), but only requires a mutably borrowed instance.
pub fn set_emit_tracked(&mut self, toggle: bool) -> &mut Self {
self.emit_tracked = toggle;
self
}
/// Controls the way untracked files are emitted. By default, this is happening immediately and without any simplification.
pub fn emit_untracked(mut self, mode: EmissionMode) -> Self {
self.emit_untracked = mode;
self
}
/// Like [`emit_untracked()`](Self::emit_untracked), but only requires a mutably borrowed instance.
pub fn set_emit_untracked(&mut self, mode: EmissionMode) -> &mut Self {
self.emit_untracked = mode;
self
}
/// If `toggle` is `true`, emit empty directories as well. Note that a directory also counts as empty if it has any
/// amount or depth of nested subdirectories, as long as none of them includes a file.
/// Thus, this makes leaf-level empty directories visible, as those don't have any content.
pub fn emit_empty_directories(mut self, toggle: bool) -> Self {
self.emit_empty_directories = toggle;
self
}
/// Like [`emit_empty_directories()`](Self::emit_empty_directories), but only requires a mutably borrowed instance.
pub fn set_emit_empty_directories(&mut self, toggle: bool) -> &mut Self {
self.emit_empty_directories = toggle;
self
}
/// If `toggle` is `true`, we will not only find non-bare repositories in untracked directories, but also bare ones.
///
/// Note that this is very costly, but without it, bare repositories will appear like untracked directories when collapsed,
/// and they will be recursed into.
pub fn classify_untracked_bare_repositories(mut self, toggle: bool) -> Self {
self.classify_untracked_bare_repositories = toggle;
self
}
/// Like [`classify_untracked_bare_repositories()`](Self::classify_untracked_bare_repositories), but only requires a mutably borrowed instance.
pub fn set_classify_untracked_bare_repositories(&mut self, toggle: bool) -> &mut Self {
self.classify_untracked_bare_repositories = toggle;
self
}
/// Control whether entries that are in an about-to-be collapsed directory will be emitted. The default is `None`,
/// so entries in a collapsed directory are not observable.
pub fn emit_collapsed(mut self, value: Option<CollapsedEntriesEmissionMode>) -> Self {
self.emit_collapsed = value;
self
}
/// Like [`emit_collapsed()`](Self::emit_collapsed), but only requires a mutably borrowed instance.
pub fn set_emit_collapsed(&mut self, value: Option<CollapsedEntriesEmissionMode>) -> &mut Self {
self.emit_collapsed = value;
self
}
/// This is a `libgit2` compatibility flag, and if enabled, symlinks that point to directories will be considered a directory
/// when checking for exclusion.
///
/// This is relevant if `src2` points to `src`, and is excluded with `src2/`. If `false`, `src2` will not be excluded,
/// if `true` it will be excluded as the symlink is considered a directory.
///
/// In other words, for Git compatibility this flag should be `false`, the default, for `git2` compatibility it should be `true`.
pub fn symlinks_to_directories_are_ignored_like_directories(mut self, toggle: bool) -> Self {
self.symlinks_to_directories_are_ignored_like_directories = toggle;
self
}
/// Like [`symlinks_to_directories_are_ignored_like_directories()`](Self::symlinks_to_directories_are_ignored_like_directories),
/// but only requires a mutably borrowed instance.
pub fn set_symlinks_to_directories_are_ignored_like_directories(&mut self, toggle: bool) -> &mut Self {
self.symlinks_to_directories_are_ignored_like_directories = toggle;
self
}
}