Struct RemoteOp 

pub struct RemoteOp {
    pub what: &'static str,
    pub doing: &'static str,
    pub args: &'static [&'static str],
    pub flags: &'static [RemoteFlag],
}

Fields

what: &'static str

NC.4: what this does, as an imperative phrase a user reads (“continue rebase”, not “rebase –continue”). The notification label is built from it — see Self::label — and must read correctly before “failed” as well as before a summary.

doing: &'static str

The same, in progress, for the fire-time echo (“continuing rebase…”). Spelled out rather than derived: appending “ing” to what produced “stage alling” and “cherry-pick –continueing”.

args: &'static [&'static str]

Base argv passed to git, before flags.

flags: &'static [RemoteFlag]

Toggleable flags, in args_schema order.

Implementations

impl RemoteOp

pub const PULL: Self

pub const PUSH: Self

pub const FETCH: Self

pub const CHERRY_PICK_CONTINUE: Self

MG.34: the way out of a rebase that stopped.

magit-edit-line-commit marks a commit edit, which is only useful if the rebase can be resumed afterwards — and until this slice the ONLY sequencer control was C-c C-k inside a todo buffer, so a stopped rebase left the repository in a state the editor could not finish. Shipping the edit row without these would have been shipping a trap.

GIT_EDITOR is forced to true by [run_remote_op] for the same reason run_rebase does it: --continue opens the commit message in $EDITOR, and an editor we cannot drive would hang the task forever.

pub const CHERRY_PICK_SKIP: Self

pub const CHERRY_PICK_ABORT: Self

pub const REVERT_CONTINUE: Self

pub const REVERT_SKIP: Self

pub const REVERT_ABORT: Self

pub const MERGE_CONTINUE: Self

Conclude a merge stopped on a conflict. Equivalent to committing the prepared merge message once the index is clean; git refuses it while unmerged paths remain, which is the right answer and is reported rather than swallowed.

pub const MERGE_ABORT: Self

Throw the merge away and restore the branch.

pub const REBASE_CONTINUE: Self

pub const REBASE_SKIP: Self

pub const REBASE_ABORT: Self

The abort C-c C-k runs, reachable when there is no todo buffer open — which is the case once the rebase has actually started.

pub const NOTES_PRUNE: Self

MG.37: the notes operations with no argument. spawn_remote_op’s shape — one bounded argv, off-thread, notify — fits them for the same reason it fits the rebase sequencer.

pub const NOTES_MERGE_COMMIT: Self

pub const NOTES_MERGE_ABORT: Self

pub const AM_CONTINUE: Self

MG.39: the way out of a git am that stopped.

am stops on a patch that does not apply, exactly as rebase stops on edit — and for the same reason as MG.34’s sequencer commands, shipping the apply without these would leave the repository in a state the editor cannot finish.

pub const AM_SKIP: Self

pub const AM_ABORT: Self

pub const STAGE_ALL: Self

MG.23b: magit’s S — stage every tracked modification at once.

add --update, matching magit-stage-modified: tracked changes only. Untracked files are deliberately NOT swept in — “stage everything” quietly adding a file you never told git about is how build artefacts and secrets get committed. Magit reaches that behaviour behind a prefix argument, which is exactly the deferred <C-u> work; until then s on the Untracked entry in magit-status is the explicit path.

pub const UNSTAGE_ALL: Self

MG.23b: magit’s U — unstage everything.

A bare git reset: the index goes back to HEAD and the working tree is untouched, so nothing is lost and every change is still there to re-stage. That is why it does not ask, per §12.13’s no-confirm set for index-only work — the blast radius is wider than one file but it is still fully reversible.

pub const STASH_KEEP_INDEX: Self

MG.41d: magit’s x — stash everything but leave the index staged, so a partially-staged commit can be tried in isolation.

pub const STASH_STAGED: Self

MG.41d: magit’s i — stash only what is staged.

pub const STASH: Self

pub fn argv(&self, args: &Args) -> Vec<String>

Resolve the full argv for this run: the base plus every flag the caller enabled. args is positional by flags order — see RemoteOp::flags.

pub fn label(&self, argv: &[String]) -> String

NC.4: the notification label for one run, naming what the resolved argv acts on.

Built from the argv rather than the transient state, so it describes what actually ran — including a destination resolved at run time. A force-push, a dry run and a push of tags each read differently from a plain push; before this they all read “push”.

pub fn preview(&self, value_of: &dyn Fn(&str) -> Option<String>) -> String

The command line this run would execute, for the transient’s live preview. Renders what argv will actually pass, so the preview cannot claim one thing and the run do another.

pub fn arg_specs(&self) -> Vec<ArgSpec>

args_schema for this operation’s ex-command — one optional bool per flag, in slice order.

Trait Implementations

impl Clone for RemoteOp

fn clone(&self) -> RemoteOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RemoteOp

impl Debug for RemoteOp

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

Formats the value using the given formatter.

impl Eq for RemoteOp

impl PartialEq for RemoteOp

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RemoteOp