[thisisgm]

Stacked on #26: its eighteen commits come first here, the last twenty are this pull request's, and I will rebase it as soon as #26 lands.

Ten changes to search (/), one commit each with its own tests: a search no longer asks the disk about every file, later keys are answered from memory and still find a file made since, the best matches come first, a query can follow the path, one typo is forgiven, a very large folder shows matches while it is still read, Select All and a refresh reach the matches past the first window, a search goes on answering while it is read again, and the status in the search field leaves room for the query in a narrow pane. An eleventh commit answers the review: a path typed out exactly is found when folding its letters makes it longer than it is stored. Four more answer a second one: a search reads at most 2,000,000 names, the nearest folders first, and the field then says how many it read; no link is followed on the way to a folder; a capital starts a word in a name that has letters past ASCII; and the index's numbers have names. The last one is tests only: the cases that hold a walk pass on a machine with one processor, none rests on the folder watcher's timer, and one more lands an answer that the end of a walk overtook. The newest commit takes out a pause: the field waited for 150 ms without a key before it asked, and it now asks at every key. The last two take out a flicker while typing: the selection and the cursor change in the frame an answer is drawn and not before, the cursor stays on the best match, the end of a search puts it back on the item it left, and a folder's item count stays on screen from one answer to the next. One more answers the review of those two: a selection made again after a key, with nothing changed (Select All pressed a second time), is kept when the answer lands. The suite goes from 236 to 276 tests. No library, depends or optdepends entry is added, and nothing runs when no search is open: no index is kept on disk and nothing is read ahead of the first key.

What you'd notice

• Each key answers at once. Every key walked the whole tree again and asked the disk about every file on the way. The first key now walks the tree once, reading names and types from the directory alone, and later keys are answered from those names in memory. The names are let go when the search closes, the folder changes or it is read again. The field kept a 150 ms wait from the days when every key walked the tree, and asked only once the typing paused. That wait is gone: the field asks at each key, so the results follow the typing.
• No flicker while typing. A key cleared the selection at once, a frame or two before its answer was drawn, so the highlighted row blinked. Each answer left the cursor on the item or the row it had been on, which scrolled the list away from the best match, and Escape showed the folder a frame before its cursor. Folder counts (3 items) went out for a frame at every key and came back. Now the selection changes in the frame the new rows are drawn, the cursor is on the first row of each answer until it is moved to another item, Escape shows the folder with the cursor back on the item it left in the same frame, and a folder that was already listed keeps its count on screen while it is counted again. A folder that was not on screen before still gets its count after its row, as it does when any folder opens. Showing or hiding hidden files clears the counts at once, since a count made the other way is wrong, and the folders are counted again.
• The best matches come first. Results came in name order and stopped at 1,000. They are now ranked: the exact name, then a name or a word that starts with the query, then its letters in order. Rows arrive 350 at a time as the view scrolls, and the field says how many matched.
• A query can follow the path. editor/src/render found nothing, since only names were compared. The folders above a row now take as much of the query as they can and the name takes the rest. A name that holds the query still comes first.
• One typo is forgiven. redner for render found nothing. When no name spells the query, names one edit away are listed (two for long words), ahead of names that only hold its letters scattered in order. Digits are never edited, and a query that some name spells out never pays for this.
• A very large folder answers while it is read. On a very large tree the first key waited for the whole walk. After a short hold the best matches read so far are shown and refreshed until the walk lands, and the field says it is still reading.
• Select All takes every match, and a refresh keeps them. With rows arriving 350 at a time, Select All takes the matches that are not rows yet by path, at once, from the answer in memory: a copy or a delete pressed next acts on all of them, and the rows still arrive as the view scrolls. A search that is read again (a file changed, or F5) shows as many rows as it did and keeps what is selected while it still matches, and the partial answers shown while a large tree is read again drop nothing from the selection: a copy or a delete pressed then still names every selected file, found again or not yet, and the rows come back as many as they were. A row selected while the new answer is on its way stays selected too, among the rows shown or past them. The names are read under the search's lock and the disk is asked with the lock let go, so Select All never waits on the disk.
• A later key finds what was made since. Later keys were answered from the names read at the first key alone, and only the searched folder itself is watched, so a file made in a subfolder afterwards stayed missing until the search was closed. A later key is still answered from memory at once; the folders are then read again behind the answer, off the UI thread, and the new answer takes over when it is whole.
• A search read again keeps answering. A change on disk or F5 walked the folders again from nothing, so a search that had landed fell back to partial answers and a partial count. It now answers from the walk it has until the new one has answered, then takes the new one. One walk runs at a time: a change that comes during a walk is read once that walk is whole, so a folder that keeps changing never starves the answer. Showing or hiding hidden files starts the search over. Select All takes every match while a large tree is still being read, and under any sort, not only best first. Sorted another way, a list cut to the best 1,000 matches says so in the path bar, with how many matched.
• The query stays readable in a narrow pane. The status at the end of the search field says where it searches and how many matched. It was drawn at its full width, and the field's padding was that width, so in a split window or a narrow one it ran out of the field and over the query. It is now cut short with an ellipsis before the query has less than 160 pixels, and not drawn in a field with no room for it at all. In a field with room for both nothing changes.

Numbers

Measured on a Linux server with a small driver that links the same sources and types into the same model the window uses, on a folder tree of 100,000 files, warm cache, two runs of ten timings a query after two warm-ups. Times are from the key to the rows being ready.

Query	main	this branch
The walk	inside every query below	41.1 to 42.1 ms, once, at the first key
An exact name, render_frame.rs	69.8 to 74.3 ms	under 0.1 ms
One typo, redner_frame.rs	69.0 to 75.0 ms, nothing found	11.6 to 13.0 ms, the file found
Along the path, editor/src/components/render	66.0 to 71.6 ms, nothing found	under 0.1 ms, the file found
A deep path, archive/2024/client/reports/quarterly	63.8 to 68.5 ms, nothing found	under 0.1 ms, the file found
An extension, .svg, 6,458 matches	20.6 to 23.9 ms, stops at the first 1,000	3.3 to 3.5 ms, all counted, the best 350 shown

On main every key pays for the walk again, so its times are a walk and a compare. On the branch the walk is paid once, and a key is a pass over the names in memory. The typo pass is the slow one, since it runs only after that pass found no name that spells the query. The tree takes 7.0 MB while the search is open.

Screenshots

Each picture is main above and this branch below, in the list view, on the same small source tree.

render: main lists by name, the branch ranks the folder and the exact names first and counts the matches.

editor/src/render: a path query.

redner: one typo.

A window split in two panes, render typed in the right one: this branch before its last commit above, with it below.

Tests

Forty new cases, each failing without its commit: a search asks the disk only about the folders it enters and the rows it shows; a later key is answered before any folder is read again; a file made since the folders were read is found at the next key; the exact name, a name or a word that starts with the query, and scattered letters come in that order; rows arrive a window at a time while the count is whole; a query follows the folders above a name; a typo is forgiven only when no name spells the query, and ranks above scattered letters; a tree still being read shows the matches found so far; Select All selects all 500 of 500 matches at once when 350 are shown, and names them all; a search read again keeps the 500 rows it showed and the selection at row 420; it keeps what Select All took past the rows, less a file that is gone; and through the partial answers of a tree being read again all 500 selected files stay selected and named, and the 500 rows come back; Select All while a tree is still read takes every match found so far; a search that landed keeps its rows and its count while it is read again, also while a download keeps changing the folder; Select All under another sort takes every match; what Select All names is whole by the time the selection says it changed; a search that is cleared forgets how many matched; a match gone from the disk since the walk still has its row; a change during the first walk is read once that walk is whole; a walk made again takes over only when it has answered; Select All after a key taken back takes every match; a row selected while a search is read again stays selected when the new answer leaves it past the rows shown; hiding hidden files starts the search over; a search that ends stops its second walk; the path bar says how many matched and how many are shown, whatever the folder is called; and the status in a narrow field is cut short so the query keeps its room, mirrored too, changes the field's padding and never its width, and is not drawn in a field with no room for it; a path whose letter grows when it is folded is found typed out, as a folder's name and as a file's, while a path in ASCII too short for the query is still ruled out before a folder is read. A tree of more names than a search keeps is read up to that many, the nearest, and the field says how many were read, beside how many rows are shown when the list is cut too; a folder swapped for a link while its own folders wait is not read through; a folder searched through a link that is turned elsewhere mid-read stays the tree it was; and büro finds MeinBüro.txt ahead of xbüro.txt. A key typed in the search field is the query at once, with no pause waited out; and keys typed while the first walk still reads start no walk beside it, are read once more together when it ends, and what lands is the answer to the last of them, with no earlier key's answer shown on the way; a key leaves the selection alone until its answer lands, and what was selected since is kept, also when it is the same selection asked for again, and is still cut to what the answer matches; the end of a search shows the folder and says so in one turn; in the window, the cursor is on the first row of each answer, follows a better match found later, stays with an item it was moved to, and is back on the item it left when the search ends; and a folder two answers list shows its count in the turn the second lands, is counted again all the same, and never shows a count made with hidden files the other way. Every commit builds and passes the suite on its own, also with TMPDIR set to a folder whose name has a space, where only extractRefusesWhatWouldLandOutside fails, as it does on main.

Limits

• The names of a tree are held in memory while its search is open: about 70 bytes a file on the tree above.
• A search reads at most 2,000,000 names (about 140 MB at that rate), the nearest folders first. Of a bigger tree the field says N matches in X and below, only the nearest 2,000,000 items read.
• Folders are opened with openat2, so the walk needs Linux 5.6 or later.
• Each later key walks the tree again behind its answer, on the thread pool: one walk at a time, and keys typed during a walk ask for one more between them.
• A typo is looked for in names only, not along the path, and only when no name spells the query.

[greptile-apps]

Confidence Score: 5/5

[Medium impact] The latest changes appear safe to merge; the previous selection-loss issue is addressed.

Summary

The PR adds ranked search, path matching, typo support, and answers from names held in memory.

• Search finds and ranks matches from names and paths.
• Search keeps selected matches and places the cursor with the results.
• The search field shows useful status without hiding the query.
• Folder views read file details as the visible rows need them.
• Sidebar lists notify the view only when their own contents change.
• Theme rounding follows Hyprland changes while the app is open.

_{Reviews (20) · Last reviewed commit: "Keep a selection made again after a sear..." · Reviewed by Greptile}