Skip to main content

cleaner_core/tree/
builder.rs

1use 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    /// Build tree with SINGLE WalkDir pass - maximum performance
18    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        // Protected directories (NEVER auto-clean inside these, but allow scanning and manual TUI deletion)
49        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        // Walk and index each directory in one pass so RawEntry collections are
81        // consumed before the next directory is retained.
82        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        // 3. Compute sizes in place.
140        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        // Add navigation in parallel. Entry sorting is deferred until a
151        // directory is opened, avoiding work for directories never viewed.
152        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            // Add navigation
159            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}