disk: a disk-space treemap on intuiTUIve¶

Round 1: diskonaut¶

The clone is examples/disk.rs, a rebuild of diskonaut (Aram Drevekenin, MIT; tui-rs with crossterm, jwalk for the scan). It is one screen and a few boxes over it, so the round covers all of it.

What was built (1,395 lines after rustfmt: about 170 the folder tree and the scan, 200 the treemap's layout, 50 moving between tiles, 100 sizes and text fitting, 160 the app's state and actions, 490 the screen, 180 options and the app; tests 710 lines in tests/disk.rs, 21 tests):

• The map: the current folder's children as tiles sized by the space they take, largest first, squarified with diskonaut's rules (a tile at least 8 columns by 3 rows, a cell counted 2.5 times as tall as wide), each tile's name (a folder's with / and (+n descendants) or (+n), cut in the middle as long[...]name) and size with its share (78.1K (46%), shorter forms when narrow), the items too small for a tile grouped in a block of x at the bottom right with diskonaut's legend (x = Small files), and "Folder is empty". The tiles are panels in rows and columns with collapse_borders(), so the lines join (┬ ┴ ├ ┤) as diskonaut's do. The selected tile is filled (blue for a folder, grey with magenta text for a file).
• Drawn while scanning: the scan runs on a thread (spawn_stream) walking with rs-rich-ext's listing::walk (hidden entries included, links not followed) and sends entries in batches; the map grows as they arrive, the title says Scanning: 58.6K (2 files) with a bold marker running along it, the status line shows the path read last, and the key legend leaves out delete. Sizes are blocks on disk (du's) or, with -a, the length.
• The title: Total: 171.5K (13 files), freed: 0 | /base/sub (78.1K, 2 files) (+1 larger file(s), zoom out to show), each part as long as the width allows (diskonaut's "telescope"), (failed to read n files) and (CAUTION: running as root) in red, the total lit yellow for 250 ms after a delete, the path red for 250 ms after Esc at the top.
• Keys, diskonaut's: arrows, hjkl and Ctrl+F/B/N/P move to the tile on that side sharing the most edge (off the map: nothing selected; with nothing selected: the first); Enter enters the selected folder (the largest when nothing is selected); Esc goes up, the selection and zoom restored; +/-/0 zoom past the largest items; Backspace (and Ctrl+D, which the original does not have) deletes after "Delete this file?" / "Delete folder with n children?" with the path and (y/n), "Deleting" while it runs on a thread, an error box when it fails; during the scan it says "Can't delete while scanning" (the variant that fits, any key dismisses); q and Ctrl+C ask "Are you sure you want to quit?"; -d deletes without asking.
• A small window (under 50 x 15): "Terminal window is too small ¯\_(ツ)_/¯", or a shorter form; only q and Ctrl+C work there.

Tests scan a temporary folder written with known sizes (apparent sizes) and assert the tiles' labels, the joined frame, the small items' block and legend, movement, entering and leaving, zoom, deleting (the file is gone and freed: grows), the failed delete, the quit box and the small window. The live scan is tested with a Walker the test feeds one entry at a time; the model (squarify covering the map exactly once, shares, the small block, equal empty files, movement on hand-made tiles) without the app.

Bespoke: no Widget. The squarify (about 120 lines) and the directional movement (about 40) are the clone's own: there is no treemap layout and no spatial navigation to use. Both are gaps below. The title, status and key lines pick the longest form that fits in the clone's code (fit, the title's parts), a third gap.

Left out or changed: diskonaut's parallel scan (jwalk on rayon; this walk is single-threaded); its rule for the small items' block (a rectangle from the first unrenderable tile's corner, which may cut into a strip; here the block is what is left after the last strip that fits, with two cells kept for it when items remain); diskonaut's exact loading indicator (a few letters in bold running along the title, approximated); Windows' resize handling. Fixed on the way: diskonaut pushes a history entry when Enter lands on a file, so a later Esc restores the wrong selection; and it counts a deleted folder's descendants but not the folder itself.

New gaps and bugs¶

Friction with the existing APIs¶

• place works only in layers. The too-small message is a layers([text(..).place(Center, Center)]) of one layer; on a plain node .place does nothing, silently.
• A collapsed child's size counts the shared line. In row([a.fixed(5), b]).collapse_borders() the next panel starts at column 4. Natural once known, but not in the guide; a treemap's (x, w) from line to line becomes .fixed(w + 1).
• each sizes its children as rows: a child with no size is one row tall, so the rebuilt map needs .fixed(rows) from the viewport, read untracked when the child is built (a resize changes the key through the map's memo, which rebuilds it).
• .style() on a panel fills its border too. The selected tile's fill goes on the panel's content instead, so the joined frame stays in the border colour. The frame is border_style("default"): the dark theme's border is blue, diskonaut's lines are the terminal's.
• Testing a scan fed from the test's thread. wait_for_tasks(true) would wait on a stream that waits on the test, so the live-scan test runs without it and polls (advance, a 10 ms sleep, look again). Driver::until(|d| .., timeout) would say that once.
• Signals and handlers worked well. The whole state is a Copy struct of signals and one memo (the map, from the tree, the folder, the zoom and the viewport); after gives the 250 ms flashes, spawn the delete with its "Deleting" box (a switch on a signal inside the modal), cx.modal_with every box, and the headless driver with wait_for_tasks(true) makes the scan and the delete deterministic.

Components that would help¶

Round 2: rebuilt on round 6¶

examples/disk.rs went from 1,395 lines to 1,192 (tests 710 to 709, 21 tests, all passing unchanged but for two lines noted below).

Replaced¶

Still hand-built, and why¶

• The joined frame from tiles (joined). The treemap node places each tile at its rectangle, but tiles that are panels do not share their lines (collapsing is row/column/grid only), so diskonaut's look (┬ ┴ ├ ┤) would become doubled lines. The clone lays the tiles out with squarify and turns them into a collapsed grid instead, and rebuilds the whole map (keyed) when the selection moves.
• A workaround for squarify's rest (12 lines): see the bug below.
• The folder tree and the scan (Tree, Folder, disk_walker, the batching in scan): no weighted tree, disk-usage plugin or batched stream yet (round 1's gaps, still open).
• The selection stays a Signal<Option<usize>> beside the map, not the focus: diskonaut has "nothing selected" (and Enter then takes the largest folder), and the tiles are rebuilt on every move.
• Fill on the selected tile goes on the panel's content, as before.

Behaviour changes¶

• The layout is squarify's, not the clone's strips: the same folder gives slightly different tiles (on the test folder, movie.mp4 and docs now split their column evenly). The tests' moves still hold because the clone breaks ties as diskonaut does (the last).
• Names cut in the middle read long_na…me.txt (truncate_middle's …), not diskonaut's long[...]name; the clone's own truncate_middle test went with the function.
• The warning box shows the longest form that fits its real width ("Deletion is not allowed while scanning" in an 80-column window, where the clone guessed half the screen and showed "Can't delete while scanning"); the live-scan test now expects that. The component's choice is the better one: it fits what is there.
• The small-window message is one form (App::min_size takes a string), where the clone picked a shorter one on a narrow window.

New gaps¶

Round 1's open gaps: a weighted tree and the disk-usage plugin, a batched stream with a time flush, place working outside layers, and a confirm in the app's own look.

Bugs found¶

Fixed in 0.0.21 (2a36216): a rest too thin for a tile grows until it fits; the test is in tests/round7_bugs.rs, and the example's 12-line workaround is gone.

squarify drops every tile when the rest's tile is narrower than the minimum. The rest's own tile is held to min too; when it cannot be (a thin strip beside one large item), the loop lowers k to 0 and puts every item in the rest, so the largest item, 96% of the area, gets no tile and the whole map is the rest's block. The clone works around it (a strip of 3 rows for the rest, the others above). Minimal failing test:

#[test]
fn a_thin_rest_does_not_swallow_the_tiles() {
    use intuituive::layout::squarify;
    use intuituive::screen::Rect;
    let weights = [15000.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0];
    let map = squarify(Rect::new(0, 0, 79, 20), &weights, (8, 3), 2.5);
    // Fails: tiles[0] is empty and the rest is the whole rectangle.
    assert!(!map.tiles[0].is_empty(), "{map:?}");
}

The fix is probably to hold only the item tiles to min, or to grow the rest's weight until its tile fits, rather than fall back to k = 0.

Components that would help¶