A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.
Rust
disktree-core: scan, layout, free space and removal
Tobi Lutke60209e9caee5
diff --git a/crates/disktree-core/Cargo.toml b/crates/disktree-core/Cargo.tomlnew file mode 100644index 0000000..21ac328--- /dev/null+++ b/crates/disktree-core/Cargo.toml@@ -0,0 +1,19 @@+[package]+name = "disktree-core"+version.workspace = true+edition.workspace = true+rust-version.workspace = true+license.workspace = true+description = "Filesystem scanning and treemap layout for disktree"++[lints]+workspace = true++[dependencies]+chrono = { version = "0.4.45", default-features = false, features = ["clock", "std"] }+rayon = { workspace = true }+rustix = { version = "1.1", features = ["fs"] }+rustc-hash = { workspace = true }++[dev-dependencies]+tempfile = "3"diff --git a/crates/disktree-core/src/lib.rs b/crates/disktree-core/src/lib.rsnew file mode 100644index 0000000..4b6354d--- /dev/null+++ b/crates/disktree-core/src/lib.rs@@ -0,0 +1,13 @@+//! `disktree-core`: scanning, layout, space accounting and deletion, with no+//! UI dependency.+//!+//! The split exists so the parts that must be *correct* — size accounting,+//! hardlink de-duplication, aspect-ratio layout, and what may be deleted — can+//! be built and tested without GPUI, a display, or a GPU.++pub mod removal;+pub mod scan;+pub mod size;+pub mod space;+pub mod tree;+pub mod treemap;diff --git a/crates/disktree-core/src/removal.rs b/crates/disktree-core/src/removal.rsnew file mode 100644index 0000000..5e4ffd0--- /dev/null+++ b/crates/disktree-core/src/removal.rs@@ -0,0 +1,844 @@+//! Turning marked paths into deletions, safely.+//!+//! Three things matter here, in this order: never remove something the user did+//! not point at, never descend into a different filesystem, and always be able+//! to say what happened.+//!+//! Two mechanisms are offered:+//!+//! * [`RemovalMode::Permanent`] — `rm -rf` semantics, implemented with the+//! standard library rather than by shelling out, so no path ever reaches a+//! shell and no filename can be misread as an option.+//! * [`RemovalMode::Trash`] — move to the desktop trash, using `trash-put`,+//! then `gio trash`, then a built-in XDG implementation. The backend is+//! detected once and named in the UI so the user knows what actually happens.++use std::fs;+use std::io;+use std::path::{Component, Path, PathBuf};+use std::process::Command;+use std::sync::Arc;+use std::sync::atomic::{AtomicBool, Ordering};+use std::sync::mpsc::{self, Receiver};+use std::thread;++/// One path the user asked to remove.+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct Target {+ pub path: PathBuf,+ /// Bytes measured when the path was marked; used for the projection.+ pub bytes: u64,+ pub is_dir: bool,+ pub hidden: bool,+}++/// How a removal should be carried out.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum RemovalMode {+ /// Delete now. Not recoverable.+ #[default]+ Permanent,+ /// Move to the desktop trash so the removal can be undone.+ Trash,+}++impl RemovalMode {+ pub const fn label(self) -> &'static str {+ match self {+ Self::Permanent => "Delete permanently",+ Self::Trash => "Move to trash",+ }+ }++ pub const fn detail(self) -> &'static str {+ match self {+ Self::Permanent => "rm -rf: unrecoverable",+ Self::Trash => "recoverable until the trash is emptied",+ }+ }+}++/// A target that will not be touched, and why.+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct Blocked {+ pub path: PathBuf,+ pub reason: String,+}++/// The work a [`RemovalMode`] will actually do.+#[derive(Clone, Debug, Default)]+pub struct Plan {+ /// Targets to act on, with any target contained in another removed first.+ pub targets: Vec<Target>,+ /// Marked paths covered by a target above; reported, not acted on.+ pub covered: Vec<Target>,+ /// Marked paths that must not be touched.+ pub blocked: Vec<Blocked>,+}++impl Plan {+ pub fn bytes(&self) -> u64 {+ self.targets.iter().map(|target| target.bytes).sum()+ }++ pub const fn is_empty(&self) -> bool {+ self.targets.is_empty()+ }+}++/// Build the plan for `targets`, which must all live under `root`.+///+/// Paths outside `root` are blocked rather than removed: the tree the user was+/// looking at is the only thing they consented to act on.+pub fn plan(targets: &[Target], root: &Path) -> Plan {+ let root = normalize(root);+ let home = std::env::var_os("HOME").map(PathBuf::from);+ let mut plan = Plan::default();+ let mut accepted: Vec<Target> = Vec::new();++ for target in targets {+ let path = normalize(&target.path);+ if let Some(reason) = refuse(&path, &root, home.as_deref()) {+ plan.blocked.push(Blocked {+ path: target.path.clone(),+ reason,+ });+ continue;+ }+ accepted.push(Target {+ path,+ ..target.clone()+ });+ }++ // A path inside another target is removed with it. Keep the outer one and+ // report the inner one so the review screen can explain the nesting.+ accepted.sort_by(|left, right| left.path.cmp(&right.path));+ let mut outer: Vec<Target> = Vec::new();+ for target in accepted {+ if outer+ .iter()+ .any(|candidate| target.path.starts_with(&candidate.path))+ {+ plan.covered.push(target);+ } else {+ outer.push(target);+ }+ }+ plan.targets = outer;+ plan+}++/// Why this path must not be removed, if it must not.+fn refuse(path: &Path, root: &Path, home: Option<&Path>) -> Option<String> {+ if path.parent().is_none() {+ return Some("the filesystem root cannot be removed".into());+ }+ if path == root {+ return Some("the scanned root cannot be removed".into());+ }+ if home.is_some_and(|home| path == normalize(home)) {+ return Some("the home directory cannot be removed".into());+ }+ if !path.starts_with(root) {+ return Some("outside the scanned root".into());+ }+ if is_mount_point(path) {+ return Some(+ "a mount point: removing it would cross onto another filesystem"+ .into(),+ );+ }+ None+}++/// Whether `path` sits on a different device than its parent, i.e. is a+/// mount point. Descending into one would delete data the user never marked.+#[cfg(unix)]+pub fn is_mount_point(path: &Path) -> bool {+ use std::os::unix::fs::MetadataExt as _;+ let Ok(meta) = fs::symlink_metadata(path) else {+ return false;+ };+ if !meta.is_dir() {+ return false;+ }+ let Some(parent) = path.parent() else {+ return true;+ };+ match fs::symlink_metadata(parent) {+ Ok(parent_meta) => parent_meta.dev() != meta.dev(),+ // A directory whose parent cannot be stat'ed is not worth the risk.+ Err(_) => true,+ }+}++#[cfg(not(unix))]+pub fn is_mount_point(_path: &Path) -> bool {+ false+}++/// Lexically normalize a path: resolve `.` and `..` without touching the+/// filesystem, so a symlink can never redirect a guard.+///+/// A `..` at the root has nowhere to go, so `/..` is `/` rather than the empty+/// path. A leading `..` on a relative path is preserved.+pub fn normalize(path: &Path) -> PathBuf {+ let mut out = PathBuf::new();+ for component in path.components() {+ match component {+ Component::CurDir => {}+ Component::ParentDir => {+ if matches!(+ out.components().next_back(),+ Some(Component::Normal(_))+ ) {+ out.pop();+ } else if !out.has_root() && out.as_os_str().is_empty() {+ out.push("..");+ }+ }+ Component::Prefix(_)+ | Component::RootDir+ | Component::Normal(_) => {+ out.push(component.as_os_str());+ }+ }+ }+ out+}++/// Which tool, if any, moves files to the desktop trash.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum TrashBackend {+ /// `trash-put` from trash-cli.+ TrashPut,+ /// `gio trash`, present anywhere `GLib` is installed.+ Gio,+ /// The XDG trash directory, implemented here.+ XdgHome,+ /// No way to move files to a trash on this machine.+ #[default]+ Unavailable,+}++impl TrashBackend {+ pub const fn is_available(self) -> bool {+ match self {+ Self::TrashPut | Self::Gio | Self::XdgHome => true,+ Self::Unavailable => false,+ }+ }++ pub const fn label(self) -> &'static str {+ match self {+ Self::TrashPut => "trash-put",+ Self::Gio => "gio trash",+ Self::XdgHome => "XDG trash",+ Self::Unavailable => "no trash tool found",+ }+ }++ pub const fn detail(self) -> &'static str {+ match self {+ Self::TrashPut => {+ "uses trash-cli, the same trash as your file manager"+ }+ Self::Gio => "uses GLib, the same trash as your file manager",+ Self::XdgHome => {+ "moves into ~/.local/share/Trash on the same volume"+ }+ Self::Unavailable => {+ "install trash-cli or keep deleting permanently"+ }+ }+ }+}++/// Detect the best available trash backend for this machine.+pub fn detect_trash_backend() -> TrashBackend {+ if which("trash-put") {+ TrashBackend::TrashPut+ } else if which("gio") {+ TrashBackend::Gio+ } else if home_trash_dir().is_some() {+ TrashBackend::XdgHome+ } else {+ TrashBackend::Unavailable+ }+}++fn which(program: &str) -> bool {+ let Some(path) = std::env::var_os("PATH") else {+ return false;+ };+ std::env::split_paths(&path).any(|dir| {+ let candidate = dir.join(program);+ fs::metadata(candidate).is_ok_and(|meta| meta.is_file())+ })+}++fn home_trash_dir() -> Option<PathBuf> {+ let data = std::env::var_os("XDG_DATA_HOME").map_or_else(+ || {+ std::env::var_os("HOME")+ .map(PathBuf::from)+ .map(|home| home.join(".local/share"))+ },+ |value| Some(PathBuf::from(value)),+ )?;+ Some(data.join("Trash"))+}++/// What a running removal reports.+#[derive(Clone, Debug)]+pub enum RemovalEvent {+ Start {+ total: usize,+ },+ Item {+ path: PathBuf,+ bytes: u64,+ outcome: Result<(), String>,+ },+ Done {+ removed: u64,+ bytes: u64,+ failed: usize,+ },+}++/// A removal running on its own thread.+#[derive(Debug)]+pub struct RemovalHandle {+ events: Receiver<RemovalEvent>,+ cancel: Arc<AtomicBool>,+}++impl RemovalHandle {+ /// Take the next event, if one has arrived.+ pub fn poll(&self) -> Option<RemovalEvent> {+ // Empty and Disconnected mean the same thing to the caller: there is+ // nothing more to do this tick.+ self.events.try_recv().ok()+ }++ /// Stop before the next target starts.+ pub fn cancel(&self) {+ self.cancel.store(true, Ordering::Relaxed);+ }+}++/// Start removing the plan's targets on a worker thread.+pub fn spawn(plan: Plan, mode: RemovalMode) -> RemovalHandle {+ let (sender, events) = mpsc::channel();+ let cancel = Arc::new(AtomicBool::new(false));+ let worker_cancel = Arc::clone(&cancel);+ let backend = if mode == RemovalMode::Trash {+ detect_trash_backend()+ } else {+ TrashBackend::Unavailable+ };++ let worker = thread::Builder::new()+ .name("disktree-remove".into())+ .spawn({+ let sender = sender.clone();+ move || run(&plan, mode, backend, &worker_cancel, &sender)+ });+ if let Err(error) = worker {+ let _ = sender.send(RemovalEvent::Item {+ path: PathBuf::new(),+ bytes: 0,+ outcome: Err(format!(+ "could not start the removal worker: {error}"+ )),+ });+ }++ RemovalHandle { events, cancel }+}++fn run(+ plan: &Plan,+ mode: RemovalMode,+ backend: TrashBackend,+ cancel: &AtomicBool,+ sender: &mpsc::Sender<RemovalEvent>,+) {+ let _ = sender.send(RemovalEvent::Start {+ total: plan.targets.len(),+ });+ let mut removed = 0_u64;+ let mut bytes = 0_u64;+ let mut failed = 0_usize;++ for target in &plan.targets {+ if cancel.load(Ordering::Relaxed) {+ break;+ }+ let outcome = match mode {+ RemovalMode::Permanent => remove_permanently(&target.path),+ RemovalMode::Trash => move_to_trash(&target.path, backend),+ };+ if outcome.is_ok() {+ removed += 1;+ bytes += target.bytes;+ } else {+ failed += 1;+ }+ let _ = sender.send(RemovalEvent::Item {+ path: target.path.clone(),+ bytes: target.bytes,+ outcome: outcome.map_err(|error| error.to_string()),+ });+ }++ let _ = sender.send(RemovalEvent::Done {+ removed,+ bytes,+ failed,+ });+}++/// `rm -rf` semantics: a symlink is unlinked, never followed.+pub fn remove_permanently(path: &Path) -> io::Result<()> {+ let meta = fs::symlink_metadata(path)?;+ if meta.is_dir() {+ fs::remove_dir_all(path)+ } else {+ fs::remove_file(path)+ }+}++/// Move one path to the desktop trash.+pub fn move_to_trash(path: &Path, backend: TrashBackend) -> io::Result<()> {+ match backend {+ TrashBackend::TrashPut => run_tool(Path::new("trash-put"), &[], path),+ TrashBackend::Gio => run_tool(Path::new("gio"), &["trash"], path),+ TrashBackend::XdgHome => trash_via_xdg(path),+ TrashBackend::Unavailable => Err(io::Error::other(+ "no trash tool is installed; use permanent deletion instead",+ )),+ }+}++/// Run one trash tool on one path.+///+/// `--` is passed before the path so that a file named `-rf` is read as a path+/// and never as an option. Splitting this out is also what makes the argument+/// order testable without writing to anybody's real trash.+fn run_tool(program: &Path, arguments: &[&str], path: &Path) -> io::Result<()> {+ let output = Command::new(program)+ .args(arguments)+ .arg("--")+ .arg(path)+ .output()?;+ if output.status.success() {+ Ok(())+ } else {+ let stderr = String::from_utf8_lossy(&output.stderr);+ Err(io::Error::other(format!(+ "{} failed: {}",+ program.display(),+ stderr.trim()+ )))+ }+}++/// The XDG trash layout, implemented directly so the app still has a trash on+/// machines without `trash-cli` or `GLib`.+///+/// Only same-volume paths can be trashed this way: the specification forbids+/// copying a file into a trash directory on another filesystem.+fn trash_via_xdg(path: &Path) -> io::Result<()> {+ let trash = home_trash_dir().ok_or_else(|| {+ io::Error::other("neither XDG_DATA_HOME nor HOME is set")+ })?;+ trash_into(path, &trash)+}++/// Move `path` into the trash directory at `trash`.+#[cfg(unix)]+pub fn trash_into(path: &Path, trash: &Path) -> io::Result<()> {+ use std::os::unix::fs::MetadataExt as _;++ let files = trash.join("files");+ let info = trash.join("info");+ fs::create_dir_all(&files)?;+ fs::create_dir_all(&info)?;++ let source = fs::symlink_metadata(path)?;+ let trash_meta = fs::metadata(&files)?;+ if source.dev() != trash_meta.dev() {+ return Err(io::Error::other(+ "on a different filesystem than the trash; use permanent deletion",+ ));+ }++ let name = path+ .file_name()+ .ok_or_else(|| {+ io::Error::other("refusing to trash a path without a name")+ })?+ .to_string_lossy()+ .into_owned();+ let (candidate, trashed_name) = unique_name(&files, &name);+ fs::rename(path, &candidate)?;++ let info_path = info.join(format!("{trashed_name}.trashinfo"));+ let contents = format!(+ "[Trash Info]\nPath={}\nDeletionDate={}\n",+ percent_encode(&path.to_string_lossy()),+ deletion_date()+ );+ if let Err(error) = fs::write(&info_path, contents) {+ // Put it back rather than leaving an entry the trash UI cannot restore.+ let _ = fs::rename(&candidate, path);+ return Err(error);+ }+ Ok(())+}++#[cfg(not(unix))]+pub fn trash_into(_path: &Path, _trash: &Path) -> io::Result<()> {+ Err(io::Error::other(+ "the XDG trash is only implemented on Unix",+ ))+}++/// `name`, or `name.1`, `name.2`, … until the name is free in `dir`.+fn unique_name(dir: &Path, name: &str) -> (PathBuf, String) {+ let first = dir.join(name);+ if !first.exists() {+ return (first, name.to_string());+ }+ for index in 1..10_000 {+ let candidate = format!("{name}.{index}");+ let path = dir.join(&candidate);+ if !path.exists() {+ return (path, candidate);+ }+ }+ (dir.join(name), name.to_string())+}++/// Percent-encode a path for a `.trashinfo` file: everything outside the+/// unreserved set is escaped, so spaces and newlines survive.+pub fn percent_encode(input: &str) -> String {+ let mut out = String::with_capacity(input.len());+ for byte in input.bytes() {+ let unreserved = byte.is_ascii_alphanumeric()+ || matches!(byte, b'/' | b'-' | b'.' | b'_' | b'~');+ if unreserved {+ out.push(char::from(byte));+ } else {+ use std::fmt::Write as _;+ let _ = write!(out, "%{byte:02X}");+ }+ }+ out+}++fn deletion_date() -> String {+ // The specification wants ISO 8601 in local time; chrono is already in the+ // dependency graph, so use it rather than approximating the offset.+ chrono::Local::now().format("%Y-%m-%dT%H:%M:%S").to_string()+}++#[cfg(test)]+mod tests {+ use super::*;+ use tempfile::TempDir;++ fn target(path: &Path, bytes: u64) -> Target {+ Target {+ path: path.to_path_buf(),+ bytes,+ is_dir: path.is_dir(),+ hidden: false,+ }+ }++ fn tree() -> TempDir {+ let temp = TempDir::new().expect("tempdir");+ fs::create_dir_all(temp.path().join("a/b")).expect("mkdir");+ fs::write(temp.path().join("a/one.bin"), vec![b'x'; 10])+ .expect("write");+ fs::write(temp.path().join("a/c.bin"), vec![b'x'; 20]).expect("write");+ fs::create_dir_all(temp.path().join("other")).expect("mkdir");+ temp+ }++ #[test]+ fn a_plan_keeps_only_the_outermost_targets() {+ let temp = tree();+ let root = temp.path();+ let inner = target(&root.join("a/b"), 5);+ let outer = target(&root.join("a"), 30);+ let separate = target(&root.join("other"), 0);++ let plan =+ plan(&[inner.clone(), outer.clone(), separate.clone()], root);+ assert_eq!(plan.targets.len(), 2);+ assert!(plan.targets.contains(&outer));+ assert!(plan.targets.contains(&separate));+ assert_eq!(plan.covered.len(), 1);+ assert_eq!(plan.covered[0].path, inner.path);+ assert_eq!(plan.bytes(), 30);+ }++ #[test]+ fn the_root_and_home_are_refused() {+ let temp = tree();+ let root = temp.path();+ let home = std::env::var_os("HOME").map(PathBuf::from);+ let mut targets = vec![target(Path::new("/"), 0), target(root, 0)];+ if let Some(home) = &home {+ targets.push(target(home, 0));+ }++ let plan = plan(&targets, root);+ assert!(plan.is_empty());+ assert_eq!(plan.blocked.len(), targets.len());+ assert!(+ plan.blocked+ .iter()+ .any(|blocked| blocked.reason.contains("home directory"))+ || home.is_none()+ );+ }++ #[test]+ fn paths_outside_the_root_are_refused() {+ let temp = tree();+ let plan = plan(&[target(Path::new("/etc/passwd"), 1)], temp.path());+ assert!(plan.is_empty());+ assert_eq!(plan.blocked[0].reason, "outside the scanned root");+ }++ #[test]+ fn sibling_prefixes_are_not_treated_as_containment() {+ let temp = tree();+ let root = temp.path();+ fs::create_dir_all(root.join("a-real")).expect("mkdir");+ let plan = plan(+ &[target(&root.join("a"), 1), target(&root.join("a-real"), 1)],+ root,+ );+ assert_eq!(plan.targets.len(), 2, "a-real is not inside a");+ assert!(plan.covered.is_empty());+ }++ #[test]+ fn normalize_resolves_dots_without_the_filesystem() {+ assert_eq!(+ normalize(Path::new("/home/tobi/./src/../src/")),+ PathBuf::from("/home/tobi/src")+ );+ assert_eq!(normalize(Path::new("a/../b")), PathBuf::from("b"));+ assert_eq!(normalize(Path::new("/..")), PathBuf::from("/"));+ assert_eq!(normalize(Path::new("../x")), PathBuf::from("../x"));+ }++ #[test]+ fn mount_points_are_recognized() {+ let temp = tree();+ assert!(!is_mount_point(temp.path()));+ // /proc is a mount point everywhere Linux runs this test.+ if Path::new("/proc/self").exists() {+ assert!(is_mount_point(Path::new("/proc")));+ }+ }++ #[test]+ fn permanent_removal_takes_directories_and_leaves_siblings() {+ let temp = tree();+ let doomed = temp.path().join("a/b");+ remove_permanently(&doomed).expect("remove dir");+ assert!(!doomed.exists());+ assert!(temp.path().join("a/c.bin").exists());+ }++ #[test]+ fn permanent_removal_unlinks_a_symlink_instead_of_following_it() {+ let temp = tree();+ let keep = TempDir::new().expect("tempdir");+ fs::write(keep.path().join("precious.bin"), b"data").expect("write");+ let link = temp.path().join("link");+ std::os::unix::fs::symlink(keep.path(), &link).expect("symlink");++ remove_permanently(&link).expect("remove link");+ assert!(!link.exists());+ assert!(keep.path().join("precious.bin").exists());+ }++ #[test]+ fn a_missing_target_reports_not_found() {+ let temp = tree();+ let error = remove_permanently(&temp.path().join("absent"))+ .expect_err("missing");+ assert_eq!(error.kind(), io::ErrorKind::NotFound);+ }++ #[test]+ fn percent_encoding_escapes_what_the_spec_requires() {+ assert_eq!(percent_encode("/home/tobi/a b"), "/home/tobi/a%20b");+ assert_eq!(percent_encode("/a/b-c.d_e~f"), "/a/b-c.d_e~f");+ assert_eq!(percent_encode("/a/néw"), "/a/n%C3%A9w");+ assert_eq!(percent_encode("/a\nb"), "/a%0Ab");+ }++ #[test]+ fn trash_names_avoid_collisions() {+ let temp = TempDir::new().expect("tempdir");+ let (first, first_name) = unique_name(temp.path(), "notes");+ assert_eq!(first_name, "notes");+ fs::write(&first, b"x").expect("write");++ let (second, second_name) = unique_name(temp.path(), "notes");+ assert_eq!(second_name, "notes.1");+ assert_ne!(first, second);+ }++ #[test]+ fn the_xdg_trash_moves_a_file_and_records_where_it_came_from() {+ // A private trash directory keeps the test out of the real trash can.+ let trash = TempDir::new().expect("tempdir");+ let work = TempDir::new().expect("tempdir");+ let file = work.path().join("doomed.bin");+ fs::write(&file, b"payload").expect("write");++ trash_into(&file, trash.path()).expect("trashed");++ assert!(!file.exists());+ let moved = trash.path().join("files/doomed.bin");+ assert!(moved.exists(), "moved into the trash");+ assert_eq!(fs::read(&moved).expect("read"), b"payload");+ let info =+ fs::read_to_string(trash.path().join("info/doomed.bin.trashinfo"))+ .expect("info file");+ assert!(info.starts_with("[Trash Info]\nPath="), "{info}");+ assert!(info.contains("doomed.bin"));+ assert!(info.contains("DeletionDate="));+ }++ #[test]+ fn a_trash_info_path_is_restorable() {+ let trash = TempDir::new().expect("tempdir");+ let work = TempDir::new().expect("tempdir");+ let file = work.path().join("with space.bin");+ fs::write(&file, b"x").expect("write");+ trash_into(&file, trash.path()).expect("trashed");++ let info = fs::read_to_string(+ trash.path().join("info/with space.bin.trashinfo"),+ )+ .expect("info file");+ let recorded = info+ .lines()+ .find_map(|line| line.strip_prefix("Path="))+ .expect("a path");+ assert_eq!(recorded, percent_encode(&file.to_string_lossy()));+ assert!(recorded.ends_with("with%20space.bin"));+ }++ #[test]+ fn a_removal_run_reports_every_item_and_a_total() {+ let temp = tree();+ let root = temp.path();+ let plan = plan(+ &[+ target(&root.join("a/b"), 0),+ target(&root.join("a/c.bin"), 20),+ target(&root.join("absent"), 0),+ ],+ root,+ );+ assert_eq!(plan.targets.len(), 3);++ let handle = spawn(plan, RemovalMode::Permanent);+ let mut events = Vec::new();+ for _ in 0..2000 {+ while let Some(event) = handle.poll() {+ events.push(event);+ }+ if matches!(events.last(), Some(RemovalEvent::Done { .. })) {+ break;+ }+ thread::sleep(std::time::Duration::from_millis(1));+ }++ assert!(matches!(events[0], RemovalEvent::Start { total: 3 }));+ let items = events+ .iter()+ .filter(|event| matches!(event, RemovalEvent::Item { .. }))+ .count();+ assert_eq!(items, 3);+ match events.last() {+ Some(RemovalEvent::Done {+ removed,+ bytes,+ failed,+ }) => {+ assert_eq!(*removed, 2);+ assert_eq!(*failed, 1);+ assert_eq!(*bytes, 20);+ }+ other => panic!("expected Done, got {other:?}"),+ }+ assert!(!root.join("a/b").exists());+ assert!(root.join("a/one.bin").exists());+ }++ #[test]+ fn a_trash_tool_is_called_with_the_path_after_a_separator() {+ use std::os::unix::fs::PermissionsExt as _;+ let temp = TempDir::new().expect("tempdir");+ let recording = temp.path().join("argv");+ let script = temp.path().join("fake-trash-put");+ fs::write(+ &script,+ format!(+ "#!/bin/sh\nprintf '%s\\n' \"$@\" > {}\n",+ recording.display()+ ),+ )+ .expect("write the script");+ fs::set_permissions(&script, fs::Permissions::from_mode(0o755))+ .expect("chmod");++ // A path that would be an option if the separator were missing.+ let doomed = temp.path().join("-rf");+ fs::write(&doomed, b"not this time").expect("write");+ run_tool(&script, &[], &doomed).expect("the tool ran");++ let recorded = fs::read_to_string(&recording).expect("the argv");+ let lines: Vec<&str> = recorded.lines().collect();+ assert_eq!(lines, vec!["--", doomed.to_string_lossy().as_ref()]);+ assert!(doomed.exists(), "the real tool would have moved it");+ }++ #[test]+ fn a_failing_trash_tool_reports_its_stderr() {+ use std::os::unix::fs::PermissionsExt as _;+ let temp = TempDir::new().expect("tempdir");+ let script = temp.path().join("angry-trash-put");+ fs::write(&script, "#!/bin/sh\necho 'no trash here' >&2\nexit 3\n")+ .expect("write");+ fs::set_permissions(&script, fs::Permissions::from_mode(0o755))+ .expect("chmod");++ let error = run_tool(&script, &[], temp.path()).expect_err("it failed");+ assert!(error.to_string().contains("no trash here"), "{error}");+ }++ #[test]+ fn detection_prefers_a_tool_this_machine_has() {+ let backend = detect_trash_backend();+ if which("trash-put") {+ assert_eq!(backend, TrashBackend::TrashPut);+ }+ assert!(backend.is_available());+ }+}diff --git a/crates/disktree-core/src/scan.rs b/crates/disktree-core/src/scan.rsnew file mode 100644index 0000000..b75d9d3--- /dev/null+++ b/crates/disktree-core/src/scan.rs@@ -0,0 +1,921 @@+//! Parallel filesystem scanning.+//!+//! The shape follows dust, because that shape is the reason dust is fast:+//!+//! * one `rayon::scope` per root, so recursion depth is O(1) however deep the+//! tree is,+//! * every directory is a `PendingDir` with an atomic completion counter and a+//! `+1` sentinel, so a directory is only built once its own scan *and* all of+//! its subdirectory tasks have finished,+//! * children are handed to the parent as finished `Node`s and sizes are+//! aggregated bottom-up in one serial pass, which is also where hardlinks are+//! de-duplicated.+//!+//! What is added on top of dust's approach: live progress counters the UI can+//! poll without locking, and cooperative cancellation so a re-scan can abandon+//! a walk of a large home directory instead of queueing behind it.++use std::fs::{self, DirEntry, Metadata};+use std::io;+use std::path::{Path, PathBuf};+use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};+use std::sync::mpsc::{self, Receiver, TryRecvError};+use std::sync::{Arc, Mutex, MutexGuard, PoisonError};+use std::thread;++use rayon::Scope;+use rustc_hash::FxHashSet;++use crate::tree::{Metric, Node, NodeKind, aggregate};++/// Errors kept verbatim before the list is truncated; the count keeps rising.+const MAX_ERROR_DETAIL: usize = 50;++/// How a scan measures and filters the tree.+#[derive(Clone, Debug)]+pub struct ScanOptions {+ /// Measure apparent length instead of allocated blocks. Apparent size is+ /// what `ls -l` shows; blocks are what the volume actually spends, which is+ /// what a disk-space tool normally wants.+ pub apparent_size: bool,+ /// Follow symlinks. Off by default: a home directory is full of links, and+ /// following them double-counts.+ pub follow_links: bool,+ /// Include dotfiles and dot-directories. On by default, like dust and `du`:+ /// `~/.cache` is frequently the largest directory in a home directory.+ pub include_hidden: bool,+ /// Do not cross filesystem boundaries below the root.+ pub one_filesystem: bool,+ /// Stop descending past this depth. Totals below that depth are then+ /// unknown, which makes an overview scan of a huge tree cheap.+ pub max_depth: Option<usize>,+ /// Count a hardlinked file once instead of once per link.+ pub dedup_hardlinks: bool,+ /// Whether children are ranked by bytes or by file count.+ pub metric: Metric,+}++impl Default for ScanOptions {+ fn default() -> Self {+ Self {+ apparent_size: false,+ follow_links: false,+ include_hidden: true,+ one_filesystem: false,+ max_depth: None,+ dedup_hardlinks: true,+ metric: Metric::Bytes,+ }+ }+}++/// Counters a running scan publishes for the UI.+///+/// Plain relaxed atomics: this is a progress meter, not a synchronisation+/// point, and the UI reads a snapshot that is allowed to be a few entries+/// stale.+#[derive(Debug, Default)]+pub struct ScanProgress {+ files: AtomicU64,+ dirs: AtomicU64,+ bytes: AtomicU64,+ errors: AtomicU64,+ finished: AtomicBool,+ cancelled: AtomicBool,+ messages: Mutex<Vec<String>>,+}++/// A point-in-time view of [`ScanProgress`].+#[derive(Clone, Debug, Default, PartialEq, Eq)]+pub struct ScanSnapshot {+ pub files: u64,+ pub dirs: u64,+ pub bytes: u64,+ pub errors: u64,+ pub finished: bool,+ pub cancelled: bool,+ /// Up to [`MAX_ERROR_DETAIL`] unreadable paths, most recent last.+ pub messages: Vec<String>,+}++impl ScanProgress {+ fn count_file(&self, bytes: u64) {+ self.files.fetch_add(1, Ordering::Relaxed);+ self.bytes.fetch_add(bytes, Ordering::Relaxed);+ }++ fn count_dir(&self) {+ self.dirs.fetch_add(1, Ordering::Relaxed);+ }++ fn record_error(&self, path: &Path, error: &io::Error) {+ self.errors.fetch_add(1, Ordering::Relaxed);+ let message = format!("{}: {error}", path.display());+ let mut messages = lock(&self.messages);+ if messages.len() < MAX_ERROR_DETAIL {+ messages.push(message);+ }+ drop(messages);+ }++ fn finish(&self) {+ self.finished.store(true, Ordering::Relaxed);+ }++ /// Ask the walk to stop at the next directory boundary.+ pub fn cancel(&self) {+ self.cancelled.store(true, Ordering::Relaxed);+ }++ /// Stop the walk now, without waiting for the worker thread.+ pub fn is_cancelled(&self) -> bool {+ self.cancelled.load(Ordering::Relaxed)+ }++ pub fn snapshot(&self) -> ScanSnapshot {+ ScanSnapshot {+ files: self.files.load(Ordering::Relaxed),+ dirs: self.dirs.load(Ordering::Relaxed),+ bytes: self.bytes.load(Ordering::Relaxed),+ errors: self.errors.load(Ordering::Relaxed),+ finished: self.finished.load(Ordering::Relaxed),+ cancelled: self.is_cancelled(),+ messages: lock(&self.messages).clone(),+ }+ }+}++/// A scan running on its own thread.+#[derive(Debug)]+pub struct ScanHandle {+ pub progress: Arc<ScanProgress>,+ result: Receiver<io::Result<Node>>,+}++impl ScanHandle {+ /// Start walking `root` on a worker thread.+ pub fn spawn(root: PathBuf, options: ScanOptions) -> Self {+ let progress = Arc::new(ScanProgress::default());+ let context = Arc::new(WalkContext {+ options,+ progress: Arc::clone(&progress),+ root_device: Mutex::new(None),+ visited_dirs: Mutex::new(FxHashSet::default()),+ root: Mutex::new(None),+ });+ let (sender, result) = mpsc::channel();++ // The closure owns the sender, so a failed spawn drops it and the+ // receiver reports the failure. Record the real reason alongside it.+ let worker = thread::Builder::new().name("disktree-scan".into()).spawn(+ move || {+ let outcome = scan_blocking(&root, &context);+ context.progress.finish();+ let _ = sender.send(outcome);+ },+ );+ if let Err(error) = worker {+ progress.record_error(Path::new("scan worker"), &error);+ progress.finish();+ }++ Self { progress, result }+ }++ /// Take the finished tree, if the walk is done.+ pub fn poll(&self) -> Option<io::Result<Node>> {+ match self.result.try_recv() {+ Ok(outcome) => Some(outcome),+ Err(TryRecvError::Empty) => None,+ Err(TryRecvError::Disconnected) => Some(Err(io::Error::other(+ "the scan worker stopped without a result",+ ))),+ }+ }++ /// Abandon the walk; the worker still finishes the directory it is in.+ pub fn cancel(&self) {+ self.progress.cancel();+ }+}++/// Walk `root` and return the aggregated tree. Blocking.+pub fn scan(root: &Path, options: ScanOptions) -> io::Result<Node> {+ let progress = Arc::new(ScanProgress::default());+ let context = Arc::new(WalkContext {+ options,+ progress: Arc::clone(&progress),+ root_device: Mutex::new(None),+ visited_dirs: Mutex::new(FxHashSet::default()),+ root: Mutex::new(None),+ });+ let node = scan_blocking(root, &context)?;+ progress.finish();+ Ok(node)+}++struct WalkContext {+ options: ScanOptions,+ progress: Arc<ScanProgress>,+ /// Device of the root, resolved once, only needed for `one_filesystem`.+ root_device: Mutex<Option<u64>>,+ /// Directories already entered, so followed symlinks cannot loop.+ visited_dirs: Mutex<FxHashSet<(u64, u64)>>,+ /// Set by the root's `complete`, read after the scope joins.+ root: Mutex<Option<Node>>,+}++impl WalkContext {+ fn root_device(&self, path: &Path) -> Option<u64> {+ let mut cached = lock(&self.root_device);+ if let Some(device) = *cached {+ return Some(device);+ }+ let device = fs::metadata(path).map(|meta| device_of(&meta)).ok();+ *cached = device;+ device+ }++ fn cancelled(&self) -> bool {+ self.progress.is_cancelled()+ }++ /// Decide what to do with an entry, and account for the work it implies.+ fn classify(&self, entry: &DirEntry) -> Classified {+ let path = entry.path();+ let file_type = match entry.file_type() {+ Ok(file_type) => file_type,+ Err(error) => {+ self.progress.record_error(&path, &error);+ return Classified::Skipped;+ }+ };+ // Non-UTF-8 names are lossy for display. The scan still measures them+ // correctly; only the reported name is approximate.+ let name: Box<str> =+ entry.file_name().to_string_lossy().into_owned().into();++ if !self.options.include_hidden && name.starts_with('.') {+ return Classified::Skipped;+ }++ if file_type.is_symlink() {+ return self.classify_symlink(&path, name);+ }++ if file_type.is_dir() {+ if self.options.one_filesystem {+ let device = entry.metadata().map(|meta| device_of(&meta));+ match (device, self.root_device(&path)) {+ (Ok(device), Some(root_device))+ if device != root_device =>+ {+ return Classified::Skipped;+ }+ (Err(error), _) => {+ self.progress.record_error(&path, &error);+ return Classified::Skipped;+ }+ _ => {}+ }+ }+ self.progress.count_dir();+ return Classified::Subdirectory(path);+ }++ match entry.metadata() {+ Ok(meta) => self.leaf(name, kind_of(&meta, file_type), &meta),+ Err(error) => {+ self.progress.record_error(&path, &error);+ Classified::Skipped+ }+ }+ }++ fn classify_symlink(&self, path: &Path, name: Box<str>) -> Classified {+ if !self.options.follow_links {+ // Not followed: the link occupies only its target string, which+ // `du` reports as a handful of bytes or nothing at all.+ return match fs::symlink_metadata(path) {+ Ok(meta) => {+ let size = measure(&meta, self.options.apparent_size);+ self.progress.count_file(size);+ Classified::Entry(leaf_node(+ name,+ NodeKind::Symlink,+ size,+ &meta,+ ))+ }+ Err(error) => {+ self.progress.record_error(path, &error);+ Classified::Skipped+ }+ };+ }++ let meta = match fs::metadata(path) {+ Ok(meta) => meta,+ Err(error) => {+ // A dangling link is normal, not an error worth counting.+ if error.kind() != io::ErrorKind::NotFound {+ self.progress.record_error(path, &error);+ }+ return Classified::Skipped;+ }+ };++ if meta.is_dir() {+ if let Some(key) = file_identity(&meta)+ && !lock(&self.visited_dirs).insert(key)+ {+ return Classified::Skipped;+ }+ self.progress.count_dir();+ return Classified::Subdirectory(path.to_path_buf());+ }++ self.leaf(name, kind_of(&meta, meta.file_type()), &meta)+ }++ fn leaf(+ &self,+ name: Box<str>,+ kind: NodeKind,+ meta: &Metadata,+ ) -> Classified {+ let size = measure(meta, self.options.apparent_size);+ self.progress.count_file(size);+ Classified::Entry(leaf_node(name, kind, size, meta))+ }+}++/// What a directory entry turned out to be.+enum Classified {+ /// Descend into this directory on a new task.+ Subdirectory(PathBuf),+ /// A leaf that contributes size.+ Entry(Node),+ /// Filtered out, unreadable, or a symlink we chose not to follow.+ Skipped,+}++/// One directory being walked, plus the counter that decides when it is done.+#[derive(Debug)]+struct PendingDir {+ path: PathBuf,+ parent: Option<Arc<Self>>,+ /// Starts at 1 for the directory itself; one more per subdirectory task.+ /// When it reaches zero the directory is complete.+ pending: AtomicUsize,+ /// Files found directly here, and finished subdirectories handed back up.+ children: Mutex<Vec<Node>>,+ read_error: AtomicBool,+ depth: usize,+}++impl PendingDir {+ const fn new(+ path: PathBuf,+ parent: Option<Arc<Self>>,+ depth: usize,+ ) -> Self {+ Self {+ path,+ parent,+ pending: AtomicUsize::new(1),+ children: Mutex::new(Vec::new()),+ read_error: AtomicBool::new(false),+ depth,+ }+ }++ /// Turn a completed directory into a node. Only called when `pending` has+ /// reached zero, so every child is already in `self.children`.+ ///+ /// `bytes` and `own_bytes` are left at zero on purpose: the walk cannot+ /// know the aggregate, and [`crate::tree::aggregate`] derives both from the+ /// children once every child is present.+ fn build(&self) -> Node {+ Node {+ name: file_name(&self.path),+ kind: NodeKind::Directory,+ bytes: 0,+ own_bytes: 0,+ files: 0,+ own_files: 0,+ dirs: 1,+ inode: None,+ read_error: self.read_error.load(Ordering::Relaxed),+ children: std::mem::take(&mut *lock(&self.children)),+ }+ }+}++fn scan_blocking(root: &Path, context: &Arc<WalkContext>) -> io::Result<Node> {+ let root_meta = fs::metadata(root)?;+ if !root_meta.is_dir() {+ return Err(io::Error::new(+ io::ErrorKind::InvalidInput,+ format!("{} is not a directory", root.display()),+ ));+ }+ if context.options.one_filesystem {+ *lock(&context.root_device) = Some(device_of(&root_meta));+ }+ if context.options.follow_links+ && let Some(key) = file_identity(&root_meta)+ {+ lock(&context.visited_dirs).insert(key);+ }++ let root_dir = Arc::new(PendingDir::new(root.to_path_buf(), None, 0));+ rayon::scope(|scope| walk(scope, &root_dir, context));++ let node = lock(&context.root).take();+ let node = node.ok_or_else(|| {+ io::Error::other(format!("{} produced no tree", root.display()))+ })?;+ Ok(finish_tree(node, &context.options))+}++/// Read one directory, spawn a task per subdirectory, then report completion.+///+/// Flat tasks inside the scope: the worker stack never grows with tree depth.+fn walk(scope: &Scope<'_>, dir: &Arc<PendingDir>, context: &Arc<WalkContext>) {+ let mut subdirs: Vec<Arc<PendingDir>> = Vec::new();+ let mut leaves: Vec<Node> = Vec::new();++ match fs::read_dir(&dir.path) {+ Ok(entries) => {+ for entry in entries {+ if context.cancelled() {+ break;+ }+ match entry {+ Ok(entry) => match context.classify(&entry) {+ Classified::Subdirectory(path) => {+ let child = Arc::new(PendingDir::new(+ path,+ Some(Arc::clone(dir)),+ dir.depth + 1,+ ));+ subdirs.push(child);+ }+ Classified::Entry(node) => leaves.push(node),+ Classified::Skipped => {}+ },+ Err(error) => {+ context.progress.record_error(&dir.path, &error);+ }+ }+ }+ }+ Err(error) => {+ context.progress.record_error(&dir.path, &error);+ dir.read_error.store(true, Ordering::Relaxed);+ }+ }++ // A depth-limited scan still measures what is directly in the directory,+ // it just does not descend further.+ let descend = context+ .options+ .max_depth+ .is_none_or(|max_depth| dir.depth < max_depth);+ if descend {+ for subdir in subdirs {+ if context.cancelled() {+ break;+ }+ dir.pending.fetch_add(1, Ordering::AcqRel);+ let subdir = Arc::clone(&subdir);+ let context = Arc::clone(context);+ scope.spawn(move |scope| walk(scope, &subdir, &context));+ }+ }+ lock(&dir.children).extend(leaves);++ signal_done(&Arc::clone(dir), context);+}++/// Report that one task for `dir` is done: either its own scan, or one of its+/// children. The last one to report builds the node and bubbles up.+///+/// This is the whole reason for the `+1` sentinel: a directory is only built+/// once its own scan *and* every subdirectory task has finished, no matter+/// which of them lands last.+fn signal_done(dir: &Arc<PendingDir>, context: &Arc<WalkContext>) {+ if dir.pending.fetch_sub(1, Ordering::AcqRel) != 1 {+ return;+ }+ let node = dir.build();+ let Some(parent) = dir.parent.clone() else {+ *lock(&context.root) = Some(node);+ return;+ };+ lock(&parent.children).push(node);+ signal_done(&parent, context);+}++/// Charge a hardlinked file once, then derive every aggregate from the result.+///+/// Zeroing `own_bytes` rather than `bytes` is deliberate:+/// [`crate::tree::aggregate`] recomputes totals from the direct contents, so a+/// patched `bytes` would be overwritten.+fn finish_tree(mut node: Node, options: &ScanOptions) -> Node {+ if options.dedup_hardlinks {+ let mut seen = FxHashSet::default();+ mark_duplicate_hardlinks(&mut node, &mut seen);+ }+ aggregate(&mut node, options.metric);+ node+}++fn mark_duplicate_hardlinks(node: &mut Node, seen: &mut FxHashSet<(u64, u64)>) {+ if !node.is_dir() {+ if node.inode.is_some_and(|key| !seen.insert(key)) {+ node.own_bytes = 0;+ }+ return;+ }+ for child in &mut node.children {+ mark_duplicate_hardlinks(child, seen);+ }+}++fn leaf_node(+ name: Box<str>,+ kind: NodeKind,+ size: u64,+ meta: &Metadata,+) -> Node {+ let mut node = Node::entry(name, kind, size);+ node.inode = file_identity(meta);+ node+}++fn measure(meta: &Metadata, apparent_size: bool) -> u64 {+ if apparent_size {+ meta.len()+ } else {+ allocated_bytes(meta).unwrap_or(meta.len())+ }+}++/// Allocated bytes, `st_blocks * 512`: sparse files spend less than they claim,+/// and this is the number that matches `du`.+///+/// Returns `Option` because only Unix reports allocated blocks; elsewhere the+/// caller falls back to the apparent length.+#[allow(+ clippy::unnecessary_wraps,+ reason = "the Option is the non-Unix answer, where the caller falls back"+)]+#[cfg(unix)]+fn allocated_bytes(meta: &Metadata) -> Option<u64> {+ use std::os::unix::fs::MetadataExt as _;+ Some(meta.blocks().saturating_mul(512))+}++#[cfg(not(unix))]+fn allocated_bytes(_meta: &Metadata) -> Option<u64> {+ None+}++#[cfg(unix)]+fn device_of(meta: &Metadata) -> u64 {+ use std::os::unix::fs::MetadataExt as _;+ meta.dev()+}++#[cfg(not(unix))]+fn device_of(_meta: &Metadata) -> u64 {+ 0+}++/// `(device, inode)`, or `None` where the platform does not expose them.+/// Hardlink de-duplication and symlink loop detection both depend on this, so+/// they are simply unavailable rather than silently wrong elsewhere.+#[allow(+ clippy::unnecessary_wraps,+ reason = "the Option is the non-Unix answer, so both arms must agree"+)]+#[cfg(unix)]+fn file_identity(meta: &Metadata) -> Option<(u64, u64)> {+ use std::os::unix::fs::MetadataExt as _;+ Some((meta.dev(), meta.ino()))+}++#[cfg(not(unix))]+fn file_identity(_meta: &Metadata) -> Option<(u64, u64)> {+ None+}++fn kind_of(meta: &Metadata, file_type: fs::FileType) -> NodeKind {+ if meta.is_dir() || file_type.is_dir() {+ NodeKind::Directory+ } else if meta.is_file() || file_type.is_file() {+ NodeKind::File+ } else if file_type.is_symlink() {+ NodeKind::Symlink+ } else {+ NodeKind::Other+ }+}++/// The display name of a scanned root: its final component, or the path itself+/// for `/`.+fn file_name(path: &Path) -> Box<str> {+ path.file_name()+ .map_or_else(+ || path.to_string_lossy().into_owned(),+ |name| name.to_string_lossy().into_owned(),+ )+ .into()+}++/// A poisoned lock means another task panicked; the data is still a valid tree+/// prefix, and refusing to read it would turn one panic into two.+fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {+ mutex.lock().unwrap_or_else(PoisonError::into_inner)+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::tree::Metric;+ use std::fs;+ use tempfile::TempDir;++ /// Apparent sizes, so the assertions are about the tree rather than about+ /// how the filesystem rounds a small file up to a block.+ fn options() -> ScanOptions {+ ScanOptions {+ apparent_size: true,+ ..ScanOptions::default()+ }+ }++ fn write(root: &Path, relative: &str, bytes: usize) -> PathBuf {+ let path = root.join(relative);+ fs::create_dir_all(path.parent().expect("parent")).expect("mkdir");+ fs::write(&path, vec![b'x'; bytes]).expect("write");+ path+ }++ fn scan_dir(root: &Path, options: &ScanOptions) -> Node {+ scan(root, options.clone()).expect("scan")+ }++ fn child<'a>(node: &'a Node, name: &str) -> &'a Node {+ node.children+ .iter()+ .find(|child| &*child.name == name)+ .unwrap_or_else(|| {+ panic!("no child named {name} in {:?}", node.name)+ })+ }++ #[test]+ fn totals_are_summed_bottom_up() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "a/one.bin", 1000);+ write(root, "a/nested/two.bin", 2000);+ write(root, "b/three.bin", 500);++ let tree = scan_dir(root, &options());+ assert_eq!(tree.bytes, 3500);+ assert_eq!(tree.files, 3);+ assert_eq!(tree.dirs, 4, "root, a, a/nested, b");+ assert_eq!(child(&tree, "a").bytes, 3000);+ assert_eq!(child(child(&tree, "a"), "nested").bytes, 2000);+ assert_eq!(child(&tree, "b").bytes, 500);+ }++ #[test]+ fn children_are_ranked_largest_first() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "small.bin", 10);+ write(root, "large.bin", 1000);+ write(root, "medium.bin", 100);++ let tree = scan_dir(root, &options());+ let names: Vec<&str> = tree.children.iter().map(|c| &*c.name).collect();+ assert_eq!(names, vec!["large.bin", "medium.bin", "small.bin"]);+ }++ #[test]+ fn a_directory_reports_its_own_bytes_separately() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "direct.bin", 700);+ write(root, "sub/deep.bin", 300);++ let tree = scan_dir(root, &options());+ assert_eq!(tree.own_bytes, 700);+ assert_eq!(tree.own_files, 1);+ assert_eq!(tree.bytes, 1000);+ assert_eq!(tree.files, 2);+ }++ #[test]+ fn hardlinks_are_charged_once_by_default() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ let original = write(root, "original.bin", 4096);+ fs::hard_link(&original, root.join("link.bin")).expect("hard link");++ let deduped = scan_dir(root, &options());+ assert_eq!(deduped.bytes, 4096);+ assert_eq!(deduped.files, 2, "both names still exist");++ let counted = scan_dir(+ root,+ &ScanOptions {+ dedup_hardlinks: false,+ ..options()+ },+ );+ assert_eq!(counted.bytes, 8192);+ }++ #[test]+ fn hidden_entries_are_included_by_default_and_excluded_on_request() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, ".cache/blob.bin", 900);+ write(root, "visible.bin", 100);++ let default = scan_dir(root, &options());+ assert_eq!(default.bytes, 1000);+ assert_eq!(child(&default, ".cache").bytes, 900);++ let without = scan_dir(+ root,+ &ScanOptions {+ include_hidden: false,+ ..options()+ },+ );+ assert_eq!(without.bytes, 100);+ }++ #[test]+ fn symlinks_are_not_followed_by_default() {+ let temp = TempDir::new().expect("tempdir");+ let outside = TempDir::new().expect("tempdir");+ write(outside.path(), "elsewhere.bin", 5000);+ let root = temp.path();+ write(root, "real.bin", 100);+ std::os::unix::fs::symlink(outside.path(), root.join("link"))+ .expect("symlink");++ let tree = scan_dir(root, &options());+ // Only the real file's bytes; the link itself holds just its target+ // string, and its 5000-byte destination is outside this tree.+ assert!(tree.bytes < 200, "{}", tree.bytes);+ let link = child(&tree, "link");+ assert_eq!(link.kind, NodeKind::Symlink);+ assert!(link.bytes < 100, "a link holds only its target string");+ }++ #[test]+ fn followed_symlink_loops_do_not_hang_the_scan() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "sub/leaf.bin", 42);+ std::os::unix::fs::symlink(root, root.join("sub/loop"))+ .expect("symlink");++ let tree = scan_dir(+ root,+ &ScanOptions {+ follow_links: true,+ ..options()+ },+ );+ assert_eq!(tree.bytes, 42);+ }++ #[test]+ fn max_depth_stops_descending_but_keeps_direct_files() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "here.bin", 10);+ write(root, "a/there.bin", 20);+ write(root, "a/b/far.bin", 30);++ let tree = scan_dir(+ root,+ &ScanOptions {+ max_depth: Some(1),+ ..options()+ },+ );+ assert_eq!(tree.own_bytes, 10);+ let a = child(&tree, "a");+ assert_eq!(+ a.bytes, 20,+ "direct files at the cut-off depth still count"+ );+ assert!(+ a.children.iter().all(|child| !child.is_dir()),+ "descending stopped at depth 1"+ );+ assert_eq!(a.files, 1);+ }++ #[test]+ fn file_count_metric_ranks_by_entries() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ for index in 0..5 {+ write(root, &format!("many/f{index}.bin"), 1);+ }+ write(root, "one/huge.bin", 100_000);++ let tree = scan_dir(root, &options());+ assert_eq!(child(&tree, "one").bytes, 100_000);+ assert_eq!(tree.children[0].name.as_ref(), "one");++ let by_files = scan_dir(+ root,+ &ScanOptions {+ metric: Metric::Files,+ ..options()+ },+ );+ assert_eq!(by_files.children[0].name.as_ref(), "many");+ assert_eq!(by_files.children[0].files, 5);+ }++ #[test]+ fn an_unreadable_directory_is_recorded_not_fatal() {+ use std::os::unix::fs::PermissionsExt as _;+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "readable.bin", 11);+ let locked = root.join("locked");+ fs::create_dir_all(&locked).expect("mkdir");+ write(&locked, "hidden.bin", 22);+ fs::set_permissions(&locked, fs::Permissions::from_mode(0o000))+ .expect("chmod");++ // Running as root would bypass the permission bits entirely.+ let readable = fs::read_dir(&locked).map(|mut it| it.next().is_some());+ let progress = Arc::new(ScanProgress::default());+ let context = Arc::new(WalkContext {+ options: options(),+ progress: Arc::clone(&progress),+ root_device: Mutex::new(None),+ visited_dirs: Mutex::new(FxHashSet::default()),+ root: Mutex::new(None),+ });+ let tree = scan_blocking(root, &context).expect("scan still succeeds");+ let _ = fs::set_permissions(&locked, fs::Permissions::from_mode(0o700));++ assert_eq!(tree.bytes, 11);+ let node = child(&tree, "locked");+ if matches!(readable, Ok(false)) {+ assert!(node.read_error);+ assert!(progress.snapshot().errors >= 1);+ assert!(!progress.snapshot().messages.is_empty());+ }+ }++ #[test]+ fn a_file_root_is_rejected() {+ let temp = TempDir::new().expect("tempdir");+ let path = write(temp.path(), "file.bin", 1);+ let error = scan(&path, options()).expect_err("a file is not a tree");+ assert_eq!(error.kind(), io::ErrorKind::InvalidInput);+ }++ #[test]+ fn a_spawned_scan_reports_progress_and_a_result() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ write(root, "a/one.bin", 1024);+ write(root, "b/two.bin", 2048);++ let handle = ScanHandle::spawn(root.to_path_buf(), options());+ let mut outcome = None;+ for _ in 0..2000 {+ if let Some(result) = handle.poll() {+ outcome = Some(result);+ break;+ }+ thread::sleep(std::time::Duration::from_millis(1));+ }+ let tree = outcome.expect("the scan finished").expect("a tree");+ assert_eq!(tree.bytes, 3072);++ let snapshot = handle.progress.snapshot();+ assert!(snapshot.finished);+ assert_eq!(snapshot.files, 2);+ assert_eq!(snapshot.errors, 0);+ }+}diff --git a/crates/disktree-core/src/size.rs b/crates/disktree-core/src/size.rsnew file mode 100644index 0000000..74f49c6--- /dev/null+++ b/crates/disktree-core/src/size.rs@@ -0,0 +1,135 @@+//! Human-readable sizes and counts.+//!+//! Binary units, like `du -h` and dust. One decimal below 10, none above 100:+//! enough resolution to compare neighbours without a wall of digits.++const BYTE_UNITS: [&str; 6] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];++/// `1.4 GiB`, `523 MiB`, `12 B`.+pub fn human_bytes(bytes: u64) -> String {+ scale(bytes).format(1)+}++/// `1.4G`, `523M`, `12B`: for tile labels, where columns are scarce.+pub fn human_bytes_short(bytes: u64) -> String {+ scale(bytes).format(0)+}++fn scale(bytes: u64) -> Scaled {+ let mut value = bytes as f64;+ let mut unit = 0;+ while value >= 1024.0 && unit + 1 < BYTE_UNITS.len() {+ value /= 1024.0;+ unit += 1;+ }+ Scaled { value, unit }+}++struct Scaled {+ value: f64,+ unit: usize,+}++impl Scaled {+ fn format(&self, gap: usize) -> String {+ // Whole bytes have no fraction to show: `0 B`, not `0.0 B`.+ let text = if self.unit == 0 {+ format!("{:.0}", self.value)+ } else if self.value < 9.95 {+ format!("{:.1}", self.value)+ } else {+ format!("{:.0}", self.value)+ };+ if gap == 0 {+ format!("{text}{}", BYTE_UNITS[self.unit])+ } else {+ format!("{text} {}", BYTE_UNITS[self.unit])+ }+ }+}++/// `1.2k`, `3.4M`, `812`: file counts, which grow past a million quickly.+pub fn human_count(count: u64) -> String {+ let value = count as f64;+ if count < 10_000 {+ format!("{count}")+ } else if value < 1_000_000.0 {+ format!("{:.1}k", value / 1_000.0)+ } else if value < 1_000_000_000.0 {+ format!("{:.1}M", value / 1_000_000.0)+ } else {+ format!("{:.1}G", value / 1_000_000_000.0)+ }+}++/// Share of `total` as a whole percentage, saturating instead of dividing by+/// zero.+pub fn share(part: u64, total: u64) -> f64 {+ if total == 0 {+ 0.0+ } else {+ (part as f64 / total as f64) * 100.0+ }+}++/// Compass width for a share, e.g. `▓▓▓░░`.+pub fn share_bar(part: u64, total: u64, width: usize) -> String {+ let filled = if total == 0 {+ 0+ } else {+ ((part as f64 / total as f64) * width as f64).round() as usize+ };+ let filled = filled.min(width);+ let mut bar = String::with_capacity(width);+ for index in 0..width {+ bar.push(if index < filled { '▓' } else { '░' });+ }+ bar+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn bytes_use_binary_units_with_one_decimal_below_ten() {+ assert_eq!(human_bytes(0), "0 B");+ assert_eq!(human_bytes(7), "7 B");+ assert_eq!(human_bytes(12), "12 B");+ assert_eq!(human_bytes(1024), "1.0 KiB");+ assert_eq!(human_bytes(1536), "1.5 KiB");+ assert_eq!(+ human_bytes(1024 * 1024 * 1024 + 400 * 1024 * 1024),+ "1.4 GiB"+ );+ assert_eq!(human_bytes(512 * 1024 * 1024), "512 MiB");+ }++ #[test]+ fn short_form_drops_the_space() {+ assert_eq!(human_bytes_short(1536), "1.5KiB");+ assert_eq!(human_bytes_short(512 * 1024), "512KiB");+ }++ #[test]+ fn counts_switch_to_metric_suffixes() {+ assert_eq!(human_count(0), "0");+ assert_eq!(human_count(9_999), "9999");+ assert_eq!(human_count(12_000), "12.0k");+ assert_eq!(human_count(2_500_000), "2.5M");+ }++ #[test]+ fn share_survives_a_zero_total() {+ assert!((share(5, 0) - 0.0).abs() < f64::EPSILON);+ assert!((share(1, 4) - 25.0).abs() < f64::EPSILON);+ }++ #[test]+ fn share_bar_is_always_the_requested_width() {+ assert_eq!(share_bar(1, 4, 4).chars().count(), 4);+ assert_eq!(share_bar(4, 4, 4), "▓▓▓▓");+ assert_eq!(share_bar(0, 4, 4), "░░░░");+ assert_eq!(share_bar(1, 0, 3).chars().count(), 3);+ }+}diff --git a/crates/disktree-core/src/space.rs b/crates/disktree-core/src/space.rsnew file mode 100644index 0000000..62ecb13--- /dev/null+++ b/crates/disktree-core/src/space.rs@@ -0,0 +1,113 @@+//! Free space on the volume a path lives on.+//!+//! This is what makes "amount of crap I found" a real number rather than an+//! estimate: the app measures the volume before and after a removal, and shows+//! the projection while marking.++use std::io;+use std::path::Path;++/// A volume's capacity in bytes.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub struct SpaceInfo {+ /// Total size of the volume.+ pub total: u64,+ /// Free blocks, including the reserve only root may write to.+ pub free: u64,+ /// Free blocks this user may actually write; what `df -h` reports.+ pub available: u64,+}++impl SpaceInfo {+ /// Space in use, computed from `free` rather than `available` so the figure+ /// does not jump when a reserve is opened to root.+ pub const fn used(&self) -> u64 {+ self.total.saturating_sub(self.free)+ }++ /// Share of the volume in use, `0.0..=1.0`.+ pub fn used_fraction(&self) -> f32 {+ if self.total == 0 {+ 0.0+ } else {+ (self.used() as f64 / self.total as f64) as f32+ }+ }++ /// Free space after `bytes` are removed, saturating at the volume size and+ /// never counting the same byte twice.+ #[must_use]+ pub fn after_removing(&self, bytes: u64) -> Self {+ let available = self.available.saturating_add(bytes).min(self.total);+ let free = self.free.saturating_add(bytes).min(self.total);+ Self {+ total: self.total,+ free,+ available,+ }+ }+}++/// Read the space on the volume containing `path`.+pub fn space_info(path: &Path) -> io::Result<SpaceInfo> {+ let stat = rustix::fs::statvfs(path)?;+ // `f_frsize` is the fragment size the block counts are expressed in;+ // `f_bsize` is only a hint for I/O. Some filesystems report zero for+ // `f_frsize`, so fall back rather than claiming a zero-sized volume.+ let block = if stat.f_frsize == 0 {+ stat.f_bsize+ } else {+ stat.f_frsize+ };+ Ok(SpaceInfo {+ total: stat.f_blocks.saturating_mul(block),+ free: stat.f_bfree.saturating_mul(block),+ available: stat.f_bavail.saturating_mul(block),+ })+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn a_real_volume_reports_plausible_numbers() {+ let temp = std::env::temp_dir();+ let space = space_info(&temp).expect("temp dir has a volume");+ assert!(space.total > 0, "{space:?}");+ assert!(space.free <= space.total, "{space:?}");+ assert!(space.available <= space.free, "{space:?}");+ assert!((0.0..=1.0).contains(&space.used_fraction()), "{space:?}");+ }++ #[test]+ fn a_missing_path_reports_the_io_error() {+ let error = space_info(Path::new("/definitely/not/here"))+ .expect_err("no volume");+ assert_eq!(error.kind(), io::ErrorKind::NotFound);+ }++ #[test]+ fn projecting_removal_cannot_exceed_the_volume() {+ let space = SpaceInfo {+ total: 1000,+ free: 100,+ available: 100,+ };+ let after = space.after_removing(50);+ assert_eq!(after.available, 150);+ assert_eq!(after.free, 150);+ assert_eq!(after.total, 1000);++ let capped = space.after_removing(10_000);+ assert_eq!(capped.available, 1000);+ assert_eq!(capped.used(), 0);+ assert!((capped.used_fraction() - 0.0).abs() < f32::EPSILON);+ }++ #[test]+ fn used_fraction_handles_an_empty_volume_report() {+ let space = SpaceInfo::default();+ assert!((space.used_fraction() - 0.0).abs() < f32::EPSILON);+ }+}diff --git a/crates/disktree-core/src/tree.rs b/crates/disktree-core/src/tree.rsnew file mode 100644index 0000000..5d3b612--- /dev/null+++ b/crates/disktree-core/src/tree.rs@@ -0,0 +1,387 @@+//! The scanned tree.++use std::path::{Path, PathBuf};++/// What a node represents on disk.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum NodeKind {+ Directory,+ File,+ Symlink,+ /// Sockets, fifos and devices: addressable, but not space.+ Other,+}++impl NodeKind {+ pub const fn is_dir(self) -> bool {+ matches!(self, Self::Directory)+ }+}++/// How a node's importance is measured.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum Metric {+ /// Bytes, apparent or on-disk depending on [`crate::scan::ScanOptions`].+ #[default]+ Bytes,+ /// Number of files at or beneath the node.+ Files,+}++impl Metric {+ pub const fn label(self) -> &'static str {+ match self {+ Self::Bytes => "size",+ Self::Files => "files",+ }+ }++ #[must_use]+ pub const fn toggled(self) -> Self {+ match self {+ Self::Bytes => Self::Files,+ Self::Files => Self::Bytes,+ }+ }+}++/// One entry in the scanned tree.+///+/// Totals and direct figures are both kept: `own_bytes` and `own_files` are+/// what sits directly in a directory, `bytes` and `files` are the subtree+/// totals the treemap draws. The selection line needs both, and keeping them means+/// no second traversal when one of them is displayed.+#[derive(Clone, Debug)]+pub struct Node {+ pub name: Box<str>,+ pub kind: NodeKind,+ /// Subtree total: direct contents plus every descendant.+ pub bytes: u64,+ /// Bytes of the leaf entries directly in this directory, or this file's+ /// own size. Derived by [`aggregate`].+ pub own_bytes: u64,+ /// Files at or beneath this node; `1` for a file.+ pub files: u64,+ /// Files directly in this directory; `1` for a file. Derived by+ /// [`aggregate`].+ pub own_files: u64,+ /// Directories at or beneath this node; `1` for a directory.+ pub dirs: u64,+ /// `(device, inode)` for files, used to de-duplicate hardlinks.+ pub inode: Option<(u64, u64)>,+ /// The directory could not be read; its contents are unknown.+ pub read_error: bool,+ /// Children, ordered by [`Metric`] value, descending.+ pub children: Vec<Self>,+}++impl Node {+ /// A directory with no children yet.+ #[allow(+ clippy::missing_const_for_fn,+ reason = "`impl Into<Box<str>>` cannot be called in a const fn"+ )]+ pub fn directory(name: impl Into<Box<str>>) -> Self {+ Self {+ name: name.into(),+ kind: NodeKind::Directory,+ bytes: 0,+ own_bytes: 0,+ files: 0,+ own_files: 0,+ dirs: 1,+ inode: None,+ read_error: false,+ children: Vec::new(),+ }+ }++ /// A leaf entry.+ pub fn entry(+ name: impl Into<Box<str>>,+ kind: NodeKind,+ bytes: u64,+ ) -> Self {+ Self {+ name: name.into(),+ kind,+ bytes,+ own_bytes: bytes,+ files: u64::from(kind == NodeKind::File),+ own_files: u64::from(kind == NodeKind::File),+ dirs: 0,+ inode: None,+ read_error: false,+ children: Vec::new(),+ }+ }++ pub const fn is_dir(&self) -> bool {+ self.kind.is_dir()+ }++ /// The value a treemap should weight this node by.+ pub const fn value(&self, metric: Metric) -> u64 {+ match metric {+ Metric::Bytes => self.bytes,+ Metric::Files => self.files,+ }+ }++ pub fn child(&self, index: usize) -> Option<&Self> {+ self.children.get(index)+ }++ /// Follow `crumbs` from this node. Crumbs are child indices, so they stay+ /// valid across re-sorting only for the tree they were produced from.+ pub fn resolve(&self, crumbs: &[usize]) -> Option<&Self> {+ let mut node = self;+ for &index in crumbs {+ node = node.children.get(index)?;+ }+ Some(node)+ }++ /// The chain of nodes ending at `crumbs`, including this node.+ pub fn resolve_chain<'a>(&'a self, crumbs: &[usize]) -> Vec<&'a Self> {+ let mut chain = vec![self];+ let mut node = self;+ for &index in crumbs {+ match node.children.get(index) {+ Some(child) => {+ chain.push(child);+ node = child;+ }+ None => break,+ }+ }+ chain+ }++ /// Index of the largest child, used to pick a useful descent target.+ pub const fn largest_child(&self) -> Option<usize> {+ if self.children.is_empty() {+ None+ } else {+ Some(0)+ }+ }++ /// Depth of the deepest descendant.+ pub fn depth(&self) -> u32 {+ self.children+ .iter()+ .map(Self::depth)+ .max()+ .map_or(0, |deepest| deepest + 1)+ }++ /// Breadth-first search for the first node whose name contains `needle`+ /// (case-insensitive), returning its crumbs and the node.+ pub fn find(&self, needle: &str) -> Option<(Vec<usize>, &Self)> {+ let needle = needle.to_lowercase();+ if needle.is_empty() {+ return None;+ }+ let mut queue = vec![(Vec::new(), self)];+ while let Some((crumbs, node)) = queue.pop() {+ for (index, child) in node.children.iter().enumerate() {+ if child.name.to_lowercase().contains(&needle) {+ let found: Vec<usize> = crumbs+ .iter()+ .copied()+ .chain(std::iter::once(index))+ .collect();+ return Some((found, child));+ }+ if child.is_dir() && !child.children.is_empty() {+ let mut next = crumbs.clone();+ next.push(index);+ queue.push((next, child));+ }+ }+ }+ None+ }+}++/// Recompute `bytes`, `files`, `dirs` and the direct totals bottom-up, then+/// order children by `metric`, largest first.+///+/// `bytes` and `files` are the subtree totals; `own_bytes` and `own_files` are+/// the direct contents, derived from the leaf children rather than tracked+/// separately. Deriving them is what keeps the two consistent: hardlink+/// de-duplication rewrites a leaf's weight, and every total above it —+/// including its parent's "direct" figure — follows without a second pass.+pub fn aggregate(node: &mut Node, metric: Metric) {+ if !node.is_dir() {+ node.bytes = node.own_bytes;+ node.files = node.own_files;+ node.dirs = 0;+ return;+ }++ let mut bytes = 0;+ let mut files = 0;+ let mut own_bytes = 0;+ let mut own_files = 0;+ let mut dirs: u64 = 1;+ for child in &mut node.children {+ aggregate(child, metric);+ bytes += child.bytes;+ files += child.files;+ dirs += child.dirs;+ if !child.is_dir() {+ own_bytes += child.bytes;+ own_files += child.files;+ }+ }+ node.bytes = bytes;+ node.files = files;+ node.own_bytes = own_bytes;+ node.own_files = own_files;+ node.dirs = dirs;++ // Largest first: a treemap lays out big tiles best, and the order is what+ // makes "descend into the largest child" meaningful.+ node.children.sort_by(|left, right| {+ right+ .value(metric)+ .cmp(&left.value(metric))+ .then_with(|| left.name.cmp(&right.name))+ });+}++/// Absolute path of the node at `crumbs` beneath a scanned root.+pub fn path_of(root_path: &Path, root: &Node, crumbs: &[usize]) -> PathBuf {+ let mut path = root_path.to_path_buf();+ let mut node = root;+ for &index in crumbs {+ match node.children.get(index) {+ Some(child) => {+ path.push(&*child.name);+ node = child;+ }+ None => break,+ }+ }+ path+}++#[cfg(test)]+mod tests {+ use super::*;++ fn leaf(name: &str, bytes: u64) -> Node {+ Node::entry(name, NodeKind::File, bytes)+ }++ #[test]+ fn aggregate_derives_totals_and_orders_children() {+ let mut root = Node::directory("root");+ let mut nested = Node::directory("child");+ nested.children.push(leaf("deep", 7));+ root.children.push(nested);+ root.children.push(leaf("direct", 5));+ root.children.push(leaf("small", 9));++ aggregate(&mut root, Metric::Bytes);+ assert_eq!(root.own_bytes, 5 + 9, "direct leaves only");+ assert_eq!(root.bytes, 5 + 9 + 7);+ assert_eq!(root.files, 3);+ assert_eq!(root.own_files, 2);+ assert_eq!(root.dirs, 2);+ assert_eq!(child_named(&root, "child").own_bytes, 7);+ assert_eq!(&*root.children[0].name, "small", "9 bytes, largest first");+ assert_eq!(&*root.children[2].name, "direct");++ // A file's own size is what it weighs; aggregates never invent more.+ let mut single = leaf("solo", 3);+ aggregate(&mut single, Metric::Bytes);+ assert_eq!(single.bytes, 3);+ assert_eq!(single.own_bytes, 3);+ assert_eq!(single.files, 1);+ assert_eq!(single.dirs, 0);+ }++ fn child_named<'a>(node: &'a Node, name: &str) -> &'a Node {+ node.children+ .iter()+ .find(|child| &*child.name == name)+ .unwrap_or_else(|| panic!("no child named {name}"))+ }++ #[test]+ fn aggregate_can_rank_by_file_count() {+ let mut root = Node::directory("root");+ let mut many = Node::directory("many");+ for index in 0..5 {+ many.children.push(leaf(&format!("f{index}"), 1));+ }+ root.children.push(many);+ root.children.push(leaf("huge", 10_000));++ aggregate(&mut root, Metric::Bytes);+ assert_eq!(&*root.children[0].name, "huge");+ aggregate(&mut root, Metric::Files);+ assert_eq!(&*root.children[0].name, "many");+ assert_eq!(root.children[0].files, 5);+ }++ #[test]+ fn resolve_walks_child_indices() {+ let mut root = Node::directory("root");+ let mut nested = Node::directory("child");+ nested.children.push(leaf("deep", 1));+ root.children.push(nested);++ assert!(root.resolve(&[]).is_some());+ assert_eq!(root.resolve(&[0, 0]).map(|n| &*n.name), Some("deep"));+ assert!(root.resolve(&[0, 1]).is_none());+ assert_eq!(root.resolve_chain(&[0, 0]).len(), 3);+ }++ #[test]+ fn path_of_joins_names_beneath_the_root() {+ let mut root = Node::directory("root");+ let mut nested = Node::directory("child");+ nested.children.push(leaf("deep", 1));+ root.children.push(nested);++ let path = path_of(Path::new("/home/tobi"), &root, &[0, 0]);+ assert_eq!(path, PathBuf::from("/home/tobi/child/deep"));+ }++ #[test]+ fn largest_child_is_the_first_child_because_children_are_sorted() {+ let mut root = Node::directory("root");+ root.children.push(leaf("big", 10));+ root.children.push(leaf("small", 1));+ assert_eq!(root.largest_child(), Some(0));+ assert_eq!(Node::directory("empty").largest_child(), None);+ }++ #[test]+ fn find_reports_crumbs_and_is_case_insensitive() {+ let mut root = Node::directory("root");+ let mut target = Node::directory("target");+ target.children.push(leaf("needle-file", 1));+ root.children.push(target);++ let (crumbs, found) = root.find("NEEDLE").expect("found");+ assert_eq!(crumbs, vec![0, 0]);+ assert_eq!(&*found.name, "needle-file");+ assert!(root.find("").is_none());+ assert!(root.find("absent").is_none());+ }++ #[test]+ fn depth_counts_edges() {+ let mut root = Node::directory("root");+ let mut nested = Node::directory("child");+ nested.children.push(leaf("deep", 1));+ root.children.push(nested);+ assert_eq!(root.depth(), 2);+ assert_eq!(leaf("x", 0).depth(), 0);+ }+}diff --git a/crates/disktree-core/src/treemap.rs b/crates/disktree-core/src/treemap.rsnew file mode 100644index 0000000..c5dc2d7--- /dev/null+++ b/crates/disktree-core/src/treemap.rs@@ -0,0 +1,617 @@+//! Squarified treemap layout.+//!+//! Bruls, Huizing and van Wijk's squarified algorithm: grow a row of tiles+//! while the worst aspect ratio inside it keeps improving, then start a new row+//! in the remaining space. That is what produces the legible mosaic of+//! KDirStat-style explorers instead of the slivers a naive slice-and-dice+//! gives.+//!+//! Layout runs in pixels, in the coordinate space of an unzoomed viewport. The+//! view applies its own pan and zoom when painting, so re-layout is only needed+//! when the tree, the viewport size, or the requested depth changes.++use crate::tree::{Metric, Node};++/// An axis-aligned rectangle in viewport pixels.+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub struct Rect {+ pub x: f32,+ pub y: f32,+ pub w: f32,+ pub h: f32,+}++impl Rect {+ pub const fn new(x: f32, y: f32, w: f32, h: f32) -> Self {+ Self { x, y, w, h }+ }++ pub fn right(&self) -> f32 {+ self.x + self.w+ }++ pub fn bottom(&self) -> f32 {+ self.y + self.h+ }++ pub fn area(&self) -> f32 {+ (self.w.max(0.0)) * (self.h.max(0.0))+ }++ pub fn contains(&self, x: f32, y: f32) -> bool {+ x >= self.x && x < self.right() && y >= self.y && y < self.bottom()+ }++ /// Shrink on every side, never past empty.+ #[must_use]+ pub fn inset(&self, padding: f32) -> Self {+ let w = padding.mul_add(-2.0, self.w).max(0.0);+ let h = padding.mul_add(-2.0, self.h).max(0.0);+ Self::new(self.x + padding, self.y + padding, w, h)+ }++ #[must_use]+ pub fn scaled(&self, scale: f32) -> Self {+ Self::new(+ self.x * scale,+ self.y * scale,+ self.w * scale,+ self.h * scale,+ )+ }++ #[must_use]+ pub fn translated(&self, dx: f32, dy: f32) -> Self {+ Self::new(self.x + dx, self.y + dy, self.w, self.h)+ }+}++/// What a tile stands for.+#[derive(Clone, Debug, PartialEq, Eq)]+pub enum TileKind {+ /// A real node at `crumbs`, which are child indices from the scanned root.+ Node { crumbs: Vec<usize> },+ /// The tail of a long child list, merged so its area is still accounted+ /// for instead of silently dropped.+ Others { crumbs: Vec<usize>, count: usize },+}++/// One rectangle of the mosaic.+#[derive(Clone, Debug)]+pub struct Tile {+ pub kind: TileKind,+ pub rect: Rect,+ /// Nesting level: 0 tiles are children of the current root.+ pub depth: u32,+ /// The band this directory reserved for its own name, when it is+ /// subdivided. Its children are laid out below it, so a parent's name+ /// never sits on top of a child — and the band is part of the parent for+ /// hit-testing, which makes a parent reachable without aiming at its+ /// border.+ pub header: Option<Rect>,+}++impl Tile {+ pub fn crumbs(&self) -> &[usize] {+ match &self.kind {+ TileKind::Node { crumbs } | TileKind::Others { crumbs, .. } => {+ crumbs+ }+ }+ }+}++/// How much of the tree to draw, and how finely.+#[derive(Clone, Debug, PartialEq)]+pub struct LayoutOptions {+ /// Nesting levels drawn at once; 1 draws only the root's children.+ pub max_depth: u32,+ /// Gap between siblings and inset into a parent: what makes nesting+ /// visible without a colour legend.+ pub padding: f32,+ /// Tiles below this many pixels are dropped; they cannot be read or hit.+ pub min_tile: f32,+ /// Children kept per directory. The tail merges into one `Others` tile.+ pub max_children: usize,+ /// Height of the band a subdivided directory keeps for its own name.+ pub header: f32,+}++impl Default for LayoutOptions {+ fn default() -> Self {+ Self {+ max_depth: 3,+ padding: 2.0,+ min_tile: 5.0,+ max_children: 96,+ header: 17.0,+ }+ }+}++/// Lay out everything beneath `root` inside `area`.+///+/// `root_crumbs` is where `root` sits in the scanned tree. Every tile's+/// crumbs extend it, so they always address the scanned tree, never the node+/// being drawn: a caller that resolves a tile from the scanned root gets that+/// tile, at any depth.+pub fn layout(+ root: &Node,+ root_crumbs: &[usize],+ area: Rect,+ metric: Metric,+ options: &LayoutOptions,+) -> Vec<Tile> {+ let mut tiles = Vec::new();+ let mut crumbs = root_crumbs.to_vec();+ place_children(root, area, metric, options, 0, &mut crumbs, &mut tiles);+ tiles+}++fn place_children(+ node: &Node,+ area: Rect,+ metric: Metric,+ options: &LayoutOptions,+ depth: u32,+ crumbs: &mut Vec<usize>,+ out: &mut Vec<Tile>,+) {+ if node.children.is_empty() || area.w <= 0.0 || area.h <= 0.0 {+ return;+ }++ // Rank by importance ourselves: the tree is already sorted, but a metric+ // switch or a hand-built tree must not produce a bad layout.+ let mut ranked: Vec<(usize, f64)> = node+ .children+ .iter()+ .enumerate()+ .map(|(index, child)| (index, child.value(metric) as f64))+ .filter(|(_, value)| *value > 0.0)+ .collect();+ if ranked.is_empty() {+ return;+ }+ ranked.sort_by(|left, right| right.1.total_cmp(&left.1));++ let kept = ranked.len().min(options.max_children);+ let mut values: Vec<f64> =+ ranked[..kept].iter().map(|(_, value)| *value).collect();+ let mut sources: Vec<Option<usize>> = ranked[..kept]+ .iter()+ .map(|(index, _)| Some(*index))+ .collect();+ let tail_count = ranked.len() - kept;+ if tail_count > 0 {+ values.push(ranked[kept..].iter().map(|(_, value)| *value).sum());+ sources.push(None);+ }++ for (slot, raw) in squarify(&values, area).iter().enumerate() {+ let rect = raw.inset(options.padding);+ if rect.w < options.min_tile || rect.h < options.min_tile {+ continue;+ }+ let Some(index) = sources[slot] else {+ out.push(Tile {+ kind: TileKind::Others {+ crumbs: crumbs.clone(),+ count: tail_count,+ },+ rect,+ depth,+ header: None,+ });+ continue;+ };++ let child = &node.children[index];+ let subdividable = child.is_dir() && depth + 1 < options.max_depth;+ // A directory that is about to be subdivided claims a header band for+ // its own name. When there is no room for one it stays whole: a name+ // drawn over its own children is worse than one level less of detail,+ // and zooming in gives it the room back.+ let header = subdividable+ .then(|| header_band(rect, options, depth))+ .flatten();+ crumbs.push(index);+ out.push(Tile {+ kind: TileKind::Node {+ crumbs: crumbs.clone(),+ },+ rect,+ depth,+ header,+ });+ if let Some(header) = header {+ let body = Rect::new(+ rect.x,+ header.bottom(),+ rect.w,+ rect.bottom() - header.bottom(),+ );+ place_children(+ child,+ body,+ metric,+ options,+ depth + 1,+ crumbs,+ out,+ );+ }+ crumbs.pop();+ }+}++/// The band a directory keeps for its name, or `None` when the tile is too+/// small to leave its children a usable area below it.+///+/// Deeper levels get a slimmer band: their names are shorter and their tiles+/// are smaller.+fn header_band(+ rect: Rect,+ options: &LayoutOptions,+ depth: u32,+) -> Option<Rect> {+ let height = (depth as f32)+ .mul_add(-1.5, options.header)+ .max(options.header * 0.6);+ let body = rect.h - height;+ if rect.w < 44.0 || body < options.min_tile * 3.0 {+ return None;+ }+ Some(Rect::new(rect.x, rect.y, rect.w, height))+}++/// Split `area` into one rectangle per value, proportional to it.+///+/// Returned in the order of `values`, not in layout order.+pub fn squarify(values: &[f64], area: Rect) -> Vec<Rect> {+ let mut rects = vec![Rect::default(); values.len()];+ let total: f64 = values.iter().filter(|value| **value > 0.0).sum();+ if total <= 0.0 || area.w <= 0.0 || area.h <= 0.0 {+ return rects;+ }++ let mut order: Vec<usize> =+ (0..values.len()).filter(|i| values[*i] > 0.0).collect();+ order.sort_by(|left, right| values[*right].total_cmp(&values[*left]));++ let scale = f64::from(area.w) * f64::from(area.h) / total;+ let areas: Vec<f64> =+ order.iter().map(|index| values[*index] * scale).collect();++ let mut free = area;+ let mut start = 0;+ while start < areas.len() {+ let side = f64::from(free.w.min(free.h));+ let mut end = start + 1;+ let mut row_sum = areas[start];+ let mut row_worst = worst_ratio(&areas[start..end], row_sum, side);++ while end < areas.len() {+ let candidate_sum = row_sum + areas[end];+ let candidate_worst =+ worst_ratio(&areas[start..=end], candidate_sum, side);+ if candidate_worst > row_worst {+ break;+ }+ row_sum = candidate_sum;+ row_worst = candidate_worst;+ end += 1;+ }++ if free.w >= free.h {+ // A vertical strip on the left; tiles stack top to bottom.+ let strip_w = (row_sum / f64::from(free.h)) as f32;+ let strip_w = strip_w.min(free.w);+ let mut y = free.y;+ for index in start..end {+ let height = if strip_w > 0.0 {+ (areas[index] / f64::from(strip_w)) as f32+ } else {+ 0.0+ };+ let height = height.min(free.bottom() - y).max(0.0);+ rects[order[index]] = Rect::new(free.x, y, strip_w, height);+ y += height;+ }+ free.x += strip_w;+ free.w -= strip_w;+ } else {+ // A horizontal strip along the top; tiles run left to right.+ let strip_h = (row_sum / f64::from(free.w)) as f32;+ let strip_h = strip_h.min(free.h);+ let mut x = free.x;+ for index in start..end {+ let width = if strip_h > 0.0 {+ (areas[index] / f64::from(strip_h)) as f32+ } else {+ 0.0+ };+ let width = width.min(free.right() - x).max(0.0);+ rects[order[index]] = Rect::new(x, free.y, width, strip_h);+ x += width;+ }+ free.y += strip_h;+ free.h -= strip_h;+ }+ start = end;+ }+ rects+}++/// Worst (largest) aspect ratio in a row of `areas` laid along `side`.+fn worst_ratio(areas: &[f64], row_sum: f64, side: f64) -> f64 {+ if row_sum <= 0.0 || side <= 0.0 {+ return f64::INFINITY;+ }+ let thickness = row_sum / side;+ areas.iter().fold(0.0_f64, |worst, area| {+ if *area <= 0.0 || thickness <= 0.0 {+ return worst;+ }+ let other = area / thickness;+ let ratio = (thickness / other).max(other / thickness);+ worst.max(ratio)+ })+}++/// The deepest tile containing a point.+///+/// Children are emitted after their parent and are inset inside it, so the last+/// match in reverse order is the most specific one.+pub fn hit(tiles: &[Tile], x: f32, y: f32) -> Option<&Tile> {+ tiles.iter().rev().find(|tile| tile.rect.contains(x, y))+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::tree::NodeKind;++ fn file(name: &str, bytes: u64) -> Node {+ Node::entry(name, NodeKind::File, bytes)+ }++ /// A directory whose direct contents are the given children, so aggregate+ /// totals are consistent before layout runs.+ fn dir(name: &str, children: Vec<Node>) -> Node {+ let mut node = Node::directory(name);+ node.children = children;+ crate::tree::aggregate(&mut node, Metric::Bytes);+ node+ }++ fn area() -> Rect {+ Rect::new(0.0, 0.0, 800.0, 500.0)+ }++ #[test]+ fn squarify_fills_the_area() {+ let values = [40.0, 30.0, 20.0, 5.0, 3.0, 2.0];+ let rects = squarify(&values, area());+ let covered: f32 = rects.iter().map(Rect::area).sum();+ assert!(+ (covered - area().area()).abs() < 1.0,+ "covered {covered} of {}",+ area().area()+ );+ for rect in &rects {+ assert!(rect.x >= -0.01 && rect.y >= -0.01);+ assert!(rect.right() <= area().right() + 0.01);+ assert!(rect.bottom() <= area().bottom() + 0.01);+ }+ }++ #[test]+ fn squarify_keeps_aspect_ratios_reasonable() {+ // Same distribution as the canonical squarify example: 6, 6, 4, 3, 2, 2,+ // 1 on a 6x4 canvas.+ let values = [6.0, 6.0, 4.0, 3.0, 2.0, 2.0, 1.0];+ let rects = squarify(&values, Rect::new(0.0, 0.0, 600.0, 400.0));+ for rect in &rects {+ let ratio = (rect.w / rect.h).max(rect.h / rect.w);+ assert!(ratio <= 4.0, "aspect ratio {ratio} in {rect:?}");+ }+ }++ #[test]+ fn squarify_survives_degenerate_input() {+ assert_eq!(squarify(&[], area()).len(), 0);+ assert!(+ squarify(&[0.0, 0.0], area())+ .iter()+ .all(|r| r.area().abs() < f32::EPSILON)+ );+ assert!(+ squarify(&[1.0], Rect::new(0.0, 0.0, 0.0, 10.0))[0]+ .area()+ .abs()+ < f32::EPSILON+ );+ }++ #[test]+ fn layout_nests_children_inside_their_parent() {+ // Depth first, parent before its own children: that order is what lets+ // the view paint in sequence and hit-test in reverse.+ let root = dir(+ "root",+ vec![+ dir("big", vec![file("inside", 100), file("also", 50)]),+ file("small", 10),+ ],+ );++ let tiles = layout(+ &root,+ &[],+ area(),+ Metric::Bytes,+ &LayoutOptions::default(),+ );+ let crumbs: Vec<&[usize]> = tiles.iter().map(Tile::crumbs).collect();+ assert_eq!(crumbs, vec![&[0][..], &[0, 0], &[0, 1], &[1]]);++ let parent = &tiles[0];+ let child = &tiles[1];+ assert_eq!(child.depth, 1);+ assert!(parent.rect.contains(child.rect.x, child.rect.y));+ assert!(+ parent+ .rect+ .contains(child.rect.right() - 0.5, child.rect.bottom() - 0.5)+ );+ }++ #[test]+ fn layout_depth_one_stops_at_direct_children() {+ let root = dir("root", vec![dir("big", vec![file("inside", 100)])]);++ let options = LayoutOptions {+ max_depth: 1,+ ..LayoutOptions::default()+ };+ let tiles = layout(&root, &[], area(), Metric::Bytes, &options);+ assert_eq!(tiles.len(), 1);+ assert_eq!(tiles[0].crumbs(), &[0]);+ }++ #[test]+ fn a_subdivided_directory_keeps_a_header_for_its_own_name() {+ let root = dir(+ "root",+ vec![dir("big", vec![file("inside", 100), file("also", 50)])],+ );+ let tiles = layout(+ &root,+ &[],+ area(),+ Metric::Bytes,+ &LayoutOptions::default(),+ );++ let parent = tiles+ .iter()+ .find(|tile| tile.crumbs() == [0])+ .expect("the parent tile");+ let header = parent.header.expect("a parent keeps a header");+ assert!(header.w > 0.0 && header.h > 0.0);+ assert!(+ (header.y - parent.rect.y).abs() < f32::EPSILON,+ "the band sits at the top of its tile"+ );+ assert!(header.bottom() <= parent.rect.bottom());++ // Every descendant starts below the band, so no child is drawn under+ // the parent's name.+ for tile in tiles.iter().filter(|tile| tile.crumbs().len() > 1) {+ assert!(+ tile.rect.y >= header.bottom() - f32::EPSILON,+ "{:?} overlaps the header",+ tile.crumbs()+ );+ }++ // And the band belongs to the parent for hit-testing.+ let centre = (header.x + header.w / 2.0, header.y + header.h / 2.0);+ let hit_tile = hit(&tiles, centre.0, centre.1).expect("a hit");+ assert_eq!(hit_tile.crumbs(), &[0]);+ }++ #[test]+ fn a_tile_without_room_for_a_header_stays_whole() {+ let root = dir("root", vec![dir("big", vec![file("inside", 100)])]);+ let options = LayoutOptions {+ // A band this tall leaves no usable body under it.+ header: 400.0,+ min_tile: 150.0,+ ..LayoutOptions::default()+ };+ let tiles = layout(&root, &[], area(), Metric::Bytes, &options);+ assert_eq!(tiles.len(), 1, "the child was not subdivided");+ assert!(tiles[0].header.is_none(), "and it has no band of its own");+ }++ #[test]+ fn tile_crumbs_address_the_scanned_tree_not_the_drawn_node() {+ // Draw the node at [3, 1] of some larger tree: its tiles must be+ // [3, 1, …], or anything resolving them from the scanned root would+ // find a stranger.+ let node = dir("inner", vec![file("a", 10), file("b", 5)]);+ let tiles = layout(+ &node,+ &[3, 1],+ area(),+ Metric::Bytes,+ &LayoutOptions::default(),+ );+ assert!(!tiles.is_empty());+ for tile in &tiles {+ assert!(tile.crumbs().starts_with(&[3, 1]), "{:?}", tile.crumbs());+ assert_eq!(tile.crumbs().len(), 3);+ }+ }++ #[test]+ fn a_leaf_never_claims_a_header() {+ let root = dir("root", vec![file("solo", 10)]);+ let tiles = layout(+ &root,+ &[],+ area(),+ Metric::Bytes,+ &LayoutOptions::default(),+ );+ assert!(tiles.iter().all(|tile| tile.header.is_none()));+ }++ #[test]+ fn layout_merges_the_child_tail_into_one_tile() {+ let children: Vec<Node> = (0..10)+ .map(|index| file(&format!("f{index}"), 10 - index))+ .collect();+ let root = dir("root", children);+ let options = LayoutOptions {+ max_children: 4,+ ..LayoutOptions::default()+ };+ let tiles = layout(&root, &[], area(), Metric::Bytes, &options);+ let others: Vec<&Tile> = tiles+ .iter()+ .filter(|tile| matches!(tile.kind, TileKind::Others { .. }))+ .collect();+ assert_eq!(others.len(), 1);+ assert!(matches!(others[0].kind, TileKind::Others { count: 6, .. }));+ }++ #[test]+ fn hit_returns_the_deepest_tile() {+ let root = dir(+ "root",+ vec![dir("big", vec![file("inside", 100)]), file("small", 1)],+ );++ let tiles = layout(+ &root,+ &[],+ area(),+ Metric::Bytes,+ &LayoutOptions::default(),+ );+ let child = tiles+ .iter()+ .find(|tile| tile.crumbs() == [0, 0])+ .expect("child tile");+ let centre = (+ child.rect.x + child.rect.w / 2.0,+ child.rect.y + child.rect.h / 2.0,+ );+ let found = hit(&tiles, centre.0, centre.1).expect("a hit");+ assert_eq!(found.crumbs(), &[0, 0]);+ assert!(hit(&tiles, -50.0, -50.0).is_none());+ }+}