Lutra/crates/engine/src/cmd/git_stash.rs
danny 95fd9b926f A3: derive the pinned command and catalog key lists in tests
Each command module keeps its own COMMAND_IDS next to its commands; the
engine listing test checks their union against the registry, so a missing
or extra command still fails without one shared list. The menu and palette
tests derive their expectation from the listing and check grouping and
ordering rules; the catalog's runtime keys are scanned from the sources.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 18:38:41 +01:00

231 lines
7.1 KiB
Rust

//! Stash commands (M4.9): `git.stash`, `git.stashList`, `git.stashApply`
//! and `git.stashDrop`, run like every `git.*` command (a pending outcome
//! off the lock, git and the repository cached by [`super::git`]). The
//! three that change the repository emit `gitChanged`.
use lutra_vcs::StashEntry;
use serde::Deserialize;
use serde_json::{Value, json};
use super::git::start_with;
use super::params::parse;
use crate::{Command, CommandSpec, EngineError, Outcome, Registry, State};
/// Largest index the commands take; the list holds at most 1,000 entries.
const MAX_INDEX: usize = 100_000;
/// Registers the stash commands.
///
/// # Errors
/// [`EngineError::Internal`] if an id is taken.
pub fn register(registry: &mut Registry) -> Result<(), EngineError> {
registry.register(Box::new(Stash))?;
registry.register(Box::new(StashList))?;
registry.register(Box::new(StashApply))?;
registry.register(Box::new(StashDrop))?;
Ok(())
}
/// One entry as the commands return it.
fn entry_json(entry: &StashEntry) -> Value {
json!({
"index": entry.index,
"hash": entry.hash,
"branch": entry.branch,
"message": entry.message,
"wip": entry.wip,
"date": entry.date,
})
}
/// Refuses an index past [`MAX_INDEX`].
fn check_index(command: &str, index: usize) -> Result<(), EngineError> {
if index > MAX_INDEX {
return Err(EngineError::invalid_params(
command,
format!("index must be 0 to {MAX_INDEX}"),
));
}
Ok(())
}
/// Params of `git.stash`.
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
struct StashParams {
/// The entry's message; blank means git's "WIP on" message.
#[serde(default)]
message: Option<String>,
/// Stash untracked files too.
#[serde(default)]
include_untracked: bool,
}
/// `git.stash`.
struct Stash;
impl Command for Stash {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "git.stash",
label: "Git: Stash Changes",
menu_path: None,
default_shortcut: None,
params: "{ message?: string (blank: git's \"WIP on <branch>\" message; line breaks become spaces), includeUntracked?: boolean (false) }; stashes every local change of the repository's work tree and resets it to HEAD; returns { entry: { index: 0, hash, branch, message, wip, date } }; refused with a clear message without a commit, with unmerged files, or with nothing to stash. Dirty buffers are not saved first",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: StashParams = parse(command, params)?;
start_with(
state,
command,
true,
Box::new(move |repo| {
let entry = repo.stash(p.message.as_deref(), p.include_untracked)?;
Ok(json!({"entry": entry_json(&entry)}))
}),
)
}
}
/// `git.stashList`.
struct StashList;
impl Command for StashList {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "git.stashList",
label: "Git: List Stashes",
menu_path: None,
default_shortcut: None,
params: "none; returns { stashes: [{ index, hash, branch: string | null, message, wip, date (ISO 8601) }] } newest first (index 0 is stash@{0}), at most 1,000",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let _: serde_json::Map<String, Value> = parse(command, params)?;
start_with(
state,
command,
false,
Box::new(move |repo| {
let stashes: Vec<Value> = repo.stash_list()?.iter().map(entry_json).collect();
Ok(json!({"stashes": stashes}))
}),
)
}
}
/// Params of `git.stashApply`.
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct ApplyParams {
/// The entry.
index: usize,
/// Drop the entry after applying it cleanly.
#[serde(default)]
pop: bool,
/// The entry's hash as listed; refuses when the stash changed since.
#[serde(default)]
hash: Option<String>,
}
/// `git.stashApply`.
struct StashApply;
impl Command for StashApply {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "git.stashApply",
label: "Git: Apply Stash",
menu_path: None,
default_shortcut: None,
params: "{ index: number (stash@{index}), pop?: boolean (false: keep the entry), hash?: the entry's hash from git.stashList, refused when the entry at index differs }; returns {}; refused with a clear message for a missing entry, unmerged files, local changes that would be overwritten, untracked files in the way, or conflicts (the files then hold conflict markers and the entry is kept)",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: ApplyParams = parse(command, params)?;
check_index(command, p.index)?;
start_with(
state,
command,
true,
Box::new(move |repo| {
repo.stash_apply(p.index, p.pop, p.hash.as_deref())?;
Ok(json!({}))
}),
)
}
}
/// Params of `git.stashDrop`.
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct DropParams {
/// The entry.
index: usize,
/// The entry's hash as listed.
#[serde(default)]
hash: Option<String>,
}
/// `git.stashDrop`.
struct StashDrop;
impl Command for StashDrop {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "git.stashDrop",
label: "Git: Drop Stash",
menu_path: None,
default_shortcut: None,
params: "{ index: number (stash@{index}), hash?: the entry's hash from git.stashList, refused when the entry at index differs }; deletes the entry; returns {}",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: DropParams = parse(command, params)?;
check_index(command, p.index)?;
start_with(
state,
command,
true,
Box::new(move |repo| {
repo.stash_drop(p.index, p.hash.as_deref())?;
Ok(json!({}))
}),
)
}
}
/// The ids of the commands this module registers, checked against the
/// registry by the engine's listing test. Add a new command's id here.
#[cfg(test)]
pub(crate) const COMMAND_IDS: &[&str] = &[
"git.stash",
"git.stashApply",
"git.stashDrop",
"git.stashList",
];