cleaner_core/tree/
builder.rs1use super::entry::DirEntry;
2use super::progress::ScanProgress;
3use super::sizing::apply_directory_sizes;
4use super::DirTree;
5use crate::fastwalk;
6use crate::patterns::PatternMatcher;
7use crate::pool::SCAN_POOL;
8use crate::protected::protected_paths_for_root;
9use foldhash::{HashMap, HashMapExt};
10use rayon::prelude::*;
11use std::ffi::OsString;
12use std::path::{Path, PathBuf};
13use std::sync::atomic::{AtomicBool, Ordering};
14use std::sync::Arc;
15
16impl DirTree {
17 pub fn build_with_progress(
19 root: &Path,
20 matcher: &PatternMatcher,
21 progress: Arc<ScanProgress>,
22 cancelled: Arc<AtomicBool>,
23 force: bool,
24 ) -> Self {
25 #[cfg(test)]
26 let profile_started = std::time::Instant::now();
27
28 #[cfg(target_os = "macos")]
29 let docker_path: Option<PathBuf> = {
30 if let Some(home) = std::env::var_os("HOME") {
31 let docker_container =
32 PathBuf::from(home).join("Library/Containers/com.docker.docker");
33 if docker_container.exists() {
34 Some(docker_container)
35 } else {
36 None
37 }
38 } else {
39 None
40 }
41 };
42 #[cfg(not(target_os = "macos"))]
43 let docker_path: Option<PathBuf> = None;
44
45 #[cfg(target_os = "macos")]
46 let root_clone = root.to_path_buf();
47
48 let protected_paths = protected_paths_for_root(root, force);
50
51 let skip_check = Arc::new(move |path: &Path| -> bool {
52 if let Some(ref docker) = docker_path {
53 if path.starts_with(docker) {
54 return true;
55 }
56 }
57 #[cfg(target_os = "macos")]
58 {
59 if (path.starts_with("/System/Volumes") || path == Path::new("/System/Volumes"))
60 && !root_clone.starts_with("/System/Volumes")
61 {
62 return true;
63 }
64 if (path.starts_with("/Volumes") || path == Path::new("/Volumes"))
65 && !root_clone.starts_with("/Volumes")
66 {
67 return true;
68 }
69 }
70 false
71 });
72
73 let progress_clone = Arc::clone(&progress);
74 let progress_cb = Arc::new(move |dirs: usize, files: usize, bytes: u64| {
75 progress_clone.dirs.fetch_add(dirs, Ordering::Relaxed);
76 progress_clone.files.fetch_add(files, Ordering::Relaxed);
77 progress_clone.bytes.fetch_add(bytes, Ordering::Relaxed);
78 });
79
80 let walk = fastwalk::walk_parallel_mapped(
83 root.to_path_buf(),
84 &SCAN_POOL,
85 skip_check,
86 Some(progress_cb),
87 &|dir_path, entries| {
88 let dir_is_protected = protected_paths
89 .iter()
90 .any(|protected| dir_path.starts_with(protected));
91 Arc::new(
92 entries
93 .into_iter()
94 .filter(|entry| !entry.is_symlink)
95 .map(|entry| {
96 let entry_is_protected = dir_is_protected
97 || (entry.is_dir
98 && protected_paths.iter().any(|protected| {
99 dir_path.join(&entry.name).starts_with(protected)
100 }));
101 let is_temp = if entry_is_protected {
102 false
103 } else if entry.is_dir {
104 matcher.is_temp_directory(&entry.name)
105 } else {
106 matcher.is_temp_file(&entry.name)
107 };
108 DirEntry {
109 name: entry.name,
110 size: entry.size,
111 is_dir: entry.is_dir,
112 is_temp,
113 }
114 })
115 .collect(),
116 )
117 },
118 );
119 #[cfg(test)]
120 let scan_elapsed = profile_started.elapsed();
121 progress.errors.fetch_add(walk.errors, Ordering::Relaxed);
122 let mut children: HashMap<PathBuf, Arc<Vec<DirEntry>>> = walk.entries;
123
124 if cancelled.load(Ordering::Relaxed) {
125 progress.done.store(true, Ordering::Release);
126 return Self::from_shared_children(HashMap::new());
127 }
128
129 progress.begin_stage(1, children.len());
130 progress
131 .stage_current
132 .store(children.len(), Ordering::Relaxed);
133
134 if cancelled.load(Ordering::Relaxed) {
135 progress.done.store(true, Ordering::Release);
136 return Self::from_shared_children(children);
137 }
138
139 progress.begin_stage(2, children.len());
141 apply_directory_sizes(root, &mut children, &progress, &cancelled);
142 #[cfg(test)]
143 let sizing_elapsed = profile_started.elapsed().saturating_sub(scan_elapsed);
144
145 if cancelled.load(Ordering::Relaxed) {
146 progress.done.store(true, Ordering::Release);
147 return Self::from_shared_children(children);
148 }
149
150 progress.begin_stage(3, children.len());
153 let root_clone = root.to_path_buf();
154 children.par_iter_mut().for_each(|(dir_path, entries)| {
155 if cancelled.load(Ordering::Relaxed) {
156 return;
157 }
158 if dir_path != &root_clone && dir_path.parent().is_some() {
160 Arc::make_mut(entries).insert(
161 0,
162 DirEntry {
163 name: OsString::from(".."),
164 size: 0,
165 is_dir: true,
166 is_temp: false,
167 },
168 );
169 }
170 });
171 progress
172 .stage_current
173 .store(children.len(), Ordering::Relaxed);
174
175 progress.done.store(true, Ordering::Release);
176 #[cfg(test)]
177 if std::env::var_os("CLEANER_PROFILE_ROOT").is_some() {
178 println!(
179 "tui phases: scan/index={scan_elapsed:?} sizing={sizing_elapsed:?} finalizing={:?}",
180 profile_started
181 .elapsed()
182 .saturating_sub(scan_elapsed)
183 .saturating_sub(sizing_elapsed)
184 );
185 }
186 Self::from_shared_children(children)
187 }
188}