Struct CloneCommand 

pub struct CloneCommand {
    pub executor: CommandExecutor,
    pub url: String,
    pub directory: Option<PathBuf>,
    pub bare: bool,
    pub mirror: bool,
    pub depth: Option<u32>,
    pub branch: Option<String>,
    pub single_branch: bool,
    pub recurse_submodules: bool,
    pub origin: Option<String>,
    pub quiet: bool,
}

Builder for git clone.

Fields

executor: CommandExecutor

Shared executor.

url: String

Remote URL (required).

directory: Option<PathBuf>

Local destination directory.

bare: bool

--bare.

mirror: bool

--mirror.

depth: Option<u32>

--depth.

branch: Option<String>

--branch.

single_branch: bool

--single-branch.

recurse_submodules: bool

--recurse-submodules.

origin: Option<String>

--origin.

quiet: bool

--quiet.

Implementations

impl CloneCommand

pub fn new(url: impl Into<String>) -> Self

Create a new clone command for url.

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

Target directory.

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

Clone as a bare repository.

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

Mirror all refs.

pub fn depth(&mut self, depth: u32) -> &mut Self

Shallow clone with the given depth.

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

Check out the named branch instead of the remote HEAD.

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

Clone only a single branch.

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

Recursively clone submodules.

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

Set the remote name (default origin).

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

Suppress output.

Trait Implementations

impl Clone for CloneCommand

fn clone(&self) -> CloneCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CloneCommand

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

Formats the value using the given formatter.

impl GitCommand for CloneCommand

type Output = Repository

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<Repository>> + 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.