Crate devx_cmd

devx-cmd provides more convenient primitives for spawning child processes than std::process targeted for use in development scripts specifically.

The main entities of the crate are Cmd (builder for executable commands), and Child (represents a spawned process).

There are also some convenient macros to reduce boilerplate. Here is the basic usage example:

use devx_cmd::{read, run, cmd, Cmd};

// Initialize some low-overhead logger implementation for the `log` crate
simple_logger::SimpleLogger::new().init().unwrap();

// Run the program, logging the invocation via [`log`] crate and waiting until it finishes
// This is used only for side-effects.
// Note that if the process ends with a non-zero status code, this will return an error.
run!("ls", "-la")?;

// Same as `run!()`, but captures the stdout and returns it as a `String`
// there is also a `read_bytes!()` for non-utf8 sequences
let output = read!("echo", "foo")?;
assert_eq!(output.trim(), "foo");

let mut cmd = cmd!("rustfmt");
cmd
    // Set `trace` level for logging command invocation and output (`debug` by default)
    .log_cmd(log::Level::Trace)
    // Don't log error if the command fails
    .log_err(None)
    .stdin("fn foo () -> u32 {42}\n");

// Spawn without waiting for its completion, but capturing the stdout
let mut child = cmd.spawn_piped()?;

// Read output line-by-line
let first_line = child.stdout_lines().next().unwrap();

assert_eq!(first_line.trim(), "fn foo() -> u32 {");

// Dropping the child process `kill()`s it (and ignores the `Result`)
// Use `.wait()/.read()` to wait until its completion.
drop(child);

Macros

cmd

Create a Cmd with the given binary and arguments.

read

Shortcut for cmd!(...).read().

read_bytes

Shortcut for cmd!(...).read_bytes().

run

Shortcut for cmd!(...).run().

Structs

Child

Wraps std::process::Child, kills and waits for the process on Drop. It will log the fact that std::process::Child::kill() was called in Drop. You should use Child::wait() for the process to finish with any of the available methods if you want to handle the error, otherwise it will be ignored.

Cmd

More convenient version of std::process::Command. Allows for spawning child processes with or without capturing their stdout. It also comes with inbuilt logging of the invocations via log crate.

Error

Opaque error which happened during command execution.

Enums

Ostream

Defines the kind of standard process output stream.

Type Definitions

Result

Shortcut for Result<T, devx_cmd::Error>