Struct Cmd

pub struct Cmd {
    pub inner: Command,
    /* private fields */
}

A fancier Command, see the crate’s top-level docs!

Fields

inner: Command

The inner Command, in case you need to access it

Implementations

impl Cmd

Constructors

pub fn new(command: impl AsRef<OsStr>, summary: impl Into<String>) -> Self

Create a new Command with an additional “summary” of what this is trying to do

impl Cmd

Builder APIs

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

Pipe stdout into stderr

This is useful for cases where you want your program to livestream the output of a command to give your user realtime feedback, but the command randomly writes some things to stdout, and you don’t want your own stdout tainted.

If the the “stdout_to_stderr_modern” feature is enabled, this will just do command.stdout(std::io::stderr());, which will actually let the two streams interleave and ideally do the best possible thing. In the future this will be enabled by default (once the MSRV is acceptable).

Otherwise, it will use a polyfilled implementation for output and status that captures child stdout and prints it to the parent stderr at the end. If using status, command.stderr(std::io::Inherit) will be forced on, ignoring your own settings for stderr.

pub fn log(&mut self, strategy: impl Into<Option<LogStrategy>>) -> &mut Self

Set how executions of this command should logged, accepting:

• tracing: tracing::Level (the default, set to `tracing::Level::INFO``)
• stdout: std::io::Stdout
• stderr: std::io::Stderr
• not at all: None

You can explicitly invoke the selected logging with Cmd::log_command

pub fn check(&mut self, checked: bool) -> &mut Self

Set whether Status::success should be checked after executions (except spawn, which doesn’t yet have a Status to check).

Defaults to true.

If true, an Err will be produced by those execution commands.

Executions which produce status will pass them to Cmd::maybe_check_status, which uses this setting.

impl Cmd

Execution APIs

pub fn run(&mut self) -> Result<()>

Equivalent to Cmd::status, but doesn’t bother returning the actual status code (because it’s captured in the Result)

pub fn spawn(&mut self) -> Result<Child>

Equivalent to std::process::Command::spawn, but logged and with the error wrapped.

pub fn output(&mut self) -> Result<Output>

Equivalent to std::process::Command::output, but logged, with the error wrapped, and status checked (by default)

pub fn status(&mut self) -> Result<ExitStatus>

Equivalent to std::process::Command::status but logged, with the error wrapped, and status checked (by default)

impl Cmd

Transparently forwarded std::process::Command APIs

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

Forwards to std::process::Command::arg

pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Self

where K: AsRef<OsStr>, V: AsRef<OsStr>,

Forwards to std::process::Command::env

pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Self

where I: IntoIterator<Item = (K, V)>, K: AsRef<OsStr>, V: AsRef<OsStr>,

Forwards to std::process::Command::envs

pub fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Self

Forwards to std::process::Command::env_remove

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

Forwards to std::process::Command::env_clear

pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self

Forwards to std::process::Command::current_dir

pub fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Forwards to std::process::Command::stdin

pub fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Forwards to std::process::Command::stdout

pub fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Forwards to std::process::Command::stderr

pub fn get_program(&self) -> &OsStr

Forwards to std::process::Command::get_program

pub fn get_args(&self) -> CommandArgs<'_>

Forwards to std::process::Command::get_args

pub fn get_envs(&self) -> CommandEnvs<'_>

Forwards to std::process::Command::get_envs

pub fn get_current_dir(&self) -> Option<&Path>

Forwards to std::process::Command::get_current_dir

impl Cmd

Diagnostic APIs (used internally, but available for yourself)

pub fn check_status(&self, status: ExitStatus) -> Result<()>

Check Status::success, producing a contextful Error if it’s false.`

pub fn maybe_check_status(&self, status: ExitStatus) -> Result<()>

Invoke Cmd::check_status if Cmd::check is true (defaults to true).

pub fn log_command(&self)

Log the current Command using the method specified by Cmd::log (defaults to tracing::info!).