Struct CommitOp 

pub struct CommitOp {
    pub what: &'static str,
    pub label: &'static str,
    pub trailing: &'static [&'static str],
    pub ex_command: &'static str,
    pub args: &'static [&'static str],
    pub confirm_action: Option<&'static str>,
}

MG.20: an operation that acts on ONE commit.

Reset, revert and cherry-pick share a shape the RemoteOps above do not: they need a target — the commit under the cursor — so they cannot be fired from a context-free global handler. The target is resolved through crate::buffer_state::MagitView::commit_at_cursor, which every view answers for its own row format.

Fields

what: &'static str

The git spelling, for the echo, the confirm prompt and the ex-command’s doc line — places that show the command.

label: &'static str

NC.4: what it does, for the notification, completed by the commit it acted on (“hard-reset to 3f2a1c0”). The argv it used to show there named a full sha and several flags, and read the same for every op in a burst.

trailing: &'static [&'static str]

MG.41d: tokens appended AFTER the commit (see Self::argv). Empty for every op that takes none.

ex_command: &'static str

MG.23j: this op’s ex-command name, without the :.

Load-bearing in two places beyond documentation. It is the scriptable surface (:magit-cherry-pick <sha>), and it is what the commit picker fires: a picked candidate resolves to the ex line "<ex_command> <sha>".

That shape was once the ONLY route — the host’s InvokeCommand arm destructured args away, so a value not baked into the line was lost. Fixed 2026-08-03: the arm now renders args onto the line, and both forms work. This one is kept because it is also the exact text a user would type, which keeps the picker a front-end to the command rather than a second way in.

args: &'static [&'static str]

argv template; the resolved commit is appended.

confirm_action: Option<&'static str>

When set, the operation asks before running and this is the -execute half it fires on “yes”. Reset –hard is the only one today: it discards working-tree changes irrecoverably, which is the same bar x / branch-delete / stash-drop are held to.

Implementations

impl CommitOp

pub const REVERT: Self

pub const CHERRY_PICK: Self

pub const RESET_WORKTREE: Self

MG.43f: magit’s reset w — reset the WORKING TREE to a commit, leaving HEAD and the index alone.

git restore --source <commit> --worktree is exactly this, and is why the row needs no plumbing: reset moves HEAD, and checkout <commit> -- . writes the index too. Verified against real git — a file staged before the restore is still staged after it.

The commit sits between --source and the rest, which is what trailing is for.

pub const REVERT_CHANGES: Self

MG.43a: magit’s revert v — apply the inverse to the working tree and index WITHOUT committing.

--no-commit is the whole row: V records a revert commit, v leaves the reversal staged so it can be edited, split, or combined before committing. No --no-edit here because nothing is committed, so git never opens an editor to hang on.

pub const CHERRY_PICK_APPLY: Self

MG.43a: magit’s cherry-pick a — apply the commit’s changes without recording a commit. Peer of Self::REVERT_CHANGES.

pub const RESET_SOFT: Self

pub const RESET_MIXED: Self

pub const RESET_HARD: Self

pub const RESET_KEEP: Self

MG.41d: magit’s k — move HEAD but refuse if that would discard uncommitted work, unlike --hard which discards it silently. No confirm precisely because git itself declines rather than destroying anything.

pub const RESET_INDEX: Self

MG.41d: magit’s i — set the index to commit WITHOUT moving HEAD. The trailing -- is what makes it index-only; the same command without it moves HEAD too.

pub const COMMIT_FIXUP: Self

MG.41d: magit’s f fixup — record a fixup! commit that a later rebase --autosquash folds into commit.

pub const COMMIT_SQUASH: Self

MG.41d: magit’s s squash — like fixup, but the message is kept for editing when the autosquash runs.

pub fn argv(&self, commit: &str) -> Vec<String>

Full argv for commit.

Trait Implementations

impl Clone for CommitOp

fn clone(&self) -> CommitOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CommitOp

impl Debug for CommitOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for CommitOp

impl PartialEq for CommitOp

fn eq(&self, other: &CommitOp) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CommitOp