(53ffb94) Run the command the prompt parsed, and redraw the board on what it wrote, and bump to 0.32.16
The prompt parsed a line and named what it resolved to. This is the half that does it: the parsed command goes to the same cmd_* handler main.rs hands it to, against the selected tab's own .worklane, with a Sink over a buffer collecting what the handler says instead of stdout. One dispatch table, not two. main.rs's match on Command is lifted into `dispatch`, over the command, the start path and the sink, and both callers go through it. A second copy in tui.rs would drift the first time a command was added and would drift silently, since both halves go on compiling; the match is exhaustive so a new verb cannot fall into an `_` arm either. Only `tui` is matched outside it, in main, because the board is that table's caller rather than an entry in it, and reached from the prompt it is refused in those words. Two things the board has to do that the CLI never had to. It reloads unconditionally after a command returns rather than waiting for the digest, so a reader does not watch their own mv take up to a poll interval to appear, and either way, since a handler that failed part way through has still written. And the selection is restored by uuid across that reload: mv puts the card in another column, set --title renames its file, and a filter can drop it out of view, so the slot is not the ticket. Where the board cannot follow it, the notice says so and which key shows it. What the handler says is what the board reports, word for word. Notice therefore holds as many lines as the command used, and notice_on_row is the one rule for where they go: one line on the footer row where a copy's notice has always gone, anything else as a box at the foot of the columns. A box rather than more rows of footer, because a footer that grew and shrank as notices came and went would reflow the columns on every keypress. A handler that errors leaves the prompt open with the line intact, the usual cause being an ambiguous id. `without_escapes` in util.rs is the guard at the seam. A handler's own output is plain because the sink is, but an error message is built with color_text, which asks the process about its stdout and under the board answers yes about a terminal the message is not going to; a ratatui paragraph prints an escape rather than obeying it. That is 6d327df's fault on a new path. The merge tab is refused for now, resolved by index rather than by the tab's name, which is a label two projects can share. Routing by the card a command names is ebc5755. Not done here, and both tracked: check with no criterion still reaches ask_which_criterion and reads a raw-mode stdin, which is 6d37042's criterion 4 and commented there; and check_blockers warns about a dangling blocker with eprintln!, which reaches the alternate screen because it never passes through dispatch's result, filed as c680e24.
This commit is contained in:
+99
-69
@@ -1,3 +1,5 @@
|
||||
use std::path::Path;
|
||||
|
||||
use anyhow::Result;
|
||||
use clap::Parser;
|
||||
|
||||
@@ -50,76 +52,16 @@ fn main() -> Result<()> {
|
||||
let mut sink = Sink::std();
|
||||
|
||||
let result = match cli.command {
|
||||
// The board is the one thing `dispatch` does not run, and it is matched here
|
||||
// rather than there because it is the *caller* of that table rather than an entry
|
||||
// in it: a `tui` reached from the command prompt would enter the alternate screen
|
||||
// a second time from inside the draw loop. `dispatch` refuses it in those words.
|
||||
//
|
||||
// No subcommand opens the board, the way a bare `frig` does, and with no path
|
||||
// it opens the board above the working directory.
|
||||
None => run_tui(&[], &start),
|
||||
Some(Command::Tui { paths }) => run_tui(&paths, &start),
|
||||
Some(Command::Init) => cmd_init(&start, &mut sink),
|
||||
Some(Command::Add(args)) => cmd_add(&args, &start, &mut sink),
|
||||
Some(Command::Ls(args)) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_ls(&args, &worklane_dir, &mut sink)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_show(&id, &worklane_dir, &mut sink)
|
||||
}
|
||||
Some(Command::Mv(args)) => cmd_mv(&args, &start, &mut sink),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start, &mut sink),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start, &mut sink),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start, &mut sink),
|
||||
Some(Command::Chown(args)) => cmd_chown(&args, &start, &mut sink),
|
||||
Some(Command::Check(args)) => cmd_check(&args, true, &start, &mut sink),
|
||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start, &mut sink),
|
||||
Some(Command::Comment {
|
||||
ticket,
|
||||
body,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_comment(&ticket, &body, &actor, actor_from_git, &start, &mut sink),
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start, &mut sink),
|
||||
CampaignCommand::Ls { ids } => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_campaign_ls(&worklane_dir, ids, &mut sink)
|
||||
}
|
||||
CampaignCommand::Set(args) => cmd_campaign_set(&args, &start, &mut sink),
|
||||
CampaignCommand::Append(args) => cmd_campaign_append(&args, &start, &mut sink),
|
||||
CampaignCommand::Show { campaign } => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_campaign_show(&campaign, &worklane_dir, &mut sink)
|
||||
}
|
||||
},
|
||||
Some(Command::Assign {
|
||||
campaign,
|
||||
ticket,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start, &mut sink),
|
||||
// The bare form and `ls` are one arm: `worklane tags` was the listing before the
|
||||
// group existed and the fish completion still calls it that way, so the two
|
||||
// spellings cannot be allowed to drift into two behaviours.
|
||||
Some(Command::Tags { command }) => match command {
|
||||
None | Some(TagCommand::Ls) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_tags(&worklane_dir, &mut sink)
|
||||
}
|
||||
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start, &mut sink),
|
||||
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start, &mut sink),
|
||||
},
|
||||
// No board either, for the reason `install-skill` has none: a completion script
|
||||
// is generated from the clap definition and is the same wherever it is run.
|
||||
Some(Command::Completions { shell }) => {
|
||||
completions::generate(shell, sink.as_write()).map_err(Into::into)
|
||||
}
|
||||
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||
// before there is a `.worklane` anywhere.
|
||||
Some(Command::InstallSkill { skill, force, print }) => {
|
||||
cmd_install_skill(skill.as_deref(), force, print, &mut sink)
|
||||
}
|
||||
// No board either, and one agent rather than both: opencode loads the tool file,
|
||||
// Claude Code has no path for one.
|
||||
Some(Command::InstallTool { force, print }) => cmd_install_tool(force, print, &mut sink),
|
||||
Some(command) => dispatch(&command, &start, &mut sink),
|
||||
};
|
||||
|
||||
// The board (and every handler) own their own writing, so flush what the last one
|
||||
@@ -128,6 +70,93 @@ fn main() -> Result<()> {
|
||||
result
|
||||
}
|
||||
|
||||
/// Run one parsed command against the board at or above `start`, saying what it did
|
||||
/// through `sink`.
|
||||
///
|
||||
/// **The one mapping from a parsed command to the function that performs it.** `main`
|
||||
/// calls it with the process's stdout and the working directory; the command prompt on
|
||||
/// the board calls it with a buffer and the selected tab's own root, and reads back what
|
||||
/// the handler said. A second copy of this match inside `tui.rs` would be a copy that
|
||||
/// drifted the first time a command was added, and it would drift *silently*, since both
|
||||
/// halves would go on compiling.
|
||||
///
|
||||
/// A command added to [`Command`] therefore lands here once and is runnable from both.
|
||||
/// The match is exhaustive for exactly that reason: there is no `_` arm for a new verb to
|
||||
/// fall into and do nothing.
|
||||
pub fn dispatch(command: &Command, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
match command {
|
||||
// Reachable only from the prompt, since `main` takes this arm before it gets
|
||||
// here. A board is not something a board can open.
|
||||
Command::Tui { .. } => Err(anyhow::anyhow!("`tui` opens a board, and you are on one")),
|
||||
Command::Init => cmd_init(start, sink),
|
||||
Command::Add(args) => cmd_add(args, start, sink),
|
||||
Command::Ls(args) => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_ls(args, &worklane_dir, sink)
|
||||
}
|
||||
Command::Show { id } => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_show(id, &worklane_dir, sink)
|
||||
}
|
||||
Command::Mv(args) => cmd_mv(args, start, sink),
|
||||
Command::Set(args) => cmd_set(args, start, sink),
|
||||
Command::Append(args) => cmd_append(args, start, sink),
|
||||
Command::Relate(args) => cmd_relate(args, start, sink),
|
||||
Command::Chown(args) => cmd_chown(args, start, sink),
|
||||
Command::Check(args) => cmd_check(args, true, start, sink),
|
||||
Command::Uncheck(args) => cmd_check(args, false, start, sink),
|
||||
Command::Comment {
|
||||
ticket,
|
||||
body,
|
||||
actor,
|
||||
actor_from_git,
|
||||
} => cmd_comment(ticket, body, actor, *actor_from_git, start, sink),
|
||||
Command::Campaign { command } => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(args, start, sink),
|
||||
CampaignCommand::Ls { ids } => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_campaign_ls(&worklane_dir, *ids, sink)
|
||||
}
|
||||
CampaignCommand::Set(args) => cmd_campaign_set(args, start, sink),
|
||||
CampaignCommand::Append(args) => cmd_campaign_append(args, start, sink),
|
||||
CampaignCommand::Show { campaign } => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_campaign_show(campaign, &worklane_dir, sink)
|
||||
}
|
||||
},
|
||||
Command::Assign {
|
||||
campaign,
|
||||
ticket,
|
||||
actor,
|
||||
actor_from_git,
|
||||
} => cmd_assign(campaign, ticket, actor, *actor_from_git, start, sink),
|
||||
// The bare form and `ls` are one arm: `worklane tags` was the listing before the
|
||||
// group existed and the fish completion still calls it that way, so the two
|
||||
// spellings cannot be allowed to drift into two behaviours.
|
||||
Command::Tags { command } => match command {
|
||||
None | Some(TagCommand::Ls) => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_tags(&worklane_dir, sink)
|
||||
}
|
||||
Some(TagCommand::Add(args)) => cmd_tag_add(args, start, sink),
|
||||
Some(TagCommand::Set(args)) => cmd_tag_set(args, start, sink),
|
||||
},
|
||||
// No board either, for the reason `install-skill` has none: a completion script
|
||||
// is generated from the clap definition and is the same wherever it is run.
|
||||
Command::Completions { shell } => {
|
||||
completions::generate(*shell, sink.as_write()).map_err(Into::into)
|
||||
}
|
||||
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||
// before there is a `.worklane` anywhere.
|
||||
Command::InstallSkill { skill, force, print } => {
|
||||
cmd_install_skill(skill.as_deref(), *force, *print, sink)
|
||||
}
|
||||
// No board either, and one agent rather than both: opencode loads the tool file,
|
||||
// Claude Code has no path for one.
|
||||
Command::InstallTool { force, print } => cmd_install_tool(*force, *print, sink),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------- tui --
|
||||
|
||||
/// Restore the terminal whatever happens.
|
||||
@@ -222,9 +251,10 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
|
||||
// And the command prompt, third, on the same contract: while a command is being
|
||||
// typed `q` is a letter, `d` leaves the columns alone and `tab` stays out of the
|
||||
// project tabs. No screen, because nothing it does measures the board yet. The
|
||||
// rule is `Board::prompt_key`, where a test can reach it.
|
||||
if board.prompt_key(key) {
|
||||
// project tabs. It takes the screen because enter runs the command and then has
|
||||
// to bring the ticket it moved back into view. The rule is `Board::prompt_key`,
|
||||
// where a test can reach it.
|
||||
if board.prompt_key(key, screen) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
+742
-79
File diff suppressed because it is too large
Load Diff
+40
-1
@@ -303,6 +303,42 @@ pub fn color_text(text: &str, color: Color) -> String {
|
||||
paint(text, color, should_use_colors())
|
||||
}
|
||||
|
||||
/// `text` with every ANSI escape sequence taken out of it.
|
||||
///
|
||||
/// The inverse of what [`paint`] writes, and the guard at the seam where a handler's
|
||||
/// words become something the board draws: ratatui prints an escape as literal bytes
|
||||
/// rather than obeying it, so a painted status reaches the screen as `\x1b[33m` and
|
||||
/// the word after it.
|
||||
///
|
||||
/// A [`Sink`] the board owns is plain, so this is not about a handler's ordinary
|
||||
/// output. It is about the strings that never go through one: an error message is
|
||||
/// built with `color_text`, which asks the *process* about its stdout, and under the
|
||||
/// board that answers yes about a terminal the message is not going to.
|
||||
pub fn without_escapes(text: &str) -> String {
|
||||
let mut out = String::with_capacity(text.len());
|
||||
let mut chars = text.chars();
|
||||
|
||||
while let Some(c) = chars.next() {
|
||||
if c != '\x1b' {
|
||||
out.push(c);
|
||||
continue;
|
||||
}
|
||||
|
||||
// A CSI sequence is `\x1b[`, then parameter bytes, closed by a final byte in
|
||||
// `@` to `~`. That is every sequence `Color` writes. Anything else is a short
|
||||
// escape whose one following character goes with it, which `next` has taken.
|
||||
if chars.next() == Some('[') {
|
||||
for c in chars.by_ref() {
|
||||
if ('\x40'..='\x7e').contains(&c) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// A destination for a command's output, chosen by the caller.
|
||||
///
|
||||
/// `main` hands a handler its own stdout and nothing about the CLI changes; the
|
||||
@@ -332,7 +368,10 @@ impl<'a> Sink<'a> {
|
||||
|
||||
/// An in-memory buffer, plain, for a test or a caller that colours the text
|
||||
/// itself.
|
||||
#[allow(dead_code)]
|
||||
///
|
||||
/// What the board's command prompt passes: the handler's words come back as text
|
||||
/// and the board styles them with ratatui, which is also why it must not be handed
|
||||
/// a coloured one — a paragraph prints an escape rather than obeying it.
|
||||
pub fn buffer(target: &'a mut Vec<u8>) -> Sink<'a> {
|
||||
Sink {
|
||||
writer: Box::new(target),
|
||||
|
||||
Reference in New Issue
Block a user