From 1af098381515fbe3a4fe678cd023c7fd74418ae1 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Sat, 24 Oct 2026 12:43:02 -0300 Subject: Search converge 5/6: the old search pipeline phased out, the notice-band / for texts, Find/Grep prompts and walks on the loop, +Recent, n/N as Look-the-next-row; docs, tutor, Help and goldens to the query pane --- docs/helix-keys.md | 8 +- docs/typ/builtins-gui.json | 2 +- docs/typ/builtins-tty.json | 2 +- docs/typ/cheatsheet.typ | 6 +- docs/typ/guide.typ | 46 +++++- docs/typ/reference.typ | 28 ++-- src/Output.zig | 31 ++-- src/Query.zig | 176 +++++++++++++++------ src/builtins.zig | 41 ++--- src/config.zig | 7 +- src/fs.zig | 285 +---------------------------------- src/look.zig | 83 ++-------- src/ninep/ctl.zig | 50 +++--- src/normal.zig | 28 ++-- src/tagline.zig | 1 + src/tutor.txt | 16 +- test/output.zig | 9 ++ test/pdf.zig | 4 +- test/snapshots/builtins.snap | 23 +++ test/snapshots/dump.golden | 3 + test/snapshots/find.golden | 146 +++++++----------- test/snapshots/find.snap | 126 +++++----------- test/snapshots/fsearch.golden | 111 +++++++------- test/snapshots/fsearch.snap | 63 +++----- test/snapshots/grep.golden | 44 +++--- test/snapshots/grep.snap | 91 +++-------- test/snapshots/lookrange.golden | 47 +++--- test/snapshots/lookrange.snap | 22 ++- test/snapshots/lsp-client.golden | 23 +-- test/snapshots/lsp-client.snap | 11 +- test/snapshots/lspdebug.snap | 7 +- test/snapshots/lsprelpath.golden | 170 ++++++++++++--------- test/snapshots/lsprelpath.snap | 35 ++--- test/snapshots/msg.golden | 4 +- test/snapshots/msg.snap | 2 +- test/snapshots/stepgrain.golden | 123 ++++++++------- test/snapshots/stepgrain.snap | 59 ++------ test/snapshots/tagbottom.golden | 13 +- test/snapshots/tagbottomshort.golden | 38 ++--- test/snapshots/topbarexec.golden | 22 ++- 40 files changed, 858 insertions(+), 1148 deletions(-) diff --git a/docs/helix-keys.md b/docs/helix-keys.md index 8155685f..fa06c9a6 100644 --- a/docs/helix-keys.md +++ b/docs/helix-keys.md @@ -134,14 +134,14 @@ language-backend queries, and the shell pipe. | `Space` (normal, body) | starts the pardes LEADER: a key path runs the same builtin words used by tags and the topbar. The main groups are `f` files, `h` docs, `c` columns, `t` toggles/effects, `a` panel animations, `s` session, `j` jumps, `l` language, and `w` directional focus; `SPC ?` lists every path and ` ?` lists one group in `+Help`. Neither `Exit` (quits the editor, acme's Exit) nor `Kill` (stops the commands pardes typed into terminals, acme's Kill) has a leader path: both are the topbar's and the root `ctl`'s. The pending path appears on the active pane's transient body/message row. Esc or an unmapped key abandons it. Paths, Help rows, and dispatch are all generated from the builtin registry at comptime; the leader applies only to a BODY in normal mode because tags and tty programs own their input | pardes-specific; helix spends Space on pickers/LSP (section C), while pardes uses acme-style executable words | | `SPC y` `SPC Y` `SPC p` `SPC P` `SPC R` | helix's clipboard menu on helix's own letters: yank the selection to the system clipboard (`ClipYank`) or the PRIMARY selection alone (`ClipYankMain`), paste the system clipboard after (`ClipPaste`) / before (`ClipPasteBefore`) the selection, replace the selection with it (`ClipReplace`) | the same as `"+y`, `"+p`, `"+P`, `"+R`: register `+` (and `*`) IS the desktop's clipboard, the only register that reaches it. `SPC y` writes `+` alone, as helix's does, not the default register too. Builtins rather than bare chords because a leader path names a builtin: they land in Help's index and are executable words like every other verb. The clipboard holds one text, so N values go out joined by newlines, as helix sends them. On a tty the write is OSC 52 out and the READ is OSC 52 back, which many terminals refuse or gate — so `SPC y` works there and `SPC p` can be a no-op | out of corpus | | a paste from the OUTER terminal | one `Event.paste`, spliced in at the cursor | the tty shell enables bracketed paste and coalesces `paste_start`..`paste_end` into a single event; before that the bytes arrived as individual key presses and normal mode RAN them, which is how a pasted `d` deleted a line. The bytes deliberately never enter the yank register — clipboard and default register are separate stores in both directions | pardes-specific | -| `/` (any pane) | pardes' own plain-substring search into a `+Search` output buffer: the pattern is typed on a line of its own on the pane's notice band, Enter fills the buffer, and its rows are ordinary look targets. Enter also goes to the first row using `Pardes.lookFirstHit`, so `/foo` lands on the first hit with the matched span selected. A pattern that matched nothing opens its empty buffer and moves nothing | kept as-is; not in the corpus (helix `/` is regex search). Find and Grep answer with other files and deliberately do not jump. `LookNext` / `LookPrev` select subsequent result rows | pardes-specific | -| `n` / `N` | next / previous regex match in the current text, using the last search register; counts repeat and ends wrap | only the primary selection is replaced; in select mode each match is added and becomes primary. Named registers work. `*` sets the pattern from selections with word boundaries, `Alt-*` without. The former Look ring is `LookNext` / `LookPrev`, `SPC j n` / `SPC j p`. The change is bookmarked `pardes-nN-helix`; its predecessor is `pardes-nN-before-helix`. PDFs retain their location-result navigation | helix-verified | +| `/` (a text) | a query pane under the pane (`src/Query.zig`): a `+Search` whose line 1 is the query, typed into; helix's regex with smart case, every match tinted and ticked on the rail as you type (the pane's places, `src/Places.zig`), the first after the cursor selected (helix's incremental preview). `Ctrl-n`/`Ctrl-p` step while typing; Enter lands, fills `/` and keeps the rows as text; Esc while typing restores the text and closes the pane. Line 1's first word names the source (`/`, `Find`, `Grep`, `Recent`, `Panes`, `Symbols`, `All`, `Refs`, `Def`, `Impl`, `Diagnostics`), helix's pickers as one pane. A terminal's and a PDF's `/` keep the notice-band prompt and its `+Search` | helix's `/` semantics (regex, smart case, preview); the pane is pardes' | pardes-specific | +| `n` / `N` | next / previous match of the text's places when a query pane fed them (a `/`, a list's places in this text: refs, diagnostics, a Grep's hits), round the ends without a message; else the last search register's regex in the current text, as before; counts repeat | only the primary selection is replaced; in select mode each match is added and becomes primary. Named registers work. `*` sets the pattern from selections with word boundaries (`Alt-*` without) and seeds the text's query pane with it, the keyboard staying. The former Look ring is `LookNext` / `LookPrev`, `SPC j n` / `SPC j p`. PDFs retain their location-result navigation | helix-verified | | insert: printable text | file: real edit; terminal: typed run splice | | helix-verified (file) | | insert: `Enter` | newline; keeps the current full indent levels and adds one 4-space logical tab when the text before the cursor ends in `(`, `[`, `{`, or `)` (including `})`) | plain lines match `insert_newline`; delimiter heuristic is pardes-specific | helix-verified (plain) / pardes-specific (delimiter) | | insert: `Backspace` (+ `Shift-Backspace`) | delete prev char, joins lines at col 0; in a line's leading blanks, back to the previous 4-column indent stop (a whole unit when on one; a tab still goes alone) | matches `delete_char_backward` and its dedent; `Ctrl-h` alias in B | helix-verified | | insert: `Up` `Down` `Left` `Right` | move cursor | matches helix's "not recommended" insert arrows | helix-verified | -| `gd` `gD` `gy` `gi` `gr` | LSP definition / declaration / type-definition / implementation / references. One answer jumps straight there; several fill `+Search`, where `LookNext` / `LookPrev` walk and Enter opens | Ctrl+left-click is the mouse spelling of `gd`; language support depends on the configured backend | out of corpus | +| `gd` `gD` `gy` `gi` `gr` | LSP definition / declaration / type-definition / implementation / references. One answer jumps straight there; several (definition, implementation, references) fill the text's query pane, line 1 `Def`/`Impl`/`Refs`, their places in the text tinted and stepped by `n`/`N`; the others fill `+Search`, where `LookNext` / `LookPrev` walk and Enter opens | Ctrl+left-click is the mouse spelling of `gd`; language support depends on the configured backend | out of corpus | | `]d` `[d` / `]D` `[D` | step the diagnostics list / go to its last or first; if no list is up, asking the backend for one is part of the press | | out of corpus | | `=` | `format_selections` — writes a `- old` / `+ new` diff into `+Lsp` | deliberate divergence: the seam returns ROWS, not edits, so this SHOWS the formatting instead of applying it. Not in the corpus, so there is no waiver to name — the query leaves the core as an effect the headless harness has no shell to perform | out of corpus | | `Ctrl-o` / `Ctrl-i` | jumplist back / forward (also Mouse4 / Mouse5 in SDL, macOS and web); successful navigation clears selections in both panes and places the cursor at the saved location; raw tty forwards both to the child — the `Back` / `Forward` builtins, also on `SPC j o` / `SPC j i`, with `SPC j l` rendering the stack as a buffer; a closed file's entry stays, marked `(closed)`, and a jump to it opens the file again at its place | helix binds both keys (`jump_backward` / `jump_forward`) but to a POSITION jumplist; pardes' stack is over panes and focus, so the keys agree and the semantics do not. `Ctrl-i` and Tab are the same byte under the legacy encoding; there Tab keeps meaning execute, and the pair only separates where the host speaks the kitty keyboard protocol | pardes-specific | @@ -353,7 +353,7 @@ text. | Key(s) | Helix behavior | Reason | | --- | --- | --- | -| `?` | reverse search prompt | pardes keeps its own `/` plain substring search into an output buffer. `*`, `Alt-*` and search-repeat `n`/`N` are implemented and verified above | +| `?` | reverse search prompt | pardes' `/` is a query pane (above); `N` steps backward. `*`, `Alt-*` and search-repeat `n`/`N` are implemented and verified above | | `Space` mode: `f F e . b j g G ' w c C Alt-c / ?` | pickers, global search, palette | pickers and the command palette do not exist here — but the KEY is taken: pardes' own leader runs the acme builtins (section A). Two halves of helix's space mode DO exist and are in section A: the clipboard menu (`y Y p P R`, helix's letters on helix's leader) and the LSP menu, moved one prefix deeper to `SPC l k/r/a/h/s/S/d/D` because `d`, `k`, `s` and `h` were already pardes' most-pressed keys | | Popup `Ctrl-u`/`Ctrl-d`, Completion menu, Signature help tables | LSP popups | LSP | | Picker table (all rows), Prompt table (all rows) | picker / prompt internals | pickers — pardes' tag line is its own one-line editor | diff --git a/docs/typ/builtins-gui.json b/docs/typ/builtins-gui.json index c238955c..88c9d864 100644 --- a/docs/typ/builtins-gui.json +++ b/docs/typ/builtins-gui.json @@ -51,7 +51,7 @@ {"name": "Forward", "leader": "SPC j i", "also": ["C-i"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Ctrl-i: one step forward again, up to wherever Back started."}, {"name": "Get", "leader": null, "also": [], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "acme's Get: the pane's file read again, its unsaved edits refused once as Del refuses them."}, {"name": "Grain", "leader": null, "also": [], "arg": true, "scope": "root", "setting": true, "choices": "on, off, 0-3", "doc": "The page takes a fine, still grain, like paper: a level, 0 (off) through 3."}, - {"name": "Grep", "leader": "SPC f g", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "Find's sibling: Find matches file NAMES under this pane's directory, Grep matches file CONTENTS under every pane's directory at once."}, + {"name": "Grep", "leader": "SPC f g", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "Find's sibling: Find matches file NAMES under this pane's directory, Grep matches the LINES of those files, on the disk engine's worker."}, {"name": "GripWidth", "leader": null, "also": [], "arg": true, "scope": "root", "setting": true, "choices": null, "doc": "The grip and scrollbar width, as a percent of the theme's rail."}, {"name": "Help", "leader": "SPC ?", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Open the help: every key and every builtin."}, {"name": "Hover", "leader": "SPC l k", "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Ask the language server about the symbol under the cursor."}, diff --git a/docs/typ/builtins-tty.json b/docs/typ/builtins-tty.json index 791eef63..01ae6bc5 100644 --- a/docs/typ/builtins-tty.json +++ b/docs/typ/builtins-tty.json @@ -45,7 +45,7 @@ {"name": "FocusTint", "leader": null, "also": [], "arg": true, "scope": "root", "setting": true, "choices": "on, off", "doc": "The focused pane's and column's tags are tinted, on or off."}, {"name": "Forward", "leader": "SPC j i", "also": ["C-i"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Ctrl-i: one step forward again, up to wherever Back started."}, {"name": "Get", "leader": null, "also": [], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "acme's Get: the pane's file read again, its unsaved edits refused once as Del refuses them."}, - {"name": "Grep", "leader": "SPC f g", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "Find's sibling: Find matches file NAMES under this pane's directory, Grep matches file CONTENTS under every pane's directory at once."}, + {"name": "Grep", "leader": "SPC f g", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "Find's sibling: Find matches file NAMES under this pane's directory, Grep matches the LINES of those files, on the disk engine's worker."}, {"name": "Help", "leader": "SPC ?", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Open the help: every key and every builtin."}, {"name": "Hover", "leader": "SPC l k", "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Ask the language server about the symbol under the cursor."}, {"name": "InactiveDim", "leader": null, "also": [], "arg": true, "scope": "root", "setting": true, "choices": null, "doc": "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off."}, diff --git a/docs/typ/cheatsheet.typ b/docs/typ/cheatsheet.typ index 7b140a04..76f4b866 100644 --- a/docs/typ/cheatsheet.typ +++ b/docs/typ/cheatsheet.typ @@ -59,7 +59,7 @@ Helix-style: motions *select*, then an edit acts on the selection. Mode box: bla [#keys("i", "a", "I", "A", "o", "O")], [insert; #key("Esc") back to normal], [#keys("s", "S")], [regex: a cursor per match, split], [#keys("C", ",")], [cursor on next line; keep primary], - [#keys("/", "n", "N")], [search, next, previous], + [#keys("/", "n", "N")], [search (a query pane), next, previous], [#keys("m i", "m m")], [textobject, matching bracket], [#key("|")], [pipe each selection through the shell], [#keys("g d", "g r")], [definition, references (language server)], @@ -87,6 +87,8 @@ Helix-style: motions *select*, then an edit acts on the selection. Mode box: bla key("SPC f f"), word("Find"), key("SPC f g"), word("Grep"), key("SPC f r"), word("Recent"), + key("SPC b b"), word("Panes"), + key("SPC s s"), [declarations], key("SPC f c"), word("Config"), key("SPC d"), word("Del"), key("SPC n t"), word("Tty"), @@ -119,7 +121,7 @@ Helix-style: motions *select*, then an edit acts on the selection. Mode box: bla `git diff` output is a diff: #btn("B3") on a file line, an `@@` or a line's `+`/`-` jumps there. #doc("tags", section: "reviewing-diffs") == Finding things -- #word("Find") `name`, #word("Grep") `text` (literal): a `+Search` listing. #word("Recent"): files lately. #word("Help"), #word("Tutor"). +- A query pane under the pane: line 1 the query, its first word the source: `/pat`, `Find name` (fuzzy), `Grep text` (literal), `Recent`, `Panes`, `Symbols`, `All`. #keys("Ctrl-n", "Ctrl-p") step, #key("Enter") lands and keeps the rows, #key("Esc") puts things back. #word("Help"), #word("Tutor"). == Sessions `pardes --detach=work`; `--attach=work` or #word("Attach") `work`; #word("Detach") leaves it running. #doc("detached") diff --git a/docs/typ/guide.typ b/docs/typ/guide.typ index e60b4231..65c7334d 100644 --- a/docs/typ/guide.typ +++ b/docs/typ/guide.typ @@ -20,9 +20,9 @@ [the session's directory], [where pardes started, or the directory `pardes DIR` named; workspace and column tags run there], [active column], [where the next new pane goes (below)], [command pane], [a terminal that runs one command line and shows its output], - [`+` names], [panes pardes makes, named in their directory: `+New` a scratch (text with no file yet), `+Search` a listing of places, `+Pager` paged text, `+Errors` output, `+Unsaved` the panes holding unsaved text], + [`+` names], [panes pardes makes, named in their directory: `+New` a scratch (text with no file yet), `+Search` a query pane or a listing of places, `+Pager` paged text, `+Errors` output, `+Unsaved` the panes holding unsaved text], [serial], [a pane's number, never reused: the `3` in `@p3:12` and in 9P paths], - [message row], [the line where pardes says what happened, and asks: answer a prompt (a search, #word("Save")'s path) with #key("Enter"), cancel it with #key("Esc")], + [message row], [the line where pardes says what happened, and asks: answer a prompt (#key("s")'s regex, #word("Save")'s path) with #key("Enter"), cancel it with #key("Esc")], ) = Modes @@ -166,11 +166,45 @@ on the cheatsheet. A relative path is found in the directory of the pane the #word("Look") came from, then of each pane on the jump list, most recent first. += Search + +#key("/") opens a query pane under the pane: a `+Search` whose first line +is the query, typed into, and whose rows are what it finds, made again at +each key. It takes its rows from the pane it searches and from no other, +is born #word("SearchRows") rows tall and never resizes itself; nothing +found is a count of `0` in its tag, not an exit. + #pairs( - [#key("/") `TODO` #key("Enter")], [a `+Search` of the lines holding `TODO`, the cursor on the first; #keys("n", "N") select the next or previous match], - [#word("Find") `conf`], [a `+Search` of the files below the pane's directory with `conf` in their names], - [#word("Grep") `TODO`], [a `+Search` of the lines holding `TODO`, literally, under every pane's directory], + [#key("/") `vw`], [every match in the text tinted and ticked on its scroll rail, the first after the cursor selected; the rows under line 1 are the lines holding it, a line number in the gutter, each under the declaration it is in], + [#keys("Ctrl-n", "Ctrl-p")], [the next or previous match, typing; the text follows it], + [#key("Enter")], [the keyboard on the match, the pattern in `/`, the rows kept as text (#word("Save") keeps them as a file)], + [#keys("n", "N")], [the next or previous match in the text, round the end without a word], + [#key("Esc")], [typing: the text as it was, the query pane closed], + [#key("*")], [the selection as line 1, the keyboard staying in the text], ) + +Line 1's first word names what it searches, and editing the word changes it: + +#pairs( + [`/pat`], [the pane's own text: a regex, any case unless it has a capital (#key("/"))], + [`Find name`], [the files below the pane's directory, by a fuzzy match of their names (#key("SPC f f"), #word("Find"))], + [`Grep text`], [the lines of those files holding `text`, literally (#key("SPC f g"), #word("Grep")); past 2000 lines #word("More") goes on], + [`Recent name`], [the files opened lately (#key("SPC f r"), #word("Recent"))], + [`Panes name`], [the open panes (#key("SPC b b"), #word("Panes"))], + [`Symbols name`], [the text's declarations (#key("SPC s s"))], + [`All pat`], [every open pane's text, its rows under each pane (#key("SPC /"))], + [`Refs`, `Def`, `Impl`, `Diagnostics`], [the language server's lists; their places in the text tinted as a `/`'s are, `]d` stepping the diagnostics], +) + +A row in a file no pane shows is shown in a `+Preview` under the query +pane, following #keys("Ctrl-n", "Ctrl-p") and #btn("B1"), never the +pointer; #key("Enter") makes the preview that file's pane where it stands. +#btn("B3") on a row's line number looks at the row; #btn("B2") on line 1 +runs it again. The next search from the same pane reuses its query pane, +its kept rows back on #key("Esc") (#word("SearchPane") `new`: a pane each; +#word("SearchPlace") `column`: in a finder column at the right). A PDF's +and a terminal's #key("/") still ask on the message row and list a +`+Search`. #clip("search") = Unsaved panes @@ -281,7 +315,7 @@ refusals and `--nested` are in the reference. [#key("w") #key("d")], [select a word, delete it: motions select, edits act on the selection], [#key("x"), #key("v"), #key(";")], [select the line; extend; collapse to the cursor], [#key("s")], [a cursor per regex match; every edit acts at each], - [#key("/"), #keys("n", "N")], [substring search; repeat the search in the current text, wrapping at the ends], + [#key("/"), #keys("n", "N")], [search the text in a query pane (#link()[Search]); step its matches, round the ends], [#keys("SPC j n", "SPC j p")], [#word("LookNext") / #word("LookPrev"): select locations across panes; #key("Enter") opens one], [#key("g l")], [line end], [`12G`], [line 12; a bare #key("G") does nothing], diff --git a/docs/typ/reference.typ b/docs/typ/reference.typ index c14ad659..386b9f0f 100644 --- a/docs/typ/reference.typ +++ b/docs/typ/reference.typ @@ -909,7 +909,8 @@ at 200, ending in `…`. Control characters become spaces. pane from the root). - #file("/recent"): up to 200 files, PDFs and images, most recent first, `open ` or `closed `; kept in `$XDG_STATE_HOME/pardes/recent`. - #word("Recent") shows them in a pane, an open one at its dot now and a + #word("Recent") lists them in a query pane (line 1 `Recent`, the rest + narrowing them by a fuzzy match), an open one at its dot now and a closed one at its last (a PDF's is its page); a #word("Look") of a row reopens it there. - #file("/status"): `pid`, `version`, `panes`. @@ -972,15 +973,22 @@ one a #file("exec") open still holds is never reused. In a command pane, #key("n = Find and Grep -#word("Find") matches file names, #word("Grep") the text of lines, both literally and -ignoring ASCII case. #word("Grep") reads whole files and stops at 512 -hits, #word("Find") at 512 names. The walk stops at 20000 files or 100000 entries, -16 deep, and passes over `.git`, `.jj`, `target`, `node_modules`, -`.venv`, `__pycache__`, `.zig-cache` and `zig-out`. A cap hit, or a -directory it could not open, is said at the end: `cut at 512 hits`, `walk cut at N entries`, `N -directories skipped: permission denied`. A search that finds nothing and -skipped nothing fails, `Grep: text not found`, and leaves the `+Search` as -it was. +Both fill the asking pane's query pane (#doc("guide", section: "search")), +line 1 `Find name` or `Grep text`, and run on a worker thread, never on +the loop that draws: `rg` when it is on `PATH` (`rg --files` and `rg --json +--fixed-strings --smart-case`, so `.gitignore` is honoured and hidden files +are passed over), else pardes's own walk, sorted, 16 deep, passing over +dot-directories, `.git`, `.jj`, `target`, `node_modules`, `.venv`, +`__pycache__`, `.zig-cache` and `zig-out`. #word("Find") lists the files once +and matches their names fuzzily at each key (the best first, 200 shown); +#word("Grep") matches the text of lines literally, any case unless the text +has a capital, once the typing pauses (80 ms), and stops at 2000 lines: +#word("More") (in the query pane's tag) goes on for 2000 more. A directory the +walk could not open is said under the rows: `N directories skipped: +permission denied`. A new query cancels the last; rows of a query no +longer asked never land. Written to #file("exec") (a script) the search runs +to its end before the write is answered, and one that finds nothing fails, +`Grep: text not found`, `Find: name not found`, its query pane's count `0`. = On screen diff --git a/src/Output.zig b/src/Output.zig index 1e62b04a..01e3e0f1 100644 --- a/src/Output.zig +++ b/src/Output.zig @@ -857,15 +857,6 @@ pub fn dropUnsaved(p: *Pardes, gone: *const Pane) void { } } -/// Recent: the one +Recent, filled again when it is there (as Find and -/// Grep's +Search is), else opened below the asking pane. -pub fn openRecent(p: *Pardes, id: usize) !void { - var out: std.Io.Writer.Allocating = .init(p.gpa); - errdefer out.deinit(); - try recentText(p, &out.writer, true); - try refillOrOpen(p, id, .{ .cmd = .Recent }, try out.toOwnedSlice()); -} - /// The one stepped output from `from`, filled again with `content` when it /// is there (Recent, Jumplist), or opened when it is not. fn refillOrOpen(p: *Pardes, id: usize, from: Origin, content: []u8) !void { @@ -971,6 +962,28 @@ fn helpContent(gpa: std.mem.Allocator, prefix: []const u8) ![]u8 { } if (show_calls_help) try w.writeAll(calls_help); if (prefix.len == 0) try w.writeAll(language_footer); + // The paths that run a builtin with a word (config.leader_args), and how + // a query pane is driven: under SPC f, b, s and in the whole listing. + const search_group = for (config.leader_args) |la| { + if (std.mem.startsWith(u8, la.path, prefix)) break true; + } else std.mem.eql(u8, prefix, "f"); + if (prefix.len == 0 or search_group) { + try w.writeAll("\nsearch: a query pane under the text,\nits line 1 the query, its first word\nthe source (/ Find Grep Recent Panes\nSymbols All Refs Def Impl Diagnostics)\n"); + for (config.leader_args) |la| { + if (!std.mem.startsWith(u8, la.path, prefix)) continue; + var keys: [16]u8 = @splat(' '); + for (la.path, 0..) |c, i| keys[2 * i] = c; + try w.print("{s} {s} {s}\n", .{ keys[0..8], @tagName(la.cmd), la.arg }); + } + if (prefix.len == 0) try w.writeAll( + "/ * the text (* seeds it)\n" ++ + "C-n C-p Up Down step, typing on line 1\n" ++ + "n N step the text's places\n" ++ + "Enter land there, keep the rows\n" ++ + "Esc put every view back\n" ++ + "More a Grep past 2000 lines\n", + ); + } return out.toOwnedSlice(); } diff --git a/src/Query.zig b/src/Query.zig index 48378a18..3a75a7f5 100644 --- a/src/Query.zig +++ b/src/Query.zig @@ -153,8 +153,10 @@ window: struct { lo: usize = 0, hi: usize = 0 } = .{}, /// made every third, the frame's time going to the finding. waited: u8 = 0, names: Names = .{}, -/// A Grep's lines, as the disk engine sends them (Stream.zig, `take`). +/// A Grep's lines, as the disk engine sends them (Stream.zig, `take`), and +/// the current one's index among them. found: std.ArrayList(Found) = .empty, +grep_at: usize = 0, found_bytes: std.ArrayList(u8) = .empty, grep_gen: u32 = 0, /// The language server's rows for Refs, Def, Impl, Diagnostics, as it gave @@ -256,6 +258,10 @@ pub fn open(p: *Pardes, from: usize, source: Source, arg: []const u8, focus: boo File.setContent(p, f, new); q.reset(p); if (rp.collapsed) layout.toggleCollapse(p, id); + // A source that previews gets its +Preview now, at the key that + // asked, not under the typing later. + if (previews(source) and previewOf(p, id) == null) + _ = makePreview(p, id, @max(pardes.BOX_H, rp.tag_rows) + p.settings.search_rows, layout.groupRoot(p, id)); } else { if (existing) |old| { // SearchPane new: the last one stays where it is, a result of @@ -297,8 +303,20 @@ fn create(p: *Pardes, owner_id: usize, line: []const u8, source: Source) ?usize const body: u16 = 1 + p.settings.search_rows; const tag = @max(pardes.BOX_H, np.tag_rows); const with_preview = previews(source); - // The preview, made right after, takes its own rows from the owner. - const want = tag + body; + // The preview, made right after, takes its own rows from the owner: + // when the owner has not the rows for both, they share what it has, so + // the group is whole from the first key and nothing moves later. + var want: u16 = tag + body; + var preview_rows: u16 = tag + p.settings.search_rows; + if (with_preview) { + layout.compute(p); + const spare = p.rects[owner_id].h -| layout.minRows(p, owner_id); + if (spare < want + preview_rows) { + const both = want + preview_rows; + want = @max(tag + 2, @as(u16, @intCast(@as(u32, spare) * want / both))); + preview_rows = spare -| want; + } + } if (p.settings.search_place == .column) { // The finder column (phase 6): until it exists, under the owner. if (!layout.attach(p, owner_id, free, want)) exec.placeNew(p, owner_id, owner_id, free, .doc); @@ -307,7 +325,7 @@ fn create(p: *Pardes, owner_id: usize, line: []const u8, source: Source) ?usize // new pane is, the one place a search moves another pane. exec.placeNew(p, owner_id, owner_id, free, .doc); } - if (with_preview) _ = makePreview(p, free); + if (with_preview) _ = makePreview(p, free, preview_rows, owner_id); return free; } @@ -495,9 +513,14 @@ fn produce(p: *Pardes, id: usize, tick: bool) void { q.found.clearRetainingCapacity(); q.found_bytes.clearRetainingCapacity(); q.grep_gen +%= 1; + q.grep_at = 0; q.current = null; // On the disk engine's worker, once the typing pauses. - if (a.pat.len > 0) Stream.query(p, rp.serial, .grep, a.pat, dir, .typed) else if (p.stream.target == rp.serial) { + // A script's (a 9P write): run to its end before it answers. + if (a.pat.len > 0) { + Stream.query(p, rp.serial, .grep, a.pat, dir, if (p.fs.serving) .now else .typed); + if (p.fs.serving) Stream.step(p); + } else if (p.stream.target == rp.serial) { _ = p.stream.stop(); } feedGrepPlaces(p, q, rp.serial, a.pat); @@ -548,7 +571,10 @@ fn startSource(p: *Pardes, id: usize, q: *Query, source: Source, owner_id: ?usiz switch (source) { // The files under the directory, listed once on the disk engine's // worker (rg --files, else the walk); each keystroke scores them. - .find => Stream.query(p, rp.serial, .files, "", dir, .now), + .find => { + Stream.query(p, rp.serial, .files, "", dir, .now); + if (p.fs.serving) Stream.step(p); + }, .recent => { var out: std.Io.Writer.Allocating = .init(gpa); defer out.deinit(); @@ -828,7 +854,9 @@ fn makeTextRows(p: *Pardes, id: usize, oid: usize, full: bool) !void { // Grouped once a parse of the text exists: asked of the worker now. if (ownerDecls(p, &owner.file.?, false) == null) Stream.parseFor(p, oid); const at = set.current orelse (if (set.seek) |s| Places.firstFrom(set.hits.items, s) else 0); - const from = if (full) 0 else at -| live_rows / 2; + // While typed, a window of rows from just before the current place, so + // it sits under line 1. + const from = if (full) 0 else at -| 2; q.window = .{ .lo = from, .hi = from }; if (set.started and set.from == rp.serial) { if (from > 0) { @@ -856,7 +884,9 @@ fn showPlacesCurrent(p: *Pardes, id: usize) void { const owner = p.panes[p.paneBySerial(q.owner) orelse return].?; const set = &owner.places; q.total = if (set.from == rp.serial) set.hits.items.len else 0; - q.more = q.more or (set.from == rp.serial and !set.complete()); + // still counting: the places not all found yet (the rows' own cut is + // said in a row of theirs) + q.more = set.from == rp.serial and !set.complete(); q.k = if (set.current) |c| c + 1 else 0; if (set.from != rp.serial) q.k = 0; q.current = null; @@ -995,6 +1025,7 @@ fn makeNameRows(p: *Pardes, id: usize, pat: []const u8) !void { } } if (q.names.hits.items.len > shown) try noteRow(p, q, &out, &rows, " ... and more: type more of the name"); + if (q.source == .find) try skippedRow(p, q, rp, &out, &rows); setRows(p, rp, &out, &rows); const f = &rp.file.?; f.pager_spans = spans.toOwnedSlice(p.gpa) catch &.{}; @@ -1004,7 +1035,7 @@ fn makeNameRows(p: *Pardes, id: usize, pat: []const u8) !void { q.current = if (shown > 0) 0 else null; countCurrent(q); showCurrent(rp); - showTarget(p, id); + if (q.current == null) blankPreview(p, id) else showTarget(p, id); } /// A Grep keeps this many lines: the rest wait (the disk engine's `More`). @@ -1016,14 +1047,14 @@ fn makeGrepRows(p: *Pardes, id: usize, full: bool) !void { const rp = p.panes[id].?; const q = rp.query.?; const dir = std.fs.path.dirname(rp.file.?.path) orelse "/"; - const at: usize = if (q.current) |c| (if (c < q.items.items.len) q.items.items[c].hit else 0) else 0; + const at: usize = @min(q.grep_at, q.found.items.len -| 1); q.items.clearRetainingCapacity(); var out: std.ArrayList(u8) = .empty; defer out.deinit(p.gpa); var rows: std.ArrayList(locations.Row) = .empty; var last_path: []const u8 = ""; var pathbuf: [4096 + 8]u8 = undefined; - const lo = if (full) 0 else at -| live_rows / 2; + const lo = if (full) 0 else at -| 2; const hi = if (full) q.found.items.len else @min(q.found.items.len, lo + live_rows); if (lo > 0) { var hb: [64]u8 = undefined; @@ -1048,12 +1079,23 @@ fn makeGrepRows(p: *Pardes, id: usize, full: bool) !void { try noteRow(p, q, &out, &rows, std.fmt.bufPrint(&hb, " ... {d} lines after these", .{q.found.items.len - hi}) catch " ..."); } if (p.stream.target == rp.serial and p.stream.state == .capped) try noteRow(p, q, &out, &rows, " ... stopped at 2000 lines: More in the tag goes on"); + try skippedRow(p, q, rp, &out, &rows); setRows(p, rp, &out, &rows); q.total = q.found.items.len; q.more = p.stream.busyFor(rp.serial); q.current = current orelse firstHit(q); countGrepCurrent(q); showCurrent(rp); + if (q.current == null) blankPreview(p, id); +} + +/// What the disk walk passed over, said under the rows: a search that +/// found nothing where it could not look says so, never just nothing. +fn skippedRow(p: *Pardes, q: *Query, rp: *Pane, out: *std.ArrayList(u8), rows: *std.ArrayList(locations.Row)) !void { + const n = p.stream.skipped; + if (p.stream.target != rp.serial or n == 0) return; + var hb: [96]u8 = undefined; + try noteRow(p, q, out, rows, std.fmt.bufPrint(&hb, " {d} director{s} skipped: permission denied", .{ n, if (n == 1) "y" else "ies" }) catch " directories skipped"); } /// `k` for a Grep: the current row's line among all the lines sent. @@ -1128,7 +1170,9 @@ pub fn fillList(p: *Pardes, owner_id: usize, source: Source, rows: []const u8) v const line = lineOne(rp.file.?.content); const a = parse(line) orelse return; makeListRows(p, qid, a.pat) catch |err| p.reportError(qid, "search", err); - toLineOne(p, qid); + // A list to pick from, typed into; diagnostics are a jump (]d): the + // keyboard stays on the place in the text. + if (source != .diagnostics) toLineOne(p, qid) else p.active = owner_id; } fn makeListRows(p: *Pardes, id: usize, pat: []const u8) !void { @@ -1141,8 +1185,10 @@ fn makeListRows(p: *Pardes, id: usize, pat: []const u8) !void { var rows: std.ArrayList(locations.Row) = .empty; const owner_id = p.paneBySerial(q.owner); const owner_path: []const u8 = if (owner_id) |oid| (if (p.panes[oid].?.file) |f| f.path else "") else ""; - var feed: std.ArrayList(Places.Hit) = .empty; - defer feed.deinit(p.gpa); + // Each open file's places in the list, its tints and n/N: the owner's + // and any other pane's the rows land in. + var feeds: [pardes.MAX_PANES]std.ArrayList(Places.Hit) = @splat(.empty); + defer for (&feeds) |*f| f.deinit(p.gpa); // In order: by path, then place, as a list of places reads. var sorted: std.ArrayList([]const u8) = .empty; defer sorted.deinit(p.gpa); @@ -1174,27 +1220,28 @@ fn makeListRows(p: *Pardes, id: usize, pat: []const u8) !void { } const rest = std.mem.trimStart(u8, ln[@min(t.end, ln.len)..], " \t:"); const col0 = t.at.col -| 1; - try q.items.append(p.gpa, .{ .kind = .hit, .n = 1 }); - // The row's text: the line in the owner when it is the owner's, - // else as the server said it. + // The row's text: the line as an open pane has it, when one shows + // the file, else as the server said it. var code: []const u8 = rest; - var col = col0; - var end = if (t.at.end_col > 0 and t.at.end_line == t.at.line) t.at.end_col else col0 + 1; - if (owner_id) |oid| if (std.mem.eql(u8, path, owner_path)) { - const owner_f = &p.panes[oid].?.file.?; - if (t.at.line <= File.nlines(p.gpa, owner_f)) { - const ls = File.lineStart(p.gpa, owner_f, t.at.line - 1); - const nx = File.lineStart(p.gpa, owner_f, t.at.line); - const le = if (nx > ls and owner_f.content[nx - 1] == '\n') nx - 1 else nx; - code = owner_f.content[ls..le]; - col = @min(col0, code.len); - end = @min(@max(end, col + 1), code.len); - feed.append(p.gpa, .{ .start = ls + col, .end = ls + @max(end, col + 1) }) catch {}; - } - } else { - col = 0; - end = 0; - }; + var col = @min(col0, rest.len); + var end = @min(if (t.at.end_col > 0 and t.at.end_line == t.at.line) t.at.end_col else col0 + 1, rest.len); + var shown_in: u32 = 0; + for (p.panes, 0..) |slot, i| { + const tp = slot orelse continue; + if (!searchable(tp)) continue; + const tf = &tp.file.?; + if (tf.output != null or !std.mem.eql(u8, tf.path, path) or t.at.line > File.nlines(p.gpa, tf)) continue; + const ls = File.lineStart(p.gpa, tf, t.at.line - 1); + const nx = File.lineStart(p.gpa, tf, t.at.line); + const le = if (nx > ls and tf.content[nx - 1] == '\n') nx - 1 else nx; + code = tf.content[ls..le]; + col = @min(col0, code.len); + end = @min(@max(end, col + 1), code.len); + feeds[i].append(p.gpa, .{ .start = ls + col, .end = ls + @max(end, col + 1) }) catch {}; + shown_in = tp.serial; + break; + } + try q.items.append(p.gpa, .{ .kind = .hit, .n = 1, .serial = shown_in }); try writeHitRow(p, &out, &rows, 9, path, t.at.line, code, col, end, &.{}); n += 1; } @@ -1203,12 +1250,14 @@ fn makeListRows(p: *Pardes, id: usize, pat: []const u8) !void { q.total = n; q.more = false; q.current = firstHit(q); + for (p.panes, 0..) |slot, i| if (slot) |tp| { + if (feeds[i].items.len > 0) tp.places.feed(p, tp, rp.serial, feeds[i].items, null) else if (tp.places.from == rp.serial) tp.places.clear(p.gpa); + }; if (owner_id) |oid| { const owner = p.panes[oid].?; // Current: the first place after where it was asked (the answer // may come after the cursor moved), shown in the owner. const asked_at: usize = if (p.lsp_last) |last| (if (last.serial == owner.serial) last.offset else owner.places.origin(owner)) else owner.places.origin(owner); - owner.places.feed(p, owner, rp.serial, feed.items, null); const hits = owner.places.hits.items; var next: ?usize = null; for (hits, 0..) |h, i| if (h.start > asked_at) { @@ -1261,6 +1310,13 @@ fn showCurrent(rp: *Pane) void { }; const r: i32 = @intCast(c + 1); rp.body.msel = .{ .active = true, .r0 = r, .r1 = r }; + // Typed into, line 1 stays in view whatever the current row: what you + // type is never scrolled away (the live rows start just before the + // current one, so it sits under line 1). Frozen, the row is scrolled to. + if (!q.frozen) { + if (rp.scroll() != 0) rp.scrollBy(-rp.scroll()); + return; + } const off = rp.scroll(); const shown = off + @as(i32, rp.rows) - 1; if (r > shown) rp.scrollBy(r - shown) else if (r < off) rp.scrollBy(r - off); @@ -1296,6 +1352,7 @@ fn setCurrent(p: *Pardes, id: usize, i: usize, show: bool) void { const q = rp.query.?; q.current = i; const it = q.items.items[i]; + if (q.source == .grep and it.kind == .hit) q.grep_at = it.hit; const rows = rp.file.?.location_rows; if (it.serial != 0 and i + 1 < rows.len) if (p.paneBySerial(it.serial)) |tid| { const tp = p.panes[tid].?; @@ -1325,6 +1382,17 @@ pub fn step(p: *Pardes, id: usize, delta: i32) void { return; } }; + // A Grep: by its lines, the window made again when the next is past it. + if (q.source == .grep and q.found.items.len > 0) { + const n = q.found.items.len; + q.grep_at = if (delta > 0) (q.grep_at + 1) % n else (q.grep_at + n - 1) % n; + const in_window = for (q.items.items) |it| { + if (it.kind == .hit and it.hit == q.grep_at) break true; + } else false; + if (!in_window) makeGrepRows(p, id, q.frozen) catch {}; + for (q.items.items, 0..) |it, i| if (it.kind == .hit and it.hit == q.grep_at) return setCurrent(p, id, i, true); + return; + } const items = q.items.items; if (items.len == 0) return; var i: usize = q.current orelse (if (delta > 0) items.len - 1 else 0); @@ -1335,6 +1403,26 @@ pub fn step(p: *Pardes, id: usize, delta: i32) void { setCurrent(p, id, i, true); } +/// Nothing current (a query that matches nothing): the +Preview shows +/// nothing, rather than a file the query no longer names. +fn blankPreview(p: *Pardes, qid: usize) void { + const pid = previewOf(p, qid) orelse return; + const pane = p.panes[pid].?; + const f = &pane.file.?; + if (f.content.len == 0) return; + const dir = std.fs.path.dirname(p.panes[qid].?.file.?.path) orelse "/"; + const path = std.fmt.allocPrint(p.gpa, "{s}/{s}", .{ dir, config.preview_buffer }) catch return; + const empty = p.gpa.alloc(u8, 0) catch { + p.gpa.free(path); + return; + }; + p.gpa.free(f.path); + f.path = path; + File.setContent(p, f, empty); + f.saved_revision = f.revision; + f.scroll = 0; +} + /// Where the current row points, shown with the keyboard left where it is: /// a place in an open pane's text selected there (its places' current), /// in view; a file an open pane shows, its line there; any other file in @@ -1399,8 +1487,11 @@ pub fn isPreview(p: *Pardes, pane: *const Pane) ?usize { return null; } -/// A +Preview made under query pane `qid`, out of its rows alone. -fn makePreview(p: *Pardes, qid: usize) ?usize { +/// A +Preview made under query pane `qid`, `rows` tall, out of `giver`'s +/// rows: the text that asked, at the key that asked; the query pane itself +/// when its source word was edited to one that previews while typing (its +/// line 1 stays where it is). +fn makePreview(p: *Pardes, qid: usize, rows: u16, giver: usize) ?usize { const rp = p.panes[qid].?; const free = p.freeSlot() orelse return null; const dir = std.fs.path.dirname(rp.file.?.path) orelse "/"; @@ -1410,10 +1501,7 @@ fn makePreview(p: *Pardes, qid: usize) ?usize { return null; }; layout.compute(p); - const rows = @max(pardes.BOX_H, np.tag_rows) + p.settings.search_rows; - // Out of the group's root, the text that asked: the query pane keeps - // the rows it was typed into with (made later, for a reused pane). - if (!layout.attachFrom(p, qid, free, rows, layout.groupRoot(p, qid))) { + if (!layout.attachFrom(p, qid, free, rows, giver)) { p.removePane(free, qid) catch {}; return null; } @@ -1425,7 +1513,7 @@ fn makePreview(p: *Pardes, qid: usize) ?usize { /// file open in a pane would be shown there instead), the place centred /// and selected. Made when the pane has none and its owner has the rows. fn displayPreview(p: *Pardes, qid: usize, path: []const u8, at: look.Spot) void { - const id = previewOf(p, qid) orelse makePreview(p, qid) orelse return; + const id = previewOf(p, qid) orelse makePreview(p, qid, p.rects[qid].h / 2, qid) orelse return; const pane = p.panes[id].?; const f = &pane.file.?; if (!std.mem.eql(u8, f.path, path)) { @@ -1706,8 +1794,8 @@ pub fn key(p: *Pardes, id: usize, k: Key) bool { land(p, id, null); return true; } - const down = (k.cp == Key.down and !k.ctrl and !k.alt) or (k.ctrl and !k.alt and k.cp == 'n'); - const up = (k.cp == Key.up and !k.ctrl and !k.alt) or (k.ctrl and !k.alt and k.cp == 'p'); + const down = hit(k, config.query_next); + const up = hit(k, config.query_prev); if (down or up) { step(p, id, if (down) 1 else -1); return true; diff --git a/src/builtins.zig b/src/builtins.zig index c8909e66..cda962de 100644 --- a/src/builtins.zig +++ b/src/builtins.zig @@ -1712,38 +1712,42 @@ const e_search_miss_grep = "Grep: text not found"; /// List the files below this pane's directory whose names hold its argument, in a +Search. pub const Find = struct { pub const takes_arg = true; + // A script's Find names what to find (bare, it is a key's prompt). pub const requires_arg = true; pub const output: OutputTraits = .{ .name = config.search_buffer, .steps = true }; pub fn run(c: Ctx) void { + // A query pane under this pane, line 1 `Find ` and the word: bare + // (SPC f f) typed into; with a word (B2, a script) listed, the + // keyboard left where it was, a script told of a miss. const pat = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); - if (pat.len > 0) { - const rows = look.runSearch(c.p, c.id, pat, .find, .top, false) catch |err| return c.p.reportError(c.id, "Find", err); - if (rows == 0) c.p.reportFailure(c.id, e_search_miss_find); - return; - } - // Bare (SPC f f): the query pane, line 1 `Find `, typed into. - panes.Query.open(c.p, c.id, .find, "", true); + panes.Query.open(c.p, c.id, .find, pat, pat.len == 0); + if (pat.len > 0) missed(c, e_search_miss_find); } }; /// Find's sibling: Find matches file NAMES under this pane's directory, Grep -/// matches file CONTENTS under every pane's directory at once. +/// matches the LINES of those files, on the disk engine's worker. pub const Grep = struct { pub const takes_arg = true; pub const requires_arg = true; pub const output: OutputTraits = .{ .name = config.search_buffer, .steps = true, .locations = true }; pub fn run(c: Ctx) void { const pat = std.mem.trim(u8, c.arg orelse "", " \t\r\n"); - if (pat.len > 0) { - const rows = look.runSearch(c.p, c.id, pat, .grep, .top, false) catch |err| return c.p.reportError(c.id, "Grep", err); - if (rows == 0) c.p.reportFailure(c.id, e_search_miss_grep); - return; - } - // Bare (SPC f g): the query pane, line 1 `Grep `, typed into. - panes.Query.open(c.p, c.id, .grep, "", true); + panes.Query.open(c.p, c.id, .grep, pat, pat.len == 0); + if (pat.len > 0) missed(c, e_search_miss_grep); } }; +/// A script's Find or Grep (a 9P write runs it to its end before it +/// answers) that found nothing fails as one: the query pane stays, its +/// count 0, and the write hears `not found`. +fn missed(c: Ctx, text: []const u8) void { + if (!c.p.fs.serving) return; + const qid = panes.Query.ofOwner(c.p, c.pane.serial) orelse return; + const q = c.p.panes[qid].?.query.?; + if (q.total == 0) c.p.reportFailure(c.id, text); +} + /// Search in a query pane under this pane, line 1 the argument (`Panes`, /// `Symbols lay`, `All needle`, `/re`, any of its words); bare, `/`. pub const Search = struct { @@ -1898,11 +1902,10 @@ pub const Last = struct { pub const Recent = struct { pub const scope: Scope = .session; pub const takes_arg = true; - pub const output: OutputTraits = .{ .name = config.recent_buffer, .steps = true, .locations = true }; pub fn run(c: Ctx) void { - // From a pane: the query pane under it, line 1 `Recent `, typed - // into; from a header, which no pane owns, the +Recent list. - if (c.p.exec_header or c.p.panes[c.id] == null) return panes.Output.openRecent(c.p, c.id) catch |err| c.p.reportError(c.id, "recent", err); + // The query pane under the pane the keyboard is in, line 1 + // `Recent `, typed into; what follows the word narrows the files. + if (c.p.panes[c.id] == null) return c.p.reportFailure(c.id, "Recent: open a pane to search from"); panes.Query.open(c.p, c.id, .recent, std.mem.trim(u8, c.arg orelse "", " \t\r\n"), true); } }; diff --git a/src/config.zig b/src/config.zig index 25c9dc5a..fff99ad2 100644 --- a/src/config.zig +++ b/src/config.zig @@ -365,6 +365,11 @@ pub const command_line: []const Chord = &.{.{ .cp = ':' }}; pub const search: []const Chord = &.{.{ .cp = '/' }}; pub const search_next: []const Chord = &.{.{ .cp = 'n' }}; pub const search_prev: []const Chord = &.{.{ .cp = 'N' }}; +/// Typing on a query pane's line 1 (Query.zig): the next and the previous +/// hit current, the text following (helix's prompt walks its history with +/// these; a query has none). Tab stays the exec chord. +pub const query_next: []const Chord = &.{ .{ .cp = 'n', .ctrl = true }, .{ .cp = Key.down } }; +pub const query_prev: []const Chord = &.{ .{ .cp = 'p', .ctrl = true }, .{ .cp = Key.up } }; pub const search_selection: []const Chord = &.{.{ .cp = '*', .alt = true }}; pub const search_selection_word: []const Chord = &.{.{ .cp = '*' }}; pub const pipe_selection: []const Chord = &.{.{ .cp = '|' }}; @@ -526,8 +531,6 @@ pub const comment_tokens: []const struct { exts: []const []const u8, token: []co }; pub const search_marker = " /"; -pub const find_marker = " Find /"; -pub const grep_marker = " Grep /"; pub const rename_marker = " Rename /"; pub const symbol_marker = " WsSymbols /"; pub const save_marker = " Save "; diff --git a/src/fs.zig b/src/fs.zig index cb813262..08379697 100644 --- a/src/fs.zig +++ b/src/fs.zig @@ -1115,297 +1115,16 @@ pub const WalkNotes = struct { } }; const find_max_depth = 16; -const find_max_steps = 100_000; -/// One root's Find or Grep rows at most: its hits, each a path and a line. -pub const search_root_output_bytes = find_max_hits * (4096 + 320); pub const find_skip = [_][]const u8{ ".git", ".jj", "target", "node_modules", ".venv", "__pycache__", ".zig-cache", "zig-out", }; -/// A directory the walk may not open or read is passed over and counted in -/// `notes.skipped`, its siblings' hits kept: one locked directory is not -/// every search's failure. A cap the walk hit is noted too. -pub fn find(arena: std.mem.Allocator, dir: []const u8, pat: []const u8, out: []u8, notes: *WalkNotes) !usize { - var hits: [find_max_hits][]const u8 = undefined; - var hits_len: usize = 0; - if (platform_has_fs) { - pardes.turn.yield(); - defer pardes.turn.back(); - const io = std.Io.Threaded.global_single_threaded.io(); - var root = try std.Io.Dir.cwd().openDir(io, dir, .{ .iterate = true }); - defer root.close(io); - var w = try root.walkSelectively(arena); - defer w.deinit(); - var steps: usize = 0; - walk: while (steps < find_max_steps and hits_len < hits.len) { - steps += 1; // an unreadable dir burns a step too, so it cannot spin - const e = (w.next(io) catch { - notes.skipped += 1; - continue; - }) orelse break; - if (std.ascii.findIgnoreCase(e.basename, pat) != null) { - hits[hits_len] = try arena.dupe(u8, e.path); - hits_len += 1; - } - if (e.kind != .directory or e.depth() >= find_max_depth) continue; - for (find_skip) |s| if (std.mem.eql(u8, e.basename, s)) continue :walk; - w.enter(io, e) catch { - notes.skipped += 1; - }; - } - if (hits_len >= hits.len) notes.hits_cut = true; - if (steps >= find_max_steps) notes.walk_cut = find_max_steps; - } else { - for (sources) |s| { - if (hits_len >= hits.len) break; - if (std.ascii.findIgnoreCase(std.fs.path.basename(s.path), pat) != null) { - hits[hits_len] = s.path; - hits_len += 1; - } - } - } - std.mem.sort([]const u8, hits[0..hits_len], {}, struct { - fn lt(_: void, a: []const u8, b: []const u8) bool { - return std.mem.lessThan(u8, a, b); - } - }.lt); - var written: usize = 0; - for (hits[0..hits_len]) |h| { - if (h.len + 1 > out.len - written) break; - @memcpy(out[written..][0..h.len], h); - written += h.len; - out[written] = '\n'; - written += 1; - } - return written; -} - -const grep_max_bytes = 256 * 1024; +// Find and Grep walk on the disk engine's worker now (Stream.zig); what is +// left here is what their notes and skips were. const grep_max_files = 20_000; -const GrepResult = struct { bytes: usize, hits: usize }; - -/// `text` starts at line `first_line` + 1 of its file. -fn grepText(path: []const u8, text: []const u8, pat: []const u8, out: []u8, budget: usize, first_line: usize) GrepResult { - var result: GrepResult = .{ .bytes = 0, .hits = 0 }; - var line: usize = first_line; - var it = std.mem.splitScalar(u8, text, '\n'); - while (it.next()) |raw| { - line += 1; - if (result.hits >= budget) break; - const at = std.ascii.findIgnoreCase(raw, pat) orelse continue; - const ln = std.mem.trimEnd(u8, raw, " \t\r"); - var cut = @min(ln.len, 200); - while (cut > 0 and cut < ln.len and ln[cut] & 0xc0 == 0x80) cut -= 1; - const row = std.fmt.bufPrint(out[result.bytes..], "{s}:{d}:{d}{c}{d} {s}\n", .{ - path, line, at + 1, config.range_sep, at + pat.len, ln[0..cut], - }) catch break; - result.bytes += row.len; - result.hits += 1; - } - return result; -} - -pub fn grep(arena: std.mem.Allocator, gpa: std.mem.Allocator, dir: []const u8, base: []const u8, pat: []const u8, out: []u8, notes: *WalkNotes) !usize { - var hits: usize = 0; - var written: usize = 0; - if (!platform_has_fs) { - for (sources) |s| { - if (hits >= find_max_hits or written == out.len) break; - const result = grepText(s.path, s.contents, pat, out[written..], find_max_hits - hits, 0); - hits += result.hits; - written += result.bytes; - } - return written; - } - const root_path = std.mem.trimEnd(u8, dir, "/"); - const home = std.mem.trimEnd(u8, base, "/"); - const files = try arena.alloc([]const u8, grep_max_files); - var files_len: usize = 0; - // A walk and thousands of reads: the turn goes out for all of it. - pardes.turn.yield(); - defer pardes.turn.back(); - { - const io = std.Io.Threaded.global_single_threaded.io(); - var root = try std.Io.Dir.cwd().openDir(io, dir, .{ .iterate = true }); - defer root.close(io); - var w = try root.walkSelectively(arena); - defer w.deinit(); - var steps: usize = 0; - walk: while (steps < find_max_steps and files_len < files.len) { - steps += 1; - const e = (w.next(io) catch { - notes.skipped += 1; - continue; - }) orelse break; - if (e.kind == .directory) { - if (e.depth() >= find_max_depth) continue; - for (find_skip) |s| if (std.mem.eql(u8, e.basename, s)) continue :walk; - w.enter(io, e) catch { - notes.skipped += 1; - }; - continue; - } - if (e.kind != .file) continue; - files[files_len] = try std.fmt.allocPrint(arena, "{s}/{s}", .{ root_path, e.path }); - files_len += 1; - } - if (files_len >= files.len) notes.walk_cut = grep_max_files else if (steps >= find_max_steps) notes.walk_cut = find_max_steps; - } - std.mem.sort([]const u8, files[0..files_len], {}, struct { - fn lt(_: void, a: []const u8, b: []const u8) bool { - return std.mem.lessThan(u8, a, b); - } - }.lt); - const buf = try gpa.alloc(u8, grep_max_bytes); - defer gpa.free(buf); - for (files[0..files_len]) |path| { - if (hits >= find_max_hits or written == out.len) { - notes.hits_cut = true; - break; - } - var pathbuf: [4096]u8 = undefined; - const path_z = std.fmt.bufPrintSentinel(&pathbuf, "{s}", .{path}, 0) catch return error.PathTooLong; - const fd = libc.open(path_z, .{ .ACCMODE = .RDONLY, .CLOEXEC = true, .NONBLOCK = true }); - if (fd < 0) continue; - defer _ = libc.close(fd); - // The whole file, a buffer at a time: each searched through its last - // whole line, the rest carried into the next. - const shown = lsp.rel(home, path); - var len: usize = 0; - var lines_before: usize = 0; - var first = true; - file: while (true) { - var eof = false; - while (len < buf.len) { - const n = libc.read(fd, buf[len..].ptr, buf.len - len); - if (n < 0) { - if (libc.errno(n) == .INTR) continue; - break :file; - } - if (n == 0) { - eof = true; - break; - } - len += @intCast(n); - } - if (first and std.mem.indexOfScalar(u8, buf[0..@min(len, 1024)], 0) != null) break; - first = false; - // A line longer than the buffer is searched in buffer-sized parts. - const end = if (eof) len else if (std.mem.lastIndexOfScalar(u8, buf[0..len], '\n')) |nl| nl + 1 else len; - const result = grepText(shown, buf[0..end], pat, out[written..], find_max_hits - hits, lines_before); - hits += result.hits; - written += result.bytes; - if (eof or hits >= find_max_hits or written == out.len) break; - lines_before += std.mem.count(u8, buf[0..end], "\n"); - std.mem.copyForwards(u8, buf[0 .. len - end], buf[end..len]); - len -= end; - } - if (hits >= find_max_hits) notes.hits_cut = true; - } - return written; -} - -test "grep skips a file it cannot read instead of abandoning the search" { - if (!platform_has_fs) return; - const gpa = std.testing.allocator; - var tmp = std.testing.tmpDir(.{}); - defer tmp.cleanup(); - var base_buf: [std.fs.max_path_bytes]u8 = undefined; - const dir = base_buf[0..try tmp.dir.realPath(std.testing.io, &base_buf)]; - - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "a-locked.txt", .data = "needle here\n" }); - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "b-open.txt", .data = "needle here\n" }); - var locked_buf: [std.fs.max_path_bytes]u8 = undefined; - const locked = try std.fmt.bufPrintSentinel(&locked_buf, "{s}/a-locked.txt", .{dir}, 0); - if (libc.chmod(locked, 0) != 0) return; - const probe = libc.open(locked, .{ .ACCMODE = .RDONLY }); - if (probe >= 0) { - _ = libc.close(probe); - _ = libc.chmod(locked, 0o644); - return error.SkipZigTest; - } - - var arena: std.heap.ArenaAllocator = .init(gpa); - defer arena.deinit(); - const out = try gpa.alloc(u8, 64 * 1024); - defer gpa.free(out); - var notes: WalkNotes = .{}; - const n = try grep(arena.allocator(), gpa, dir, dir, "needle", out, ¬es); - _ = libc.chmod(locked, 0o644); // so `tmp.cleanup` can remove it - - try std.testing.expect(std.mem.indexOf(u8, out[0..n], "b-open.txt") != null); - try std.testing.expect(std.mem.indexOf(u8, out[0..n], "a-locked.txt") == null); -} - -test "a directory the walk may not open is skipped and counted: Grep and Find keep every other hit" { - if (!platform_has_fs) return; - const gpa = std.testing.allocator; - var tmp = std.testing.tmpDir(.{}); - defer tmp.cleanup(); - var base_buf: [std.fs.max_path_bytes]u8 = undefined; - const dir = base_buf[0..try tmp.dir.realPath(std.testing.io, &base_buf)]; - try tmp.dir.createDirPath(std.testing.io, "locked"); - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "locked/needle-in.txt", .data = "needle\n" }); - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "needle-out.txt", .data = "needle\n" }); - var locked_buf: [std.fs.max_path_bytes]u8 = undefined; - const locked = try std.fmt.bufPrintSentinel(&locked_buf, "{s}/locked", .{dir}, 0); - if (libc.chmod(locked, 0) != 0) return; - defer _ = libc.chmod(locked, 0o755); // so `tmp.cleanup` can remove it - if (isDir(locked)) return error.SkipZigTest; // root reads it anyway - var arena: std.heap.ArenaAllocator = .init(gpa); - defer arena.deinit(); - const out = try gpa.alloc(u8, 64 * 1024); - defer gpa.free(out); - var notes: WalkNotes = .{}; - var n = try grep(arena.allocator(), gpa, dir, dir, "needle", out, ¬es); - try std.testing.expect(std.mem.indexOf(u8, out[0..n], "needle-out.txt:1:") != null); - try std.testing.expectEqual(@as(usize, 1), notes.skipped); - notes = .{}; - n = try find(arena.allocator(), dir, "needle", out, ¬es); - try std.testing.expect(std.mem.indexOf(u8, out[0..n], "needle-out.txt") != null); - try std.testing.expectEqual(@as(usize, 1), notes.skipped); -} - -test "Grep reads a long file to its end, and says when its hits were cut" { - if (!platform_has_fs) return; - const gpa = std.testing.allocator; - var tmp = std.testing.tmpDir(.{}); - defer tmp.cleanup(); - var base_buf: [std.fs.max_path_bytes]u8 = undefined; - const dir = base_buf[0..try tmp.dir.realPath(std.testing.io, &base_buf)]; - // A match past the first buffer of a long file, on its own line number. - const long = try gpa.alloc(u8, grep_max_bytes + 64); - defer gpa.free(long); - @memset(long, 'x'); - for (0..long.len / 64) |i| long[i * 64] = '\n'; - @memcpy(long[long.len - 8 ..][0..7], "needle\n"); - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "long.txt", .data = long }); - var arena: std.heap.ArenaAllocator = .init(gpa); - defer arena.deinit(); - const out = try gpa.alloc(u8, 256 * 1024); - defer gpa.free(out); - var notes: WalkNotes = .{}; - var n = try grep(arena.allocator(), gpa, dir, dir, "needle", out, ¬es); - var want_buf: [64]u8 = undefined; - const want = try std.fmt.bufPrint(&want_buf, "long.txt:{d}:", .{std.mem.count(u8, long, "\n")}); - try std.testing.expect(std.mem.startsWith(u8, out[0..n], want)); - // More hits than the cap. - var many: std.ArrayList(u8) = .empty; - defer many.deinit(gpa); - for (0..find_max_hits + 10) |_| try many.appendSlice(gpa, "needle\n"); - try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "many.txt", .data = many.items }); - notes = .{}; - n = try grep(arena.allocator(), gpa, dir, dir, "needle", out, ¬es); - try std.testing.expect(notes.hits_cut); - var said: [256]u8 = undefined; - const lines = said[0..notes.write(&said)]; - try std.testing.expectEqualStrings("cut at 512 hits\n", lines); - try std.testing.expect(WalkNotes.isNote("cut at 512 hits") and WalkNotes.isNote("2 directories skipped: permission denied") and !WalkNotes.isNote("src/2 directories.txt")); -} - fn isDir(path: [*:0]const u8) bool { const fd = libc.open(path, .{ .ACCMODE = .RDONLY, .DIRECTORY = true, .CLOEXEC = true }); if (fd < 0) return false; diff --git a/src/look.zig b/src/look.zig index eed3dbd9..cd8df4fc 100644 --- a/src/look.zig +++ b/src/look.zig @@ -532,7 +532,6 @@ pub fn cursorWordSel(p: *Pardes, pane: *Pane) Pane.Sel { return .{ .state = .done, .c0 = vcol, .c1 = vcol, .r0 = vrow, .r1 = vrow }; } -const Search = enum { text, find, grep }; const SearchStart = enum { top, cursor }; @@ -550,20 +549,13 @@ pub fn submitSearch(p: *Pardes, id: usize) void { const slash = std.mem.indexOfScalar(u8, armed, '/') orelse return; if (std.mem.startsWith(u8, armed, config.rename_marker)) return p.lspRequest(id, .rename, armed[slash + 1 ..]); if (std.mem.startsWith(u8, armed, config.symbol_marker)) return p.lspRequest(id, .workspace_symbols, armed[slash + 1 ..]); - const kind: Search = if (std.mem.startsWith(u8, armed, config.find_marker)) - .find - else if (std.mem.startsWith(u8, armed, config.grep_marker)) - .grep - else - .text; - _ = runSearch(p, id, armed[slash + 1 ..], kind, .top, true) catch |err| return p.reportError(id, "search", err); - if (kind == .text) { - var pattern: std.ArrayList(u8) = .empty; - normal.appendSearchLiteral(&pattern, p.scratch.allocator(), armed[slash + 1 ..]) catch return; - p.registers.put(p.gpa, '/', pattern.items, 0, 1, true); - p.registers.last_search = '/'; - lookFirstHit(p, id); - } + // A PDF's `/` and a terminal's: a text's is its query pane (Query.zig). + _ = runSearch(p, id, armed[slash + 1 ..], .top, true) catch |err| return p.reportError(id, "search", err); + var pattern: std.ArrayList(u8) = .empty; + normal.appendSearchLiteral(&pattern, p.scratch.allocator(), armed[slash + 1 ..]) catch return; + p.registers.put(p.gpa, '/', pattern.items, 0, 1, true); + p.registers.last_search = '/'; + lookFirstHit(p, id); } fn lookFirstHit(p: *Pardes, id: usize) void { @@ -589,7 +581,7 @@ fn lookFirstHit(p: *Pardes, id: usize) void { /// of rows: past it, the rows stop and say where. pub const search_text_output_bytes = 16 << 20; -pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start: SearchStart, open_empty: bool) !usize { +pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, start: SearchStart, open_empty: bool) !usize { const pane = p.panes[id] orelse return 0; // Blanks at either end are the pattern's (a look of an indented line); // a builtin's argument comes trimmed already. @@ -607,49 +599,7 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start var nrows: usize = 0; var anchor: ?usize = null; var notes: filesystem.WalkNotes = .{}; - if (kind == .grep) { - var roots: [MAX_PANES][]const u8 = undefined; - var nroots: usize = 0; - for (p.panes) |slot| { - const pp = slot orelse continue; - // A pane of the served tree (/virtual/, /n//) has no - // directory on this host to walk, and one that named `/` would - // swallow every other root: passed over. - const d = filesystem.localPath(Pardes.paneDir(pp)) orelse continue; - if (filesystem.isVirtual(if (pp.file) |f| f.path else d)) continue; - var covered = false; - var k: usize = 0; - while (k < nroots) { - if (pathUnder(d, roots[k])) { - covered = true; - break; - } - if (pathUnder(roots[k], d)) { // this one swallows a root already kept - nroots -= 1; - roots[k] = roots[nroots]; - continue; - } - k += 1; - } - if (covered) continue; - roots[nroots] = d; - nroots += 1; - } - out = try @import("memory.zig").unfilled(arena, @max(1, nroots) * filesystem.search_root_output_bytes); - // A pane's directory that is not there (a scratch named into one - // not made yet, a peer's) has nothing to grep: passed over, not the - // search's failure. - for (roots[0..nroots]) |r| - out_len += filesystem.grep(arena, p.gpa, r, dir, pat, out[out_len..], ¬es) catch |err| switch (err) { - error.FileNotFound, error.NotDir, error.AccessDenied => continue, - else => return err, - }; - nrows = std.mem.count(u8, out[0..out_len], "\n"); - } else if (kind == .find) { - out = try @import("memory.zig").unfilled(arena, filesystem.search_root_output_bytes); - out_len = try filesystem.find(arena, dir, pat, out, ¬es); - nrows = std.mem.count(u8, out[0..out_len], "\n"); - } else if (pane.hasPdf()) { + if (pane.hasPdf()) { out = try @import("memory.zig").unfilled(arena, search_text_output_bytes); if (comptime pdf_enabled) { const found = try panes.Pdf.searchRows( @@ -700,19 +650,10 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, kind: Search, start const noted = notes.write(out[out_len..]); out_len += noted; nrows += std.mem.count(u8, out[out_len - noted .. out_len], "\n"); - // A Find or Grep that finds nothing leaves its directory's +Search as - // it was: the failure says why, and the last search's rows are still - // that search's (its tag names it). + // A word looked for that is nowhere opens nothing. if (!open_empty and nrows == 0) return 0; const content = try p.gpa.dupe(u8, out[0..out_len]); - // the buffer records WHICH search filled it, pattern and all: Find and - // Grep are builtins (words you can execute), the bare `/` is a key - const from: panes.Output.Origin = switch (kind) { - .text => .search, - .find => .{ .cmd = .Find }, - .grep => .{ .cmd = .Grep }, - }; - try panes.Output.fillResults(p, id, dir, from, pat, content, anchor); + try panes.Output.fillResults(p, id, dir, .search, pat, content, anchor); return nrows; } @@ -1466,7 +1407,7 @@ fn lookUnresolved(p: *Pardes, id: usize, pane: *Pane, trimmed: []const u8, text: if (p.settings.look_word == .search and pane.file != null) return lookWord(p, id, pane, text); p.word_look = true; defer p.word_look = false; - const rows = runSearch(p, id, text, .text, .cursor, false) catch |err| { + const rows = runSearch(p, id, text, .cursor, false) catch |err| { p.reportError(id, "search", err); return; }; diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig index 45336a1e..635e03a6 100644 --- a/src/ninep/ctl.zig +++ b/src/ninep/ctl.zig @@ -3017,7 +3017,7 @@ test "a builtin that needs its argument, written bare to an exec, is EINVAL as t } } -test "Grep with no hit says grep: no match and opens nothing, a missing pane directory passed over" { +test "a script's Grep and Find fill the pane's one query pane, a row a line under its file; a miss says not found and opens nothing" { const p = try withFile(testing.allocator, "x\n"); defer p.deinit(); var tmp = testing.tmpDir(.{}); @@ -3028,22 +3028,26 @@ test "Grep with no hit says grep: no match and opens nothing, a missing pane dir const dir = dir_buf[0..try tmp.dir.realPath(testing.io, &dir_buf)]; var line: [4200]u8 = undefined; _ = wr(p, Node.of(serialOf(p), .name), try std.fmt.bufPrint(&line, "{s}/a.txt\n", .{dir})); - // A hit opens its +Search, a row a line: exec reads it back. Find and - // Grep share it, a directory's one +Search, each run replacing it. + // A hit fills the pane's query pane, line 1 the command, its rows under + // the file they are in: exec reads it back. Find and Grep share it, the + // pane's one query pane, each run replacing it. try testing.expectEqual(Status.ok, wr(p, Node.of(serialOf(p), .exec), "Grep bravo\n").reply.status); const grepped = p.panes[p.paneBySerial(try std.fmt.parseInt(u32, std.mem.trimEnd(u8, rd(p, root_exec, 0, 64).bytes, "\n"), 10)).?].?; - try testing.expectEqual(@as(usize, 2), std.mem.count(u8, grepped.file.?.content, "other.txt:")); - try testing.expect(std.mem.indexOf(u8, grepped.file.?.content, "other.txt:2") != null); - try testing.expect(std.mem.indexOf(u8, grepped.file.?.content, "other.txt:3") != null); + const rows = grepped.file.?.content; + try testing.expect(std.mem.startsWith(u8, rows, "Grep bravo\n")); + try testing.expect(std.mem.indexOf(u8, rows, "\nother.txt\n") != null); + try testing.expect(std.mem.indexOf(u8, rows, "2 bravo here\n") != null); + try testing.expect(std.mem.indexOf(u8, rows, "3 three bravo\n") != null); + try testing.expectEqual(@as(usize, 2), grepped.query.?.total); try testing.expectEqual(Status.ok, wr(p, Node.of(serialOf(p), .exec), "Find other\n").reply.status); const found = p.panes[p.paneBySerial(try std.fmt.parseInt(u32, std.mem.trimEnd(u8, rd(p, root_exec, 0, 64).bytes, "\n"), 10)).?].?; - try testing.expect(std.mem.indexOf(u8, found.file.?.content, "other.txt") != null); try testing.expectEqual(grepped.serial, found.serial); + try testing.expect(std.mem.indexOf(u8, found.file.?.content, "\nother.txt\n") != null); try testing.expect(std.mem.indexOf(u8, found.file.?.content, "bravo here") == null); - // The same Find again reads back the +Search, not the pane it ran in. + // The same Find again reads back the query pane, not the pane it ran in. try testing.expectEqual(Status.ok, wr(p, Node.of(serialOf(p), .exec), "Find other\n").reply.status); try testing.expectEqualStrings(try std.fmt.bufPrint(&line, "{d}\n", .{found.serial}), rd(p, root_exec, 0, 64).bytes); - // A Grep run from the +Search itself fills that one, never a second. + // A Grep run from the query pane itself fills that one, never a second. try testing.expectEqual(Status.ok, wr(p, Node.of(found.serial, .exec), "Grep bravo\n").reply.status); try testing.expectEqualStrings(try std.fmt.bufPrint(&line, "{d}\n", .{found.serial}), rd(p, root_exec, 0, 64).bytes); var searches: usize = 0; @@ -3052,23 +3056,19 @@ test "Grep with no hit says grep: no match and opens nothing, a missing pane dir }; try testing.expectEqual(@as(usize, 1), searches); try testing.expect(std.mem.indexOf(u8, found.file.?.content, "bravo here") != null); - // A second pane in a directory that is not there. - const other = try th.newPane(p); - _ = wr(p, Node.of(other, .name), "/tmp/pardes-no-such-dir-zz/b.txt\n"); var count: usize = 0; for (p.panes) |slot| count += @intFromBool(slot != null); + // A miss: said to the script, the query pane's count 0, nothing opened. const missed = wr(p, Node.of(serialOf(p), .exec), "Grep zzqqnomatchzz\n"); try testing.expectEqual(E.NOENT, missed.errno()); try testing.expectEqualStrings("Grep: text not found", missed.reply.ename); + try testing.expectEqual(@as(usize, 0), found.query.?.total); const unfound = wr(p, Node.of(serialOf(p), .exec), "Find zzqqnomatchzz\n"); try testing.expectEqual(E.NOENT, unfound.errno()); try testing.expectEqualStrings("Find: name not found", unfound.reply.ename); var after: usize = 0; for (p.panes) |slot| after += @intFromBool(slot != null); try testing.expectEqual(count, after); - // The +Search a miss would have filled keeps the last search's rows: - // the miss is said, and its tag names what they are of. - try testing.expect(std.mem.indexOf(u8, found.file.?.content, "bravo here") != null); } test "Unmount of a name not mounted says no such mount, which a mount reads as ENOENT" { @@ -4911,7 +4911,7 @@ test "a Rename the server answered for this file alone, with other open files sa try testing.expect(th.logHas(p, "Rename: previewed, not applied: the server renamed in this file only, and 1 other open file(s) say the name")); } -test "Find ends with what it skipped, and a Find or Grep that finds nothing leaves the +Search as it was" { +test "Find says what it skipped under its names, and a script's Find that finds nothing is told so" { if (comptime !pardes.hosted) return; const gpa = testing.allocator; var tmp = testing.tmpDir(.{}); @@ -4928,18 +4928,18 @@ test "Find ends with what it skipped, and a Find or Grep that finds nothing leav const path = try std.fmt.bufPrint(&path_buf, "{s}/zz-needle.txt", .{dir}); const p = try Pardes.init(gpa, .{ .file = path, .tty_only = true, .cols = 80, .rows = 30 }); defer p.deinit(); - try testing.expect(p.executeBuiltinLine(0, "Find needle")); - const search = p.panes[p.panes[0].?.search_pane.?].?; + // the walk's own skips are what is said (rg would pass over in silence) + p.stream.engine = .walk; + try testing.expectEqual(Status.ok, wr(p, Node.of(serialOf(p), .exec), "Find needle\n").reply.status); + const search = p.panes[pardes.panes.Query.ofOwner(p, p.panes[0].?.serial).?].?; const listed = search.file.?.content; try testing.expect(std.mem.endsWith(u8, listed, "1 directory skipped: permission denied\n")); - try testing.expect(std.mem.startsWith(u8, listed, "zz-needle.txt\n")); - // Nothing found where it looked, and nothing passed over: the miss is - // said, and the +Search keeps the last search's rows. + try testing.expect(std.mem.startsWith(u8, listed, "Find needle\nzz-needle.txt\n")); + // Nothing found: the miss is said, the query pane's count 0. _ = std.c.chmod(locked, 0o755); - const before = try gpa.dupe(u8, listed); - defer gpa.free(before); - try testing.expect(p.executeBuiltinLine(0, "Find nosuchname")); - try testing.expectEqualStrings(before, search.file.?.content); + const missed = wr(p, Node.of(serialOf(p), .exec), "Find nosuchname\n"); + try testing.expectEqual(E.NOENT, missed.errno()); + try testing.expectEqual(@as(usize, 0), search.query.?.total); try testing.expect(th.logHas(p, "Find: name not found")); } diff --git a/src/normal.zig b/src/normal.zig index ebace536..f5bdb9dc 100644 --- a/src/normal.zig +++ b/src/normal.zig @@ -757,22 +757,18 @@ fn executeNormalAction(p: *Pardes, t: *Text, semantic: modal.Normal.Action) void .add_newline => |newline| return edit.addNewline(p, t, newline.direction == .forward, newline.count), .diagnostic => |diagnostic| { const fwd = diagnostic.direction == .forward; - if (!diagnostic.endpoint) { - if (panes.Output.resultsFrom(p, pane, .{ .query = .diagnostics }) and - look.searchStep(p, p.active, if (fwd) 1 else -1)) return; - return p.lspRequest(p.active, .diagnostics, ""); - } - if (!panes.Output.resultsFrom(p, pane, .{ .query = .diagnostics })) - return p.lspRequest(p.active, .diagnostics, ""); - if (!fwd) { - pane.search_row = null; - _ = look.searchStep(p, p.active, 1); - return; - } - const rp = p.panes[pane.search_pane orelse return] orelse return; - const rf = rp.file orelse return; - pane.search_row = std.mem.count(u8, rf.content, "\n"); - _ = look.searchStep(p, p.active, -1); + // Once a Diagnostics query fed them, the diagnostics are this + // text's places: ]d and [d step them as n and N do, ]D and [D + // go to the last and the first. Until then, asked for. + const set = &pane.places; + const fed = set.started and set.provenance == .list and if (p.paneBySerial(set.from)) |qid| + (if (p.panes[qid].?.query) |q| q.source == .diagnostics else false) + else + false; + if (!fed) return p.lspRequest(p.active, .diagnostics, ""); + if (!diagnostic.endpoint) return set.step(p, pane, fwd, 1, false); + if (set.hits.items.len == 0) return; + set.goTo(pane, if (fwd) set.hits.items.len - 1 else 0, false); }, .move => |move| switch (move.motion) { .left => { diff --git a/src/tagline.zig b/src/tagline.zig index 3c8dd3e1..c057772d 100644 --- a/src/tagline.zig +++ b/src/tagline.zig @@ -184,6 +184,7 @@ pub fn curTail(pane: *Pane) []const u8 { pub fn defaultTail(pane: *const Pane) []const u8 { if (comptime pdf_enabled) if (pane.pdf != null) return pdf_pane_tail; if (pane.query) |q| return if (q.frozen) query_frozen_tail else if (q.capped) query_capped_tail else query_live_tail; + if (pane.file) |file| if (file.output) |out| if (out.from == .preview) return query_live_tail; if (pane.file) |file| if (file.listing != null) return dir_pane_tail; if (pane.file) |file| if (file.pager) return if (file.pager_diff) pager_diff_pane_tail else pager_pane_tail; if (pane.file != null and pane.colorAlgo() == .diff) return diff_pane_tail; diff --git a/src/tutor.txt b/src/tutor.txt index 083a5028..188a485d 100644 --- a/src/tutor.txt +++ b/src/tutor.txt @@ -101,8 +101,10 @@ 1. `Look` :20 here: the cursor goes to line 20 of this pane. 2. Drag across :/^=.*UNSAVED/ with B3 held: `Look` takes exactly what you swept, a regex here, and goes to Part 7's heading. - 3. Press /, type keys, press Enter: a +Search lists the lines with - keys and the cursor goes to the first. n and N select search matches. + 3. Press / and type keys: a +Search opens under this pane, its first + line the query; each match lights up and is listed as you type, and + Ctrl-n steps. Enter puts the cursor on it and keeps the list; n and N + step them. Esc while typing puts everything back. -> Guide: Look @@ -259,9 +261,9 @@ typed ] p, [ p step by paragraph; ] d, [ d by diagnostic ] space a blank line below; [ space above | filter every selection through the shell - / case-insensitive SUBSTRING search, one hit a line; the - regex lives on s and S - n / N next/previous search match (Helix); v adds matches + / search in a query pane under the text: a regex, any + case unless it has a capital; line 1 is the query + n / N next/previous match, round the end; v adds matches SPC j n/p `LookNext`/`LookPrev`: select locations; Enter opens Ctrl-c comment or uncomment the lines @@ -344,11 +346,11 @@ typed ; collapses first bare G does nothing; ge is the START of the last line s / S regex cursors; m i/a textobjects; m s/r/d surround - / is a case-insensitive SUBSTRING search, not a regex + / opens a query pane: line 1 the query, Enter lands SPC is the leader (SPC ? is `Help`) vs HELIX selection is LINE-first (x), v for characters; / is a - substring search; n/N repeat it in the current text. + pane: Find, Grep, Recent are its line 1's first word. vs VIM no verb+noun: the motion already selected, so wd is what dw was; Esc goes back a pane; bare G does nothing. vs BOTH a terminal is just a pane, and the session can outlive diff --git a/test/output.zig b/test/output.zig index 8ba2f357..8eb389c8 100644 --- a/test/output.zig +++ b/test/output.zig @@ -219,6 +219,15 @@ test "references fill the asking text's query pane: sorted under their files, th try std.testing.expectEqual(@as(?usize, 2), source.places.current); try std.testing.expectEqual(@as(i32, 3), source.body.cur_row); try std.testing.expectEqual(@as(usize, 6), results.query.?.total); + // Ctrl-n on line 1, Enter: the keyboard on that ref in the text + try std.testing.expectEqual(qid, p.active); + p.update(.{ .key = .{ .cp = 'n', .ctrl = true } }); + try std.testing.expectEqual(@as(?usize, 3), source.places.current); + p.update(.{ .key = .{ .cp = Key.enter } }); + try std.testing.expectEqual(@as(usize, 0), p.active); + try std.testing.expectEqual(@as(i32, 4), source.body.cur_row); + p.update(.{ .key = .{ .cp = 'N' } }); + try std.testing.expectEqual(@as(?usize, 2), source.places.current); // n in the owner steps them, round the end without a word p.active = 0; p.update(.{ .key = .{ .cp = 'n' } }); diff --git a/test/pdf.zig b/test/pdf.zig index ea23f90a..d4efdfaf 100644 --- a/test/pdf.zig +++ b/test/pdf.zig @@ -1053,7 +1053,7 @@ test "MuPDF pane renders, navigates, searches, and round-trips its page" { try std.testing.expect(pane.pdf.?.document_scroll_y > before_height_scroll); const revision_before_search = active_raster.revision; - _ = try pardes.look.runSearch(p, 0, "Pardes", .text, .top, true); + _ = try pardes.look.runSearch(p, 0, "Pardes", .top, true); try std.testing.expectEqualStrings("Pardes", pane.pdf.?.search_query); try std.testing.expectEqual(revision_before_search, active_raster.revision); const results_id = pane.search_pane orelse return error.MissingPdfSearchResults; @@ -1915,7 +1915,7 @@ test "PDF n/N addresses and reveals distinct MuPDF hits on one page" { p.locations_config.context = 2; p.locations_config.tscontext = true; - _ = try pardes.look.runSearch(p, 0, "Pardes", .text, .top, true); + _ = try pardes.look.runSearch(p, 0, "Pardes", .top, true); const results_id = pane.search_pane orelse return error.MissingPdfSearchResults; const results = p.panes[results_id].?.file.?; var found: [3]bool = @splat(false); diff --git a/test/snapshots/builtins.snap b/test/snapshots/builtins.snap index 73509c24..cf367c5a 100644 --- a/test/snapshots/builtins.snap +++ b/test/snapshots/builtins.snap @@ -37,6 +37,29 @@ wheel up 110 50 wheel up 110 50 wheel up 110 50 wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 +wheel up 110 50 wait 10000 Look enter, right-click wait 10000 Exec tab, middle-click wait 10000 Filter diff --git a/test/snapshots/dump.golden b/test/snapshots/dump.golden index 571bacbc..72bb85a7 100644 --- a/test/snapshots/dump.golden +++ b/test/snapshots/dump.golden @@ -37,6 +37,7 @@ .collapsed = false, .serial = 1, .tag_tail = null, + .attached_to = null, .terminal = .{ .cwd = "/tmp/pardes-snap/dump/cwd", .shell = "", @@ -62,6 +63,7 @@ .collapsed = false, .serial = 2, .tag_tail = null, + .attached_to = null, .terminal = .{ .cwd = "/tmp/pardes-snap/dump/cwd", .shell = "", @@ -87,6 +89,7 @@ .collapsed = false, .serial = 3, .tag_tail = null, + .attached_to = null, .terminal = .{ .cwd = "/tmp/pardes-snap/dump/cwd", .shell = "", diff --git a/test/snapshots/find.golden b/test/snapshots/find.golden index 47480b83..e5c11193 100644 --- a/test/snapshots/find.golden +++ b/test/snapshots/find.golden @@ -2,91 +2,61 @@ | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol | /tmp/pardes-snap/find/cwd/here.txt Save Tty Collapse Del -| 1 Find SPC f -== snap armed grid=120x41 cursor=119,4 -|3: 1 Find Find -|4: Find / -== snap typing grid=120x41 cursor=119,3 -|3: 1 Find Find /zqm -|4: -== snap results grid=120x41 cursor=7,3 -|3: 1 Find -|5: /tmp/pardes-snap/find/cwd/+Search Save Tty Collapse Del -|6: 1 sub/ZQMARK-beta.txt -|7: 2 sub/nest/zqmark-gamma.txt -|8: 3 zqmark-alpha.txt -|9: 4 -== snap first grid=120x41 cursor=7,10 -|9: /tmp/pardes-snap/find/cwd/sub/ZQMARK-beta.txt Save Tty Collapse Del -|10: 1 beta body -== style first grid=120x41 -|0: 0-1 d,#1d2824, 2-119 #b2c3b8,#1d2824, -|1: 0-1 d,#887455, 2-119 #becfc4,#314738, -|2: 0-1 d,#496656, 2-27 #b2c3b8,#1d2824, 28-36 #d3b0d9,#1d2824, 37-119 #b2c3b8,#1d2824, -|3: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-119 #e5eee5,#0d1410, -|4: 0-0 d,#608269, 1-119 d,#0d1410, -|5: 0-1 d,#496656, 2-27 #b2c3b8,#1d2824, 28-35 #d3b0d9,#1d2824, 36-119 #b2c3b8,#1d2824, -|6: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-119 #e5eee5,#0d1410, -|7: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-119 #e5eee5,#0d1410, -|8: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-119 #e5eee5,#0d1410, -|9: 0-1 d,#add38a, 2-31 #becfc4,#314738, 32-47 #dfbce5,#314738, 48-119 #becfc4,#314738, -|10: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-119 #e5eee5,#0d1410, -|11: 0-0 d,#608269, 1-119 d,#0d1410, -|12: 0-0 d,#608269, 1-119 d,#0d1410, -|13: 0-0 d,#608269, 1-119 d,#0d1410, -|14: 0-0 d,#608269, 1-119 d,#0d1410, -|15: 0-0 d,#608269, 1-119 d,#0d1410, -|16: 0-0 d,#608269, 1-119 d,#0d1410, -|17: 0-0 d,#608269, 1-119 d,#0d1410, -|18: 0-0 d,#608269, 1-119 d,#0d1410, -|19: 0-0 d,#608269, 1-119 d,#0d1410, -|20: 0-0 d,#608269, 1-119 d,#0d1410, -|21: 0-0 d,#608269, 1-119 d,#0d1410, -|22: 0-0 d,#608269, 1-119 d,#0d1410, -|23: 0-0 d,#608269, 1-119 d,#0d1410, -|24: 0-0 d,#608269, 1-119 d,#0d1410, -|25: 0-0 d,#608269, 1-119 d,#0d1410, -|26: 0-0 d,#608269, 1-119 d,#0d1410, -|27: 0-0 d,#608269, 1-119 d,#0d1410, -|28: 0-0 d,#608269, 1-119 d,#0d1410, -|29: 0-0 d,#608269, 1-119 d,#0d1410, -|30: 0-0 d,#608269, 1-119 d,#0d1410, -|31: 0-0 d,#608269, 1-119 d,#0d1410, -|32: 0-0 d,#608269, 1-119 d,#0d1410, -|33: 0-0 d,#608269, 1-119 d,#0d1410, -|34: 0-0 d,#608269, 1-119 d,#0d1410, -|35: 0-0 d,#608269, 1-119 d,#0d1410, -|36: 0-0 d,#608269, 1-119 d,#0d1410, -|37: 0-0 d,#608269, 1-119 d,#0d1410, -|38: 0-0 d,#608269, 1-119 d,#0d1410, -|39: 0-0 d,#608269, 1-119 d,#0d1410, -|40: 0-0 d,#608269, 1-119 d,#0d1410, -== snap second grid=120x41 cursor=7,13 -|12: /tmp/pardes-snap/find/cwd/sub/nest/zqmark-gamma.txt Save Tty Collapse Del -|13: 1 gamma body -== snap third grid=120x41 cursor=7,16 -|15: /tmp/pardes-snap/find/cwd/zqmark-alpha.txt Save Tty Collapse Del -|16: 1 alpha body -== snap back grid=120x41 cursor=7,13 -== snap word grid=120x41 cursor=7,13 -|3: 1 Find Find -|4: Find / -== snap cancel grid=120x41 cursor=7,7 -|3: 1 Find Find / -|4: -|13: 1 gamma body Last -== snap nomatch grid=120x41 cursor=7,3 -|3: 1 Find -|6: 1 -|7: -|8: -|13: 1 gamma body -== snap refit grid=120x41 cursor=7,3 -|6: 1 sub/ZQMARK-beta.txt -|7: 2 sub/nest/zqmark-gamma.txt -|8: 3 zqmark-alpha.txt -== snap topbar grid=120x41 cursor=12,16 -|6: 1 zqmark-alpha.txt -|7: 2 -|8: -|16: 1 alpha body Find +| 1 Find zqm SPC f +== snap armed grid=120x41 cursor=7,23 +|3: 1 Find zqm Find +|22: ^ +Search 1/5 Del +|23: Find +|24: here.txt +|25: other.txt +|26: sub/ZQMARK-beta.txt +|27: sub/nest/zqmark-gamma.txt +|28: zqmark-alpha.txt +|32: /tmp/pardes-snap/find/cwd/+Preview Del +|33: 1 +== snap typing grid=120x41 cursor=10,23 +|3: 1 Find zqm +|22: ^ +Search 1/3 Del +|23: Find zqm +|24: zqmark-alpha.txt +|25: sub/ZQMARK-beta.txt +|26: sub/nest/zqmark-gamma.txt +|27: +|28: +|32: /tmp/pardes-snap/find/cwd/zqmark-alpha.txt Del +|33: 1 alpha body +== snap next grid=120x41 cursor=10,23 +|22: ^ +Search 2/3 Del +|32: /tmp/pardes-snap/find/cwd/sub/ZQMARK-beta.txt Del +|33: 1 beta body +== snap promoted grid=120x41 cursor=7,33 +|22: +Search 2/3 Save Unattach Del +|32: /tmp/pardes-snap/find/cwd/sub/ZQMARK-beta.txt Save Tty Collapse Del +== snap nomatch grid=120x41 cursor=11,14 +|13: ^ +Search 0 Del +|14: Find zzqq +|22: +|23: /tmp/pardes-snap/find/cwd/+Preview Del +|24: 1 +|25: +|26: +== snap cancel grid=120x41 cursor=7,3 +|13: +|14: +|22: +Search 2/3 Save Unattach Del +|23: Find zqm +|24: zqmark-alpha.txt +|25: sub/ZQMARK-beta.txt +|26: sub/nest/zqmark-gamma.txt +== snap topbar grid=120x41 cursor=14,3 +|3: 1 Find zqm Find +|13: +Search 1/3 Del +|14: Find zqm +|15: zqmark-alpha.txt +|16: sub/ZQMARK-beta.txt +|17: sub/nest/zqmark-gamma.txt +|22: +|23: /tmp/pardes-snap/find/cwd/zqmark-alpha.txt Del +|24: 1 alpha body +|25: +|26: diff --git a/test/snapshots/find.snap b/test/snapshots/find.snap index b2e36973..17470040 100644 --- a/test/snapshots/find.snap +++ b/test/snapshots/find.snap @@ -1,19 +1,18 @@ -# The Find builtin (SPC f f) = `fd`, in-core: it arms the SAME tag input `/` -# does, but Enter walks the pane's DIRECTORY instead of its text and writes one -# matching path per row into a "+Search" OUTPUT BUFFER. Every row is therefore -# an ordinary look target, which is the whole point: n/N SELECT the next/prev -# one with no code of their own, and the look chord — Enter, the same one that -# opens a path anywhere else — is what OPENS it. Focus then follows the file -# that opened, but the look was made FROM the results buffer, so the next n -# resumes stepping that same list. Where each pane lands is acme's placement -# (docs/typ/guide.typ, where new panes go): under the text of the pane with the -# most blank rows. The walk skips .git, matches the NAME -# case-insensitively, and sorts (readdir order is not stable). `SPC f s` is -# Save, which moved out of `w` to make this group. +# SPC f f: a query pane under the pane (Query.zig), line 1 `Find `, typed +# into. The files below the pane's directory are listed once, on the disk +# engine's worker (rg --files when it is on PATH, else the sorted walk: both +# pass over .git), and each key scores them fuzzily (pick's scorer), the best +# first, the matched letters tinted. The current one is shown in the +# +Preview under the query pane, born with it so nothing moves later; +# Ctrl-n / Ctrl-p step it, never the pointer. Enter makes the preview the +# file's pane where it stands. Esc while typing closes the query pane and +# gives its rows back. A query that matches nothing is a count of 0, not an +# exit. B2 on `Find` with a selection asks with that word, the keyboard +# staying in the text. dirmk sub dirmk sub/nest dirmk .git -file here.txt Find +file here.txt Find zqm file zqmark-alpha.txt alpha body file sub/ZQMARK-beta.txt beta body file sub/nest/zqmark-gamma.txt gamma body @@ -22,108 +21,51 @@ file .git/zqmark-hidden.txt hidden body start 41 120 here.txt wait 8000 here.txt stable 700 20000 -# SPC f is a GROUP now (Find + New + Save): the indicator stays on the tag +# SPC f is a group (Find, New, Save, Recent, Grep): the indicator waits key space key f stable 400 5000 snap group -# ... and the second f arms the input, marker visible in the tag +# the second f opens the query pane: every file listed, line 1 `Find ` key f -stable 400 5000 +wait 10000 zqmark-alpha.txt +stable 700 15000 snap armed text zqm -stable 400 5000 -snap typing -# Enter walks: three hits, sorted, .git's copy skipped, other.txt not matched -key enter -wait 10000 zqmark-alpha.txt stable 700 15000 -snap results -# n SELECTS row 1 and Enter looks it — a path, so the file OPENS, under the -# list's text, and each file after it under the one before. -key space j n -key enter +snap typing +# the next one current, its text in the preview +key c-n wait 10000 beta body stable 700 15000 -snap first -snapstyle first -key space j n -key enter -wait 10000 gamma body -stable 700 15000 -snap second -key space j n -key enter -wait 10000 alpha body -stable 700 15000 -snap third -# N walks back up one row; Enter looks it, and the file is already open, so -# the look just focuses it -key space j p +snap next +# Enter: the preview is that file's pane now, where it stood key enter stable 700 15000 -snap back -# executing the WORD Find (middle-click in a body) arms the same input — the -# enum IS the dispatch — and Esc abandons it. The input is its own line, so an -# abandoned one leaves nothing behind in the tag -press middle 8 4 -release middle 8 4 -stable 700 10000 -snap word -key esc -settle 100 -stable 400 5000 -snap cancel -# every search is asked from a PANE, and both a look and now a step leave you -# somewhere else — so click back into here.txt first. That is not bookkeeping: -# a search never refills the buffer it was asked FROM (fillResults skips it), -# so `owned by here.txt` is the whole premise of the two steps below. +snap promoted +# a second Find from here.txt reuses its query pane; nothing found is 0 press left 8 4 release left 8 4 stable 400 5000 -# a no-match walk opens an empty list of its own, under the last file's text. key space key f key f text zzqq -key enter -stable 700 10000 -# n does not stop on the empty list, because the walk is a RING across panes -# rather than one buffer's rows: with nothing look-able here it carries on -# into the list that DOES have some — the zqm one — and resumes it one row -# past where the N above left it. Nothing opens; only the selection moved. -key space j n -stable 400 5000 +stable 700 15000 snap nomatch -# ... and asking for `zqm` AGAIN re-arms the list it ALREADY filled instead of -# stacking an identical twin under the empty one — even though the step above -# left the cursor sitting in the zqm list, so the reuse is by what a buffer -# HOLDS (this search, this pattern, this directory), not by which one anything -# happens to point at. Asked from here.txt again (the click, as above), and -# the LIST it rewrites is therefore the `nomatch` frame unchanged, down to the -# byte — only the cursor comes back with it. -press left 8 4 -release left 8 4 -stable 400 5000 -key space -key f -key f -text zqm -key enter -wait 10000 zqmark-alpha.txt +# Esc: the kept rows of the last query are back +key esc +settle 100 stable 700 15000 -snap refit -# Find is a TOPBAR word too: the same -# builtin the leader path runs, reached with the mouse. Chorded — a selection -# held when it runs IS the argument — so dragging over `alpha` and clicking -# Find walks for that name with nothing typed and no input armed. Row 17 is -# `alpha body`: the three found files stack in the order the looks above -# OPENED them, which is beta, gamma, alpha down the column. -press left 8 17 -drag left 13 17 -release left 13 17 +snap cancel +# B2 on Find with `zqm` selected in here.txt: the query pane under it, the +# keyboard still in here.txt +press left 13 4 +drag left 15 4 +release left 15 4 stable 400 5000 press middle @Find 1 release middle @Find 1 +wait 10000 Find zqm stable 700 15000 snap topbar diff --git a/test/snapshots/fsearch.golden b/test/snapshots/fsearch.golden index 62c37c25..5de12bab 100644 --- a/test/snapshots/fsearch.golden +++ b/test/snapshots/fsearch.golden @@ -19,78 +19,69 @@ | /tmp/pardes-snap/fsearch/cwd Tty+bash Save Mode Filter Collapse Del | ls | g.txt -== snap typing grid=180x31 cursor=89,7 -|7: 1 l1 /MARK -== snap results grid=180x31 cursor=10,8 -|7: 1 l1 -|21: /tmp/pardes-snap/fsearch/cwd/+Search Save Tty Collapse LocationsConfig Del -|22: 1 g.txt:2:1-4 -|23: 2 MARK a -|24: 3 g.txt:6:1-4 -|25: 4 MARK b -|26: 5 g.txt:10:1-4 -|27: 6 MARK c -|28: 7 -== style results grid=180x31 +== snap slash grid=180x31 cursor=3,10 +|9: ^ +Search 0 Del +|10: / +|11: +|12: +|13: +|14: +|15: +|16: +== snap typing grid=180x31 cursor=7,10 +|9: ^ +Search 1/3 Del +|10: /MARK +|11: 2 MARK a +|12: 6 MARK b +|13: 10 MARK c +== style typing grid=180x31 |0: 0-1 d,#1d2824, 2-179 #b2c3b8,#1d2824, |1: 0-1 d,#887455, 2-89 #becfc4,#314738, 90-91 #becfc4,#887455, 92-179 #b2c3b8,#1d2824, |2: 0-1 d,#496656, 2-30 #b2c3b8,#1d2824, 31-39 #d3b0d9,#1d2824, 40-89 #b2c3b8,#1d2824, 90-91 #b2c3b8,#496656, 92-120 #b2c3b8,#1d2824, 121-129 #d3b0d9,#1d2824, 130-179 #b2c3b8,#1d2824, |3: 0-0 d,#608269, 1-1 d,#0d1410, 2-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, |4: 0-0 d,#608269, 1-1 d,#0d1410, 2-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, |5: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, -|6: 0-1 d,#add38a, 2-30 #becfc4,#314738, 31-36 #dfbce5,#314738, 37-89 #becfc4,#314738, 90-90 #becfc4,#608269, 91-179 #becfc4,#0d1410, -|7: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|8: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-10 #f5f7ee,#3c614a, 11-11 #f5f7ee,#0d1410, 12-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|9: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|10: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|11: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|12: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|13: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|14: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|15: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|16: 0-0 d,#152019, 1-3 d,#0d1410, 4-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|6: 0-1 d,#496656, 2-30 #b2c3b8,#1d2824, 31-36 #d3b0d9,#1d2824, 37-89 #b2c3b8,#1d2824, 90-90 #b2c3b8,#608269, 91-179 #b2c3b8,#0d1410, +|7: 0-0 d,#5e4923, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|8: 0-0 d,#5e4923, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #f5f7ee,#3c614a, 11-11 #f5f7ee,#0d1410, 12-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|9: 0-1 #000000,#add38a, 2-89 #becfc4,#314738, 90-90 #becfc4,#608269, 91-179 #becfc4,#0d1410, +|10: 0-0 d,#608269, 1-1 d,#0d1410, 2-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|11: 0-0 d,#608269, 1-5 d,#0d1410, 6-8 #59675c,#0d1410, 9-12 #f7e4a5,#5e4923, 13-13 #f7e4a5,#0d1410, 14-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|12: 0-0 d,#608269, 1-5 d,#0d1410, 6-8 #59675c,#0d1410, 9-12 #f7e4a5,#352e19, 13-13 #f7e4a5,#0d1410, 14-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|13: 0-0 d,#608269, 1-4 d,#0d1410, 5-8 #59675c,#0d1410, 9-12 #f7e4a5,#352e19, 13-13 #f7e4a5,#0d1410, 14-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, +|14: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|15: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|16: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, |17: 0-1 d,#496656, 2-30 #b2c3b8,#1d2824, 31-39 #d3b0d9,#1d2824, 40-89 #b2c3b8,#1d2824, 90-90 #b2c3b8,#608269, 91-179 #b2c3b8,#0d1410, |18: 0-0 d,#608269, 1-1 d,#0d1410, 2-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, |19: 0-0 d,#608269, 1-1 d,#0d1410, 2-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, |20: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, -|21: 0-1 d,#496656, 2-30 #b2c3b8,#1d2824, 31-38 #d3b0d9,#1d2824, 39-89 #b2c3b8,#1d2824, 90-90 #b2c3b8,#608269, 91-179 #b2c3b8,#0d1410, -|22: 0-0 d,#608269, 1-4 d,#0d1410, 5-89 #59675c,#0d1410, 90-90 #59675c,#608269, 91-179 #59675c,#0d1410, -|23: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #f7e4a5,#5e4923, 11-11 #f7e4a5,#0d1410, 12-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|24: 0-0 d,#608269, 1-4 d,#0d1410, 5-89 #59675c,#0d1410, 90-90 #59675c,#608269, 91-179 #59675c,#0d1410, -|25: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #f7e4a5,#5e4923, 11-11 #f7e4a5,#0d1410, 12-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|26: 0-0 d,#608269, 1-4 d,#0d1410, 5-89 #59675c,#0d1410, 90-90 #59675c,#608269, 91-179 #59675c,#0d1410, -|27: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #f7e4a5,#5e4923, 11-11 #f7e4a5,#0d1410, 12-89 #e5eee5,#0d1410, 90-90 #e5eee5,#608269, 91-179 #e5eee5,#0d1410, -|28: 0-0 d,#608269, 1-4 d,#0d1410, 5-89 #59675c,#0d1410, 90-90 #59675c,#608269, 91-179 #59675c,#0d1410, +|21: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|22: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|23: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|24: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|25: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|26: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|27: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, +|28: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, |29: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, |30: 0-0 d,#608269, 1-89 d,#0d1410, 90-90 d,#608269, 91-179 d,#0d1410, -== snap second grid=180x31 cursor=10,12 -== snap third grid=180x31 cursor=10,12 +== snap ctrln grid=180x31 cursor=7,10 |7: 5 l5 |8: 6 MARK b -|9: 7 l7 -|10: 8 l8 -|11: 9 l9 -|12: 10 MARK c -|13: 11 l11 -|14: 12 l12 -|15: -|16: -== snap back grid=180x31 cursor=10,12 -|7: 1 l1 -|8: 2 MARK a -|9: 3 l3 -|10: 4 l4 -|11: 5 l5 -|12: 6 MARK b -|13: 7 l7 -|14: 8 l8 -|15: 9 l9 -|16: 10 MARK c -== snap cancel grid=180x31 cursor=10,12 -== snap nomatch grid=180x31 cursor=7,26 -|11: /tmp/pardes-snap/fsearch/cwd/+Search Save Tty Collapse LocationsConfig Del -|12: 1 +|9: ^ +Search 2/3 Del +== snap landed grid=180x31 cursor=10,8 +|9: +Search 2/3 Save Unattach Del +== snap n grid=180x31 cursor=10,8 +|7: 9 l9 +|8: 10 MARK c +== snap N grid=180x31 cursor=10,7 +|7: 6 MARK b +|8: 7 l7 +== snap cancel grid=180x31 cursor=10,7 +== snap nomatch grid=180x31 cursor=7,10 +|9: ^ +Search 0 Del +|10: /zzqq +|11: +|12: |13: -|14: -|15: -|16: diff --git a/test/snapshots/fsearch.snap b/test/snapshots/fsearch.snap index 431e7126..fbb9baeb 100644 --- a/test/snapshots/fsearch.snap +++ b/test/snapshots/fsearch.snap @@ -1,13 +1,13 @@ -# `/` file search: the pattern types into the tag (persistent, no popup); -# Enter searches the buffer in-core and writes `path:LINE:COL-ENDCOL text` into -# a +Search OUTPUT BUFFER (a file pane with no file behind it — no Save in its -# tag) — AND GOES TO THE FIRST HIT, which is the step `n` is and the look Enter -# is, run for you in that buffer. From there n/N SELECT the next/prev row and -# open nothing, and Enter — the look chord — is what scrolls the file pane to -# the hit AND SELECTS IT: the row names the match's whole span, not just where -# it starts. Esc abandons the input; a no-match search opens an EMPTY buffer -# (every search gets its own, stacked under the pane) with nothing in it for n -# to stop on, and goes nowhere. +# `/` in a file: its query pane under it (Query.zig), line 1 `/` and the +# pattern, typed into; nothing on the notice band. Each key searches the +# file again (a regex, any case unless it has a capital): every match is +# tinted and ticked on the scroll rail, the first at or after the cursor +# selected and in view, and the rows under line 1 are the lines holding a +# match, a line number in the gutter. Ctrl-n steps while typing; Enter puts +# the keyboard on the match, the pattern in `/`, and keeps the rows as text; +# n / N then step the matches in the file, round the end without a word. A +# later `/` reuses the pane; Esc while typing brings the kept rows back. A +# pattern that matches nothing is a count of 0, not an exit. file g.txt l1\nMARK a\nl3\nl4\nl5\nMARK b\nl7\nl8\nl9\nMARK c\nl11\nl12 # Builtins announce themselves by default, and an announcement is a band at # the top of the body -- which moves every row this script clicks. What the @@ -30,51 +30,32 @@ release right 6 9 wait 10000 MARK a stable 700 15000 snap opened -# / starts the search input in the tag; the pattern is visible while typing key / stable 400 5000 +snap slash text MARK stable 400 5000 snap typing +snapstyle typing +key c-n +stable 400 5000 +snap ctrln key enter -# Locations stack the target under its line now, so the two halves are -# two rows: wait for both rather than for one joined line. -wait 10000 g.txt:2:1-4 -wait 10000 MARK a stable 700 10000 -# ...and the submit already looked result 1: the file scrolled to line 2 and -# the four cells the pattern matched there came up selected — the styles below -# are what prove the second half of that. No `n` was pressed to get here. -snap results -snapstyle results -# n/N walk on from there, one row of the list per press, Enter looking what -# the step selected -key space j n -key enter -stable 700 15000 -snap second -key space j n -key enter -stable 700 15000 -snap third -# N walks back up to result 2 (line 6), Enter looks it -key space j p -key enter -stable 700 15000 -snap back -# Esc abandons the input: the tag tail is restored +snap landed +text n +stable 400 5000 +snap n +text N +stable 400 5000 +snap N key / text zz key esc settle 100 stable 400 5000 snap cancel -# a no-match search: nothing in the empty list for n to stop on, so the ring -# carries it back into the list that has rows and it resumes there key / text zzqq -key enter stable 700 10000 -key space j n -stable 400 5000 snap nomatch diff --git a/test/snapshots/grep.golden b/test/snapshots/grep.golden index 957096c3..6dbe19fa 100644 --- a/test/snapshots/grep.golden +++ b/test/snapshots/grep.golden @@ -19,22 +19,28 @@ | /tmp/pardes-snap/grep/cwd Tty+bash Save Mode Filter Collapse Del | ls | a.txt noise.txt sub -== snap typing grid=180x31 cursor=89,7 -|7: 1 hello TARGET one Grep /TARGET -== snap results grid=180x31 cursor=7,7 -|7: 1 hello TARGET one -|21: /tmp/pardes-snap/grep/cwd/+Search Save Tty Collapse LocationsConfig Del -|22: 1 a.txt:1:7-12 hello TARGET one -|23: 2 a.txt:3:6-11 last TARGET line -|24: 3 sub/b.txt:2:1-6 TARGET inside sub -|25: 4 -== snap first grid=180x31 cursor=18,7 -== snap opened-hit grid=180x31 cursor=12,12 -|10: /tmp/pardes-snap/grep/cwd/sub/b.txt Save Tty Collapse Del -|11: 1 deep -|12: 2 TARGET inside sub -== snap nomatch grid=180x31 cursor=2,4 -|25: /tmp/pardes-snap/grep/cwd/sub/+Search Save Tty Collapse LocationsConfig Del -|26: 1 -== snap chordsel grid=180x31 cursor=19,7 -== snap chord grid=180x31 cursor=19,7 +== snap typing grid=180x31 cursor=13,10 +|9: ^ +Search 1/3 Del +|10: Grep TARGET +|11: a.txt +|12: 1 hello TARGET one +|13: /tmp/pardes-snap/grep/cwd/+Preview Del +|14: 1 +== snap second grid=180x31 cursor=13,10 +|7: 2 nothing here +|8: 3 last TARGET line +|9: ^ +Search 2/3 Del +== snap preview grid=180x31 cursor=13,10 +|9: ^ +Search 3/3 Del +|13: /tmp/pardes-snap/grep/cwd/sub/b.txt Del +|14: 1 deep +|15: 2 TARGET inside sub +== snap opened-hit grid=180x31 cursor=12,15 +|9: +Search 3/3 Save Unattach Del +|13: /tmp/pardes-snap/grep/cwd/sub/b.txt Save Tty Collapse Del +== snap nomatch grid=180x31 cursor=11,15 +|14: ^ +Search 0 Del +|15: Grep zzqq +== snap esc grid=180x31 cursor=12,15 +|14: 1 deep +|15: 2 TARGET inside sub diff --git a/test/snapshots/grep.snap b/test/snapshots/grep.snap index b3ce2947..16e61d20 100644 --- a/test/snapshots/grep.snap +++ b/test/snapshots/grep.snap @@ -1,31 +1,20 @@ -# The Grep builtin (topbar word, `SPC f g`): `grep -R`, in-core. It arms the -# SAME tag input `/` and Find use, but the walk reads file CONTENTS under every -# pane's directory at once — minus any directory another pane's already -# contains, so a tree two panes sit in is searched ONCE and every hit appears -# once. A row is `path:LINE:COL-ENDCOL text` — the match's whole span, so -# looking it SELECTS the hit — with the path RELATIVE to the directory -# of the pane that asked — the same directory its results buffer is named in, -# so the short name resolves; only a hit from outside that tree stays absolute. -# n/N SELECT the next/prev row like any other result list and open nothing — -# one press per row, the location at its head, never the matched text after it; -# Enter looks what they leave selected, and a row pointing into a file nothing -# has open yet opens it. +# The Grep builtin (topbar word, `SPC f g`): the query pane under the pane +# that asked, line 1 `Grep ` and the text, the lines of the files below its +# directory holding it (literally, any case unless it has a capital), on the +# disk engine's worker once the typing pauses: rg --json when it is on PATH, +# else the sorted walk. The rows sit under their file's name, a line number +# in the gutter. A hit in a file an open pane shows is shown there; one in a +# file nothing shows, in the +Preview under the query pane, which Enter makes +# the file's pane. A query that matches nothing is a count of 0, and Esc +# while typing brings the kept rows back. dirmk sub file a.txt hello TARGET one\nnothing here\nlast TARGET line file sub/b.txt deep\nTARGET inside sub file noise.txt nothing to see -# Builtins announce themselves by default, and an announcement is a band at -# the top of the body -- which moves every row this script clicks. What the -# verbs do is what is under test, not the announcement. config Verbose off -# The stacked layout spends two rows on each hit, which puts the third one -# below the fold of this results pane; the claim here is which hits there are. -config LocationsConfig layout:inline start 31 180 -n 3 wait 8000 a.txt stable 700 20000 -# open a.txt: a SECOND pane, whose directory the shell's cwd already covers — -# its root is dropped, which is what keeps the hits below un-duplicated press left 5 9 release left 5 9 stable 400 5000 @@ -39,70 +28,34 @@ release right 6 9 wait 10000 hello TARGET stable 700 15000 snap opened -# middle-click Grep on the topbar: the input -# arms on the ACTIVE pane's tag, exactly where `/` would have typed +# middle-click Grep on the topbar: the query pane under a.txt, typed into press middle @Grep 1 release middle @Grep 1 stable 400 5000 text TARGET -stable 400 5000 -snap typing -# Enter walks: two hits in a.txt, one in sub/b.txt, sorted by path — and the -# file that holds none of them contributes no row. -key enter -wait 10000 sub/b.txt:2:1 +# three lines (the pane is short: its count says how many) +wait 10000 +Search 1/3 stable 700 15000 -snap results -# n selects the first row and Enter looks it: absolute path, line 1, columns -# 7..12 (`TARGET`), and those six cells come up selected -key space j n -key enter +snap typing +# a.txt's hits are shown in a.txt; sub/b.txt's in the preview +key c-n stable 700 15000 -snap first -# ...and stepping on into sub/b.txt, then looking it, opens the file nothing -# had open -key space j n -key enter +snap second +key c-n +wait 10000 deep stable 700 15000 -key space j n +snap preview key enter -wait 10000 TARGET inside sub stable 700 15000 snap opened-hit -# a pattern nothing holds: an empty list of its own, with nothing in it for n -# to stop on — so the ring carries that step out of it and on round. It lands -# in the SHELL, whose `ls` row is free text and steps word by word: the TARGET -# list is standing on its last row, and a row-grained walk has nothing left in -# it to offer. The look above is why these read the way they do: it left the -# cursor in sub/b.txt, so the empty list is named in sub/ rather than cwd/, and -# it left the hit SELECTED there (a ranged result row is one a look selects). -# Armed from the LEADER, not the topbar word, because of that selection: a -# topbar execute chords whatever is selected into its argument, so a -# middle-click here would run `Grep TARGET` and never ask for a pattern at -# all. The leader path runs the builtin with no argument, which is what this -# step is about; the chord itself is the last two snaps below. key space key f key g stable 400 5000 text zzqq -key enter stable 700 10000 -key space j n -stable 400 5000 snap nomatch -# the acme chord: a builtin executed with a SELECTION held takes it as the -# argument, so dragging over `TARGET` in a.txt and then clicking Grep runs the -# walk on that word at once — no tag input, nothing typed. TARGET already has -# a list open from above, so this refills THAT one; only the zzqq list below is -# a second buffer, because only it is a different search. -press left @TARGET 8 -drag left @TARGET+6 8 -release left @TARGET+6 8 +key esc +settle 100 stable 400 5000 -snap chordsel -press middle @Grep 1 -release middle @Grep 1 -wait 10000 sub/b.txt:2:1 -stable 700 15000 -snap chord +snap esc diff --git a/test/snapshots/lookrange.golden b/test/snapshots/lookrange.golden index 4a286faa..86a4b0ac 100644 --- a/test/snapshots/lookrange.golden +++ b/test/snapshots/lookrange.golden @@ -68,28 +68,31 @@ |12: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, |15: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-11 #e5eee5,#0d1410, 12-149 #f5f7ee,#3c614a, |16: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-10 #f5f7ee,#3c614a, 11-149 #f5f7ee,#0d1410, -== snap hit1 grid=150x31 cursor=15,14 -|17: /tmp/pardes-snap/lookrange/cwd/+Search Save Tty Collapse LocationsConfig Del -|18: 1 r.txt:7:4-9 -|19: 2 gg NEEDLE gg -|20: 3 r.txt:8:6-11 -|21: 4 hhhh NEEDLE -|22: 5 +== snap hit1 grid=150x31 cursor=17,15 +|21: +Search 2/2 Save Unattach Del +|22: /NEEDLE +|23: 7 gg NEEDLE gg +|24: 8 hhhh NEEDLE == style hit1 grid=150x31 -|14: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-9 #e5eee5,#0d1410, 10-15 #f5f7ee,#3c614a, 16-16 #f5f7ee,#0d1410, 17-149 #e5eee5,#0d1410, -|15: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, -|16: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, -|17: 0-1 d,#496656, 2-32 #b2c3b8,#1d2824, 33-40 #d3b0d9,#1d2824, 41-149 #b2c3b8,#1d2824, -|18: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|19: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-9 #e5eee5,#0d1410, 10-15 #f7e4a5,#5e4923, 16-16 #f7e4a5,#0d1410, 17-149 #e5eee5,#0d1410, -|20: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|21: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-11 #e5eee5,#0d1410, 12-17 #f7e4a5,#5e4923, 18-149 #f7e4a5,#0d1410, -|22: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -== snap hit2 grid=150x31 cursor=17,15 -== style hit2 grid=150x31 -|14: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|14: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-9 #e5eee5,#0d1410, 10-15 #e5eee5,#352e19, 16-149 #e5eee5,#0d1410, |15: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-11 #e5eee5,#0d1410, 12-17 #f5f7ee,#3c614a, 18-149 #f5f7ee,#0d1410, -== snap back grid=150x31 cursor=15,14 -== style back grid=150x31 +|16: 0-0 d,#5e4923, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|18: 0-0 d,#e5eee5, 1-149 d,#0d1410, +|21: 0-1 d,#496656, 2-149 #b2c3b8,#1d2824, +|22: 0-0 d,#608269, 1-1 d,#0d1410, 2-149 #e5eee5,#0d1410, +|23: 0-0 d,#608269, 1-5 d,#0d1410, 6-8 #59675c,#0d1410, 9-11 #e5eee5,#0d1410, 12-17 #f7e4a5,#352e19, 18-18 #f7e4a5,#0d1410, 19-149 #e5eee5,#0d1410, +|24: 0-0 d,#608269, 1-1 d,#0d1410, 2-5 d,#3c614a, 6-149 #f5f7ee,#3c614a, +== snap hit2 grid=150x31 cursor=15,14 +== style hit2 grid=150x31 |14: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-9 #e5eee5,#0d1410, 10-15 #f5f7ee,#3c614a, 16-16 #f5f7ee,#0d1410, 17-149 #e5eee5,#0d1410, -|15: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|15: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-11 #e5eee5,#0d1410, 12-17 #e5eee5,#352e19, 18-149 #e5eee5,#0d1410, +|16: 0-0 d,#e5eee5, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|18: 0-0 d,#5e4923, 1-149 d,#0d1410, +|23: 0-0 d,#608269, 1-5 d,#0d1410, 6-8 #59675c,#0d1410, 9-11 #e5eee5,#0d1410, 12-17 #f7e4a5,#5e4923, 18-18 #f7e4a5,#0d1410, 19-149 #e5eee5,#0d1410, +== snap back grid=150x31 cursor=17,15 +== style back grid=150x31 +|14: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-9 #e5eee5,#0d1410, 10-15 #e5eee5,#352e19, 16-149 #e5eee5,#0d1410, +|15: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-11 #e5eee5,#0d1410, 12-17 #f5f7ee,#3c614a, 18-149 #f5f7ee,#0d1410, +|16: 0-0 d,#5e4923, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|18: 0-0 d,#e5eee5, 1-149 d,#0d1410, +|23: 0-0 d,#608269, 1-5 d,#0d1410, 6-8 #59675c,#0d1410, 9-11 #e5eee5,#0d1410, 12-17 #f7e4a5,#352e19, 18-18 #f7e4a5,#0d1410, 19-149 #e5eee5,#0d1410, diff --git a/test/snapshots/lookrange.snap b/test/snapshots/lookrange.snap index eb1db60a..5133e911 100644 --- a/test/snapshots/lookrange.snap +++ b/test/snapshots/lookrange.snap @@ -51,28 +51,24 @@ release right 12 7 stable 700 15000 snap stale snapstyle stale -# --- and now the first consumer. The look above left r.txt focused, so `/` -# arms on it: the rows it writes carry the match's span, and the submit goes -# straight to the first of them — with the word itself selected, which is the -# whole reason the row spells a range and not a position. +# --- and `/`: its query pane under r.txt, line 1 the pattern, the lines +# holding it as rows (a line number in the gutter, the match tinted); Enter +# puts the keyboard on the match after the cursor, the word itself selected. key / text NEEDLE -key enter -# Locations stack the target under its line now: two rows, two waits. -wait 10000 r.txt:7:4-9 wait 10000 gg NEEDLE gg stable 700 15000 +key enter +stable 700 15000 snap hit1 snapstyle hit1 -# n selects the next row, and the Enter after it goes to that hit -key space j n -key enter +# n: the next match in the text, selected +text n stable 700 15000 snap hit2 snapstyle hit2 -# N walks back onto the first hit; Enter looks it, still selected -key space j p -key enter +# N walks back onto the first, still selected +text N stable 700 15000 snap back snapstyle back diff --git a/test/snapshots/lsp-client.golden b/test/snapshots/lsp-client.golden index c9fad7b7..18ccd775 100644 --- a/test/snapshots/lsp-client.golden +++ b/test/snapshots/lsp-client.golden @@ -15,15 +15,16 @@ | 3 a + b | 4 } | 5 -== snap gr-list grid=100x25 cursor=21,6 +== snap gr-list grid=100x25 cursor=7,14 |3: 1 mod lib; -|15: /tmp/pardes-snap/lsp-client/cwd/+Search Save Tty Collapse LocationsConfig Del -|16: 1 lib.rs:2:8-10 -|17: 2 pub fn add(a: i32, b: i32) -> i32 { -|18: 3 main.rs:4:13-15 -|19: 4 let x = add(1, 2); -|20: 5 main.rs:5:13-15 -|21: 6 let y = add(3, 4); -|22: 7 -== snap gr-opened grid=100x25 cursor=21,7 -== snap gr-back grid=100x25 cursor=21,6 +|13: ^ +Search 1/3 Del +|14: Refs +|15: lib.rs +|16: 2 pub fn add(a: i32, b: i32) -> i32 { +|17: main.rs +|18: 4 let x = add(1, 2); +|19: /tmp/pardes-snap/lsp-client/cwd/+Preview Del +|20: 1 +== snap gr-opened grid=100x25 cursor=21,6 +|13: +Search 2/3 Save Unattach Del +== snap gr-back grid=100x25 cursor=21,7 diff --git a/test/snapshots/lsp-client.snap b/test/snapshots/lsp-client.snap index db94525e..d9827a2a 100644 --- a/test/snapshots/lsp-client.snap +++ b/test/snapshots/lsp-client.snap @@ -6,7 +6,8 @@ # gd on a cross-file Location -> a look: lib.rs opens with `add` selected, # and the message row still carries the server's settled state # ("lsp lspmock: ready") because nothing has cleared it yet. -# gr -> sorted rows, selecting the next occurrence; n/N continue there. +# gr -> the text's query pane, line 1 `Refs`, rows under their files, +# the next occurrence current; n/N step the places in the text. file main.rs mod lib;\n\nfn main() {\n let x = add(1, 2);\n let y = add(3, 4);\n let _ = x + y;\n}\n file lib.rs // mock fixture\npub fn add(a: i32, b: i32) -> i32 {\n a + b\n}\n start 25 100 main.rs @@ -26,12 +27,12 @@ key r wait 10000 add(3, 4) stable 700 15000 snap gr-list -# step from the selected middle row to the last hit, then return -key space j n +# Ctrl-n on line 1 steps to the next hit, Enter lands there; N in the text +# goes back to the one before, round the places in main.rs +key c-n key enter stable 700 15000 snap gr-opened -key space j p -key enter +text N stable 700 15000 snap gr-back diff --git a/test/snapshots/lspdebug.snap b/test/snapshots/lspdebug.snap index ec8d136d..22fa097b 100644 --- a/test/snapshots/lspdebug.snap +++ b/test/snapshots/lspdebug.snap @@ -39,11 +39,8 @@ text client queries key enter wait 10000 client queries wait 10000 definition -# the report sits between the source and the results, so Del asks where its -# rows go: k, back to the source above -key space d -key k -key space w j enter +# Enter left the keyboard in the report, on the match; its query pane is +# attached to it, so one Del closes both, their rows back to the source key space d stable 700 15000 snap report-closed diff --git a/test/snapshots/lsprelpath.golden b/test/snapshots/lsprelpath.golden index d961d6bd..59a3c5d0 100644 --- a/test/snapshots/lsprelpath.golden +++ b/test/snapshots/lsprelpath.golden @@ -1,4 +1,4 @@ -== snap absrow grid=100x35 cursor=21,16 +== snap absrow grid=100x35 cursor=7,17 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol | /tmp/pardes-snap/lsprelpath/cwd/sub/parent.zig Save Tty Collapse TreeContext Def Refs Del @@ -9,56 +9,70 @@ | 5 | 6 }; | 7 } -| /tmp/pardes-snap/lsprelpath/cwd/sub/+Search Save Tty Collapse LocationsConfig Del -| 1 /tmp/pardes-snap/lsprelpath/cwd/shade.zig:1:11-15 -| 2 pub const Shade = enum { -| 3 parent.zig:3:22-26 -| 4 pub fn pick(s: shade.Shade) u8 { -| /tmp/pardes-snap/lsprelpath/cwd/shade.zig Save Tty Collapse TreeContext Def Refs Del -| 1 pub const Shade = enum { -| 2 verdigris, -| 3 cinnabar, -| 4 }; -| 5 -== snap abslook grid=100x35 cursor=32,5 +| 8 +| +| +| +| +| +|^ +Search 2/2 Del +| Refs +| /tmp/pardes-snap/lsprelpath/cwd/shade.zig +| 1 pub const Shade = enum { +| parent.zig +| 3 pub fn pick(s: shade.Shade) u8 { +| +| +| +| +| /tmp/pardes-snap/lsprelpath/cwd/sub/+Preview Del +| 1 +== snap abslook grid=100x35 cursor=21,27 |3: 1 const shade = @import("../shade.zig"); +|16: +Search 1/2 Save Unattach Del +|26: /tmp/pardes-snap/lsprelpath/cwd/shade.zig Save Tty Collapse TreeContext Def Refs Del +|27: 1 pub const Shade = enum { +|28: 2 verdigris, +|29: 3 cinnabar, +|30: 4 }; +|31: 5 == style abslook grid=100x35 |0: 0-1 d,#1d2824, 2-99 #b2c3b8,#1d2824, |1: 0-1 d,#887455, 2-99 #becfc4,#314738, -|2: 0-1 d,#add38a, 2-37 #becfc4,#314738, 38-48 #dfbce5,#314738, 49-99 #becfc4,#314738, +|2: 0-1 d,#496656, 2-37 #b2c3b8,#1d2824, 38-48 #d3b0d9,#1d2824, 49-99 #b2c3b8,#1d2824, |3: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-20 #e5eee5,#0d1410, 21-27 #c9a7ed,#0d1410, 28-28 #e5eee5,#0d1410, 29-42 #b8d88a,#0d1410, 43-99 #e5eee5,#0d1410, |4: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|5: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-27 #e5eee5,#0d1410, 28-32 #f5f7ee,#3c614a, 33-99 #e5eee5,#0d1410, -|6: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-24 #c9a7ed,#0d1410, 25-99 #e5eee5,#0d1410, +|5: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-27 #e5eee5,#0d1410, 28-32 #f5f7ee,#3c614a, 33-99 #e5eee5,#0d1410, +|6: 0-0 d,#e5eee5, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-24 #c9a7ed,#0d1410, 25-99 #e5eee5,#0d1410, |7: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, |8: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|9: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, -|10: 0-1 d,#496656, 2-37 #b2c3b8,#1d2824, 38-45 #d3b0d9,#1d2824, 46-99 #b2c3b8,#1d2824, -|11: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|12: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-16 #e5eee5,#0d1410, 17-21 #f7e4a5,#5e4923, 22-22 #f7e4a5,#0d1410, 23-24 #e5eee5,#0d1410, 25-29 #c9a7ed,#0d1410, 30-99 #e5eee5,#0d1410, -|13: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|14: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-27 #e5eee5,#0d1410, 28-32 #f7e4a5,#5e4923, 33-99 #e5eee5,#0d1410, -|15: 0-1 d,#496656, 2-33 #b2c3b8,#1d2824, 34-43 #d3b0d9,#1d2824, 44-99 #b2c3b8,#1d2824, -|16: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-16 #e5eee5,#0d1410, 17-21 #f5f7ee,#3c614a, 22-22 #f5f7ee,#0d1410, 23-24 #e5eee5,#0d1410, 25-29 #c9a7ed,#0d1410, 30-99 #e5eee5,#0d1410, -|17: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|18: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|19: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, -|20: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|21: 0-0 d,#608269, 1-99 d,#0d1410, +|9: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, +|10: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, +|11: 0-0 d,#608269, 1-99 d,#0d1410, +|12: 0-0 d,#608269, 1-99 d,#0d1410, +|13: 0-0 d,#608269, 1-99 d,#0d1410, +|14: 0-0 d,#608269, 1-99 d,#0d1410, +|15: 0-0 d,#608269, 1-99 d,#0d1410, +|16: 0-1 d,#496656, 2-99 #b2c3b8,#1d2824, +|17: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|18: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|19: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-20 #e5eee5,#0d1410, 21-25 #f7e4a5,#5e4923, 26-26 #f7e4a5,#0d1410, 27-99 #e5eee5,#0d1410, +|20: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|21: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-31 #e5eee5,#0d1410, 32-36 #f7e4a5,#5e4923, 37-99 #e5eee5,#0d1410, |22: 0-0 d,#608269, 1-99 d,#0d1410, |23: 0-0 d,#608269, 1-99 d,#0d1410, |24: 0-0 d,#608269, 1-99 d,#0d1410, |25: 0-0 d,#608269, 1-99 d,#0d1410, -|26: 0-0 d,#608269, 1-99 d,#0d1410, -|27: 0-0 d,#608269, 1-99 d,#0d1410, -|28: 0-0 d,#608269, 1-99 d,#0d1410, -|29: 0-0 d,#608269, 1-99 d,#0d1410, -|30: 0-0 d,#608269, 1-99 d,#0d1410, -|31: 0-0 d,#608269, 1-99 d,#0d1410, +|26: 0-1 d,#add38a, 2-33 #becfc4,#314738, 34-43 #dfbce5,#314738, 44-99 #becfc4,#314738, +|27: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-16 #e5eee5,#0d1410, 17-21 #f5f7ee,#3c614a, 22-22 #f5f7ee,#0d1410, 23-24 #e5eee5,#0d1410, 25-29 #c9a7ed,#0d1410, 30-99 #e5eee5,#0d1410, +|28: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, +|29: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, +|30: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, +|31: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, |32: 0-0 d,#608269, 1-99 d,#0d1410, |33: 0-0 d,#608269, 1-99 d,#0d1410, |34: 0-0 d,#608269, 1-99 d,#0d1410, -== snap subrow grid=100x35 cursor=20,16 +== snap subrow grid=100x35 cursor=7,17 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol | /tmp/pardes-snap/lsprelpath/cwd/sub/subdir.zig Save Tty Collapse TreeContext Def Refs Del @@ -69,53 +83,67 @@ | 5 | 6 }; | 7 } -| /tmp/pardes-snap/lsprelpath/cwd/sub/+Search Save Tty Collapse LocationsConfig Del -| 1 inner/tint.zig:1:11-14 -| 2 pub const Tint = enum { -| 3 subdir.zig:3:20-23 -| 4 pub fn hue(t: tint.Tint) u8 { -| /tmp/pardes-snap/lsprelpath/cwd/sub/inner/tint.zig Save Tty Collapse TreeContext Def Refs Del -| 1 pub const Tint = enum { -| 2 ochre, -| 3 indigo, -| 4 }; -| 5 -== snap sublook grid=100x35 cursor=29,5 +| 8 +| +| +| +| +| +|^ +Search 2/2 Del +| Refs +| inner/tint.zig +| 1 pub const Tint = enum { +| subdir.zig +| 3 pub fn hue(t: tint.Tint) u8 { +| +| +| +| +| /tmp/pardes-snap/lsprelpath/cwd/sub/+Preview Del +| 1 +== snap sublook grid=100x35 cursor=20,27 |3: 1 const tint = @import("inner/tint.zig"); +|16: +Search 1/2 Save Unattach Del +|26: /tmp/pardes-snap/lsprelpath/cwd/sub/inner/tint.zig Save Tty Collapse TreeContext Def Refs Del +|27: 1 pub const Tint = enum { +|28: 2 ochre, +|29: 3 indigo, +|30: 4 }; +|31: 5 == style sublook grid=100x35 |0: 0-1 d,#1d2824, 2-99 #b2c3b8,#1d2824, |1: 0-1 d,#887455, 2-99 #becfc4,#314738, -|2: 0-1 d,#add38a, 2-37 #becfc4,#314738, 38-48 #dfbce5,#314738, 49-99 #becfc4,#314738, +|2: 0-1 d,#496656, 2-37 #b2c3b8,#1d2824, 38-48 #d3b0d9,#1d2824, 49-99 #b2c3b8,#1d2824, |3: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-19 #e5eee5,#0d1410, 20-26 #c9a7ed,#0d1410, 27-27 #e5eee5,#0d1410, 28-43 #b8d88a,#0d1410, 44-99 #e5eee5,#0d1410, |4: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|5: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-25 #e5eee5,#0d1410, 26-29 #f5f7ee,#3c614a, 30-99 #e5eee5,#0d1410, -|6: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-24 #c9a7ed,#0d1410, 25-99 #e5eee5,#0d1410, +|5: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-25 #e5eee5,#0d1410, 26-29 #f5f7ee,#3c614a, 30-99 #e5eee5,#0d1410, +|6: 0-0 d,#e5eee5, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-24 #c9a7ed,#0d1410, 25-99 #e5eee5,#0d1410, |7: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, |8: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|9: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, -|10: 0-1 d,#496656, 2-37 #b2c3b8,#1d2824, 38-45 #d3b0d9,#1d2824, 46-99 #b2c3b8,#1d2824, -|11: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|12: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-16 #e5eee5,#0d1410, 17-20 #f7e4a5,#5e4923, 21-21 #f7e4a5,#0d1410, 22-23 #e5eee5,#0d1410, 24-28 #c9a7ed,#0d1410, 29-99 #e5eee5,#0d1410, -|13: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|14: 0-0 d,#152019, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-10 #e5eee5,#0d1410, 11-13 #c9a7ed,#0d1410, 14-25 #e5eee5,#0d1410, 26-29 #f7e4a5,#5e4923, 30-99 #e5eee5,#0d1410, -|15: 0-1 d,#496656, 2-43 #b2c3b8,#1d2824, 44-52 #d3b0d9,#1d2824, 53-99 #b2c3b8,#1d2824, -|16: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-16 #e5eee5,#0d1410, 17-20 #f5f7ee,#3c614a, 21-21 #f5f7ee,#0d1410, 22-23 #e5eee5,#0d1410, 24-28 #c9a7ed,#0d1410, 29-99 #e5eee5,#0d1410, -|17: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|18: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, -|19: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, -|20: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, -|21: 0-0 d,#608269, 1-99 d,#0d1410, +|9: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, +|10: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, +|11: 0-0 d,#608269, 1-99 d,#0d1410, +|12: 0-0 d,#608269, 1-99 d,#0d1410, +|13: 0-0 d,#608269, 1-99 d,#0d1410, +|14: 0-0 d,#608269, 1-99 d,#0d1410, +|15: 0-0 d,#608269, 1-99 d,#0d1410, +|16: 0-1 d,#496656, 2-99 #b2c3b8,#1d2824, +|17: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|18: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|19: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-20 #e5eee5,#0d1410, 21-24 #f7e4a5,#5e4923, 25-25 #f7e4a5,#0d1410, 26-99 #e5eee5,#0d1410, +|20: 0-0 d,#608269, 1-1 d,#0d1410, 2-99 #e5eee5,#0d1410, +|21: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-29 #e5eee5,#0d1410, 30-33 #f7e4a5,#5e4923, 34-99 #e5eee5,#0d1410, |22: 0-0 d,#608269, 1-99 d,#0d1410, |23: 0-0 d,#608269, 1-99 d,#0d1410, |24: 0-0 d,#608269, 1-99 d,#0d1410, |25: 0-0 d,#608269, 1-99 d,#0d1410, -|26: 0-0 d,#608269, 1-99 d,#0d1410, -|27: 0-0 d,#608269, 1-99 d,#0d1410, -|28: 0-0 d,#608269, 1-99 d,#0d1410, -|29: 0-0 d,#608269, 1-99 d,#0d1410, -|30: 0-0 d,#608269, 1-99 d,#0d1410, -|31: 0-0 d,#608269, 1-99 d,#0d1410, +|26: 0-1 d,#add38a, 2-43 #becfc4,#314738, 44-52 #dfbce5,#314738, 53-99 #becfc4,#314738, +|27: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-16 #e5eee5,#0d1410, 17-20 #f5f7ee,#3c614a, 21-21 #f5f7ee,#0d1410, 22-23 #e5eee5,#0d1410, 24-28 #c9a7ed,#0d1410, 29-99 #e5eee5,#0d1410, +|28: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, +|29: 0-0 d,#608269, 1-4 d,#0d1410, 5-10 #59675c,#0d1410, 11-99 #e5eee5,#0d1410, +|30: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-99 #e5eee5,#0d1410, +|31: 0-0 d,#608269, 1-4 d,#0d1410, 5-99 #59675c,#0d1410, |32: 0-0 d,#608269, 1-99 d,#0d1410, |33: 0-0 d,#608269, 1-99 d,#0d1410, |34: 0-0 d,#608269, 1-99 d,#0d1410, -== snap clicked grid=100x35 cursor=15,12 +== snap clicked grid=100x35 cursor=29,5 diff --git a/test/snapshots/lsprelpath.snap b/test/snapshots/lsprelpath.snap index a83abf46..8420e134 100644 --- a/test/snapshots/lsprelpath.snap +++ b/test/snapshots/lsprelpath.snap @@ -8,7 +8,8 @@ # short to be called. # # A row in the SAME directory shortens to a bare basename; the two that a -# prefix strip can actually get wrong are here, one app each, as `gr` rows: +# prefix strip can actually get wrong are here, one app each, as `gr` rows +# (the file headers of the asking text's query pane, line 1 `Refs`): # # PARENT the enum is one level UP from the asking file, so nothing is # stripped and the row carries `/tmp/.../cwd/shade.zig`. This is @@ -32,26 +33,25 @@ file sub/subdir.zig const tint = @import("inner/tint.zig");\n\npub fn hue(t: tin start 35 100 sub/parent.zig wait 8000 fn pick stable 700 20000 -# `gr` on `Shade` in the signature (file line 3, click row 6): its -# declaration's row is in the parent directory. press left 31 6 release left 31 6 stable 400 5000 key g key r -wait 15000 cwd/shade.zig:1: +# the query pane under parent.zig, line 1 `Refs`, the rows under each file: +# shade.zig's spelled whole, its directory being above +wait 15000 cwd/shade.zig stable 700 15000 snap absrow -key esc -settle 100 -# An absolute row has to keep resolving — it is the spelling every row had -# before this, and the one every hit outside the tree still has. -key space j n +# the current row is parent.zig's own; the one before it is shade.zig's, +# shown in the +Preview, which Enter makes shade.zig's pane +key c-p +wait 10000 verdigris +stable 700 15000 key enter stable 700 15000 snap abslook snapstyle abslook -# ---- SUBDIRECTORY: under it, so the strip leaves `inner/tint.zig` ---- start 35 100 sub/subdir.zig wait 8000 fn hue stable 700 20000 @@ -60,23 +60,16 @@ release left 29 6 stable 400 5000 key g key r -wait 15000 inner/tint.zig:1: +wait 15000 inner/tint.zig stable 700 15000 snap subrow -key esc -settle 100 -key space j n +key c-p +wait 10000 ochre +stable 700 15000 key enter stable 700 15000 snap sublook snapstyle sublook -# The mouse spelling, on the OTHER row (grid row 12, 1-based click row 13). A -# right click expands to the file-ish word under the cursor -# (config.wordBounds), which has to take `inner/tint.zig:3:5-10` WHOLE — the -# separator inside a stripped path is a file char, so the scan runs back over -# `inner/` and stops on the space of the line-number prefix. A look focuses -# what it opens, so the header's cursor is the assertion: the end of `indigo` -# on line 3 of tint.zig. press right 12 13 release right 12 13 stable 700 15000 diff --git a/test/snapshots/msg.golden b/test/snapshots/msg.golden index 24018546..950c4d67 100644 --- a/test/snapshots/msg.golden +++ b/test/snapshots/msg.golden @@ -37,10 +37,10 @@ |8: |9: == snap prompt grid=70x17 cursor=69,3 -|3: 1 EXTERNAL /EXT +|3: 1 EXTERNAL Select /EXT == snap prompt-wins grid=70x17 cursor=69,4 |3: 1 AGAIN --:--:-- reloaded /tmp/pardes-snap/msg/cwd/a.txt -|4: 2 /EXT +|4: 2 Select /EXT == snap esc grid=70x17 cursor=7,4 |3: 1 AGAIN |4: 2 diff --git a/test/snapshots/msg.snap b/test/snapshots/msg.snap index 5252508a..64a77bb2 100644 --- a/test/snapshots/msg.snap +++ b/test/snapshots/msg.snap @@ -58,7 +58,7 @@ snap reloaded # its builtins instead of losing them to a long pattern. Note the tag row above # ends at `Del`: the marker and the pattern are no longer on it at all. (The # `/` keystroke also cleared the reload message, which is the rule above.) -key / +key s text EXT stable 700 15000 snap prompt diff --git a/test/snapshots/stepgrain.golden b/test/snapshots/stepgrain.golden index 3101b920..43445ed4 100644 --- a/test/snapshots/stepgrain.golden +++ b/test/snapshots/stepgrain.golden @@ -1,43 +1,55 @@ -== snap results grid=150x31 cursor=7,3 +== snap results grid=150x31 cursor=13,13 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol | /tmp/pardes-snap/stepgrain/cwd/a.txt Save Tty Collapse Del | 1 hello ZQMARK one | 2 see also sub/b.txt for ZQMARK two -| /tmp/pardes-snap/stepgrain/cwd/+Search Save Tty Collapse LocationsConfig Del -| 1 a.txt:1:7-12 -| 2 hello ZQMARK one -| 3 a.txt:2:24-29 -| 4 see also sub/b.txt for ZQMARK two -| 5 sub/b.txt:1:1-6 -| 6 ZQMARK inside sub -| 7 -== snap step-row1 grid=150x31 cursor=7,6 -== style step-row1 grid=150x31 +| +| +| +| +| +| +| +|^ +Search 1/3 Del +| Grep ZQMARK +| a.txt +| 1 hello ZQMARK one +| 2 see also sub/b.txt for ZQMARK two +| sub/b.txt +| 1 ZQMARK inside sub +| +| +| +| /tmp/pardes-snap/stepgrain/cwd/+Preview Del +| 1 +== snap step-row2 grid=150x31 cursor=13,13 +|12: ^ +Search 2/3 Del +== style step-row2 grid=150x31 |0: 0-1 d,#1d2824, 2-149 #b2c3b8,#1d2824, |1: 0-1 d,#887455, 2-149 #becfc4,#314738, |2: 0-1 d,#496656, 2-32 #b2c3b8,#1d2824, 33-38 #d3b0d9,#1d2824, 39-149 #b2c3b8,#1d2824, -|3: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, -|4: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, -|5: 0-1 d,#add38a, 2-32 #becfc4,#314738, 33-40 #dfbce5,#314738, 41-149 #becfc4,#314738, -|6: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-18 #f5f7ee,#3c614a, 19-149 #f5f7ee,#0d1410, -|7: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-12 #e5eee5,#0d1410, 13-18 #f7e4a5,#5e4923, 19-19 #f7e4a5,#0d1410, 20-149 #e5eee5,#0d1410, -|8: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|9: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-29 #e5eee5,#0d1410, 30-35 #f7e4a5,#5e4923, 36-36 #f7e4a5,#0d1410, 37-149 #e5eee5,#0d1410, -|10: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|11: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-12 #f7e4a5,#5e4923, 13-13 #f7e4a5,#0d1410, 14-149 #e5eee5,#0d1410, -|12: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|13: 0-0 d,#608269, 1-149 d,#0d1410, -|14: 0-0 d,#608269, 1-149 d,#0d1410, -|15: 0-0 d,#608269, 1-149 d,#0d1410, -|16: 0-0 d,#608269, 1-149 d,#0d1410, -|17: 0-0 d,#608269, 1-149 d,#0d1410, -|18: 0-0 d,#608269, 1-149 d,#0d1410, +|3: 0-0 d,#5e4923, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-12 #e5eee5,#0d1410, 13-18 #e5eee5,#352e19, 19-149 #e5eee5,#0d1410, +|4: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-29 #e5eee5,#0d1410, 30-35 #f5f7ee,#3c614a, 36-36 #f5f7ee,#0d1410, 37-149 #e5eee5,#0d1410, +|5: 0-0 d,#608269, 1-149 d,#0d1410, +|6: 0-0 d,#608269, 1-149 d,#0d1410, +|7: 0-0 d,#e5eee5, 1-149 d,#0d1410, +|8: 0-0 d,#608269, 1-149 d,#0d1410, +|9: 0-0 d,#608269, 1-149 d,#0d1410, +|10: 0-0 d,#608269, 1-149 d,#0d1410, +|11: 0-0 d,#608269, 1-149 d,#0d1410, +|12: 0-1 #000000,#add38a, 2-149 #becfc4,#314738, +|13: 0-0 d,#608269, 1-1 d,#0d1410, 2-149 #e5eee5,#0d1410, +|14: 0-0 d,#608269, 1-1 d,#0d1410, 2-149 #e5eee5,#0d1410, +|15: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-16 #e5eee5,#0d1410, 17-22 #f7e4a5,#5e4923, 23-23 #f7e4a5,#0d1410, 24-149 #e5eee5,#0d1410, +|16: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-33 #e5eee5,#0d1410, 34-39 #f7e4a5,#5e4923, 40-40 #f7e4a5,#0d1410, 41-149 #e5eee5,#0d1410, +|17: 0-0 d,#608269, 1-1 d,#0d1410, 2-149 #e5eee5,#0d1410, +|18: 0-0 d,#608269, 1-7 d,#0d1410, 8-10 #59675c,#0d1410, 11-16 #f7e4a5,#5e4923, 17-17 #f7e4a5,#0d1410, 18-149 #e5eee5,#0d1410, |19: 0-0 d,#608269, 1-149 d,#0d1410, |20: 0-0 d,#608269, 1-149 d,#0d1410, |21: 0-0 d,#608269, 1-149 d,#0d1410, -|22: 0-0 d,#608269, 1-149 d,#0d1410, -|23: 0-0 d,#608269, 1-149 d,#0d1410, +|22: 0-1 d,#496656, 2-32 #b2c3b8,#1d2824, 33-41 #d3b0d9,#1d2824, 42-149 #b2c3b8,#1d2824, +|23: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, |24: 0-0 d,#608269, 1-149 d,#0d1410, |25: 0-0 d,#608269, 1-149 d,#0d1410, |26: 0-0 d,#608269, 1-149 d,#0d1410, @@ -45,29 +57,32 @@ |28: 0-0 d,#608269, 1-149 d,#0d1410, |29: 0-0 d,#608269, 1-149 d,#0d1410, |30: 0-0 d,#608269, 1-149 d,#0d1410, -== snap step-row2 grid=150x31 cursor=7,8 -== style step-row2 grid=150x31 -|6: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|8: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-19 #f5f7ee,#3c614a, 20-149 #f5f7ee,#0d1410, -== snap step-row3 grid=150x31 cursor=7,10 -== snap step-wrap grid=150x31 cursor=7,6 -== snap blank-in-path grid=150x31 cursor=7,6 -|5: /tmp/pardes-snap/stepgrain/cwd/+Search Save Tty Collapse Del -|6: 1 two words.txt -|7: 2 -|8: -|9: -|10: -|11: -|12: +== snap step-row3 grid=150x31 cursor=13,13 +|12: ^ +Search 3/3 Del +|22: /tmp/pardes-snap/stepgrain/cwd/sub/b.txt Del +|23: 1 ZQMARK inside sub +== snap step-wrap grid=150x31 cursor=13,13 +|12: ^ +Search 1/3 Del +== snap blank-in-path grid=150x31 cursor=12,13 +|12: ^ +Search 1/1 Del +|13: Find words +|14: two words.txt +|15: +|16: +|17: +|18: +|22: /tmp/pardes-snap/stepgrain/cwd/two words.txt Del +|23: 1 == style blank-in-path grid=150x31 -|6: 0-0 d,#608269, 1-1 d,#0d1410, 2-4 d,#0d1410,b 5-6 #616f64,#0d1410,b 7-19 #f5f7ee,#3c614a, 20-149 #f5f7ee,#0d1410, -|7: 0-0 d,#608269, 1-4 d,#0d1410, 5-149 #59675c,#0d1410, -|8: 0-0 d,#608269, 1-149 d,#0d1410, -|9: 0-0 d,#608269, 1-149 d,#0d1410, -|10: 0-0 d,#608269, 1-149 d,#0d1410, -|11: 0-0 d,#608269, 1-149 d,#0d1410, -|12: 0-0 d,#608269, 1-149 d,#0d1410, -== snap blank-opened grid=150x31 cursor=7,9 -|8: /tmp/pardes-snap/stepgrain/cwd/two words.txt Save Tty Collapse Del -|9: 1 +|3: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|4: 0-0 d,#608269, 1-4 d,#0d1410, 5-6 #59675c,#0d1410, 7-149 #e5eee5,#0d1410, +|7: 0-0 d,#608269, 1-149 d,#0d1410, +|14: 0-0 d,#608269, 1-1 d,#0d1410, 2-5 #e5eee5,#0d1410, 6-10 #f7e4a5,#5e4923,b 11-149 #e5eee5,#0d1410, +|15: 0-0 d,#608269, 1-149 d,#0d1410, +|16: 0-0 d,#608269, 1-149 d,#0d1410, +|17: 0-0 d,#608269, 1-149 d,#0d1410, +|18: 0-0 d,#608269, 1-149 d,#0d1410, +|22: 0-1 d,#496656, 2-32 #b2c3b8,#1d2824, 33-46 #d3b0d9,#1d2824, 47-149 #b2c3b8,#1d2824, +== snap blank-opened grid=150x31 cursor=7,23 +|12: +Search 1/1 Save Unattach Del +|22: /tmp/pardes-snap/stepgrain/cwd/two words.txt Save Tty Collapse Del diff --git a/test/snapshots/stepgrain.snap b/test/snapshots/stepgrain.snap index 0f555ff8..e807981c 100644 --- a/test/snapshots/stepgrain.snap +++ b/test/snapshots/stepgrain.snap @@ -1,22 +1,11 @@ -# WHAT ONE PRESS OF `n` TAKES, and why that is not one answer. A pane's rows -# decide it (output_pane.Grain, read in Pardes.lookSpanIn): +# ONE PRESS, ONE ROW. A query pane's rows are one a line with a hit, the +# hit's line under a gutter number, and Ctrl-n / Ctrl-p (typing on line 1) +# step them a row at a time, round the end: row 2 below matched on a line +# that mentions `sub/b.txt`, and the step does not stop on that word, as the +# old word-grained walk did; the fourth press wraps back to row 1. # -# free text — a terminal, a file, a PDF — is stepped WORD by word, several -# stops to a line, because a line of it may name several places at once (the -# `ls` row in ttylook.snap hops big.txt -> plain.txt -> sub); -# -# a RESULTS BUFFER is stepped ROW by row, on the location at the head of the -# row, because a row there IS one location and the words after it are the -# MATCHED TEXT — the same hit, spelled out. That text is full of look-able -# words, and stopping on them was stopping on the same result twice. -# -# This script is the second rule. Row 2 below matched on a line that mentions -# `sub/b.txt`, so the old word-grained walk stopped there before it ever -# reached row 3; now `n` presses and rows correspond one to one, and the fourth -# press wraps the ring back to row 1. -# -# LARGEST from the head, so a path with a BLANK in it is one span rather than -# the word in front of it: `two words.txt` selects whole and opens. +# A path with a BLANK in it is one name: `two words.txt` is found whole by +# Find and Enter opens exactly it. dirmk sub file a.txt hello ZQMARK one\nsee also sub/b.txt for ZQMARK two file sub/b.txt ZQMARK inside sub @@ -24,52 +13,36 @@ run touch 'two words.txt' start 31 150 a.txt wait 8000 hello ZQMARK stable 700 20000 -# Grep from the leader: three hits, sorted by path, the empty file contributing -# none. Row 2 is the one whose TEXT holds a path. +# Grep from the leader: three hits, under their files, the empty file +# contributing none. Row 2 is the one whose TEXT holds a path. key space key f key g stable 400 5000 text ZQMARK -key enter -wait 10000 sub/b.txt:1:1 +wait 10000 ZQMARK inside sub stable 700 15000 snap results -# one press, one row: the head of row 1... -key space j n -stable 400 5000 -snap step-row1 -snapstyle step-row1 -# ...the head of row 2, and NOT the `sub/b.txt` sitting in its matched text — -# the cursor column is the assertion -key space j n +key c-n stable 400 5000 snap step-row2 snapstyle step-row2 -# ...row 3, and then the ring comes round to row 1 again -key space j n +key c-n stable 400 5000 snap step-row3 -key space j n +key c-n stable 400 5000 snap step-wrap -# Back into the file, so the Find below is asked from a pane that is not a -# results buffer (fillResults never refills the buffer it was asked from). -press left 8 4 -release left 8 4 +key esc +settle 100 stable 400 5000 -# A path with a blank in it: the row is one span from its first cell, because -# the walk asks about the LONGEST run of the row first and the filesystem is -# what vouches for it. Enter then opens exactly what is selected. +# Find `words`: the name with a blank in it, whole key space key f key f text words -key enter wait 10000 two words.txt stable 700 15000 -key space j n -stable 400 5000 snap blank-in-path snapstyle blank-in-path key enter diff --git a/test/snapshots/tagbottom.golden b/test/snapshots/tagbottom.golden index ef1bab3a..cf690a40 100644 --- a/test/snapshots/tagbottom.golden +++ b/test/snapshots/tagbottom.golden @@ -150,10 +150,19 @@ |8: 8 hhh |9: 9 iii |10: 10 jjj -== snap search-prompt grid=100x31 cursor=99,12 -|12: 1 ZZONE /ZZ +== snap search-prompt grid=100x31 cursor=5,21 +|20: /tmp/pardes-snap/tagbottom/cwd/bottom.txt Save Tty Collapse Del +|21: /ZZ +|22: 1 ZZONE +|23: 2 ZZTWO +|30: ^ +Search 1/2 Del == snap leader grid=100x31 cursor=9,13 |12: 1 ZZONE SPC +|20: +|21: +|22: +|23: +|30: /tmp/pardes-snap/tagbottom/cwd/bottom.txt Save Tty Collapse Del == snap cut-down grid=100x31 cursor=7,5 |2: 1 aaa |3: 2 bbb diff --git a/test/snapshots/tagbottomshort.golden b/test/snapshots/tagbottomshort.golden index 00d8cad0..1979cc60 100644 --- a/test/snapshots/tagbottomshort.golden +++ b/test/snapshots/tagbottomshort.golden @@ -1,41 +1,41 @@ -== snap roomy grid=80x11 cursor=79,2 +== snap roomy grid=80x11 cursor=5,5 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol -| 1 one /ZZ +| 1 one | 2 two -| 3 three -| 4 four -| 5 five -| 6 six +| /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del +| /ZZ | | -| /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del -== snap two-body grid=80x5 cursor=79,2 +| +| +|^ +Search 0 Del +== snap two-body grid=80x5 cursor=5,3 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol -| 1 one /ZZ -| 2 two | /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del -== snap one-body grid=80x4 cursor=79,2 +| /ZZ +|^ +Search 0 Del +== snap one-body grid=80x4 cursor=79,3 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol -| 1 one /ZZ | /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del +|^ +Search 0 Del == snap tag-only grid=80x2 cursor=79,1 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del -== snap regrown grid=80x11 cursor=79,2 +== snap regrown grid=80x11 cursor=5,5 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol -| 1 one /ZZ +| 1 one | 2 two -| 3 three -| 4 four -| 5 five -| 6 six +| /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del +| /ZZ | | -| /tmp/pardes-snap/tagbottomshort/cwd/s.txt Save Tty Collapse Del +| +| +|^ +Search 0 Del == snap leader-one-body grid=80x4 cursor=7,2 | Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit | New Tty Find Grep Joincol Delcol diff --git a/test/snapshots/topbarexec.golden b/test/snapshots/topbarexec.golden index 5b7d2234..63ed382c 100644 --- a/test/snapshots/topbarexec.golden +++ b/test/snapshots/topbarexec.golden @@ -26,14 +26,20 @@ |8: │pinch 1.0000 │ |9: │tscroll 0.0000 │ |10: ╰────────────────────────────────────╯ -== snap arg-still-spliced grid=90x21 cursor=14,5 +== snap arg-still-spliced grid=90x21 cursor=14,4 |1: New Tty Find Grep Joincol Delcol New Tty Find Grep Joincol Delcol |2: /tmp/pardes-snap/topbarexec/cwd Tty+bash Sa /tmp/pardes-snap/topbarexec/cwd Tty+bash Sa |3: ve Mode Filter Collapse Del ve Mode Filter Collapse Del -|4: ls Find ls -|5: zmarkfile.txt zmarkfile.txt -|6: -|7: /tmp/pardes-snap/topbarexec/cwd/+Search Sav -|8: e Tty Collapse Del -|9: 1 zmarkfile.txt -|10: 2 +|4: zmarkfile.txt Find ls +|5: zmarkfile.txt +|6: +Search 1/1 Del +|7: Find zmarkfile.txt +|8: zmarkfile.txt +|9: /tmp/pardes-snap/topbarexec/cwd/zmarkfile.t +|10: xt Del +|11: 1 hay ZQNEEDLE stack +|12: +|13: /tmp/pardes-snap/topbarexec/cwd Tty+bash Sa +|14: ve Mode Filter Collapse Del +|15: ls +|16: zmarkfile.txt -- cgit v1.3