use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver};
use std::sync::Arc;
use std::thread::{self, JoinHandle};
use nix::sys::statvfs::statvfs;
use crate::cleaner::{
CleanOptions, CleanOrchestrator, CleanResult, DetectedProject, DetectedSystemResource,
DetectorRegistry, ProjectScanner, ScanOptions as ProjectScanOptions, SystemCleanerRegistry,
};
use crate::config::CleanerConfig;
use crate::scanner::{
scan_directory, scan_directory_progressive_notifying, DirEntry, ScanOptions, ScanUpdate,
};
use walkdir::WalkDir;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
Normal,
Search,
Confirm(ConfirmAction),
Help,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConfirmAction {
Delete,
SudoDelete,
Clean,
CleanRecursive,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OperationKind {
Delete,
Clean,
CleanRecursive,
}
struct OperationState {
kind: OperationKind,
cancel: Arc<AtomicBool>,
}
struct WakeOnDrop(Option<thread::Thread>);
impl WakeOnDrop {
fn notify(&self) {
if let Some(thread) = &self.0 {
thread.unpark();
}
}
}
impl Drop for WakeOnDrop {
fn drop(&mut self) {
self.notify();
}
}
fn receive_worker<T>(receiver: &Option<Receiver<T>>) -> Option<Result<T, mpsc::TryRecvError>> {
match receiver.as_ref()?.try_recv() {
Err(mpsc::TryRecvError::Empty) => None,
result => Some(result),
}
}
struct OperationOutcome {
message: String,
rescan: bool,
refresh_system_resources: bool,
project_refresh: Option<ProjectRefresh>,
deletion_patch: Option<TreePatch>,
sudo_retry: Option<PathBuf>,
}
struct ProjectRefresh {
project: DetectedProject,
artifact_patches: Vec<TreePatch>,
}
struct TreePatch {
path: PathBuf,
replacement: Option<DirEntry>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SortOrder {
#[default]
Size,
Name,
Mtime,
}
#[derive(Debug, Clone)]
pub struct VisibleEntry {
pub entry: DirEntry,
pub depth: usize,
pub is_expanded: bool,
pub project_type: Option<String>,
pub system_resource: Option<DetectedSystemResource>,
pub is_separator: bool,
}
fn delete_path(path: &Path) -> std::io::Result<()> {
if path.is_dir() {
fs::remove_dir_all(path)
} else {
fs::remove_file(path)
}
}
fn deletion_outcome(
path: PathBuf,
scan_options: &ScanOptions,
result: std::io::Result<()>,
offer_sudo: bool,
) -> OperationOutcome {
let (message, replacement, sudo_retry) = match result {
Ok(()) => (format!("Deleted: {}", path.display()), Some(None), None),
Err(error) => {
let retry = (offer_sudo && error.kind() == std::io::ErrorKind::PermissionDenied)
.then(|| path.clone());
let replacement = scan_directory(&path, scan_options).ok().map(Some);
(format!("Error: {error}"), replacement, retry)
}
};
OperationOutcome {
message,
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: replacement.map(|replacement| TreePatch { path, replacement }),
sudo_retry,
}
}
fn cancelled_outcome(action: &str) -> OperationOutcome {
OperationOutcome {
message: format!("{} cancelled", action),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
}
}
fn refresh_cleaned_project(
mut project: DetectedProject,
scan_options: &ScanOptions,
) -> ProjectRefresh {
let mut artifact_patches = Vec::with_capacity(project.artifact_paths.len());
let mut remaining_artifacts = Vec::new();
let mut artifact_size = 0;
for path in &project.artifact_paths {
if path.exists() {
remaining_artifacts.push(path.clone());
match scan_directory(path, scan_options) {
Ok(entry) => {
artifact_size += entry.size;
artifact_patches.push(TreePatch {
path: path.clone(),
replacement: Some(entry),
});
}
Err(_) => artifact_size += dir_size(path),
}
} else {
artifact_patches.push(TreePatch {
path: path.clone(),
replacement: None,
});
}
}
project.artifact_paths = remaining_artifacts;
project.artifact_size = artifact_size;
ProjectRefresh {
project,
artifact_patches,
}
}
fn clean_project(
project: DetectedProject,
scan_options: ScanOptions,
cleaner_config: CleanerConfig,
cancel: Arc<AtomicBool>,
) -> OperationOutcome {
if cancel.load(Ordering::Acquire) {
return cancelled_outcome("Clean");
}
if project.artifact_paths.is_empty() {
return OperationOutcome {
message: "No artifacts to clean".to_string(),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
};
}
if cancel.load(Ordering::Acquire) {
return cancelled_outcome("Clean");
}
let orchestrator = CleanOrchestrator::new(
detector_registry(&cleaner_config),
CleanOptions::default(),
cleaner_config.parallel_jobs.max(1),
);
let mut results = orchestrator.clean_all(vec![project.clone()], None);
let (message, refresh_project) = match results
.pop()
.expect("one project produces one clean result")
{
CleanResult::Success { freed_bytes, .. } => (
format!(
"Cleaned {} project, freed {}",
project.display_name,
humansize::format_size(freed_bytes, humansize::BINARY)
),
true,
),
CleanResult::Failed {
error, freed_bytes, ..
} if freed_bytes > 0 => (
format!(
"Project partially cleaned, freed {}; some artifacts remain: {}",
humansize::format_size(freed_bytes, humansize::BINARY),
error
),
true,
),
CleanResult::Failed { error, .. } => (format!("Clean failed: {}", error), true),
CleanResult::Skipped { reason, .. } => (format!("Clean skipped: {}", reason), false),
};
let project_refresh = refresh_project.then(|| refresh_cleaned_project(project, &scan_options));
OperationOutcome {
message,
rescan: false,
refresh_system_resources: false,
project_refresh,
deletion_patch: None,
sudo_retry: None,
}
}
fn clean_projects(
projects: Vec<DetectedProject>,
scope: PathBuf,
cleaner_config: CleanerConfig,
cancel: Arc<AtomicBool>,
) -> OperationOutcome {
if cancel.load(Ordering::Acquire) {
return cancelled_outcome("Recursive cleanup");
}
let projects: Vec<_> = projects
.into_iter()
.filter(|project| {
project.path.starts_with(&scope)
&& project.path.is_dir()
&& project
.artifact_paths
.iter()
.all(|artifact| artifact.starts_with(&project.path))
})
.collect();
if projects.is_empty() {
return OperationOutcome {
message: "No cleanable projects remain".to_string(),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
};
}
let total = projects.len();
let orchestrator = CleanOrchestrator::new(
detector_registry(&cleaner_config),
CleanOptions::default(),
cleaner_config.parallel_jobs.max(1),
);
let results = orchestrator.clean_all_cancellable(projects, None, Arc::clone(&cancel));
let summary = CleanOrchestrator::summarize(&results);
let mut message = if cancel.load(Ordering::Acquire) {
format!(
"Recursive cleanup cancelled: cleaned {}/{} projects, freed {} ({} failed)",
summary.success_count,
total,
humansize::format_size(summary.total_freed, humansize::BINARY),
summary.failed_count
)
} else if summary.failed_count == 0 && summary.skipped_count == 0 {
format!(
"Cleaned {} projects, freed {}",
summary.success_count,
humansize::format_size(summary.total_freed, humansize::BINARY)
)
} else {
format!(
"Cleaned {} projects; {} failed, {} skipped, freed {}",
summary.success_count,
summary.failed_count,
summary.skipped_count,
humansize::format_size(summary.total_freed, humansize::BINARY)
)
};
if let Some((project, error)) = results.iter().find_map(|result| match result {
CleanResult::Failed { project, error, .. } => Some((project, error)),
_ => None,
}) {
let error = error.split_whitespace().collect::<Vec<_>>().join(" ");
message.push_str(&format!("; {}: {}", project.path.display(), error));
}
OperationOutcome {
message,
rescan: true,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
}
}
fn clean_system_resource(
resource: DetectedSystemResource,
cancel: Arc<AtomicBool>,
) -> OperationOutcome {
use crate::cleaner::SystemCleanResult;
if cancel.load(Ordering::Acquire) {
return cancelled_outcome("Clean");
}
let registry = SystemCleanerRegistry::new();
let Some(cleaner) = registry.get_cleaner(&resource.category) else {
return OperationOutcome {
message: "No cleaner found for this resource".to_string(),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
};
};
match cleaner.clean(&resource, false) {
SystemCleanResult::Success { freed_bytes, .. } => OperationOutcome {
message: format!(
"Cleaned {}, freed {}",
resource.display_name,
humansize::format_size(freed_bytes, humansize::BINARY)
),
rescan: false,
refresh_system_resources: true,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
},
SystemCleanResult::Failed { error, .. } => OperationOutcome {
message: format!("Clean failed: {}", error),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
},
SystemCleanResult::Skipped { reason, .. } => OperationOutcome {
message: format!("Clean skipped: {}", reason),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
},
}
}
fn dir_size(path: &Path) -> u64 {
WalkDir::new(path)
.into_iter()
.flatten()
.filter(|e| e.file_type().is_file())
.filter_map(|e| e.metadata().ok())
.map(|m| m.len())
.sum()
}
#[derive(Debug, Clone, Default)]
pub struct CleanPreview {
pub project_name: String,
pub artifacts: Vec<(String, u64)>, pub total_size: u64,
pub recursive: bool,
pub scope_path: Option<PathBuf>,
pub projects: Vec<ProjectPreview>,
}
#[derive(Debug, Clone)]
pub struct ProjectPreview {
pub path: PathBuf,
pub display_name: String,
pub artifact_count: usize,
pub artifact_size: u64,
}
fn detector_registry(config: &CleanerConfig) -> DetectorRegistry {
let types: Vec<&str> = config.project_types.iter().map(String::as_str).collect();
DetectorRegistry::with_types(&types)
}
fn project_scan_options(config: &CleanerConfig) -> ProjectScanOptions {
ProjectScanOptions {
max_depth: config.max_depth,
exclude_patterns: config.exclude_patterns.clone(),
follow_symlinks: false,
}
}
pub struct App {
pub root: PathBuf,
scan_options: ScanOptions,
cleaner_config: CleanerConfig,
pub tree: Option<DirEntry>,
pub visible_entries: Vec<VisibleEntry>,
pub selected: usize,
pub expanded: HashSet<PathBuf>,
pub mode: Mode,
pub search_query: String,
pub sort_order: SortOrder,
pub show_hidden: bool,
pub should_quit: bool,
pub status_message: Option<String>,
post_operation_message: Option<String>,
wakeup: Option<thread::Thread>,
defer_view_updates: bool,
view_dirty: bool,
pub(crate) cached_disk_usage: Option<(u64, u64, u64)>,
disk_usage_receiver: Option<Receiver<Option<(u64, u64, u64)>>>,
pending_sudo_delete: Option<PathBuf>,
sudo_delete_request: Option<PathBuf>,
deletion_patches: Vec<TreePatch>,
pub scanning: bool,
pub clean_preview: Option<CleanPreview>,
pub recursive_preview_running: bool,
recursive_preview_receiver: Option<Receiver<Vec<DetectedProject>>>,
#[allow(dead_code)]
recursive_preview_thread: Option<JoinHandle<()>>,
recursive_preview_cancel: Option<Arc<AtomicBool>>,
pending_recursive_projects: Option<Vec<DetectedProject>>,
pub confirmation_target: Option<VisibleEntry>,
pub system_resources: Vec<DetectedSystemResource>,
pub detect_system: bool,
detected_projects: HashMap<PathBuf, DetectedProject>,
project_detection_running: bool,
project_receiver: Option<Receiver<Vec<DetectedProject>>>,
#[allow(dead_code)]
project_thread: Option<JoinHandle<()>>,
scan_receiver: Option<Receiver<ScanUpdate>>,
#[allow(dead_code)]
scan_thread: Option<JoinHandle<()>>,
operation: Option<OperationState>,
operation_receiver: Option<Receiver<OperationOutcome>>,
#[allow(dead_code)]
operation_thread: Option<JoinHandle<()>>,
system_detection_running: bool,
system_receiver: Option<Receiver<Vec<DetectedSystemResource>>>,
#[allow(dead_code)]
system_thread: Option<JoinHandle<()>>,
}
impl App {
pub fn pending_sudo_delete(&self) -> Option<&Path> {
self.pending_sudo_delete.as_deref()
}
pub fn confirm_sudo_delete(&mut self) {
self.sudo_delete_request = self.pending_sudo_delete.take().filter(|path| {
path.is_absolute() && path != &self.root && path.starts_with(&self.root)
});
}
pub fn cancel_sudo_delete(&mut self) {
self.pending_sudo_delete = None;
self.sudo_delete_request = None;
self.status_message = Some("Sudo deletion cancelled; remaining files kept".into());
}
pub(crate) fn take_sudo_delete_request(&mut self) -> Option<PathBuf> {
self.sudo_delete_request.take()
}
pub(crate) fn sudo_delete_requested(&self) -> bool {
self.sudo_delete_request.is_some()
}
pub(crate) fn finish_sudo_delete(&mut self, path: PathBuf, result: std::io::Result<()>) {
let mut options = self.scan_options.clone();
options.include_hidden = true;
options.cache = None;
self.start_operation(
OperationKind::Delete,
"Refreshing deletion result...".into(),
move |_| deletion_outcome(path, &options, result, false),
);
}
pub(crate) fn attach_ui_thread(&mut self) {
self.wakeup = Some(thread::current());
self.defer_view_updates = true;
}
pub(crate) fn flush_view_updates(&mut self) {
if self.view_dirty {
let deferred = self.defer_view_updates;
self.defer_view_updates = false;
self.rebuild_visible_entries();
self.defer_view_updates = deferred;
}
}
pub fn new(root: PathBuf) -> Self {
Self::with_options(
root,
ScanOptions::default().with_one_file_system(true),
CleanerConfig::default(),
)
}
pub fn with_scan_options(root: PathBuf, scan_options: ScanOptions) -> Self {
Self::with_options(root, scan_options, CleanerConfig::default())
}
pub fn with_options(
root: PathBuf,
scan_options: ScanOptions,
cleaner_config: CleanerConfig,
) -> Self {
let root = root.canonicalize().unwrap_or(root);
Self {
root,
scan_options,
cleaner_config,
tree: None,
visible_entries: Vec::new(),
selected: 0,
expanded: HashSet::new(),
mode: Mode::Normal,
search_query: String::new(),
sort_order: SortOrder::default(),
show_hidden: true,
should_quit: false,
status_message: None,
post_operation_message: None,
deletion_patches: Vec::new(),
pending_sudo_delete: None,
sudo_delete_request: None,
wakeup: None,
defer_view_updates: false,
view_dirty: false,
cached_disk_usage: None,
disk_usage_receiver: None,
scanning: false,
clean_preview: None,
recursive_preview_running: false,
recursive_preview_receiver: None,
recursive_preview_thread: None,
recursive_preview_cancel: None,
pending_recursive_projects: None,
confirmation_target: None,
system_resources: Vec::new(),
detect_system: false,
detected_projects: HashMap::new(),
project_detection_running: false,
project_receiver: None,
project_thread: None,
scan_receiver: None,
scan_thread: None,
operation: None,
operation_receiver: None,
operation_thread: None,
system_detection_running: false,
system_receiver: None,
system_thread: None,
}
}
pub fn selected_entry(&self) -> Option<&VisibleEntry> {
self.visible_entries.get(self.selected)
}
fn action_target(&self) -> Option<&VisibleEntry> {
self.confirmation_target
.as_ref()
.or_else(|| self.selected_entry())
}
pub fn rebuild_visible_entries(&mut self) {
self.view_dirty = true;
if self.defer_view_updates {
return;
}
self.view_dirty = false;
let selected_path = self.selected_entry().map(|entry| entry.entry.path.clone());
self.visible_entries.clear();
let dummy_entry = DirEntry::new_dir(PathBuf::from(""), None);
for resource in &self.system_resources {
self.visible_entries.push(VisibleEntry {
entry: dummy_entry.clone(),
depth: 0,
is_expanded: false,
project_type: None,
system_resource: Some(resource.clone()),
is_separator: false,
});
}
if !self.system_resources.is_empty() && self.tree.is_some() {
self.visible_entries.push(VisibleEntry {
entry: dummy_entry,
depth: 0,
is_expanded: false,
project_type: None,
system_resource: None,
is_separator: true,
});
}
if let Some(tree) = self.tree.take() {
self.flatten_tree(&tree, 0);
self.tree = Some(tree);
}
if let Some(index) = self
.visible_entries
.iter()
.position(|entry| selected_path.as_ref() == Some(&entry.entry.path))
{
self.selected = index;
}
if !self.visible_entries.is_empty() && self.selected >= self.visible_entries.len() {
self.selected = self.visible_entries.len() - 1;
}
}
pub fn detect_system_resources(&mut self) {
if !self.detect_system {
return;
}
let registry = SystemCleanerRegistry::new();
self.system_resources = registry.detect_all();
}
fn start_system_detection(&mut self) {
if !self.detect_system || self.system_detection_running {
return;
}
let (tx, rx) = mpsc::channel();
self.system_receiver = Some(rx);
self.system_detection_running = true;
let wakeup = self.wakeup.clone();
self.system_thread = Some(thread::spawn(move || {
let _wake = WakeOnDrop(wakeup);
let result_sender = tx;
let resources = SystemCleanerRegistry::new().detect_all();
let _ = result_sender.send(resources);
}));
}
fn poll_system_detection(&mut self) -> bool {
let Some(result) = receive_worker(&self.system_receiver) else {
return false;
};
self.system_detection_running = false;
self.system_receiver = None;
self.system_thread = None;
match result {
Ok(resources) => {
self.system_resources = resources;
self.rebuild_visible_entries();
}
Err(_) => self.status_message = Some("System discovery worker stopped".into()),
}
true
}
fn discover_projects(root: &Path, cleaner_config: &CleanerConfig) -> Vec<DetectedProject> {
ProjectScanner::new(
detector_registry(cleaner_config),
project_scan_options(cleaner_config),
)
.scan(root)
}
fn discover_projects_fast(root: &Path, cleaner_config: &CleanerConfig) -> Vec<DetectedProject> {
ProjectScanner::new(
detector_registry(cleaner_config),
project_scan_options(cleaner_config),
)
.scan_fast(root)
}
fn set_detected_projects(&mut self, projects: Vec<DetectedProject>) {
self.detected_projects = projects
.into_iter()
.map(|project| (project.path.clone(), project))
.collect();
self.refresh_projects_after_deletions();
}
fn refresh_projects_after_deletions(&mut self) {
let registry = detector_registry(&self.cleaner_config);
self.detected_projects.retain(|path, project| {
if self
.deletion_patches
.iter()
.any(|patch| patch.replacement.is_none() && path.starts_with(&patch.path))
{
return false;
}
if self
.deletion_patches
.iter()
.any(|patch| patch.path.starts_with(path))
{
let Some(detector) = registry.get(&project.project_type) else {
return false;
};
if !detector.detect(path) {
return false;
}
project.artifact_paths = detector.find_artifacts(path);
project.artifact_size = project
.artifact_paths
.iter()
.filter_map(|artifact| {
self.tree
.as_ref()
.and_then(|tree| Self::tree_entry(tree, artifact))
})
.map(|entry| entry.size)
.sum();
}
true
});
}
fn tree_entry<'a>(entry: &'a DirEntry, path: &Path) -> Option<&'a DirEntry> {
if entry.path == path {
return Some(entry);
}
entry
.children
.iter()
.find(|child| path.starts_with(&child.path))
.and_then(|child| Self::tree_entry(child, path))
}
fn refresh_projects_blocking(&mut self) {
let projects = Self::discover_projects(&self.root, &self.cleaner_config);
self.set_detected_projects(projects);
}
fn start_project_detection(&mut self) {
self.detected_projects.clear();
self.project_receiver = None;
self.project_thread = None;
let root = self.root.clone();
let cleaner_config = self.cleaner_config.clone();
let (tx, rx) = mpsc::channel();
self.project_receiver = Some(rx);
self.project_detection_running = true;
let wakeup = self.wakeup.clone();
self.project_thread = Some(thread::spawn(move || {
let _wake = WakeOnDrop(wakeup);
let result_sender = tx;
let _ = result_sender.send(Self::discover_projects_fast(&root, &cleaner_config));
}));
}
fn poll_project_detection(&mut self) -> bool {
let Some(result) = receive_worker(&self.project_receiver) else {
return false;
};
self.project_detection_running = false;
self.project_receiver = None;
self.project_thread = None;
match result {
Ok(projects) => {
self.set_detected_projects(projects);
self.rebuild_visible_entries();
}
Err(_) => self.status_message = Some("Project discovery worker stopped".into()),
}
true
}
pub fn start_recursive_clean_preview(&mut self) {
if self.recursive_preview_running {
return;
}
if self.operation.is_some() {
self.status_message = Some("Another operation is already running".to_string());
return;
}
let Some(entry) = self.selected_entry().cloned() else {
self.status_message = Some("No directory selected".to_string());
return;
};
if entry.is_separator || entry.system_resource.is_some() || !entry.entry.is_dir {
self.status_message = Some("Select a directory for recursive cleanup".to_string());
return;
}
let path = entry.entry.path.clone();
self.confirmation_target = Some(entry);
let cleaner_config = self.cleaner_config.clone();
let (tx, rx) = mpsc::channel();
let cancel = Arc::new(AtomicBool::new(false));
let worker_cancel = Arc::clone(&cancel);
self.recursive_preview_receiver = Some(rx);
self.recursive_preview_cancel = Some(cancel);
self.recursive_preview_running = true;
self.pending_recursive_projects = None;
self.clean_preview = None;
self.status_message = Some(format!("Discovering projects under {}...", path.display()));
let wakeup = self.wakeup.clone();
self.recursive_preview_thread = Some(thread::spawn(move || {
let _wake = WakeOnDrop(wakeup);
let result_sender = tx;
if worker_cancel.load(Ordering::Acquire) || !path.is_dir() {
let _ = result_sender.send(Vec::new());
return;
}
let projects = ProjectScanner::new(
detector_registry(&cleaner_config),
project_scan_options(&cleaner_config),
)
.scan(&path);
let projects =
ProjectScanner::filter_by_age(projects, cleaner_config.min_age_days as u64);
if !worker_cancel.load(Ordering::Acquire) {
let _ = result_sender.send(projects);
}
}));
}
fn poll_recursive_clean_preview(&mut self) -> bool {
let Some(result) = receive_worker(&self.recursive_preview_receiver) else {
return false;
};
self.recursive_preview_running = false;
self.recursive_preview_receiver = None;
self.recursive_preview_thread = None;
self.recursive_preview_cancel = None;
let Ok(projects) = result else {
self.status_message = Some("Cleanup discovery worker stopped".into());
self.confirmation_target = None;
return true;
};
let Some(target) = self.confirmation_target.clone() else {
return true;
};
let scope = target.entry.path.clone();
let mut projects: Vec<_> = projects
.into_iter()
.filter(|project| project.path == scope || project.path.starts_with(&scope))
.filter(|project| !project.artifact_paths.is_empty())
.collect();
projects.sort_by(|a, b| a.path.cmp(&b.path));
if projects.is_empty() {
self.pending_recursive_projects = None;
self.clean_preview = None;
self.confirmation_target = None;
self.status_message = Some("No cleanable projects found".to_string());
return true;
}
let project_previews = projects
.iter()
.map(|project| ProjectPreview {
path: project.path.clone(),
display_name: project.display_name.clone(),
artifact_count: project.artifact_paths.len(),
artifact_size: project.artifact_size,
})
.collect();
let total_size = projects.iter().map(|project| project.artifact_size).sum();
self.clean_preview = Some(CleanPreview {
project_name: scope.display().to_string(),
artifacts: Vec::new(),
total_size,
recursive: true,
scope_path: Some(scope),
projects: project_previews,
});
self.pending_recursive_projects = Some(projects);
self.confirmation_target = Some(target);
self.mode = Mode::Confirm(ConfirmAction::CleanRecursive);
true
}
pub fn cancel_recursive_clean_preview(&mut self) {
if self.recursive_preview_running {
if let Some(cancel) = &self.recursive_preview_cancel {
cancel.store(true, Ordering::Release);
}
self.recursive_preview_receiver = None;
self.recursive_preview_thread = None;
self.recursive_preview_cancel = None;
self.recursive_preview_running = false;
self.status_message = Some("Recursive cleanup preview cancelled".to_string());
}
}
pub fn clear_recursive_clean_preview(&mut self) {
self.pending_recursive_projects = None;
if self
.clean_preview
.as_ref()
.is_some_and(|preview| preview.recursive)
{
self.clean_preview = None;
}
}
fn apply_tree_patch(entry: &mut DirEntry, patch: &TreePatch) -> bool {
if entry.path == patch.path {
if let Some(replacement) = &patch.replacement {
*entry = replacement.clone();
return true;
}
return false;
}
if let Some(index) = entry
.children
.iter()
.position(|child| child.path == patch.path)
{
if let Some(replacement) = &patch.replacement {
entry.children[index] = replacement.clone();
} else {
entry.children.remove(index);
}
entry.recalculate_totals();
return true;
}
for child in &mut entry.children {
if patch.path.starts_with(&child.path) && Self::apply_tree_patch(child, patch) {
entry.recalculate_totals();
return true;
}
}
false
}
fn apply_project_refresh(&mut self, refresh: ProjectRefresh) {
let selected_path = self.selected_entry().and_then(|entry| {
(!entry.is_separator && entry.system_resource.is_none())
.then(|| entry.entry.path.clone())
});
if let Some(tree) = &mut self.tree {
for patch in &refresh.artifact_patches {
Self::apply_tree_patch(tree, patch);
}
}
let project_path = refresh.project.path.clone();
self.detected_projects
.insert(project_path.clone(), refresh.project);
self.expanded.retain(|path| path.exists());
self.rebuild_visible_entries();
let selection_path = selected_path.unwrap_or(project_path);
if let Some(index) = self.visible_entries.iter().position(|entry| {
entry.system_resource.is_none()
&& !entry.is_separator
&& entry.entry.path == selection_path
}) {
self.selected = index;
}
}
fn apply_deletion_patch(&mut self, patch: TreePatch) {
let selected_path = self.selected_entry().map(|entry| entry.entry.path.clone());
if let Some(tree) = &mut self.tree {
Self::apply_tree_patch(tree, &patch);
}
if patch.replacement.is_none() {
self.expanded.retain(|path| !path.starts_with(&patch.path));
}
self.deletion_patches.push(patch);
self.refresh_projects_after_deletions();
self.rebuild_visible_entries();
if let Some(index) = self
.visible_entries
.iter()
.position(|entry| selected_path.as_ref() == Some(&entry.entry.path))
{
self.selected = index;
}
}
fn patch_scan_entry(&self, entry: &mut DirEntry) -> bool {
for patch in &self.deletion_patches {
if patch.replacement.is_none() && entry.path.starts_with(&patch.path) {
return false;
}
Self::apply_tree_patch(entry, patch);
}
true
}
fn flatten_tree(&mut self, entry: &DirEntry, depth: usize) {
if !self.show_hidden && entry.name.starts_with('.') && depth > 0 {
return;
}
if !self.search_query.is_empty() {
let name_lower = entry.name.to_lowercase();
let query_lower = self.search_query.to_lowercase();
if !name_lower.contains(&query_lower) && !self.has_matching_descendants(entry) {
return;
}
}
let is_expanded = self.expanded.contains(&entry.path);
let project_type = if entry.is_dir {
self.project_type_for_path(&entry.path)
} else {
None
};
self.visible_entries.push(VisibleEntry {
entry: entry.shallow_clone(),
depth,
is_expanded,
project_type,
system_resource: None,
is_separator: false,
});
if is_expanded && entry.is_dir {
let mut children: Vec<_> = entry.children.iter().collect();
self.sort_entries(&mut children);
for child in children {
self.flatten_tree(child, depth + 1);
}
}
}
fn project_type_for_path(&self, path: &Path) -> Option<String> {
self.detected_projects.get(path).map(|project| {
project
.display_name
.split('/')
.next()
.unwrap_or(&project.display_name)
.to_string()
})
}
fn has_matching_descendants(&self, entry: &DirEntry) -> bool {
let query_lower = self.search_query.to_lowercase();
for child in &entry.children {
let name_lower = child.name.to_lowercase();
if name_lower.contains(&query_lower) {
return true;
}
if self.has_matching_descendants(child) {
return true;
}
}
false
}
fn sort_entries(&self, entries: &mut [&DirEntry]) {
match self.sort_order {
SortOrder::Size => entries.sort_by_key(|entry| std::cmp::Reverse(entry.size)),
SortOrder::Name => entries.sort_by(|a, b| a.name.cmp(&b.name)),
SortOrder::Mtime => entries.sort_by_key(|entry| std::cmp::Reverse(entry.mtime)),
}
}
pub fn toggle_selected(&mut self) {
if let Some(entry) = self.selected_entry().cloned() {
if entry.system_resource.is_some() || entry.is_separator {
return;
}
if entry.entry.is_dir {
if self.expanded.contains(&entry.entry.path) {
self.expanded.remove(&entry.entry.path);
} else {
self.expanded.insert(entry.entry.path);
}
self.rebuild_visible_entries();
}
}
}
pub fn move_selection(&mut self, delta: i32) {
if self.visible_entries.is_empty() {
return;
}
let max_idx = self.visible_entries.len() - 1;
let new_selected = if delta < 0 {
self.selected.saturating_sub(delta.unsigned_abs() as usize)
} else {
self.selected.saturating_add(delta as usize)
};
self.selected = new_selected.min(max_idx);
if self.visible_entries[self.selected].is_separator {
if delta > 0 && self.selected < max_idx {
self.selected += 1;
} else if delta < 0 && self.selected > 0 {
self.selected -= 1;
}
}
}
pub fn expand_selected(&mut self) {
if let Some(entry) = self.selected_entry().cloned() {
if entry.system_resource.is_some() || entry.is_separator {
return;
}
if entry.entry.is_dir && !entry.is_expanded {
self.expanded.insert(entry.entry.path);
self.rebuild_visible_entries();
}
}
}
pub fn collapse_selected(&mut self) {
if let Some(entry) = self.selected_entry().cloned() {
if entry.system_resource.is_some() || entry.is_separator {
return;
}
if entry.is_expanded {
self.expanded.remove(&entry.entry.path);
self.rebuild_visible_entries();
} else {
self.go_to_parent();
}
}
}
pub fn go_to_parent(&mut self) {
if let Some(entry) = self.selected_entry() {
if entry.system_resource.is_some() || entry.is_separator {
return;
}
if let Some(parent) = entry.entry.path.parent() {
for (i, ve) in self.visible_entries.iter().enumerate() {
if ve.system_resource.is_none() && !ve.is_separator && ve.entry.path == parent {
self.selected = i;
break;
}
}
}
}
}
pub fn cycle_sort_order(&mut self) {
self.sort_order = match self.sort_order {
SortOrder::Size => SortOrder::Name,
SortOrder::Name => SortOrder::Mtime,
SortOrder::Mtime => SortOrder::Size,
};
self.rebuild_visible_entries();
self.status_message = Some(format!("Sort: {:?}", self.sort_order));
}
pub fn start_background_scan(&mut self) {
if self.scanning {
return;
}
self.deletion_patches.clear();
self.start_system_detection();
self.start_project_detection();
self.rebuild_visible_entries();
self.scanning = true;
self.status_message = Some("Scanning...".to_string());
let (tx, rx) = mpsc::channel();
self.scan_receiver = Some(rx);
let root = self.root.clone();
let mut options = self.scan_options.clone();
options.include_hidden = true;
let wakeup = self.wakeup.clone();
let handle = thread::spawn(move || {
let wake = WakeOnDrop(wakeup);
scan_directory_progressive_notifying(&root, &options, tx, || wake.notify());
});
self.scan_thread = Some(handle);
}
pub fn poll_scan_result(&mut self) -> bool {
const MAX_UPDATES: usize = 256;
let mut processed = 0;
while processed < MAX_UPDATES {
let Some(receiver) = &self.scan_receiver else {
break;
};
let scan_update = match receiver.try_recv() {
Ok(update) => update,
Err(mpsc::TryRecvError::Empty) => break,
Err(mpsc::TryRecvError::Disconnected) => ScanUpdate::Error {
message: "Scanner stopped before completing".into(),
},
};
processed += 1;
match scan_update {
ScanUpdate::Started { mut root, total } => {
self.patch_scan_entry(&mut root);
self.tree = Some(root);
if self.post_operation_message.is_none() {
self.status_message = Some(format!("Scanning 0/{}", total));
}
}
ScanUpdate::Entry {
mut entry,
completed,
total,
} => {
let name = entry.name.clone();
let keep = self.patch_scan_entry(&mut entry);
if let Some(tree) = &mut self.tree {
if keep {
tree.size += entry.size;
tree.disk_usage += entry.disk_usage;
tree.file_count += entry.file_count;
tree.dir_count += entry.dir_count + u64::from(entry.is_dir);
tree.children.push(entry);
}
}
if self.post_operation_message.is_none() {
self.status_message =
Some(format!("Scanning ({}/{}) {}", completed, total, name));
}
}
ScanUpdate::Complete => {
self.scanning = false;
self.scan_receiver = None;
self.scan_thread = None;
if let Some(tree) = &self.tree {
self.expanded
.retain(|path| Self::tree_entry(tree, path).is_some());
}
self.status_message = self.post_operation_message.take();
}
ScanUpdate::Error { message } => {
self.scanning = false;
self.scan_receiver = None;
self.scan_thread = None;
self.post_operation_message = None;
self.status_message = Some(format!("Scan error: {}", message));
}
}
}
if processed > 0 {
self.rebuild_visible_entries();
}
if processed == MAX_UPDATES {
if let Some(wakeup) = &self.wakeup {
wakeup.unpark();
}
}
processed > 0
}
pub fn poll_background_work(&mut self) -> bool {
let operation = self.poll_operation_result();
let scan = self.poll_scan_result();
let system = self.poll_system_detection();
let projects = self.poll_project_detection();
let recursive_preview = self.poll_recursive_clean_preview();
let disk = self.poll_disk_usage();
operation || scan || system || projects || recursive_preview || disk
}
pub(crate) fn start_disk_usage_refresh(&mut self) {
if self.disk_usage_receiver.is_some() {
return;
}
let (tx, rx) = mpsc::channel();
self.disk_usage_receiver = Some(rx);
let root = self.root.clone();
let wakeup = self.wakeup.clone();
thread::spawn(move || {
let _wake = WakeOnDrop(wakeup);
let result_sender = tx;
let _ = result_sender.send(Self::disk_usage_for(&root));
});
}
fn poll_disk_usage(&mut self) -> bool {
let Some(result) = receive_worker(&self.disk_usage_receiver) else {
return false;
};
self.disk_usage_receiver = None;
let usage = result.ok().flatten();
let changed = usage != self.cached_disk_usage;
self.cached_disk_usage = usage;
changed
}
pub fn operation_kind(&self) -> Option<OperationKind> {
self.operation.as_ref().map(|operation| operation.kind)
}
pub fn cancel_operation(&mut self) {
if let Some(operation) = &self.operation {
operation.cancel.store(true, Ordering::Release);
self.status_message = Some("Cancelling operation...".to_string());
}
}
fn start_operation(
&mut self,
kind: OperationKind,
status: String,
work: impl FnOnce(Arc<AtomicBool>) -> OperationOutcome + Send + 'static,
) {
if self.operation.is_some() {
self.status_message = Some("Another operation is already running".to_string());
return;
}
let cancel = Arc::new(AtomicBool::new(false));
let worker_cancel = Arc::clone(&cancel);
let (tx, rx) = mpsc::channel();
self.operation = Some(OperationState { kind, cancel });
self.operation_receiver = Some(rx);
self.status_message = Some(status);
let wakeup = self.wakeup.clone();
self.operation_thread = Some(thread::spawn(move || {
let _wake = WakeOnDrop(wakeup);
let result_sender = tx;
let outcome = work(worker_cancel);
let _ = result_sender.send(outcome);
}));
}
pub fn poll_operation_result(&mut self) -> bool {
let Some(result) = receive_worker(&self.operation_receiver) else {
return false;
};
self.operation = None;
self.operation_receiver = None;
self.operation_thread = None;
let Ok(outcome) = result else {
self.status_message = Some("Cleanup worker stopped before completing".into());
return true;
};
let message = outcome.message;
if outcome.refresh_system_resources {
self.start_system_detection();
}
if let Some(refresh) = outcome.project_refresh {
self.apply_project_refresh(refresh);
}
if let Some(patch) = outcome.deletion_patch {
self.apply_deletion_patch(patch);
if self.scanning {
self.post_operation_message = Some(message.clone());
}
}
if outcome.rescan {
self.post_operation_message = Some(message.clone());
self.cancel_scan();
self.start_background_scan();
}
self.status_message = Some(message);
if let Some(path) = outcome.sudo_retry {
self.pending_sudo_delete = Some(path);
self.mode = Mode::Confirm(ConfirmAction::SudoDelete);
}
true
}
pub fn cancel_scan(&mut self) {
if self.scanning {
self.scan_receiver = None;
self.scan_thread = None;
self.scanning = false;
}
if self.project_detection_running {
self.project_receiver = None;
self.project_thread = None;
self.project_detection_running = false;
}
self.cancel_recursive_clean_preview();
}
pub fn trigger_rescan(&mut self) {
self.deletion_patches.clear();
self.scanning = true;
self.detected_projects.clear();
self.detect_system_resources();
let mut options = self.scan_options.clone();
options.include_hidden = true;
match scan_directory(&self.root, &options) {
Ok(tree) => {
self.refresh_projects_blocking();
let old_expanded: Vec<_> = self.expanded.iter().cloned().collect();
self.expanded.clear();
for path in old_expanded {
if path.exists() {
self.expanded.insert(path);
}
}
self.tree = Some(tree);
self.rebuild_visible_entries();
}
Err(e) => {
self.status_message = Some(format!("Scan error: {}", e));
}
}
self.scanning = false;
}
pub fn initial_scan(&mut self) {
self.expanded.insert(self.root.clone());
self.trigger_rescan();
}
pub fn start_initial_scan(&mut self) {
self.expanded.insert(self.root.clone());
self.start_background_scan();
}
pub fn delete_selected(&mut self) {
let entry = match self.action_target() {
Some(entry) => entry.clone(),
None => {
self.status_message = Some("No entry selected".to_string());
return;
}
};
if entry.system_resource.is_some() {
self.status_message = Some("Cannot delete system resources".to_string());
return;
}
if entry.is_separator {
return;
}
let path = entry.entry.path;
if path == self.root {
self.status_message = Some("Cannot delete root directory".to_string());
return;
}
let display_path = path.display().to_string();
let mut scan_options = self.scan_options.clone();
scan_options.include_hidden = true;
scan_options.cache = None;
self.start_operation(
OperationKind::Delete,
format!("Deleting: {}", display_path),
move |cancel| {
if cancel.load(Ordering::Acquire) {
return OperationOutcome {
message: "Delete cancelled".to_string(),
rescan: false,
refresh_system_resources: false,
project_refresh: None,
deletion_patch: None,
sudo_retry: None,
};
}
let result = delete_path(&path);
let offer_sudo = !cancel.load(Ordering::Acquire);
deletion_outcome(path, &scan_options, result, offer_sudo)
},
);
}
pub fn clean_selected(&mut self) {
let entry = match self.action_target() {
Some(entry) => entry.clone(),
None => {
self.status_message = Some("No entry selected".to_string());
return;
}
};
if entry.is_separator {
return;
}
if let Some(resource) = entry.system_resource {
let display_name = resource.display_name.clone();
self.start_operation(
OperationKind::Clean,
format!("Cleaning {}...", display_name),
move |cancel| clean_system_resource(resource, cancel),
);
return;
}
let path = entry.entry.path;
let Some(project) = self.detected_projects.get(&path).cloned() else {
self.status_message = Some("Not a recognized project".to_string());
return;
};
if ProjectScanner::filter_by_age(
vec![project.clone()],
self.cleaner_config.min_age_days as u64,
)
.is_empty()
{
self.status_message = Some("Project is not old enough to clean".to_string());
return;
}
let mut scan_options = self.scan_options.clone();
scan_options.include_hidden = true;
self.start_operation(
OperationKind::Clean,
format!("Cleaning {}...", path.display()),
{
let cleaner_config = self.cleaner_config.clone();
move |cancel| clean_project(project, scan_options, cleaner_config, cancel)
},
);
}
pub fn clean_recursive_selected(&mut self) {
if self.operation.is_some() {
self.status_message = Some("Another operation is already running".to_string());
return;
}
let Some(projects) = self.pending_recursive_projects.take() else {
self.status_message = Some("No recursive cleanup preview available".to_string());
return;
};
let scope = self
.clean_preview
.as_ref()
.and_then(|preview| preview.scope_path.clone())
.or_else(|| self.action_target().map(|entry| entry.entry.path.clone()));
let Some(scope) = scope else {
self.status_message = Some("No directory selected".to_string());
return;
};
let cleaner_config = self.cleaner_config.clone();
let project_count = projects.len();
self.start_operation(
OperationKind::CleanRecursive,
format!("Cleaning {} projects...", project_count),
move |cancel| clean_projects(projects, scope, cleaner_config, cancel),
);
self.clean_preview = None;
}
pub fn selected_is_project(&self) -> bool {
if let Some(entry) = self.selected_entry() {
if entry.system_resource.is_some() {
return true;
}
if entry.is_separator {
return false;
}
self.detected_projects.contains_key(&entry.entry.path)
} else {
false
}
}
pub fn prepare_clean_preview(&mut self) -> bool {
let entry = match self.selected_entry() {
Some(entry) => entry.clone(),
None => return false,
};
if entry.is_separator {
return false;
}
if let Some(resource) = &entry.system_resource {
let item_info = resource
.item_count
.map(|n| format!("{} items", n))
.unwrap_or_else(|| resource.description.clone());
self.clean_preview = Some(CleanPreview {
project_name: resource.display_name.clone(),
artifacts: vec![(item_info, resource.size)],
total_size: resource.size,
recursive: false,
scope_path: None,
projects: Vec::new(),
});
return true;
}
let path = entry.entry.path;
let Some(project) = self.detected_projects.get(&path) else {
self.status_message = Some("Not a recognized project".to_string());
return false;
};
if ProjectScanner::filter_by_age(
vec![project.clone()],
self.cleaner_config.min_age_days as u64,
)
.is_empty()
{
self.status_message = Some("Project is not old enough to clean".to_string());
return false;
}
if project.artifact_paths.is_empty() {
self.status_message = Some("No artifacts to clean".to_string());
return false;
}
let artifacts: Vec<(String, u64)> = project
.artifact_paths
.iter()
.map(|artifact_path| {
let name = artifact_path
.file_name()
.map(|name| name.to_string_lossy().to_string())
.unwrap_or_else(|| artifact_path.display().to_string());
(name, dir_size(artifact_path))
})
.collect();
let total_size = artifacts.iter().map(|(_, size)| *size).sum();
self.clean_preview = Some(CleanPreview {
project_name: project.display_name.clone(),
artifacts,
total_size,
recursive: false,
scope_path: None,
projects: vec![ProjectPreview {
path: project.path.clone(),
display_name: project.display_name.clone(),
artifact_count: project.artifact_paths.len(),
artifact_size: total_size,
}],
});
true
}
pub fn get_disk_usage(&self) -> Option<(u64, u64, u64)> {
Self::disk_usage_for(&self.root)
}
fn disk_usage_for(path: &Path) -> Option<(u64, u64, u64)> {
match statvfs(path) {
Ok(stat) => {
let block_size = stat.fragment_size();
let total = stat.blocks() * block_size;
let available = stat.blocks_available() * block_size;
let used = total.saturating_sub(available);
Some((total, used, available))
}
Err(_) => None,
}
}
pub fn get_disk_usage_percent(&self) -> Option<f32> {
self.get_disk_usage().map(|(total, used, _)| {
if total > 0 {
(used as f64 / total as f64 * 100.0) as f32
} else {
0.0
}
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_initial_background_scan_expands_relative_starting_directory() {
let tmp = tempfile::tempdir_in(".").unwrap();
let child = tmp.path().join("visible-child");
fs::create_dir(&child).unwrap();
let expected_root = tmp.path().canonicalize().unwrap();
let mut app = App::new(tmp.path().to_path_buf());
app.attach_ui_thread();
app.start_initial_scan();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
while app.scanning && std::time::Instant::now() < deadline {
app.poll_background_work();
std::thread::yield_now();
}
app.flush_view_updates();
assert!(!app.scanning);
assert_eq!(app.root, expected_root);
assert!(app.expanded.contains(&expected_root));
assert!(app
.visible_entries
.iter()
.any(|entry| entry.entry.path == expected_root.join("visible-child")));
}
#[cfg(unix)]
#[test]
fn test_initial_scan_expands_symlink_starting_directory() {
let tmp = tempfile::tempdir().unwrap();
let target = tmp.path().join("target");
fs::create_dir(&target).unwrap();
fs::write(target.join("visible-child"), "file").unwrap();
let alias = tmp.path().join("alias");
std::os::unix::fs::symlink(&target, &alias).unwrap();
let mut app = App::new(alias);
app.initial_scan();
assert_eq!(app.root, target);
assert!(app.expanded.contains(&target));
assert_eq!(app.visible_entries.len(), 2);
}
#[test]
fn test_scan_backlog_is_batched_and_view_is_built_only_when_needed() {
let root = PathBuf::from("/test");
let mut app = App::new(root.clone());
app.attach_ui_thread();
app.expanded.insert(root.clone());
let (tx, rx) = mpsc::channel();
app.scan_receiver = Some(rx);
app.scanning = true;
tx.send(ScanUpdate::Started {
root: DirEntry::new_dir(root.clone(), None),
total: 10_000,
})
.unwrap();
for index in 0..10_000 {
tx.send(ScanUpdate::Entry {
entry: DirEntry::new_file(root.join(format!("{index:05}")), 1, 4096, None),
completed: index + 1,
total: 10_000,
})
.unwrap();
}
tx.send(ScanUpdate::Complete).unwrap();
drop(tx);
assert!(app.poll_scan_result());
assert!(
app.scanning,
"a bounded batch must yield before draining the whole queue"
);
assert_eq!(app.tree.as_ref().unwrap().file_count, 255);
assert!(
app.visible_entries.is_empty(),
"result application should not rebuild rows"
);
let mut batches = 1;
while app.poll_scan_result() {
batches += 1;
}
assert_eq!(batches, 40);
assert!(!app.scanning);
let tree = app.tree.as_ref().unwrap();
assert_eq!(
(tree.size, tree.disk_usage, tree.file_count),
(10_000, 40_960_000, 10_000)
);
app.flush_view_updates();
assert_eq!(app.visible_entries.len(), 10_001);
assert!(!app.view_dirty);
}
#[test]
fn test_disconnected_workers_leave_no_stuck_busy_state() {
let mut app = App::new(PathBuf::from("/test"));
let (tx, rx) = mpsc::channel();
app.scan_receiver = Some(rx);
app.scanning = true;
drop(tx);
assert!(app.poll_scan_result());
assert!(!app.scanning);
assert!(app
.status_message
.as_deref()
.unwrap()
.contains("Scanner stopped"));
let (tx, rx) = mpsc::channel();
app.operation_receiver = Some(rx);
app.operation = Some(OperationState {
kind: OperationKind::Delete,
cancel: Arc::new(AtomicBool::new(false)),
});
drop(tx);
assert!(app.poll_operation_result());
assert!(app.operation_kind().is_none());
assert!(app
.status_message
.as_deref()
.unwrap()
.contains("worker stopped"));
}
#[test]
fn test_cancelled_scan_cannot_publish_into_a_new_scan() {
let mut app = App::new(PathBuf::from("/test"));
let (old_tx, rx) = mpsc::channel();
app.scan_receiver = Some(rx);
app.scanning = true;
app.cancel_scan();
assert!(old_tx.send(ScanUpdate::Complete).is_err());
let (tx, rx) = mpsc::channel();
app.scan_receiver = Some(rx);
app.scanning = true;
tx.send(ScanUpdate::Started {
root: DirEntry::new_dir(PathBuf::from("/test"), None),
total: 0,
})
.unwrap();
tx.send(ScanUpdate::Complete).unwrap();
assert!(app.poll_scan_result());
assert!(!app.scanning);
assert!(app.tree.as_ref().unwrap().children.is_empty());
}
#[test]
fn test_deferred_view_preserves_selection_as_scan_results_arrive() {
let root = PathBuf::from("/test");
let selected = root.join("selected");
let mut app = App::new(root.clone());
let mut tree = DirEntry::new_dir(root.clone(), None);
tree.children
.push(DirEntry::new_file(selected.clone(), 1, 1, None));
tree.recalculate_totals();
app.tree = Some(tree);
app.expanded.insert(root.clone());
app.rebuild_visible_entries();
app.selected = 1;
app.attach_ui_thread();
let (tx, rx) = mpsc::channel();
app.scan_receiver = Some(rx);
tx.send(ScanUpdate::Entry {
entry: DirEntry::new_file(root.join("larger"), 100, 100, None),
completed: 2,
total: 2,
})
.unwrap();
assert!(app.poll_scan_result());
app.flush_view_updates();
assert_eq!(app.selected_entry().unwrap().entry.path, selected);
assert_eq!(app.selected, 2);
}
#[test]
fn test_app_new() {
let app = App::new(PathBuf::from("/home/user"));
assert_eq!(app.root, PathBuf::from("/home/user"));
assert_eq!(app.mode, Mode::Normal);
assert_eq!(app.selected, 0);
assert!(!app.should_quit);
assert!(app.visible_entries.is_empty());
assert!(app.expanded.is_empty());
assert_eq!(app.sort_order, SortOrder::Size);
}
#[test]
fn test_app_accepts_configured_scanner_threads() {
let app = App::with_scan_options(PathBuf::from("/tmp"), ScanOptions::new().with_threads(3));
assert_eq!(app.scan_options.threads, 3);
}
#[test]
fn test_app_selected_entry_empty() {
let app = App::new(PathBuf::from("/"));
assert!(app.selected_entry().is_none());
}
#[test]
fn test_mode_equality() {
assert_eq!(Mode::Normal, Mode::Normal);
assert_eq!(Mode::Search, Mode::Search);
assert_eq!(Mode::Help, Mode::Help);
assert_eq!(
Mode::Confirm(ConfirmAction::Delete),
Mode::Confirm(ConfirmAction::Delete)
);
assert_ne!(Mode::Normal, Mode::Search);
assert_ne!(
Mode::Confirm(ConfirmAction::Delete),
Mode::Confirm(ConfirmAction::Clean)
);
}
#[test]
fn test_sort_order_default() {
let order = SortOrder::default();
assert_eq!(order, SortOrder::Size);
}
fn create_test_tree() -> DirEntry {
let mut root = DirEntry::new_dir(PathBuf::from("/root"), None);
let mut dir_a = DirEntry::new_dir(PathBuf::from("/root/dir_a"), None);
dir_a.children.push(DirEntry::new_file(
PathBuf::from("/root/dir_a/file1.txt"),
100,
4096,
None,
));
dir_a.children.push(DirEntry::new_file(
PathBuf::from("/root/dir_a/file2.txt"),
200,
4096,
None,
));
dir_a.recalculate_totals();
let mut dir_b = DirEntry::new_dir(PathBuf::from("/root/dir_b"), None);
dir_b.children.push(DirEntry::new_file(
PathBuf::from("/root/dir_b/file3.txt"),
500,
4096,
None,
));
dir_b.recalculate_totals();
let hidden = DirEntry::new_dir(PathBuf::from("/root/.hidden"), None);
root.children.push(dir_a);
root.children.push(dir_b);
root.children.push(hidden);
root.recalculate_totals();
root
}
fn wait_for_operation(app: &mut App) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
while app.operation_kind().is_some() && std::time::Instant::now() < deadline {
app.poll_operation_result();
std::thread::yield_now();
}
assert!(
app.operation_kind().is_none(),
"background operation timed out"
);
}
#[test]
fn test_flatten_empty_tree() {
let mut app = App::new(PathBuf::from("/"));
app.rebuild_visible_entries();
assert!(app.visible_entries.is_empty());
}
#[test]
fn test_flatten_single_entry() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(DirEntry::new_dir(PathBuf::from("/root"), None));
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 1);
assert_eq!(app.visible_entries[0].depth, 0);
}
#[test]
fn test_flatten_collapsed_tree() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 1);
assert_eq!(app.visible_entries[0].entry.name, "root");
}
#[test]
fn test_flatten_expanded_tree() {
let mut app = App::new(PathBuf::from("/root"));
app.show_hidden = false;
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 3);
assert_eq!(app.visible_entries[0].entry.name, "root");
assert_eq!(app.visible_entries[0].depth, 0);
assert_eq!(app.visible_entries[1].entry.name, "dir_b");
assert_eq!(app.visible_entries[1].depth, 1);
assert_eq!(app.visible_entries[2].entry.name, "dir_a");
assert_eq!(app.visible_entries[2].depth, 1);
}
#[test]
fn test_visible_entries_do_not_clone_descendant_trees() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert!(app.tree.as_ref().unwrap().children.len() > 1);
assert!(app
.visible_entries
.iter()
.all(|visible| visible.entry.children.is_empty()));
}
#[test]
fn test_flatten_deeply_expanded() {
let mut app = App::new(PathBuf::from("/root"));
app.show_hidden = false;
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.expanded.insert(PathBuf::from("/root/dir_a"));
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 5);
}
#[test]
fn test_flatten_shows_hidden_when_enabled() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.show_hidden = true;
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 4);
assert!(app
.visible_entries
.iter()
.any(|e| e.entry.name == ".hidden"));
}
#[test]
fn test_flatten_search_filter() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.expanded.insert(PathBuf::from("/root/dir_a"));
app.search_query = "file1".to_string();
app.rebuild_visible_entries();
assert!(app.visible_entries.iter().any(|e| e.entry.name == "root"));
assert!(app.visible_entries.iter().any(|e| e.entry.name == "dir_a"));
assert!(app
.visible_entries
.iter()
.any(|e| e.entry.name == "file1.txt"));
assert!(!app.visible_entries.iter().any(|e| e.entry.name == "dir_b"));
}
#[test]
fn test_toggle_expand() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
let initial_count = app.visible_entries.len();
assert_eq!(initial_count, 1);
app.toggle_selected();
assert!(app.visible_entries.len() > initial_count);
assert!(app.expanded.contains(&PathBuf::from("/root")));
app.toggle_selected();
assert_eq!(app.visible_entries.len(), 1);
assert!(!app.expanded.contains(&PathBuf::from("/root")));
}
#[test]
fn test_selection_clamps_on_rebuild() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
app.selected = app.visible_entries.len() - 1;
app.expanded.clear();
app.rebuild_visible_entries();
assert!(app.selected < app.visible_entries.len());
}
#[test]
fn test_move_selection_down() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert_eq!(app.selected, 0);
app.move_selection(1);
assert_eq!(app.selected, 1);
}
#[test]
fn test_move_selection_up() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
app.selected = 2;
app.move_selection(-1);
assert_eq!(app.selected, 1);
}
#[test]
fn test_move_selection_clamps_lower() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
app.selected = 0;
app.move_selection(-10);
assert_eq!(app.selected, 0);
}
#[test]
fn test_move_selection_clamps_upper() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
let last = app.visible_entries.len() - 1;
app.selected = last;
app.move_selection(10);
assert_eq!(app.selected, last);
}
#[test]
fn test_move_selection_empty_list() {
let mut app = App::new(PathBuf::from("/root"));
app.move_selection(1);
assert_eq!(app.selected, 0);
}
#[test]
fn test_expand_selected() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
assert!(!app.expanded.contains(&PathBuf::from("/root")));
app.expand_selected();
assert!(app.expanded.contains(&PathBuf::from("/root")));
}
#[test]
fn test_collapse_selected() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert!(app.visible_entries[0].is_expanded);
app.collapse_selected();
assert!(!app.expanded.contains(&PathBuf::from("/root")));
}
#[test]
fn test_go_to_parent() {
let mut app = App::new(PathBuf::from("/root"));
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
app.selected = 1;
app.go_to_parent();
assert_eq!(app.selected, 0);
}
#[test]
fn test_cycle_sort_order() {
let mut app = App::new(PathBuf::from("/root"));
assert_eq!(app.sort_order, SortOrder::Size);
app.cycle_sort_order();
assert_eq!(app.sort_order, SortOrder::Name);
app.cycle_sort_order();
assert_eq!(app.sort_order, SortOrder::Mtime);
app.cycle_sort_order();
assert_eq!(app.sort_order, SortOrder::Size);
}
#[test]
fn test_sort_order_affects_display() {
let mut app = App::new(PathBuf::from("/root"));
app.show_hidden = false;
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert_eq!(app.visible_entries[1].entry.name, "dir_b");
assert_eq!(app.visible_entries[2].entry.name, "dir_a");
app.sort_order = SortOrder::Name;
app.rebuild_visible_entries();
assert_eq!(app.visible_entries[1].entry.name, "dir_a");
assert_eq!(app.visible_entries[2].entry.name, "dir_b");
}
#[test]
fn test_delete_path_file() {
let temp_dir = tempfile::tempdir().unwrap();
let file_path = temp_dir.path().join("test.txt");
fs::write(&file_path, "test").unwrap();
assert!(file_path.exists());
delete_path(&file_path).unwrap();
assert!(!file_path.exists());
}
#[test]
fn test_delete_path_directory() {
let temp_dir = tempfile::tempdir().unwrap();
let dir_path = temp_dir.path().join("subdir");
fs::create_dir(&dir_path).unwrap();
fs::write(dir_path.join("file.txt"), "test").unwrap();
assert!(dir_path.exists());
delete_path(&dir_path).unwrap();
assert!(!dir_path.exists());
}
#[test]
fn test_delete_selected_no_entry() {
let mut app = App::new(PathBuf::from("/"));
app.delete_selected();
assert!(app.status_message.is_some());
assert!(app.status_message.as_ref().unwrap().contains("No entry"));
}
#[test]
fn test_delete_selected_runs_as_background_operation() {
let temp_dir = tempfile::tempdir().unwrap();
let file_path = temp_dir.path().join("delete-me.txt");
fs::write(&file_path, "test").unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.initial_scan();
app.selected = app
.visible_entries
.iter()
.position(|entry| entry.entry.path == file_path)
.unwrap();
app.delete_selected();
assert_eq!(app.operation_kind(), Some(OperationKind::Delete));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
while app.operation_kind().is_some() && std::time::Instant::now() < deadline {
app.poll_operation_result();
std::thread::yield_now();
}
assert_eq!(app.operation_kind(), None);
assert!(!file_path.exists());
assert!(
!app.scanning,
"successful deletion should update the existing tree"
);
let tree = app.tree.as_ref().unwrap();
assert!(tree.children.is_empty());
assert_eq!(tree.size, 0);
assert_eq!(tree.disk_usage, 0);
assert_eq!(tree.file_count, 0);
}
fn finish_delete(app: &mut App) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
while app.operation_kind().is_some() && std::time::Instant::now() < deadline {
app.poll_operation_result();
std::thread::yield_now();
}
assert_eq!(app.operation_kind(), None);
}
#[test]
fn test_delete_directory_preserves_unrelated_tree_and_disk_cache() {
let tmp = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let cache_path = cache.path().join("metadata.json");
let parent = tmp.path().join("parent");
let deleted = parent.join("project");
fs::create_dir_all(deleted.join("target")).unwrap();
fs::write(deleted.join("Cargo.toml"), "[package]").unwrap();
fs::write(deleted.join("target/artifact"), "artifact").unwrap();
fs::write(parent.join("keep"), "kept").unwrap();
let mut app = App::with_scan_options(
tmp.path().to_path_buf(),
ScanOptions::default().with_cache(cache_path.clone(), 3600),
);
app.initial_scan();
app.expanded.insert(parent.clone());
app.expanded.insert(deleted.clone());
app.rebuild_visible_entries();
let cached_bytes = fs::read(&cache_path).unwrap();
fs::write(parent.join("keep"), "a much longer external change").unwrap();
app.selected = app
.visible_entries
.iter()
.position(|e| e.entry.path == deleted)
.unwrap();
app.delete_selected();
finish_delete(&mut app);
assert!(!app.scanning);
assert!(!app.project_detection_running);
assert!(!app.detected_projects.contains_key(&deleted));
assert!(!app.expanded.contains(&deleted));
assert!(app.expanded.contains(&parent));
let tree = app.tree.as_ref().unwrap();
assert_eq!((tree.size, tree.file_count, tree.dir_count), (4, 1, 1));
assert_eq!(tree.children[0].size, 4);
assert_eq!(fs::read(&cache_path).unwrap(), cached_bytes);
}
#[cfg(unix)]
#[test]
fn test_delete_failure_refreshes_only_affected_subtree() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let cache_path = cache.path().join("metadata.json");
let deleted = tmp.path().join("partial");
let blocked = deleted.join("blocked");
fs::create_dir_all(&blocked).unwrap();
fs::write(blocked.join("keep"), "protected").unwrap();
fs::write(deleted.join("removable"), "remove me").unwrap();
fs::write(tmp.path().join("unrelated"), "kept").unwrap();
fs::set_permissions(&blocked, fs::Permissions::from_mode(0o555)).unwrap();
let mut app = App::with_scan_options(
tmp.path().to_path_buf(),
ScanOptions::default().with_cache(cache_path.clone(), 3600),
);
app.initial_scan();
let cached_bytes = fs::read(&cache_path).unwrap();
fs::write(tmp.path().join("unrelated"), "external change").unwrap();
app.selected = app
.visible_entries
.iter()
.position(|e| e.entry.path == deleted)
.unwrap();
app.delete_selected();
finish_delete(&mut app);
fs::set_permissions(&blocked, fs::Permissions::from_mode(0o755)).unwrap();
assert!(!app.scanning);
assert!(app.status_message.as_deref().unwrap().starts_with("Error:"));
assert_eq!(app.mode, Mode::Confirm(ConfirmAction::SudoDelete));
assert_eq!(app.pending_sudo_delete(), Some(deleted.as_path()));
let actual = scan_directory(&deleted, &ScanOptions::default()).unwrap();
let tree = app.tree.as_ref().unwrap();
let remaining = App::tree_entry(tree, &deleted).unwrap();
assert_eq!(remaining.size, actual.size);
assert_eq!(remaining.file_count, actual.file_count);
assert_eq!(tree.size, actual.size + 4);
assert_eq!(fs::read(&cache_path).unwrap(), cached_bytes);
}
#[test]
fn test_sudo_retry_stays_bound_to_failed_path_and_patches_success() {
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
let tmp = tempfile::tempdir().unwrap();
let failed = tmp.path().join("failed");
let other = tmp.path().join("other");
fs::create_dir(&failed).unwrap();
fs::create_dir(&other).unwrap();
fs::write(failed.join("file"), "keep until confirmed").unwrap();
let mut app = App::new(tmp.path().to_path_buf());
app.initial_scan();
let (tx, rx) = mpsc::channel();
app.operation_receiver = Some(rx);
tx.send(deletion_outcome(
failed.clone(),
&ScanOptions::default(),
Err(std::io::Error::from(std::io::ErrorKind::PermissionDenied)),
true,
))
.unwrap();
assert!(app.poll_operation_result());
assert_eq!(app.mode, Mode::Confirm(ConfirmAction::SudoDelete));
assert!(
!app.sudo_delete_requested(),
"offering sudo must not execute it"
);
app.selected = app
.visible_entries
.iter()
.position(|entry| entry.entry.path == other)
.unwrap();
super::super::event::handle_key_event(
&mut app,
KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE),
);
assert_eq!(app.take_sudo_delete_request(), Some(failed.clone()));
assert_eq!(app.mode, Mode::Normal);
assert!(failed.join("file").exists());
fs::remove_dir_all(&failed).unwrap();
app.finish_sudo_delete(failed.clone(), Ok(()));
finish_delete(&mut app);
assert!(!app.scanning);
assert!(App::tree_entry(app.tree.as_ref().unwrap(), &failed).is_none());
assert!(other.exists());
assert!(app.pending_sudo_delete().is_none());
}
#[test]
fn test_sudo_prompt_can_be_declined_without_requesting_privileges() {
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
let tmp = tempfile::tempdir().unwrap();
let target = tmp.path().join("keep");
fs::write(&target, "keep").unwrap();
for code in [KeyCode::Char('n'), KeyCode::Esc] {
let mut app = App::new(tmp.path().to_path_buf());
app.pending_sudo_delete = Some(target.clone());
app.mode = Mode::Confirm(ConfirmAction::SudoDelete);
super::super::event::handle_key_event(
&mut app,
KeyEvent::new(code, KeyModifiers::NONE),
);
assert_eq!(app.mode, Mode::Normal);
assert!(app.pending_sudo_delete().is_none());
assert!(app.take_sudo_delete_request().is_none());
assert!(target.exists());
}
}
#[test]
fn test_non_permission_errors_and_failed_sudo_do_not_prompt() {
let tmp = tempfile::tempdir().unwrap();
let target = tmp.path().join("keep");
fs::write(&target, "keep").unwrap();
for (kind, offer) in [
(std::io::ErrorKind::NotFound, true),
(std::io::ErrorKind::PermissionDenied, false),
(std::io::ErrorKind::Interrupted, false),
] {
let outcome = deletion_outcome(
target.clone(),
&ScanOptions::default(),
Err(kind.into()),
offer,
);
assert!(outcome.sudo_retry.is_none());
assert!(!outcome.rescan);
assert!(target.exists());
}
}
#[test]
fn test_sudo_prompt_shows_failed_path_and_explicit_confirmation() {
let mut app = App::new(PathBuf::from("/tmp"));
app.pending_sudo_delete = Some(PathBuf::from("/tmp/permission-denied-directory"));
app.mode = Mode::Confirm(ConfirmAction::SudoDelete);
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 24)).unwrap();
terminal
.draw(|frame| super::super::ui::render(&app, frame))
.unwrap();
let text: String = terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect();
assert!(text.contains("Permission denied"));
assert!(text.contains("/tmp/permission-denied-directory"));
assert!(text.contains("[y] Retry with sudo"));
assert!(text.contains("[n/Esc] Cancel"));
}
#[test]
fn test_delete_during_scan_cannot_be_restored_by_stale_results() {
let tmp = tempfile::tempdir().unwrap();
let parent = tmp.path().join("parent");
let deleted = parent.join("project");
fs::create_dir_all(&deleted).unwrap();
fs::write(deleted.join("Cargo.toml"), "[package]").unwrap();
fs::write(parent.join("keep"), "kept").unwrap();
let mut app = App::new(tmp.path().to_path_buf());
app.initial_scan();
let stale_tree = app.tree.as_ref().unwrap().clone();
let stale_projects = app.detected_projects.values().cloned().collect();
app.expanded.insert(parent.clone());
app.rebuild_visible_entries();
app.selected = app
.visible_entries
.iter()
.position(|e| e.entry.path == deleted)
.unwrap();
let (scan_tx, scan_rx) = mpsc::channel();
app.scan_receiver = Some(scan_rx);
app.scanning = true;
let (project_tx, project_rx) = mpsc::channel();
app.project_receiver = Some(project_rx);
app.project_detection_running = true;
app.delete_selected();
finish_delete(&mut app);
assert!(app.scanning, "the existing scan should continue");
scan_tx
.send(ScanUpdate::Started {
root: DirEntry::new_dir(tmp.path().to_path_buf(), None),
total: 1,
})
.unwrap();
scan_tx
.send(ScanUpdate::Entry {
entry: stale_tree.children[0].clone(),
completed: 1,
total: 1,
})
.unwrap();
scan_tx.send(ScanUpdate::Complete).unwrap();
project_tx.send(stale_projects).unwrap();
while app.poll_background_work() {}
assert!(!app.scanning);
assert!(!app.detected_projects.contains_key(&deleted));
let tree = app.tree.as_ref().unwrap();
assert!(App::tree_entry(tree, &deleted).is_none());
assert_eq!((tree.size, tree.file_count, tree.dir_count), (4, 1, 1));
assert!(app
.status_message
.as_deref()
.unwrap()
.starts_with("Deleted:"));
fs::create_dir(&deleted).unwrap();
app.trigger_rescan();
assert!(App::tree_entry(app.tree.as_ref().unwrap(), &deleted).is_some());
}
#[test]
fn test_system_detection_starts_in_background() {
let temp_dir = tempfile::tempdir().unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.detect_system = true;
app.start_background_scan();
assert!(app.system_detection_running);
}
#[test]
fn test_recursive_clean_reports_failed_project_and_error() {
let tmp = tempfile::tempdir().unwrap();
let artifact = tmp.path().join("not-a-directory");
fs::write(&artifact, "file").unwrap();
let project = DetectedProject {
path: tmp.path().to_path_buf(),
project_type: "npm".into(),
display_name: "npm".into(),
artifact_size: 4,
artifact_paths: vec![artifact.clone()],
};
let outcome = clean_projects(
vec![project],
tmp.path().to_path_buf(),
CleanerConfig::default(),
Arc::new(AtomicBool::new(false)),
);
assert!(outcome.message.contains("1 failed"));
assert!(outcome.message.contains(&tmp.path().display().to_string()));
assert!(outcome
.message
.contains(&format!("Failed to remove {}", artifact.display())));
assert!(!outcome.message.contains('\n'));
assert!(outcome.rescan);
}
fn app_for_cleaning(root: PathBuf) -> App {
let mut cleaner = CleanerConfig::default();
cleaner.min_age_days = 0;
App::with_options(
root,
ScanOptions::default().with_one_file_system(true),
cleaner,
)
}
#[test]
fn test_clean_selected_no_entry() {
let mut app = App::new(PathBuf::from("/"));
app.clean_selected();
wait_for_operation(&mut app);
assert!(app.status_message.is_some());
assert!(app.status_message.as_ref().unwrap().contains("No entry"));
}
#[test]
fn test_clean_selected_not_a_project() {
let temp_dir = tempfile::tempdir().unwrap();
let mut app = app_for_cleaning(temp_dir.path().to_path_buf());
app.initial_scan();
app.clean_selected();
wait_for_operation(&mut app);
assert!(app.status_message.is_some());
assert!(app
.status_message
.as_ref()
.unwrap()
.contains("Not a recognized project"));
}
#[test]
fn test_clean_selected_cargo_project() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("Cargo.toml"), "[package]").unwrap();
let target_dir = temp_dir.path().join("target");
fs::create_dir(&target_dir).unwrap();
fs::write(target_dir.join("artifact.bin"), "x".repeat(1000)).unwrap();
let mut app = app_for_cleaning(temp_dir.path().to_path_buf());
app.initial_scan();
assert!(target_dir.exists());
app.clean_selected();
wait_for_operation(&mut app);
assert!(!target_dir.exists());
assert!(
!app.scanning,
"project cleanup should patch the existing tree without starting a root rescan"
);
assert!(app.status_message.is_some());
let msg = app.status_message.as_ref().unwrap();
assert!(
msg.contains("Cleaned") || msg.contains("freed"),
"Expected success message, got: {}",
msg
);
}
#[test]
fn test_clean_selected_no_artifacts() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("Cargo.toml"), "[package]").unwrap();
let mut app = app_for_cleaning(temp_dir.path().to_path_buf());
app.initial_scan();
app.clean_selected();
wait_for_operation(&mut app);
assert!(app.status_message.is_some());
assert!(app
.status_message
.as_ref()
.unwrap()
.contains("No artifacts"));
}
#[test]
fn test_selected_is_project_true() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("Cargo.toml"), "[package]").unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.initial_scan();
assert!(app.selected_is_project());
}
#[test]
fn test_selected_is_project_false() {
let temp_dir = tempfile::tempdir().unwrap();
let root = DirEntry::new_dir(temp_dir.path().to_path_buf(), None);
let mut app = App::new(temp_dir.path().to_path_buf());
app.tree = Some(root);
app.rebuild_visible_entries();
assert!(!app.selected_is_project());
}
#[test]
fn test_visible_entry_has_project_type() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("Cargo.toml"), "[package]").unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.initial_scan();
assert!(app.visible_entries[0].project_type.is_some());
assert_eq!(
app.visible_entries[0].project_type,
Some("Rust".to_string())
);
}
#[test]
fn test_project_scanner_results_are_cached_until_rescan() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("Cargo.toml"), "[package]").unwrap();
fs::create_dir(temp_dir.path().join("target")).unwrap();
fs::write(temp_dir.path().join("target/artifact"), vec![b'x'; 64]).unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.initial_scan();
assert_eq!(app.detected_projects.len(), 1);
assert_eq!(app.detected_projects[temp_dir.path()].artifact_size, 64);
assert_eq!(
app.visible_entries[0].project_type,
Some("Rust".to_string())
);
fs::remove_file(temp_dir.path().join("Cargo.toml")).unwrap();
app.rebuild_visible_entries();
assert_eq!(
app.visible_entries[0].project_type,
Some("Rust".to_string()),
"ordinary UI rebuilds should reuse project detection"
);
app.trigger_rescan();
assert_eq!(app.visible_entries[0].project_type, None);
assert!(app.detected_projects.is_empty());
}
#[test]
fn test_get_disk_usage() {
let app = App::new(PathBuf::from("/"));
let usage = app.get_disk_usage();
assert!(usage.is_some());
let (total, used, avail) = usage.unwrap();
assert!(total > 0);
assert!(used <= total);
assert!(used + avail >= total * 9 / 10); }
#[test]
fn test_get_disk_usage_percent() {
let app = App::new(PathBuf::from("/"));
let percent = app.get_disk_usage_percent();
assert!(percent.is_some());
let p = percent.unwrap();
assert!(p >= 0.0);
assert!(p <= 100.0);
}
#[test]
fn test_get_disk_usage_nonexistent_path() {
let app = App::new(PathBuf::from("/nonexistent/path/that/does/not/exist"));
let usage = app.get_disk_usage();
assert!(usage.is_none());
}
#[test]
fn test_dir_size_calculation() {
let temp_dir = tempfile::tempdir().unwrap();
let subdir = temp_dir.path().join("subdir");
fs::create_dir(&subdir).unwrap();
fs::write(subdir.join("file1.bin"), "x".repeat(100)).unwrap();
fs::write(subdir.join("file2.bin"), "y".repeat(200)).unwrap();
let size = dir_size(&subdir);
assert_eq!(size, 300);
}
#[test]
fn test_trigger_rescan() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("file.txt"), "test").unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
assert!(app.tree.is_none());
app.trigger_rescan();
assert!(app.tree.is_some());
assert!(!app.scanning);
}
#[test]
fn test_rescan_preserves_expansion() {
let temp_dir = tempfile::tempdir().unwrap();
let sub_dir = temp_dir.path().join("subdir");
fs::create_dir(&sub_dir).unwrap();
fs::write(sub_dir.join("file.txt"), "test").unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.expanded.insert(sub_dir.clone());
app.trigger_rescan();
assert!(app.expanded.contains(&sub_dir));
}
#[test]
fn test_rescan_removes_deleted_expansion() {
let temp_dir = tempfile::tempdir().unwrap();
let sub_dir = temp_dir.path().join("subdir");
fs::create_dir(&sub_dir).unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.expanded.insert(sub_dir.clone());
fs::remove_dir(&sub_dir).unwrap();
app.trigger_rescan();
assert!(!app.expanded.contains(&sub_dir));
}
#[test]
fn test_initial_scan() {
let temp_dir = tempfile::tempdir().unwrap();
fs::write(temp_dir.path().join("file.txt"), "test").unwrap();
let sub_dir = temp_dir.path().join("subdir");
fs::create_dir(&sub_dir).unwrap();
let mut app = App::new(temp_dir.path().to_path_buf());
app.initial_scan();
assert!(app.tree.is_some());
assert!(app.expanded.contains(&temp_dir.path().to_path_buf()));
assert!(app.visible_entries.len() > 1);
}
#[test]
fn test_rescan_nonexistent_directory() {
let mut app = App::new(PathBuf::from("/nonexistent/path/that/does/not/exist"));
app.trigger_rescan();
assert!(app.status_message.is_some());
assert!(app.status_message.as_ref().unwrap().contains("Scan error"));
}
fn make_test_resource(id: &str, name: &str, size: u64) -> DetectedSystemResource {
DetectedSystemResource {
resource_id: id.to_string(),
display_name: name.to_string(),
category: "docker".to_string(),
size,
description: "test".to_string(),
item_count: Some(10),
}
}
#[test]
fn test_system_resources_prepended_to_visible_entries() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
assert!(app.visible_entries[0].system_resource.is_some());
assert_eq!(
app.visible_entries[0]
.system_resource
.as_ref()
.unwrap()
.display_name,
"Resource 1"
);
assert!(app.visible_entries[1].is_separator);
assert!(app.visible_entries[2].system_resource.is_none());
assert!(!app.visible_entries[2].is_separator);
assert_eq!(app.visible_entries[2].entry.name, "root");
}
#[test]
fn test_system_resources_no_separator_without_tree() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.rebuild_visible_entries();
assert_eq!(app.visible_entries.len(), 1);
assert!(app.visible_entries[0].system_resource.is_some());
}
#[test]
fn test_move_selection_skips_separator() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.expanded.insert(PathBuf::from("/root"));
app.rebuild_visible_entries();
app.selected = 0;
app.move_selection(1);
assert!(!app.visible_entries[app.selected].is_separator);
app.move_selection(-1);
assert!(!app.visible_entries[app.selected].is_separator);
}
#[test]
fn test_selected_is_project_system_resource() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
app.selected = 0;
assert!(app.selected_is_project());
}
#[test]
fn test_selected_is_project_separator() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
app.selected = 1;
assert!(!app.selected_is_project());
}
#[test]
fn test_toggle_noop_on_system_resource() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
let count_before = app.visible_entries.len();
app.selected = 0; app.toggle_selected();
assert_eq!(app.visible_entries.len(), count_before);
}
#[test]
fn test_expand_noop_on_separator() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
let count_before = app.visible_entries.len();
app.selected = 1; app.expand_selected();
assert_eq!(app.visible_entries.len(), count_before);
}
#[test]
fn test_delete_blocked_on_system_resource() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
app.selected = 0; app.delete_selected();
assert!(app.status_message.is_some());
assert!(app
.status_message
.as_ref()
.unwrap()
.contains("Cannot delete system resources"));
}
#[test]
fn test_prepare_clean_preview_system_resource() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Docker Build Cache", 5000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
app.selected = 0; let result = app.prepare_clean_preview();
assert!(result);
assert!(app.clean_preview.is_some());
let preview = app.clean_preview.as_ref().unwrap();
assert_eq!(preview.project_name, "Docker Build Cache");
assert_eq!(preview.total_size, 5000);
}
#[test]
fn test_prepare_clean_preview_separator() {
let mut app = App::new(PathBuf::from("/root"));
app.system_resources = vec![make_test_resource("res1", "Resource 1", 1000)];
app.tree = Some(create_test_tree());
app.rebuild_visible_entries();
app.selected = 1; let result = app.prepare_clean_preview();
assert!(!result);
}
}