Struct CommitCommand 

pub struct CommitCommand {

    pub executor: CommandExecutor,
    pub message: Option<String>,
    pub message_file: Option<PathBuf>,
    pub all: bool,
    pub amend: bool,
    pub no_edit: bool,
    pub allow_empty: bool,
    pub allow_empty_message: bool,
    pub signoff: bool,
    pub no_verify: bool,
    pub author: Option<String>,
    pub date: Option<String>,
    pub only_paths: Vec<String>,
    pub quiet: bool,
    pub verbose: bool,
}

Builder for git commit.

Fields

executor: CommandExecutor

Shared executor.

message: Option<String>

-m.

message_file: Option<PathBuf>

-F file.

all: bool

--all / -a.

amend: bool

--amend.

no_edit: bool

--no-edit.

allow_empty: bool

--allow-empty.

allow_empty_message: bool

--allow-empty-message.

signoff: bool

--signoff / -s.

no_verify: bool

--no-verify.

author: Option<String>

--author.

date: Option<String>

--date.

only_paths: Vec<String>

--only specific paths.

quiet: bool

--quiet.

verbose: bool

--verbose.

Implementations

impl CommitCommand

pub fn new() -> Self

Build a bare commit command.

pub fn with_message(msg: impl Into<String>) -> Self

Convenience: commit with a message.

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

Set the commit message (-m).

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

Read the commit message from a file (-F).

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

Stage all tracked, modified files before committing (-a).

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

Amend the previous commit.

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

Reuse the last commit message without opening the editor.

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

Allow an empty commit.

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

Allow an empty commit message.

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

Add Signed-off-by: line.

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

Skip pre-commit and commit-msg hooks.

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

Override the author (--author="Name <email>").

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

Override the author date.

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

Commit only the given paths.

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

Suppress output.

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

Verbose diff output in the commit message editor.

Trait Implementations

impl Clone for CommitCommand

fn clone(&self) -> CommitCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommitCommand

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

Formats the value using the given formatter.

impl Default for CommitCommand

fn default() -> CommitCommand

Returns the “default value” for a type.

impl GitCommand for CommitCommand

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.