Trait cradle::CmdArgument

pub trait CmdArgument { }

All types that are possible arguments to cmd! have to implement this trait.

Implementations on Foreign Types

impl<T> CmdArgument for &T where
    T: CmdArgument + Clone, 

Blanket implementation for &_.

impl CmdArgument for &str

Arguments of type &str are passed into the child process as arguments.

impl CmdArgument for String

Arguments of type String are passed into the child process as arguments.

impl<'a> CmdArgument for Split<'a, char>

Allows to use split to split your argument into words:

use cradle::*;

let StdoutTrimmed(output) = cmd!("echo foo".split(' '));
assert_eq!(output, "foo");

Arguments to split must be of type char.

impl<'a> CmdArgument for SplitWhitespace<'a>

Allows to use split_whitespace to split your argument into words:

use cradle::*;

let StdoutTrimmed(output) = cmd!("echo foo".split_whitespace());
assert_eq!(output, "foo");

impl<'a> CmdArgument for SplitAsciiWhitespace<'a>

Allows to use split_ascii_whitespace to split your argument into words:

use cradle::*;

let StdoutTrimmed(output) = cmd!("echo foo".split_ascii_whitespace());
assert_eq!(output, "foo");

impl<T> CmdArgument for Vec<T> where
    T: CmdArgument, 

All elements of the given Vec are used as arguments to cmd!. Same as passing in the elements separately.

use cradle::*;

let StdoutTrimmed(output) = cmd!(vec!["echo", "foo"]);
assert_eq!(output, "foo");

impl<T, const N: usize> CmdArgument for [T; N] where
    T: CmdArgument, 

Similar to the implementation for Vec<T>. All elements of the array will be used as arguments.

use cradle::*;

let StdoutTrimmed(output) = cmd!(["echo", "foo"]);
assert_eq!(output, "foo");

Only works on rust version 1.51 and up.

impl<T> CmdArgument for &[T] where
    T: CmdArgument + Clone, 

Similar to the implementation for Vec<T>. All elements of the slice will be used as arguments.

Implementors

impl CmdArgument for LogCommand

Passing in LogCommand as an argument to cmd! will cause it to log the commands (including all arguments) to stderr. (This is similar bash’s -x option.)

use cradle::*;

cmd_unit!(LogCommand, %"echo foo");
// writes '+ echo foo' to stderr

impl<'a> CmdArgument for cradle::Split<'a>

Splits the contained string by whitespace (using split_whitespace) and uses the resulting words as separate arguments.

use cradle::*;

let StdoutTrimmed(output) = cmd!(Split("echo foo"));
assert_eq!(output, "foo");

Since this is such a common case, cradle also provides a syntactic shortcut for Split, the % symbol:

use cradle::*;

let StdoutTrimmed(output) = cmd!(%"echo foo");
assert_eq!(output, "foo");

impl<T> CmdArgument for CurrentDir<T> where
    T: AsRef<Path>, 

By default child processes inherit the current directory from their parent. You can override this with CurrentDir:

use cradle::*;

let StdoutTrimmed(output) = cmd!("pwd", CurrentDir("/tmp"));
assert_eq!(output, "/tmp");

Paths that are relative to the parent’s current directory are allowed.