(ca2a124) Add --actor-from-git beside every --actor, and bump to 0.32.8
This commit is contained in:
+87
-20
@@ -199,6 +199,13 @@ fn annotation_line(raw: &str) -> Result<String, String> {
|
||||
/// command reads as five flags.
|
||||
const ACTOR_HELP: &str = "Who the entry is attributed to, overriding WORKLANE_ACTOR and the git user. Free text, checked against nothing";
|
||||
|
||||
/// What `--actor-from-git` says on every command that writes a history entry.
|
||||
///
|
||||
/// The counterpart to [`ACTOR_HELP`]: where that one names somebody specific, this one
|
||||
/// says attribute it to the human whose checkout this is, without knowing how they spell
|
||||
/// themselves.
|
||||
const ACTOR_FROM_GIT_HELP: &str = "Attribute the entry to the detected git user instead of WORKLANE_ACTOR, for acting on the person's behalf. Cannot be combined with --actor";
|
||||
|
||||
/// Arguments that carry prose, and therefore have to accept a value starting with
|
||||
/// a hyphen.
|
||||
///
|
||||
@@ -229,26 +236,7 @@ pub enum Command {
|
||||
},
|
||||
|
||||
/// Move a ticket to a different status
|
||||
Mv {
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
|
||||
/// Target status
|
||||
#[arg(short, long)]
|
||||
status: Status,
|
||||
|
||||
/// Force move (allows backward or non-sequential moves)
|
||||
#[arg(short, long)]
|
||||
force: bool,
|
||||
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
actor: Option<String>,
|
||||
|
||||
/// Why the ticket moved, recorded in the history entry beside the transition
|
||||
/// it explains. Prose, so it takes a leading hyphen
|
||||
#[arg(long, allow_hyphen_values = PROSE)]
|
||||
reason: Option<String>,
|
||||
},
|
||||
Mv(MvArgs),
|
||||
|
||||
/// Replace fields on an existing ticket
|
||||
Set(SetArgs),
|
||||
@@ -298,6 +286,9 @@ pub enum Command {
|
||||
/// is `chown`'s. It was `--owner`, which said the wrong one of the two.
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
actor_from_git: bool,
|
||||
},
|
||||
|
||||
/// Group tickets that have to be finished together
|
||||
@@ -323,6 +314,9 @@ pub enum Command {
|
||||
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
actor_from_git: bool,
|
||||
},
|
||||
|
||||
/// The tag vocabulary: what the board carries, and what each tag means
|
||||
@@ -700,6 +694,33 @@ pub struct AddArgs {
|
||||
pub priority: Option<u8>,
|
||||
}
|
||||
|
||||
/// `mv` grew past a handful of parameters when `--actor-from-git` arrived, so it is a
|
||||
/// struct like `set` and `append` rather than an inline variant.
|
||||
#[derive(clap::Args)]
|
||||
pub struct MvArgs {
|
||||
/// Ticket UUID or title
|
||||
pub ticket: String,
|
||||
|
||||
/// Target status
|
||||
#[arg(short, long)]
|
||||
pub status: Status,
|
||||
|
||||
/// Force move (allows backward or non-sequential moves)
|
||||
#[arg(short, long)]
|
||||
pub force: bool,
|
||||
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
pub actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
pub actor_from_git: bool,
|
||||
|
||||
/// Why the ticket moved, recorded in the history entry beside the transition
|
||||
/// it explains. Prose, so it takes a leading hyphen
|
||||
#[arg(long, allow_hyphen_values = PROSE)]
|
||||
pub reason: Option<String>,
|
||||
}
|
||||
|
||||
/// `set` replaces a field outright. Owner is deliberately absent: `chown` owns that
|
||||
/// field, and status is `mv`'s, so no field has two writers.
|
||||
///
|
||||
@@ -764,6 +785,9 @@ pub struct SetArgs {
|
||||
/// command's that is logged
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
pub actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
pub actor_from_git: bool,
|
||||
}
|
||||
|
||||
impl SetArgs {
|
||||
@@ -814,6 +838,9 @@ pub struct ChownArgs {
|
||||
/// change. Both are on this command because it writes both.
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
pub actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
pub actor_from_git: bool,
|
||||
}
|
||||
|
||||
impl ChownArgs {
|
||||
@@ -1015,4 +1042,44 @@ mod tests {
|
||||
for two minor versions."
|
||||
);
|
||||
}
|
||||
|
||||
/// `--actor` and `--actor-from-git` are one pair that has to travel together: every
|
||||
/// command that takes one takes the other, documented by the same string, because
|
||||
/// the second is the first's spelling for "the human whose checkout this is".
|
||||
///
|
||||
/// A walker rather than five named commands, so a sixth entry-writing command fails
|
||||
/// this on its own `--actor` instead of being forgotten here too.
|
||||
#[test]
|
||||
fn every_actor_command_takes_actor_from_git() {
|
||||
let cli = Cli::command();
|
||||
let mut seen = 0;
|
||||
|
||||
for sub in cli.get_subcommands() {
|
||||
if sub.get_name() == "help" {
|
||||
continue;
|
||||
}
|
||||
|
||||
if !sub.get_arguments().any(|arg| arg.get_id().as_str() == "actor") {
|
||||
continue;
|
||||
}
|
||||
|
||||
seen += 1;
|
||||
let from_git = sub
|
||||
.get_arguments()
|
||||
.find(|arg| arg.get_id().as_str() == "actor_from_git")
|
||||
.unwrap_or_else(|| {
|
||||
panic!("`{}` takes --actor but not --actor-from-git", sub.get_name())
|
||||
});
|
||||
assert_eq!(
|
||||
from_git.get_help().map(|help| help.to_string()),
|
||||
Some(ACTOR_FROM_GIT_HELP.to_string()),
|
||||
"`{}` documents --actor-from-git differently",
|
||||
sub.get_name()
|
||||
);
|
||||
}
|
||||
|
||||
// A guard on the walker itself: if it stopped finding commands, every assertion
|
||||
// above would pass by never running.
|
||||
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
|
||||
}
|
||||
}
|
||||
|
||||
+20
-17
@@ -8,7 +8,7 @@ use std::path::Path;
|
||||
use crate::campaign::*;
|
||||
use crate::command::{
|
||||
AddArgs, AppendArgs, CampaignAddArgs, CampaignAppendArgs, CampaignSetArgs, CheckArgs,
|
||||
ChownArgs, LsArgs, RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
|
||||
ChownArgs, LsArgs, MvArgs, RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
|
||||
};
|
||||
use crate::history::{Kind, change, format_history, read_history, write_entry};
|
||||
use crate::install;
|
||||
@@ -598,14 +598,15 @@ 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(
|
||||
ticket_id: &str,
|
||||
target: Status,
|
||||
force: bool,
|
||||
actor: &Option<String>,
|
||||
reason: &Option<String>,
|
||||
start: &Path,
|
||||
) -> Result<()> {
|
||||
pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
let MvArgs {
|
||||
ticket: ticket_id,
|
||||
status: target,
|
||||
force,
|
||||
actor,
|
||||
actor_from_git,
|
||||
reason,
|
||||
} = args;
|
||||
let target_status = target.as_str();
|
||||
|
||||
// A reason is one fact on one line, which is how the renderer draws it, so a
|
||||
@@ -624,13 +625,13 @@ pub fn cmd_mv(
|
||||
.iter()
|
||||
.position(|status| status.as_str() == current_status)
|
||||
.unwrap();
|
||||
let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap();
|
||||
let target_idx = Status::ALL.iter().position(|status| *status == *target).unwrap();
|
||||
|
||||
// Discarding is not a stage of work, so the walk rules below do not apply to
|
||||
// entering it: a ticket is abandoned from wherever it stands. They do apply to
|
||||
// leaving it, which with discarded last in `Status::ALL` is always a backward move,
|
||||
// so un-discarding needs `-f` with no rule of its own.
|
||||
let discarding = target == Status::Discarded;
|
||||
let discarding = *target == Status::Discarded;
|
||||
|
||||
if !force && !discarding && target_idx < current_idx {
|
||||
return Err(anyhow!(
|
||||
@@ -717,7 +718,7 @@ pub fn cmd_mv(
|
||||
// crash-safe write the Status field does.
|
||||
let content = set_status_stamp(
|
||||
&content,
|
||||
target,
|
||||
*target,
|
||||
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
|
||||
&title,
|
||||
)?;
|
||||
@@ -742,7 +743,7 @@ pub fn cmd_mv(
|
||||
&parse_ticket_field(&resolved, "ID"),
|
||||
Kind::Status,
|
||||
&change(¤t_status, target_status),
|
||||
&resolve_actor(actor.as_deref()),
|
||||
&resolve_actor(actor.as_deref(), *actor_from_git),
|
||||
&reason,
|
||||
)?;
|
||||
|
||||
@@ -760,6 +761,7 @@ pub fn cmd_comment(
|
||||
ticket_id: &str,
|
||||
body: &str,
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
) -> Result<()> {
|
||||
if body.is_empty() {
|
||||
@@ -779,7 +781,7 @@ pub fn cmd_comment(
|
||||
&ticket_uuid,
|
||||
Kind::Comment,
|
||||
body,
|
||||
&resolve_actor(actor.as_deref()),
|
||||
&resolve_actor(actor.as_deref(), actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
|
||||
@@ -1028,7 +1030,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
&parse_ticket_field(&original, "Tags"),
|
||||
&parse_ticket_field(&content, "Tags"),
|
||||
),
|
||||
&resolve_actor(args.actor.as_deref()),
|
||||
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
}
|
||||
@@ -1087,7 +1089,7 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
&parse_ticket_field(&original, "Owner"),
|
||||
&parse_ticket_field(&content, "Owner"),
|
||||
),
|
||||
&resolve_actor(args.actor.as_deref()),
|
||||
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
|
||||
@@ -1772,6 +1774,7 @@ pub fn cmd_assign(
|
||||
campaign_search: &str,
|
||||
ticket_id: &str,
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
@@ -1810,7 +1813,7 @@ pub fn cmd_assign(
|
||||
&uuid,
|
||||
Kind::Campaign,
|
||||
&change(&before, campaign.name()),
|
||||
&resolve_actor(actor.as_deref()),
|
||||
&resolve_actor(actor.as_deref(), actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
|
||||
|
||||
+13
-13
@@ -57,22 +57,19 @@ fn main() -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_show(&id, &worklane_dir)
|
||||
}
|
||||
Some(Command::Mv {
|
||||
ticket,
|
||||
status,
|
||||
force,
|
||||
actor,
|
||||
reason,
|
||||
}) => cmd_mv(&ticket, status, force, &actor, &reason, &start),
|
||||
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::Comment { ticket, body, actor }) => {
|
||||
cmd_comment(&ticket, &body, &actor, &start)
|
||||
}
|
||||
Some(Command::Comment {
|
||||
ticket,
|
||||
body,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_comment(&ticket, &body, &actor, actor_from_git, &start),
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
||||
CampaignCommand::Ls { ids } => {
|
||||
@@ -86,9 +83,12 @@ fn main() -> Result<()> {
|
||||
cmd_campaign_show(&campaign, &worklane_dir)
|
||||
}
|
||||
},
|
||||
Some(Command::Assign { campaign, ticket, actor }) => {
|
||||
cmd_assign(&campaign, &ticket, &actor, &start)
|
||||
}
|
||||
Some(Command::Assign {
|
||||
campaign,
|
||||
ticket,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start),
|
||||
// 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.
|
||||
|
||||
+123
-46
@@ -449,52 +449,78 @@ pub const ACTOR_ENV: &str = "WORKLANE_ACTOR";
|
||||
/// The author written when nothing names one.
|
||||
pub const UNKNOWN_ACTOR: &str = "unknown";
|
||||
|
||||
/// The actor for the whole run: the variable, then the git user.
|
||||
/// The actor for the whole run, from the variable alone.
|
||||
///
|
||||
/// Split out from the caching wrapper for the reason `colors_wanted` is: a threaded test
|
||||
/// binary cannot mutate the process environment to reach one branch at a time.
|
||||
///
|
||||
/// An empty `WORKLANE_ACTOR` counts as unset, the convention `colors_wanted` follows for
|
||||
/// `NO_COLOR`, so a wrapper script can clear an inherited one. `git_user` is a closure
|
||||
/// rather than a value because the fallback costs a subprocess and the variable usually
|
||||
/// answers first.
|
||||
fn session_actor(env: Option<&str>, git_user: impl FnOnce() -> Option<String>) -> Option<String> {
|
||||
match env.map(str::trim).filter(|value| !value.is_empty()) {
|
||||
Some(value) => Some(value.to_string()),
|
||||
None => git_user(),
|
||||
}
|
||||
/// `NO_COLOR`, so a wrapper script can clear an inherited one. This is the half the
|
||||
/// [`resolve_actor`] cache holds; the git user lives in a cache of its own, because with
|
||||
/// `--actor-from-git` it has to be fetched even though the variable answered.
|
||||
fn session_actor(env: Option<&str>) -> Option<String> {
|
||||
env.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(str::to_string)
|
||||
}
|
||||
|
||||
/// The actor for one entry: the flag wins, otherwise the session's, otherwise unknown.
|
||||
/// The actor for one entry, from what named one.
|
||||
///
|
||||
/// Free text, validated against nothing, the way the `chown` user is: there is no
|
||||
/// registry of actors to check a name against.
|
||||
fn entry_actor(flag: Option<&str>, session: Option<&str>) -> String {
|
||||
[flag, session]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(str::trim)
|
||||
.find(|value| !value.is_empty())
|
||||
.unwrap_or(UNKNOWN_ACTOR)
|
||||
.to_string()
|
||||
///
|
||||
/// The chain depends on the flag. An explicit `--actor` wins outright either way. With
|
||||
/// `from_git`, the git user is lifted above the session rather than added beneath it:
|
||||
/// the flag says attribute this to the human, and a machine with no git user configured
|
||||
/// has nobody to name, which reads [`UNKNOWN_ACTOR`] rather than quietly attributing
|
||||
/// back to the agent. Without it, today's chain: the variable, then the git user.
|
||||
///
|
||||
/// `git_user` is a closure in both branches so the subprocess it costs is not run when
|
||||
/// something ahead of it already answered.
|
||||
fn entry_actor(
|
||||
flag: Option<&str>,
|
||||
from_git: bool,
|
||||
session: Option<&str>,
|
||||
git_user: impl FnOnce() -> Option<String>,
|
||||
) -> String {
|
||||
if let Some(name) = flag.map(str::trim).filter(|value| !value.is_empty()) {
|
||||
return name.to_string();
|
||||
}
|
||||
|
||||
if from_git {
|
||||
return git_user().unwrap_or_else(|| UNKNOWN_ACTOR.to_string());
|
||||
}
|
||||
|
||||
if let Some(name) = session.map(str::trim).filter(|value| !value.is_empty()) {
|
||||
return name.to_string();
|
||||
}
|
||||
|
||||
git_user().unwrap_or_else(|| UNKNOWN_ACTOR.to_string())
|
||||
}
|
||||
|
||||
/// Who to attribute an entry to, from the flag the call carried.
|
||||
/// Who to attribute an entry to, from the flags the call carried.
|
||||
///
|
||||
/// Precedence: flag, then `WORKLANE_ACTOR`, then the git user, then `unknown`. Every
|
||||
/// entry the CLI writes goes through here, so a board several agents write to says which
|
||||
/// of them wrote what instead of attributing all of it to one human.
|
||||
pub fn resolve_actor(flag: Option<&str>) -> String {
|
||||
// The session half is decided once, the way should_use_colors is: neither input can
|
||||
// change mid-run, and the git user costs a subprocess.
|
||||
static SESSION: OnceLock<Option<String>> = OnceLock::new();
|
||||
/// Precedence: flag, then — unless `from_git` lifted it — `WORKLANE_ACTOR`, then the git
|
||||
/// user, then `unknown`. Every entry the CLI writes goes through here, so a board
|
||||
/// several agents write to says which of them wrote what instead of attributing all of
|
||||
/// it to one human.
|
||||
pub fn resolve_actor(flag: Option<&str>, from_git: bool) -> String {
|
||||
// Each half is decided once, the way should_use_colors is: neither input can change
|
||||
// mid-run, and the git user costs a subprocess. They are two caches rather than one,
|
||||
// because baking the git user into the session's answer would leave `--actor-from-git`
|
||||
// reading whatever the run's *first* call produced — with the variable set, that call
|
||||
// never fetched git at all.
|
||||
static VARIABLE: OnceLock<Option<String>> = OnceLock::new();
|
||||
static GIT_USER: OnceLock<Option<String>> = OnceLock::new();
|
||||
|
||||
let session = SESSION.get_or_init(|| {
|
||||
let session = VARIABLE.get_or_init(|| {
|
||||
let env = std::env::var(ACTOR_ENV).ok();
|
||||
session_actor(env.as_deref(), get_git_user)
|
||||
session_actor(env.as_deref())
|
||||
});
|
||||
|
||||
entry_actor(flag, session.as_deref())
|
||||
entry_actor(flag, from_git, session.as_deref(), || {
|
||||
GIT_USER.get_or_init(get_git_user).clone()
|
||||
})
|
||||
}
|
||||
/// One file a search matched, and where it was found.
|
||||
pub struct Found {
|
||||
@@ -3678,48 +3704,99 @@ mod tests {
|
||||
/// closure returns a name that must not appear.
|
||||
#[test]
|
||||
fn the_variable_names_the_actor() {
|
||||
let session = session_actor(Some("claude"), || Some("Ansho Rei".to_string()));
|
||||
assert_eq!(entry_actor(None, session.as_deref()), "claude");
|
||||
let session = session_actor(Some("claude"));
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
assert_eq!(entry_actor(None, false, session.as_deref(), git_user), "claude");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_flag_overrides_the_variable() {
|
||||
let session = session_actor(Some("claude"), || None);
|
||||
assert_eq!(entry_actor(Some("opencode"), session.as_deref()), "opencode");
|
||||
let session = session_actor(Some("claude"));
|
||||
assert_eq!(
|
||||
entry_actor(Some("opencode"), false, session.as_deref(), || None),
|
||||
"opencode"
|
||||
);
|
||||
}
|
||||
|
||||
/// With neither supplied the author is still the git user.
|
||||
#[test]
|
||||
fn the_git_user_is_the_fallback() {
|
||||
let session = session_actor(None, || Some("Ansho Rei".to_string()));
|
||||
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
assert_eq!(
|
||||
entry_actor(None, false, session_actor(None).as_deref(), git_user),
|
||||
"Ansho Rei"
|
||||
);
|
||||
}
|
||||
|
||||
/// An empty variable counts as unset, the way `NO_COLOR` does, so a wrapper script
|
||||
/// can clear an inherited one and get the git user back.
|
||||
/// can clear an inherited one and get the git user back. Whitespace is the same
|
||||
/// case: a shell that quotes a missing value writes one.
|
||||
#[test]
|
||||
fn an_empty_variable_reads_as_unset() {
|
||||
let session = session_actor(Some(""), || Some("Ansho Rei".to_string()));
|
||||
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
|
||||
// Whitespace is the same case: a shell that quotes a missing value writes one
|
||||
let session = session_actor(Some(" "), || Some("Ansho Rei".to_string()));
|
||||
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
for raw in ["", " "] {
|
||||
let session = session_actor(Some(raw));
|
||||
assert_eq!(entry_actor(None, false, session.as_deref(), git_user), "Ansho Rei");
|
||||
}
|
||||
}
|
||||
|
||||
/// And with nothing at all, including a git that has no user configured.
|
||||
#[test]
|
||||
fn nothing_at_all_is_unknown() {
|
||||
let session = session_actor(None, || None);
|
||||
assert_eq!(entry_actor(None, session.as_deref()), UNKNOWN_ACTOR);
|
||||
let session = session_actor(None);
|
||||
assert_eq!(entry_actor(None, false, session.as_deref(), || None), UNKNOWN_ACTOR);
|
||||
// An empty flag falls through rather than writing a blank author
|
||||
assert_eq!(entry_actor(Some(""), None), UNKNOWN_ACTOR);
|
||||
assert_eq!(entry_actor(Some(""), false, None, || None), UNKNOWN_ACTOR);
|
||||
}
|
||||
|
||||
/// Free text, validated against nothing, the way the `chown` user is.
|
||||
#[test]
|
||||
fn an_actor_is_free_text() {
|
||||
let session = session_actor(Some("claude-code, session 3 (opus)"), || None);
|
||||
assert_eq!(entry_actor(None, session.as_deref()), "claude-code, session 3 (opus)");
|
||||
let session = session_actor(Some("claude-code, session 3 (opus)"));
|
||||
assert_eq!(
|
||||
entry_actor(None, false, session.as_deref(), || None),
|
||||
"claude-code, session 3 (opus)"
|
||||
);
|
||||
}
|
||||
|
||||
/// The flag is the caller acting for the person whose checkout this is: the git user
|
||||
/// is lifted above the variable rather than added beneath it.
|
||||
#[test]
|
||||
fn from_git_lifts_the_git_user_over_the_variable() {
|
||||
let session = session_actor(Some("claude"));
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
assert_eq!(entry_actor(None, true, session.as_deref(), git_user), "Ansho Rei");
|
||||
}
|
||||
|
||||
/// An explicit `--actor` still wins outright beside the lift: it names somebody
|
||||
/// specific, which is the stronger statement of the two.
|
||||
#[test]
|
||||
fn the_flag_wins_over_from_git_too() {
|
||||
let session = session_actor(Some("claude"));
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
assert_eq!(
|
||||
entry_actor(Some("opencode"), true, session.as_deref(), git_user),
|
||||
"opencode"
|
||||
);
|
||||
}
|
||||
|
||||
/// The lift is not a fallback: asked to name the human and finding none configured,
|
||||
/// the entry reads unknown instead of quietly attributing back to the agent.
|
||||
#[test]
|
||||
fn from_git_with_no_git_user_is_unknown_not_the_variable() {
|
||||
let session = session_actor(Some("claude"));
|
||||
assert_eq!(entry_actor(None, true, session.as_deref(), || None), UNKNOWN_ACTOR);
|
||||
}
|
||||
|
||||
/// An empty variable still counts as unset with the lift on, which here means the
|
||||
/// git user answers as usual.
|
||||
#[test]
|
||||
fn from_git_leaves_the_empty_variable_unset() {
|
||||
let git_user = || Some("Ansho Rei".to_string());
|
||||
assert_eq!(
|
||||
entry_actor(None, true, session_actor(Some("")).as_deref(), git_user),
|
||||
"Ansho Rei"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Reference in New Issue
Block a user