(fa5662a) Write handler output through a caller-supplied sink, and bump to 0.32.13
This commit is contained in:
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.32.12"
|
||||
version = "0.32.13"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.32.12"
|
||||
version = "0.32.13"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
+283
-125
@@ -2,7 +2,7 @@ use anyhow::{Result, anyhow};
|
||||
use chrono::Local;
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::io::{BufRead, IsTerminal};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::campaign::*;
|
||||
@@ -15,12 +15,12 @@ use crate::install;
|
||||
use crate::tag::{TAGS_FILE, TagIndex, tags_path};
|
||||
use crate::util::*;
|
||||
|
||||
pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
pub fn cmd_init(start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let dir = start.canonicalize().unwrap_or_else(|_| start.to_path_buf());
|
||||
let worklane_dir = dir.join(".worklane");
|
||||
|
||||
if worklane_dir.exists() {
|
||||
println!("worklane already initialized in: {}", worklane_dir.display());
|
||||
sink.writeln(&format!("worklane already initialized in: {}", worklane_dir.display()))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -42,11 +42,11 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
// directory was made three lines ago, so there is nothing here to truncate.
|
||||
fs::write(tags_path(&worklane_dir), TagIndex::default().render())?;
|
||||
|
||||
println!("Initialized worklane in: {}", worklane_dir.display());
|
||||
sink.writeln(&format!("Initialized worklane in: {}", worklane_dir.display()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
// Resolved before anything is read, so an unknown campaign is refused rather than
|
||||
// silently listing nothing, and the name is available for the heading. Ahead of the
|
||||
// `--ids` branch too: a completion that quietly listed the whole board because the
|
||||
@@ -58,17 +58,18 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
let tag = args.tag.as_deref();
|
||||
let priority_filter = args.priority;
|
||||
let colored = sink.use_color;
|
||||
|
||||
if args.ids {
|
||||
return list_ids(args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
return list_ids(sink, args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
}
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Members of campaign ({}) {}\n",
|
||||
color_text(short_id(&campaign.uuid), Color::Red),
|
||||
color_text(&campaign.title, Color::Green),
|
||||
);
|
||||
paint(short_id(&campaign.uuid), Color::Red, colored),
|
||||
paint(&campaign.title, Color::Green, colored),
|
||||
))?;
|
||||
}
|
||||
|
||||
if let Some(status) = args.status {
|
||||
@@ -92,16 +93,16 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
items.sort_by(|a, b| by_status_order(status, a, b));
|
||||
|
||||
if items.is_empty() {
|
||||
println!("No tickets in '{}' status.", name);
|
||||
sink.writeln(&format!("No tickets in '{}' status.", name))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("Tickets in '{}' status:\n", name);
|
||||
display_ticket_items(&items);
|
||||
sink.writeln(&format!("Tickets in '{}' status:\n", name))?;
|
||||
display_ticket_items(sink, &items)?;
|
||||
} else {
|
||||
// List all statuses with their ticket counts
|
||||
let statuses = status_dirs();
|
||||
println!("Tickets by status:\n");
|
||||
sink.writeln("Tickets by status:\n")?;
|
||||
for status in &statuses {
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
@@ -110,7 +111,7 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid, tag);
|
||||
let count = items.len();
|
||||
let label = if count == 1 { "ticket" } else { "tickets" };
|
||||
println!(" [{}] {} {}", status.to_uppercase(), count, label);
|
||||
sink.writeln(&format!(" [{}] {} {}", status.to_uppercase(), count, label))?;
|
||||
}
|
||||
|
||||
// Show all tickets except the two terminal statuses, grouped by status. Over
|
||||
@@ -134,9 +135,9 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
continue;
|
||||
}
|
||||
let status_header =
|
||||
color_text(&format!("[{}]", status.as_str().to_uppercase()), Color::Orange);
|
||||
println!("\n{}", status_header);
|
||||
display_ticket_items(&items);
|
||||
paint(&format!("[{}]", status.as_str().to_uppercase()), Color::Orange, colored);
|
||||
sink.writeln(&format!("\n{}", status_header))?;
|
||||
display_ticket_items(sink, &items)?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -160,6 +161,7 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
/// parts company with the listing. The caller is usually a shell filling in a candidate
|
||||
/// list, and an error printed over the prompt is worse there than no candidates.
|
||||
fn list_ids(
|
||||
sink: &mut Sink,
|
||||
status: Option<Status>,
|
||||
level: Option<u8>,
|
||||
campaign: Option<&str>,
|
||||
@@ -181,7 +183,7 @@ fn list_ids(
|
||||
let mut items = filtered(collect_ticket_items(&status_path)?, level, campaign, tag);
|
||||
items.sort_by(|a, b| by_status_order(status, a, b));
|
||||
for item in items {
|
||||
println!("{}\t{}", item.id, item.title);
|
||||
sink.writeln(&format!("{}\t{}", item.id, item.title))?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -243,7 +245,7 @@ fn filter_by_priority(items: Vec<TicketItem>, level: Option<u8>) -> Vec<TicketIt
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_add(args: &AddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let AddArgs {
|
||||
title,
|
||||
description,
|
||||
@@ -349,28 +351,28 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
// the same writer as every edit is the one that makes the new file appear whole.
|
||||
write_then_replace(&worklane_dir, &filepath, &filename, &body, TICKET, title)?;
|
||||
|
||||
println!("Created ticket: {}", filename);
|
||||
sink.writeln(&format!("Created ticket: {}", filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_show(search: &str, worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
let (_status, title, content) = resolve_ticket(search, worklane_dir)?;
|
||||
let ticket_uuid = parse_ticket_field(&content, "ID");
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of
|
||||
// half printing a ticket.
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of recover.
|
||||
let resolved = resolved_for(&content, worklane_dir)?;
|
||||
|
||||
// The only title in the output: content_trim_colored used to print it a second
|
||||
// The only title in the output: content_trim used to print it a second
|
||||
// time from the file content. Green per the colour guideline, and the rule is
|
||||
// measured in characters so a non-ASCII title is not over-drawn.
|
||||
println!("{}", color_text(&title, Color::Green));
|
||||
println!("{}", "─".repeat(title.chars().count()));
|
||||
println!("\n{}", content_trim_colored(&content, &resolved));
|
||||
sink.writeln(&paint(&title, Color::Green, colored))?;
|
||||
sink.writeln(&"─".repeat(title.chars().count()))?;
|
||||
sink.writeln(&format!("\n{}", content_trim(&content, colored, &resolved)))?;
|
||||
|
||||
if ticket_uuid != "_Not set_" {
|
||||
let entries = read_history(worklane_dir, &ticket_uuid)?;
|
||||
let formatted = format_history(&entries);
|
||||
println!("{}", formatted);
|
||||
sink.writeln(&formatted)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -598,7 +600,7 @@ fn check_dependents(worklane_dir: &Path, uuid: &str, title: &str) -> Result<()>
|
||||
/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse
|
||||
/// and nothing here has to check. What is left is the order of the flow, which is
|
||||
/// `Status::ALL`.
|
||||
pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_mv(args: &MvArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let MvArgs {
|
||||
ticket: ticket_id,
|
||||
status: target,
|
||||
@@ -657,10 +659,10 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
let recorded = parse_ticket_field(&resolved, "Status");
|
||||
|
||||
if recorded == target_status {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Ticket is already in '{}' status.",
|
||||
color_text(target_status, Color::Orange)
|
||||
);
|
||||
paint(target_status, Color::Orange, sink.use_color)
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -679,12 +681,12 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
&corrected,
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Corrected Status field on '{}': said {}, but the file sits in {}.",
|
||||
color_text(&title, Color::Green),
|
||||
color_text(&recorded, Color::Orange),
|
||||
color_text(target_status, Color::Orange)
|
||||
);
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
paint(&recorded, Color::Orange, sink.use_color),
|
||||
paint(target_status, Color::Orange, sink.use_color)
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -747,12 +749,12 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
&reason,
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Moved ticket '{}' from {} to {}",
|
||||
color_text(&title, Color::Green),
|
||||
color_text(¤t_status, Color::Orange),
|
||||
color_text(target_status, Color::Orange),
|
||||
);
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
paint(¤t_status, Color::Orange, sink.use_color),
|
||||
paint(target_status, Color::Orange, sink.use_color),
|
||||
))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -763,6 +765,7 @@ pub fn cmd_comment(
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
if body.is_empty() {
|
||||
return Err(anyhow!("Comment body is required."));
|
||||
@@ -785,7 +788,7 @@ pub fn cmd_comment(
|
||||
"",
|
||||
)?;
|
||||
|
||||
println!("Comment added to '{}' ({})", title, filename);
|
||||
sink.writeln(&format!("Comment added to '{}' ({})", title, filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -928,8 +931,8 @@ fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static
|
||||
}
|
||||
}
|
||||
|
||||
fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
report_in(fields, title, Color::Green, verb)
|
||||
fn report(sink: &mut Sink, fields: &[&str], title: &str, verb: &str) -> Result<()> {
|
||||
report_in(sink, fields, title, Color::Green, verb)
|
||||
}
|
||||
|
||||
/// The same, for a subject that is not a title.
|
||||
@@ -939,16 +942,28 @@ fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
/// not one of them. The colour is passed in rather than decided here, which is the trade
|
||||
/// `paint` makes with `color_text`, and it keeps the wording in one place so a tag reports
|
||||
/// a no-op in the same words a ticket does.
|
||||
fn report_in(fields: &[&str], title: &str, color: Color, verb: &str) {
|
||||
fn report_in(
|
||||
sink: &mut Sink,
|
||||
fields: &[&str],
|
||||
title: &str,
|
||||
color: Color,
|
||||
verb: &str,
|
||||
) -> Result<()> {
|
||||
if fields.is_empty() {
|
||||
println!("No changes to '{}'", color_text(title, color));
|
||||
return;
|
||||
sink.writeln(&format!("No changes to '{}'", sink.color(title, color)))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, color));
|
||||
sink.writeln(&format!(
|
||||
"{} {} on '{}'",
|
||||
verb,
|
||||
fields.join(", "),
|
||||
sink.color(title, color)
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
if let Some(field) = args.contested() {
|
||||
let name = field.name();
|
||||
return Err(anyhow!(
|
||||
@@ -1010,7 +1025,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if changed.is_empty() && cleared.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1037,10 +1052,10 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
|
||||
let shown = args.title.clone().unwrap_or(title);
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &shown, "Updated");
|
||||
report(sink, &changed, &shown, "Updated")?;
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &shown, "Cleared");
|
||||
report(sink, &cleared, &shown, "Cleared")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1061,7 +1076,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
/// for a ticket it is filing, which is a default for something new; an owner taken away
|
||||
/// says nobody owns this, and putting the person running the command there instead would
|
||||
/// hand them a ticket they were giving up.
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let (ticket_id, user) = args.target().ok_or_else(|| {
|
||||
anyhow!("chown takes a user and a ticket, or --clear with the ticket alone")
|
||||
})?;
|
||||
@@ -1073,7 +1088,7 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
let content = set_metadata_field(&original, "Owner", user.unwrap_or(NOT_SET), &title)?;
|
||||
|
||||
if content == original {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1097,11 +1112,11 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
Some(_) => "Updated",
|
||||
None => "Cleared",
|
||||
};
|
||||
report(&["owner"], &title, verb);
|
||||
report(sink, &["owner"], &title, verb)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_append(args: &AppendArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
@@ -1122,7 +1137,7 @@ pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&changed, &title, "Appended to");
|
||||
report(sink, &changed, &title, "Appended to")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1210,7 +1225,7 @@ fn find_relation(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_relate(args: &RelateArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
@@ -1303,7 +1318,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if items.is_empty() && dropped.is_empty() {
|
||||
report(&[], &title, "Recorded");
|
||||
report(sink, &[], &title, "Recorded")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1336,10 +1351,10 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &title, "Recorded");
|
||||
report(sink, &changed, &title, "Recorded")?;
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &title, "Cleared");
|
||||
report(sink, &cleared, &title, "Cleared")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1351,7 +1366,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
/// Written through `write_then_replace` rather than `fs::write`, so a failure leaves no
|
||||
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
|
||||
/// plain write; the difference is noted on the ticket rather than fixed here.
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let CampaignAddArgs {
|
||||
title,
|
||||
description,
|
||||
@@ -1382,7 +1397,7 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
|
||||
write_then_replace(&worklane_dir, &path, &filename, &body, CAMPAIGN, title)?;
|
||||
|
||||
println!("Created campaign: {}", filename);
|
||||
sink.writeln(&format!("Created campaign: {}", filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1392,26 +1407,26 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
/// scan per row rather than one scan reused, and it is deliberate: the alternative is a
|
||||
/// map from campaign uuid to counts built in a single walk, which is worth writing when
|
||||
/// a board has enough campaigns to notice and is premature now.
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool, sink: &mut Sink) -> Result<()> {
|
||||
let index = CampaignIndex::load(worklane_dir)?;
|
||||
let colored = sink.use_color;
|
||||
|
||||
// Ahead of the empty check, which prints prose: a completion must offer nothing
|
||||
// rather than offer a sentence, the same bargain `list_ids` takes with a missing
|
||||
// status directory.
|
||||
if ids {
|
||||
for campaign in index.iter() {
|
||||
println!("{}\t{}", short_id(&campaign.uuid), campaign.title);
|
||||
sink.writeln(&format!("{}\t{}", short_id(&campaign.uuid), campaign.title))?;
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if index.is_empty() {
|
||||
println!("No campaigns yet. `worklane campaign add --title` files one.");
|
||||
sink.writeln("No campaigns yet. `worklane campaign add --title` files one.")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let colored = should_use_colors();
|
||||
println!("Campaigns:\n");
|
||||
sink.writeln("Campaigns:\n")?;
|
||||
|
||||
for campaign in index.iter() {
|
||||
let standing = Standing::of(&members(worklane_dir, &campaign.uuid)?);
|
||||
@@ -1432,14 +1447,14 @@ pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
false => String::new(),
|
||||
};
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
" ({}) {}{} | {}{}",
|
||||
paint(short_id(&campaign.uuid), Color::Red, colored),
|
||||
codename,
|
||||
campaign.title,
|
||||
standing.label(),
|
||||
state,
|
||||
);
|
||||
))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1479,7 +1494,7 @@ pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
///
|
||||
/// Every status, done included, for the reason `ls --ids` includes it: a tag retired months
|
||||
/// ago is still part of the answer to what the vocabulary has been.
|
||||
pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_tags(worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
// Through the same `load` `tags add` uses, so a file that is there and cannot be read
|
||||
// is an error here too. The listing is the one tag command that could go on without the
|
||||
// file, and reporting a vocabulary while silently treating a broken file as no file is
|
||||
@@ -1507,8 +1522,8 @@ pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
|
||||
for (tag, count) in counts {
|
||||
match index.summary(&tag) {
|
||||
Some(summary) => println!("{tag}\t{count}\t{summary}"),
|
||||
None => println!("{tag}\t{count}"),
|
||||
Some(summary) => sink.writeln(&format!("{tag}\t{count}\t{summary}"))?,
|
||||
None => sink.writeln(&format!("{tag}\t{count}"))?,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1531,7 +1546,7 @@ pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
/// The whole file is re-rendered from the parsed vocabulary, so declaring a tag also
|
||||
/// re-sorts the file and rewrites its preamble. That is why an unreadable file is an error
|
||||
/// in `TagIndex::load` rather than an empty vocabulary: here, empty would mean erased.
|
||||
pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_tag_add(args: &TagAddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let mut index = TagIndex::load(&worklane_dir)?;
|
||||
|
||||
@@ -1559,7 +1574,10 @@ pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
|
||||
// The tag in its own colour, which is the colour it is drawn in on every card and in
|
||||
// every listing: `tag_color` is a pure function of the word.
|
||||
println!("Declared tag: {}", color_text(&args.tag, tag_color(&args.tag)));
|
||||
sink.writeln(&format!(
|
||||
"Declared tag: {}",
|
||||
paint(&args.tag, tag_color(&args.tag), sink.use_color)
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1577,7 +1595,7 @@ pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
/// The no-op compares the rendered file rather than the annotation, which is what `apply`
|
||||
/// does for a ticket: the file is the thing that would be written, so it is the thing worth
|
||||
/// asking whether the write would change.
|
||||
pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_tag_set(args: &TagSetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let mut index = TagIndex::load(&worklane_dir)?;
|
||||
|
||||
@@ -1606,7 +1624,7 @@ pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
)?;
|
||||
}
|
||||
|
||||
report_in(&changed, &args.tag, tag_color(&args.tag), "Updated");
|
||||
report_in(sink, &changed, &args.tag, tag_color(&args.tag), "Updated")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1649,7 +1667,7 @@ pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
/// the heading, so an insertion path here would be reachable only from a hand-edited file:
|
||||
/// that is the opposite of the Relations case, where `add` writes nothing and the insertion
|
||||
/// is the only path there is.
|
||||
pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(&args.campaign, &worklane_dir)?;
|
||||
let title = campaign.title.clone();
|
||||
@@ -1693,14 +1711,14 @@ pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if changed.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let renamed = changed.contains(&"title").then_some(()).and(args.title.as_ref());
|
||||
save_campaign(&worklane_dir, &campaign.uuid, &title, renamed, &content)?;
|
||||
|
||||
report(&changed, args.title.as_ref().unwrap_or(&title), "Updated");
|
||||
report(sink, &changed, args.title.as_ref().unwrap_or(&title), "Updated")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1717,7 +1735,7 @@ pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
///
|
||||
/// One section, so there is no loop and no list to report: what changed is the description
|
||||
/// or the call failed.
|
||||
pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(&args.campaign, &worklane_dir)?;
|
||||
|
||||
@@ -1726,7 +1744,7 @@ pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()
|
||||
|
||||
save_campaign(&worklane_dir, &campaign.uuid, &campaign.title, None, &content)?;
|
||||
|
||||
report(&[DESCRIPTION.label], &campaign.title, "Appended to");
|
||||
report(sink, &[DESCRIPTION.label], &campaign.title, "Appended to")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1735,28 +1753,35 @@ pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()
|
||||
/// Every status is shown, done included, unlike `ls`, which leaves done out of its
|
||||
/// listing. A campaign's whole point is what is finished against what is left, so
|
||||
/// hiding the finished half would hide the answer.
|
||||
pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_show(search: &str, worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
let campaign = resolve_campaign(search, worklane_dir)?;
|
||||
|
||||
println!("{}", color_text(&campaign.title, Color::Green));
|
||||
println!("{}", "─".repeat(campaign.title.chars().count()));
|
||||
sink.writeln(&paint(&campaign.title, Color::Green, colored))?;
|
||||
sink.writeln(&"─".repeat(campaign.title.chars().count()))?;
|
||||
// No relations and no campaign of its own: a campaign is not a ticket, and neither
|
||||
// belongs to one.
|
||||
println!("\n{}", content_trim_colored(&campaign.content, &Resolved::default()));
|
||||
sink.writeln(&format!(
|
||||
"\n{}",
|
||||
content_trim(&campaign.content, colored, &Resolved::default())
|
||||
))?;
|
||||
|
||||
let grouped = members(worklane_dir, &campaign.uuid)?;
|
||||
let standing = Standing::of(&grouped);
|
||||
|
||||
println!("{}", color_text("Members", Color::Orange));
|
||||
println!("{}", "─".repeat("Members".chars().count()));
|
||||
println!("\n{}", standing.label());
|
||||
sink.writeln(&paint("Members", Color::Orange, colored))?;
|
||||
sink.writeln(&"─".repeat("Members".chars().count()))?;
|
||||
sink.writeln(&format!("\n{}", standing.label()))?;
|
||||
|
||||
for (status, items) in &grouped {
|
||||
if items.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!("\n{}", color_text(&format!("[{}]", status.to_uppercase()), Color::Orange));
|
||||
display_ticket_items(items);
|
||||
sink.writeln(&format!(
|
||||
"\n{}",
|
||||
paint(&format!("[{}]", status.to_uppercase()), Color::Orange, colored)
|
||||
))?;
|
||||
display_ticket_items(sink, items)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1776,6 +1801,7 @@ pub fn cmd_assign(
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(campaign_search, &worklane_dir)?;
|
||||
@@ -1786,11 +1812,11 @@ pub fn cmd_assign(
|
||||
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, TICKET, &title)?;
|
||||
|
||||
if content == original {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Ticket '{}' is already in campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
campaign.title,
|
||||
);
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1817,11 +1843,11 @@ pub fn cmd_assign(
|
||||
"",
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Assigned '{}' to campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
campaign.title,
|
||||
);
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1832,7 +1858,7 @@ pub fn cmd_assign(
|
||||
/// reason: the opencode wrapper throws on the exit code and keeps stderr, so a list
|
||||
/// printed to stdout would be discarded and an agent would learn nothing. Prompting
|
||||
/// regardless would leave it blocked on a stdin that never closes.
|
||||
fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
fn ask_which_criterion(sink: &mut Sink, criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
let listing = criteria_list(criteria);
|
||||
|
||||
if !std::io::stdin().is_terminal() {
|
||||
@@ -1843,11 +1869,14 @@ fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
));
|
||||
}
|
||||
|
||||
println!("Acceptance criteria of '{}':", color_text(title, Color::Green));
|
||||
println!("{}", listing);
|
||||
sink.writeln(&format!(
|
||||
"Acceptance criteria of '{}':",
|
||||
paint(title, Color::Green, sink.use_color)
|
||||
))?;
|
||||
sink.writeln(&listing)?;
|
||||
// Either form, since find_criteria takes both.
|
||||
print!("Number or text: ");
|
||||
std::io::stdout().flush()?;
|
||||
sink.write("Number or text: ")?;
|
||||
sink.flush()?;
|
||||
|
||||
let mut answer = String::new();
|
||||
std::io::stdin().lock().read_line(&mut answer)?;
|
||||
@@ -1933,7 +1962,7 @@ fn resolve_criteria(criteria: &[Criterion], terms: &[String], title: &str) -> Re
|
||||
Ok(chosen)
|
||||
}
|
||||
|
||||
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, content) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
|
||||
@@ -1943,7 +1972,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
let chosen = match args.criteria.as_slice() {
|
||||
[] => vec![ask_which_criterion(&criteria, &title)?],
|
||||
[] => vec![ask_which_criterion(sink, &criteria, &title)?],
|
||||
terms => resolve_criteria(&criteria, terms, &title)?,
|
||||
};
|
||||
|
||||
@@ -1975,7 +2004,12 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
past.to_string()
|
||||
};
|
||||
|
||||
println!("{} {}: {}", state, offset + 1, color_text(&criterion.text, Color::Green));
|
||||
sink.writeln(&format!(
|
||||
"{} {}: {}",
|
||||
state,
|
||||
offset + 1,
|
||||
paint(&criterion.text, Color::Green, sink.use_color)
|
||||
))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1990,7 +2024,12 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
/// With no name, every shipped document is installed. Narrowing to one is the
|
||||
/// exception rather than the rule, so that a document added in a later version reaches
|
||||
/// anyone who already knows the command.
|
||||
pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Result<()> {
|
||||
pub fn cmd_install_skill(
|
||||
skill: Option<&str>,
|
||||
force: bool,
|
||||
print: bool,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
if print {
|
||||
// Printing every document would run them together into something that is not
|
||||
// any of them, and the point of `--print` is to diff one against its copy.
|
||||
@@ -2000,7 +2039,7 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
install::skill_names()
|
||||
)
|
||||
})?;
|
||||
print!("{}", install::skill_named(name)?.content);
|
||||
sink.write(install::skill_named(name)?.content)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -2010,14 +2049,14 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
};
|
||||
|
||||
let root = install::skills_root()?;
|
||||
let written = install_each(&chosen, &root, force, |asset| {
|
||||
let written = install_each(sink, &chosen, &root, force, |asset| {
|
||||
format!("worklane install-skill {} --print", asset.name)
|
||||
})?;
|
||||
|
||||
// Once, and only when something arrived: repeating it per document would make the
|
||||
// instruction look like part of each outcome rather than the one thing to do next.
|
||||
if written {
|
||||
println!("Claude Code and opencode pick it up on their next session");
|
||||
sink.writeln("Claude Code and opencode pick it up on their next session")?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -2033,6 +2072,7 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
/// each command has its own thing to say about what picks the asset up, and neither
|
||||
/// should say it once per asset.
|
||||
fn install_each(
|
||||
sink: &mut Sink,
|
||||
chosen: &[&install::Asset],
|
||||
root: &Path,
|
||||
force: bool,
|
||||
@@ -2043,15 +2083,26 @@ fn install_each(
|
||||
for asset in chosen {
|
||||
match asset.install(root, force)? {
|
||||
install::Outcome::Written(path) => {
|
||||
println!("Installed the {} {} to: {}", asset.name, asset.what, path.display());
|
||||
sink.writeln(&format!(
|
||||
"Installed the {} {} to: {}",
|
||||
asset.name,
|
||||
asset.what,
|
||||
path.display()
|
||||
))?;
|
||||
written = true;
|
||||
}
|
||||
install::Outcome::Unchanged(path) => {
|
||||
println!("Already up to date: {}", path.display());
|
||||
sink.writeln(&format!("Already up to date: {}", path.display()))?;
|
||||
}
|
||||
install::Outcome::Refused(path) => {
|
||||
println!("Differs from the version in this binary: {}", path.display());
|
||||
println!("Compare with `{}`, or overwrite with --force", compare(asset));
|
||||
sink.writeln(&format!(
|
||||
"Differs from the version in this binary: {}",
|
||||
path.display()
|
||||
))?;
|
||||
sink.writeln(&format!(
|
||||
"Compare with `{}`, or overwrite with --force",
|
||||
compare(asset)
|
||||
))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2064,29 +2115,136 @@ fn install_each(
|
||||
/// No name argument, where `install-skill` has an optional one: there is a single tool
|
||||
/// file, so a name could only be right or wrong, and `--print` needs no help deciding
|
||||
/// what to print.
|
||||
pub fn cmd_install_tool(force: bool, print: bool) -> Result<()> {
|
||||
pub fn cmd_install_tool(force: bool, print: bool, sink: &mut Sink) -> Result<()> {
|
||||
if print {
|
||||
print!("{}", install::TOOL.content);
|
||||
sink.write(install::TOOL.content)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let chosen: Vec<&install::Asset> = install::TOOLS.iter().collect();
|
||||
let root = install::tools_root()?;
|
||||
let written =
|
||||
install_each(&chosen, &root, force, |_| "worklane install-tool --print".to_string())?;
|
||||
let written = install_each(sink, &chosen, &root, force, |_| {
|
||||
"worklane install-tool --print".to_string()
|
||||
})?;
|
||||
|
||||
// Not "on its next session", which is what the skills say: opencode reads its config
|
||||
// once at startup and does not reload it, so a running one keeps the tools it began
|
||||
// with. The second line is there because the file is executable and looks like it
|
||||
// needs a toolchain: it does not, it runs inside opencode.
|
||||
if written {
|
||||
println!(
|
||||
"opencode loads it in every project. Restart it: the config is read at startup and never reloaded"
|
||||
);
|
||||
println!(
|
||||
"Nothing else to install. It runs in opencode's own runtime, so neither Bun nor @opencode-ai/plugin is needed on this machine"
|
||||
);
|
||||
sink.writeln(
|
||||
"opencode loads it in every project. Restart it: the config is read at startup and never reloaded",
|
||||
)?;
|
||||
sink.writeln(
|
||||
"Nothing else to install. It runs in opencode's own runtime, so neither Bun nor @opencode-ai/plugin is needed on this machine",
|
||||
)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod sink_tests {
|
||||
use super::*;
|
||||
use crate::util::Sink;
|
||||
use std::fs;
|
||||
|
||||
/// A throwaway board, so a test can point a handler at a sink without touching the
|
||||
/// real one. Cleaned up at the end; a leftover here is an aborted test, not a
|
||||
/// fixture the suite has to keep alive.
|
||||
fn temp_worklane() -> std::path::PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!("wl-sink-{}", uuid::Uuid::new_v4()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
|
||||
fs::create_dir_all(dir.join(status)).unwrap();
|
||||
}
|
||||
fs::create_dir_all(dir.join("campaigns")).unwrap();
|
||||
fs::write(dir.join("tags.md"), crate::tag::TagIndex::default().render()).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn ticket(dir: &Path, status: &str, uuid: &str) {
|
||||
fs::write(
|
||||
dir.join(status).join(format!("{}_ticket.md", uuid)),
|
||||
format!(
|
||||
"# {u} title\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
body\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {u}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: _None_\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {status}\n",
|
||||
u = uuid,
|
||||
status = status,
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// A handler writes through the sink it is handed, and a caller can read the bytes
|
||||
/// back without a terminal or a real stdout.
|
||||
#[test]
|
||||
fn handler_writes_to_a_buffer() {
|
||||
let dir = temp_worklane();
|
||||
ticket(&dir, "backlog", "abc1234-def5678");
|
||||
|
||||
let args = LsArgs {
|
||||
status: None,
|
||||
priority: None,
|
||||
tag: None,
|
||||
campaign: None,
|
||||
ids: false,
|
||||
};
|
||||
|
||||
let mut buf = Vec::new();
|
||||
{
|
||||
let mut sink = Sink::buffer(&mut buf);
|
||||
cmd_ls(&args, &dir, &mut sink).unwrap();
|
||||
}
|
||||
|
||||
let out = String::from_utf8(buf).unwrap();
|
||||
// The short id, not swallowed by a terminal, and no colour escapes without a
|
||||
// colour sink.
|
||||
assert!(out.contains("abc1234"), "ticket id missing from:\n{out}");
|
||||
assert!(!out.contains('\u{1b}'), "unexpected colour in:\n{out}");
|
||||
|
||||
fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// The same handler behind a coloured sink paints the id red, so the colour decision
|
||||
/// is the sink's and not the process's.
|
||||
#[test]
|
||||
fn handler_colours_when_the_sink_says_so() {
|
||||
let dir = temp_worklane();
|
||||
ticket(&dir, "backlog", "abc1234-def5678");
|
||||
|
||||
let args = LsArgs {
|
||||
status: None,
|
||||
priority: None,
|
||||
tag: None,
|
||||
campaign: None,
|
||||
ids: false,
|
||||
};
|
||||
|
||||
let mut buf = Vec::new();
|
||||
{
|
||||
let mut sink = Sink::new(Box::new(&mut buf), true);
|
||||
// The sink is the source of the colour decision: the same word it wraps
|
||||
// here is what the handler paints through `paint(.., sink.use_color)`.
|
||||
assert!(sink.color("abc1234", Color::Red).contains('\u{1b}'));
|
||||
cmd_ls(&args, &dir, &mut sink).unwrap();
|
||||
}
|
||||
|
||||
let out = String::from_utf8(buf).unwrap();
|
||||
assert!(out.contains("abc1234"), "ticket id missing from:\n{out}");
|
||||
assert!(out.contains('\u{1b}'), "expected colour in:\n{out}");
|
||||
|
||||
fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
|
||||
+33
-26
@@ -42,45 +42,47 @@ fn main() -> Result<()> {
|
||||
|
||||
let start = std::env::current_dir()?;
|
||||
|
||||
match cli.command {
|
||||
let mut sink = Sink::std();
|
||||
|
||||
let result = match cli.command {
|
||||
// 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),
|
||||
Some(Command::Add(args)) => cmd_add(&args, &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)
|
||||
cmd_ls(&args, &worklane_dir, &mut sink)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_show(&id, &worklane_dir)
|
||||
cmd_show(&id, &worklane_dir, &mut sink)
|
||||
}
|
||||
Some(Command::Mv(args)) => cmd_mv(&args, &start),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
||||
Some(Command::Chown(args)) => cmd_chown(&args, &start),
|
||||
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
||||
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),
|
||||
}) => 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),
|
||||
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)
|
||||
cmd_campaign_ls(&worklane_dir, ids, &mut sink)
|
||||
}
|
||||
CampaignCommand::Set(args) => cmd_campaign_set(&args, &start),
|
||||
CampaignCommand::Append(args) => cmd_campaign_append(&args, &start),
|
||||
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)
|
||||
cmd_campaign_show(&campaign, &worklane_dir, &mut sink)
|
||||
}
|
||||
},
|
||||
Some(Command::Assign {
|
||||
@@ -88,32 +90,37 @@ fn main() -> Result<()> {
|
||||
ticket,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start),
|
||||
}) => 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)
|
||||
cmd_tags(&worklane_dir, &mut sink)
|
||||
}
|
||||
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start),
|
||||
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start),
|
||||
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, &mut std::io::stdout()).map_err(Into::into)
|
||||
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)
|
||||
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),
|
||||
}
|
||||
Some(Command::InstallTool { force, print }) => cmd_install_tool(force, print, &mut sink),
|
||||
};
|
||||
|
||||
// The board (and every handler) own their own writing, so flush what the last one
|
||||
// handed the sink before returning; an error path printed nothing to flush.
|
||||
sink.flush()?;
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------- tui --
|
||||
|
||||
+89
-15
@@ -1,7 +1,7 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
use chrono::NaiveDateTime;
|
||||
use std::fs;
|
||||
use std::io::IsTerminal;
|
||||
use std::io::{IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
@@ -303,6 +303,80 @@ pub fn color_text(text: &str, color: Color) -> String {
|
||||
paint(text, color, should_use_colors())
|
||||
}
|
||||
|
||||
/// 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
|
||||
/// board (or a test) hands it an in-memory buffer and reads back what the command
|
||||
/// said. Threading the writer and the colour decision together means every print
|
||||
/// site reaches both, and a handler never asks the process about its own stdout.
|
||||
///
|
||||
/// `use_color` is the sink's answer, not a read of [`should_use_colors`]: a process
|
||||
/// whose stdout is a pipe still wants colour when the sink is a buffer a renderer
|
||||
/// will colour itself, and the board wants plain text however the terminal answers.
|
||||
pub struct Sink<'a> {
|
||||
writer: Box<dyn Write + 'a>,
|
||||
/// Whether the bytes this sink writes carry colour escapes.
|
||||
pub use_color: bool,
|
||||
}
|
||||
|
||||
impl<'a> Sink<'a> {
|
||||
/// The process's stdout, coloured by what the terminal wants.
|
||||
///
|
||||
/// What `main` passes, so the CLI's output is byte identical to before: every
|
||||
/// command wrote to stdout through `println!`, and this sink writes to the same
|
||||
/// stdout through the same [`paint`].
|
||||
pub fn std() -> Sink<'static> {
|
||||
// Through `new` so the process's stdout is just another writer the sink wraps.
|
||||
Sink::new(Box::new(std::io::stdout()), should_use_colors())
|
||||
}
|
||||
|
||||
/// An in-memory buffer, plain, for a test or a caller that colours the text
|
||||
/// itself.
|
||||
#[allow(dead_code)]
|
||||
pub fn buffer(target: &'a mut Vec<u8>) -> Sink<'a> {
|
||||
Sink {
|
||||
writer: Box::new(target),
|
||||
use_color: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Any writer, with the colour decision given.
|
||||
pub fn new(writer: Box<dyn Write + 'a>, use_color: bool) -> Sink<'a> {
|
||||
Sink { writer, use_color }
|
||||
}
|
||||
|
||||
/// The writer, for a caller that already knows how to fill it (the completions
|
||||
/// generator).
|
||||
pub fn as_write(&mut self) -> &mut dyn Write {
|
||||
&mut *self.writer
|
||||
}
|
||||
|
||||
/// Write `text` followed by a newline, the way `println!` did.
|
||||
pub fn writeln(&mut self, text: &str) -> Result<()> {
|
||||
self.writer.write_all(text.as_bytes())?;
|
||||
self.writer.write_all(b"\n")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Write `text` with no terminator, the way `print!` did. The caller flushes
|
||||
/// when it then waits on input.
|
||||
pub fn write(&mut self, text: &str) -> Result<()> {
|
||||
self.writer.write_all(text.as_bytes())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Flush the writer, so a prompt reaches the terminal before a read.
|
||||
pub fn flush(&mut self) -> Result<()> {
|
||||
self.writer.flush()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `text` wrapped in `color`'s escape when this sink is coloured.
|
||||
pub fn color(&self, text: &str, color: Color) -> String {
|
||||
paint(text, color, self.use_color)
|
||||
}
|
||||
}
|
||||
|
||||
/// What sits at a candidate `.worklane` path.
|
||||
///
|
||||
/// The distinction the walk turns on is between nothing there and something
|
||||
@@ -738,10 +812,6 @@ pub struct Resolved {
|
||||
pub campaign: Vec<Cell>,
|
||||
}
|
||||
|
||||
pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
|
||||
content_trim(content, should_use_colors(), resolved)
|
||||
}
|
||||
|
||||
/// A section heading, its rule, and the blank line the body opens under.
|
||||
///
|
||||
/// The rule is measured on the name as displayed, in characters. It used to span the
|
||||
@@ -3314,8 +3384,8 @@ fn show_priority(priority: Priority, colored: bool) -> String {
|
||||
paint(glyph, colour, colored)
|
||||
}
|
||||
|
||||
pub fn display_ticket_items(items: &[TicketItem]) {
|
||||
let colored = should_use_colors();
|
||||
pub fn display_ticket_items(sink: &mut Sink, items: &[TicketItem]) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
|
||||
for item in items {
|
||||
let id = paint(&item.id, Color::Red, colored);
|
||||
@@ -3324,15 +3394,19 @@ pub fn display_ticket_items(items: &[TicketItem]) {
|
||||
let priority = show_priority(item.priority, colored);
|
||||
|
||||
if item.created.is_empty() {
|
||||
println!(" {} ({}) {} | Owner: {} | Due: {}", priority, id, item.title, owner, due);
|
||||
sink.writeln(&format!(
|
||||
" {} ({}) {} | Owner: {} | Due: {}",
|
||||
priority, id, item.title, owner, due
|
||||
))?;
|
||||
} else {
|
||||
let created = paint(&item.created, Color::Cyan, colored);
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
" {} {} ({}) {} | Owner: {} | Due: {}",
|
||||
priority, created, id, item.title, owner, due
|
||||
);
|
||||
))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketItem>> {
|
||||
@@ -4714,7 +4788,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_section_rule_matches_the_width_of_its_name() {
|
||||
let rendered = content_trim_colored("# T\n\n## Description\nbody\n", &Resolved::default());
|
||||
let rendered = content_trim("# T\n\n## Description\nbody\n", false, &Resolved::default());
|
||||
|
||||
// Eleven characters, not fourteen: the rule used to span "## Description"
|
||||
assert!(rendered.starts_with("Description\n───────────\n"), "{rendered:?}");
|
||||
@@ -4722,7 +4796,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_non_ascii_section_name_is_not_over_drawn() {
|
||||
let rendered = content_trim_colored("# T\n\n## Résumé\nbody\n", &Resolved::default());
|
||||
let rendered = content_trim("# T\n\n## Résumé\nbody\n", false, &Resolved::default());
|
||||
|
||||
assert!(rendered.starts_with("Résumé\n──────\n"), "{rendered:?}");
|
||||
}
|
||||
@@ -4730,7 +4804,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_body_leaves_the_title_to_cmd_show() {
|
||||
let rendered =
|
||||
content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
|
||||
content_trim("# Only Once\n\n## Description\nbody\n", false, &Resolved::default());
|
||||
|
||||
assert!(!rendered.contains("Only Once"), "{rendered:?}");
|
||||
// And no gap where it was
|
||||
@@ -4740,7 +4814,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_metadata_section_renders_as_a_table_inside_the_body() {
|
||||
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n- **Owner**: alice\n";
|
||||
let rendered = content_trim_colored(content, &Resolved::default());
|
||||
let rendered = content_trim(content, false, &Resolved::default());
|
||||
|
||||
assert_eq!(rendered, "Metadata\n────────\n\nID abc\nOwner alice\n");
|
||||
}
|
||||
@@ -4853,7 +4927,7 @@ Plain line with **bold** and a [link](http://x.test/a).
|
||||
#[test]
|
||||
fn a_section_after_metadata_still_renders() {
|
||||
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n\n## Notes\n\nafter\n";
|
||||
let rendered = content_trim_colored(content, &Resolved::default());
|
||||
let rendered = content_trim(content, false, &Resolved::default());
|
||||
|
||||
assert!(rendered.contains("ID abc"), "{rendered:?}");
|
||||
assert!(rendered.contains("Notes\n─────\n"), "{rendered:?}");
|
||||
|
||||
Reference in New Issue
Block a user