Struct NotesCommand 

pub struct NotesCommand {
    pub executor: CommandExecutor,
    pub ref_namespace: Option<String>,
    pub action: NotesAction,
}

Builder for git notes.

Fields

executor: CommandExecutor

Shared executor.

ref_namespace: Option<String>

--ref <namespace> — the notes ref to operate on (raw, not prefixed).

action: NotesAction

Action.

Implementations

impl NotesCommand

pub fn add() -> Self

notes add.

pub fn append() -> Self

notes append.

pub fn copy(from: impl Into<String>, to: impl Into<String>) -> Self

notes copy <from> <to>.

pub fn show() -> Self

notes show.

pub fn list() -> Self

notes list.

pub fn remove() -> Self

notes remove.

pub fn prune() -> Self

notes prune.

pub fn ref_namespace(&mut self, ns: impl Into<String>) -> &mut Self

Operate on the given notes ref namespace, emitted as --ref <ns>.

The value is forwarded verbatim — git-spawn does not prepend refs/notes/. Pass a full ref (refs/notes/embeddings) or a short name (build); git resolves short names under refs/notes/ itself.

pub fn object(&mut self, o: impl Into<String>) -> &mut Self

Set the target object (for add, append, show, list, remove).

pub fn message(&mut self, m: impl Into<String>) -> &mut Self

Note payload as an inline string, emitted as -m <msg> (for add / append).

For binary or large payloads prefer message_file to avoid argument-length limits.

pub fn message_file(&mut self, p: impl Into<PathBuf>) -> &mut Self

Note payload read from a file, emitted as -F <path> (for add / append). The preferred form for binary or multi-kilobyte payloads.

pub fn force(&mut self) -> &mut Self

-f — replace an existing note (for add / copy).

pub fn allow_empty(&mut self) -> &mut Self

--allow-empty — store a note even when the payload is empty (for add / append).

pub fn no_stripspace(&mut self) -> &mut Self

--no-stripspace — preserve the payload byte-for-byte instead of trimming whitespace (for add / append). Required for exact binary round-trips.

pub fn ignore_missing(&mut self) -> &mut Self

--ignore-missing — exit zero when there is no note to remove (for remove).

pub fn dry_run(&mut self) -> &mut Self

-n dry run (for prune).

pub fn verbose(&mut self) -> &mut Self

-v verbose (for prune).

Trait Implementations

impl Clone for NotesCommand

fn clone(&self) -> NotesCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NotesCommand

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

Formats the value using the given formatter.

impl GitCommand for NotesCommand

type Output = CommandOutput

The typed output produced by this command.

fn get_executor(&self) -> &CommandExecutor

Borrow the shared executor.

fn get_executor_mut(&mut self) -> &mut CommandExecutor

Mutably borrow the shared executor.

fn build_command_args(&self) -> Vec<String>

Build the full argument vector (subcommand + flags + positionals) excluding the leading git program.

fn execute<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Run the command and decode its output into Self::Output.

fn execute_raw<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Spawn git with the given arguments and return the raw output.

fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self

Append a single raw argument.

fn args<I, S>(&mut self, args: I) -> &mut Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Append several raw arguments.

fn flag(&mut self, flag: &str) -> &mut Self

Append a --flag (or -f if a single character).

fn option(&mut self, key: &str, value: &str) -> &mut Self

Append a --key value pair.

fn current_dir<P: Into<PathBuf>>(&mut self, dir: P) -> &mut Self

Run git in the given working directory.

fn env<K: Into<OsString>, V: Into<OsString>>( &mut self, key: K, value: V, ) -> &mut Self

Set an environment variable for this invocation.

fn with_timeout(&mut self, timeout: Duration) -> &mut Self

Cap execution time. On expiry the process is killed and Error::Timeout is returned.

fn with_timeout_secs(&mut self, seconds: u64) -> &mut Self

Convenience: set timeout in whole seconds.