Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e20396ce6b |
@@ -62,6 +62,7 @@
|
||||
- Rules under headings are measured on the displayed name in characters, never on the raw line or in bytes
|
||||
- `resolve_ticket()` scans all status directories — it's the single source for ticket lookup by UUID prefix, title, or filename
|
||||
- `parse_ticket_field()` handles extracting metadata values from markdown format
|
||||
- `move_ticket_file()` stages the updated content in a temp file under `.worklane/`, renames it over the source, and only then renames the file into the target directory. Do not reorder these: renaming first and writing second leaves a ticket in its new directory claiming the old status, and writing to the target then deleting the source puts it in two directories at once. The temp lives outside the status directories so a leftover is never read as a ticket. A failure at the last step leaves the ticket in its old directory with a Status one move ahead, which the next `mv` corrects
|
||||
- Field lookup, read and write, is scoped to the lines under the `## Metadata` heading and anchored to the start of the line. Prose above it is free text: tickets in this repo quote field markers in their descriptions, and an unscoped search reads or rewrites those instead. `set_status_field()` carries the same scoping
|
||||
|
||||
### Ticket Resolution
|
||||
|
||||
Generated
+1
-1
@@ -1029,7 +1029,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.3.2"
|
||||
version = "0.3.3"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.3.2"
|
||||
version = "0.3.3"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
+77
-7
@@ -311,6 +311,67 @@ pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Put `content` in `filename` and move it from `from` to `to`, without ever
|
||||
/// leaving the ticket in two status directories or with half a file in it.
|
||||
///
|
||||
/// Two atomic steps, in this order. The content is staged in a temp file and
|
||||
/// renamed over the source, so a partial write is thrown away and the original is
|
||||
/// untouched. Only then is the file renamed into the target directory.
|
||||
///
|
||||
/// The old order renamed first and wrote second, so a failure in between left the
|
||||
/// ticket sitting in its new directory still claiming the old status. Writing
|
||||
/// straight to the target and deleting the source afterwards would instead have it
|
||||
/// in both directories at once. Neither happens here. The worst case is a ticket
|
||||
/// still in its old directory carrying a Status field one move ahead, which the
|
||||
/// next `mv` corrects, since the directory is what decides the current status.
|
||||
fn move_ticket_file(
|
||||
worklane_dir: &Path,
|
||||
from: &Path,
|
||||
to: &Path,
|
||||
filename: &str,
|
||||
content: &str,
|
||||
title: &str,
|
||||
) -> Result<()> {
|
||||
let source = from.join(filename);
|
||||
let dest = to.join(filename);
|
||||
|
||||
// Staged outside the status directories on purpose: a temp file left behind by a
|
||||
// hard kill is then invisible to ticket lookup and to the listing, rather than
|
||||
// showing up as a stray untitled ticket.
|
||||
let temp = worklane_dir.join(format!(".mv-{}.tmp", filename));
|
||||
|
||||
if let Err(e) = fs::write(&temp, content) {
|
||||
let _ = fs::remove_file(&temp);
|
||||
return Err(anyhow!(
|
||||
"Could not stage the update for ticket '{}' at {}: {}",
|
||||
title,
|
||||
temp.display(),
|
||||
e
|
||||
));
|
||||
}
|
||||
|
||||
if let Err(e) = fs::rename(&temp, &source) {
|
||||
let _ = fs::remove_file(&temp);
|
||||
return Err(anyhow!(
|
||||
"Could not update the status of ticket '{}' at {}: {}",
|
||||
title,
|
||||
source.display(),
|
||||
e
|
||||
));
|
||||
}
|
||||
|
||||
// The content is correct and in one place by now, so a failure here leaves the
|
||||
// ticket where it started rather than half moved.
|
||||
fs::rename(&source, &dest).map_err(|e| {
|
||||
anyhow!(
|
||||
"Could not move ticket '{}' to {}: {}",
|
||||
title,
|
||||
dest.display(),
|
||||
e
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> {
|
||||
let valid_statuses = ["backlog", "committed", "reviewing", "done"];
|
||||
let forward_order = ["backlog", "committed", "reviewing", "done"];
|
||||
@@ -390,15 +451,24 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
|
||||
// Read and update the ticket content before touching the filesystem, so a ticket
|
||||
// without a Status field is never half-moved.
|
||||
let source_path = current_path.join(&found_filename);
|
||||
let content = fs::read_to_string(&source_path)?;
|
||||
let content = fs::read_to_string(&source_path).map_err(|e| {
|
||||
anyhow!(
|
||||
"Could not read ticket '{}' at {}: {}",
|
||||
title,
|
||||
source_path.display(),
|
||||
e
|
||||
)
|
||||
})?;
|
||||
let content = set_status_field(&content, target_status, &title)?;
|
||||
|
||||
// Move the file
|
||||
let dest_path = target_path.join(&found_filename);
|
||||
fs::rename(&source_path, &dest_path)?;
|
||||
|
||||
// Write back updated content
|
||||
fs::write(&dest_path, content)?;
|
||||
move_ticket_file(
|
||||
&worklane_dir,
|
||||
¤t_path,
|
||||
&target_path,
|
||||
&found_filename,
|
||||
&content,
|
||||
&title,
|
||||
)?;
|
||||
|
||||
println!(
|
||||
"Moved ticket '{}' from {} to {}",
|
||||
|
||||
+171
@@ -431,3 +431,174 @@ fn mv_fails_when_status_field_is_missing() {
|
||||
assert!(worklane.join("backlog").join(filename).exists());
|
||||
assert!(!worklane.join("committed").join(filename).exists());
|
||||
}
|
||||
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
fn chmod(path: &std::path::Path, mode: u32) {
|
||||
let mut perms = fs::metadata(path).unwrap().permissions();
|
||||
perms.set_mode(mode);
|
||||
fs::set_permissions(path, perms).unwrap();
|
||||
}
|
||||
|
||||
fn md_files(dir: &std::path::Path) -> Vec<String> {
|
||||
match fs::read_dir(dir) {
|
||||
Ok(entries) => entries
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| name.ends_with(".md"))
|
||||
.collect(),
|
||||
Err(_) => vec![],
|
||||
}
|
||||
}
|
||||
|
||||
/// Nothing is staged in a status directory, so nothing can be left behind that the
|
||||
/// listing would read as a ticket.
|
||||
fn stray_files(worklane: &std::path::Path) -> Vec<String> {
|
||||
let mut stray: Vec<String> = fs::read_dir(worklane)
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| !["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str()))
|
||||
.collect();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
stray.extend(
|
||||
fs::read_dir(worklane.join(dir))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| !name.ends_with(".md")),
|
||||
);
|
||||
}
|
||||
|
||||
stray
|
||||
}
|
||||
|
||||
/// The bug this fixes. The old order renamed first and wrote second, so a write
|
||||
/// that failed left the ticket in its new directory still claiming the old status.
|
||||
/// A read-only ticket file is the cheapest way to make the write fail.
|
||||
#[test]
|
||||
fn mv_never_leaves_stale_content_in_the_target_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Read Only",
|
||||
"A description.",
|
||||
"abc123def456789012345678901234567890",
|
||||
"alice",
|
||||
"2026-12-31",
|
||||
"test",
|
||||
);
|
||||
|
||||
let source = worklane.join("backlog").join(&filename);
|
||||
chmod(&source, 0o444);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(&temp.path())
|
||||
.args(["mv", "abc123def4567", "--status", "committed"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
// Wherever it ended up, its Status must agree with the directory it is in
|
||||
let moved = worklane.join("committed").join(&filename);
|
||||
assert!(moved.exists(), "ticket did not move");
|
||||
let content = fs::read_to_string(&moved).unwrap();
|
||||
assert!(
|
||||
content.contains("- **Status**: committed"),
|
||||
"stale status: {content:?}"
|
||||
);
|
||||
assert!(!content.contains("- **Status**: backlog"), "{content:?}");
|
||||
|
||||
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
}
|
||||
|
||||
/// The other criterion: one directory or the other, never both. An unwritable
|
||||
/// target directory fails the move at the last step, which is the step that would
|
||||
/// have to be reordered to break this.
|
||||
#[test]
|
||||
fn mv_leaves_the_ticket_in_one_place_when_the_move_fails() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Blocked Move",
|
||||
"A description.",
|
||||
"abc123def456789012345678901234567890",
|
||||
"alice",
|
||||
"2026-12-31",
|
||||
"test",
|
||||
);
|
||||
|
||||
let target = worklane.join("committed");
|
||||
chmod(&target, 0o555);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd
|
||||
.current_dir(&temp.path())
|
||||
.args(["mv", "abc123def4567", "--status", "committed"])
|
||||
.assert()
|
||||
.failure();
|
||||
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
// Named, not a bare io error
|
||||
assert!(stderr.contains("Blocked Move"), "{stderr}");
|
||||
|
||||
assert_eq!(
|
||||
md_files(&worklane.join("backlog")),
|
||||
vec![filename.clone()],
|
||||
"the ticket left its own directory"
|
||||
);
|
||||
assert_eq!(md_files(&target).len(), 0, "the ticket is in both places");
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
|
||||
// The documented worst case: still in its old directory, carrying a Status one
|
||||
// move ahead because the content was written before the move was attempted.
|
||||
let left = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
|
||||
assert!(left.contains("- **Status**: committed"), "{left:?}");
|
||||
|
||||
// And the state is recoverable, because the directory is what decides the
|
||||
// current status, so a retry moves it rather than refusing.
|
||||
chmod(&target, 0o755);
|
||||
|
||||
let mut retry = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
retry
|
||||
.current_dir(&temp.path())
|
||||
.args(["mv", "abc123def4567", "--status", "committed"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
assert_eq!(md_files(&target), vec![filename]);
|
||||
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mv_leaves_nothing_behind_on_success() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Clean Move",
|
||||
"A description.",
|
||||
"abc123def456789012345678901234567890",
|
||||
"alice",
|
||||
"2026-12-31",
|
||||
"test",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(&temp.path())
|
||||
.args(["mv", "abc123def4567", "--status", "committed"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user