Struct ProcessResult 

pub struct ProcessResult<T> { /* private fields */ }

The captured result of running a process to completion.

T is the standard-output payload: String for the text helpers (output_string) or Vec<u8> for the raw-bytes helper (output_bytes). Standard error is always captured as text. A non-zero exit code is not treated as an error on its own — inspect code or call ensure_success.

#[must_use]: the result is the exit status — dropping it unread discards the only signal that the command failed. Call is_success / code / ensure_success. If you only need the side effect, prefer a verb that never produces a result to discard — run_unit (error-or-()) or exit_code — rather than capturing and binding to let _.

Implementations

impl<T> ProcessResult<T>

pub fn program(&self) -> &str

The program this result is attributed to (lossy UTF-8 of the program name) — the same value the error variants carry. For a Pipeline outcome this is the pipefail-attributed stage: the first stage that didn’t exit cleanly, or the last stage when every stage succeeded.

pub fn stdout(&self) -> &T

The captured standard output (text or bytes depending on T).

pub fn into_stdout(self) -> T

Consume the result and return just the captured standard output.

pub fn stderr(&self) -> &str

The captured standard error.

pub fn outcome(&self) -> Outcome

How the run ended, as the explicit three-way Outcome.

pub fn code(&self) -> Option<i32>

The process exit code, or None when the run yielded no code — killed by its timeout (timed_out is then true) or terminated by a signal on Unix (timed_out is false). There is no synthetic sentinel: a missing code is None, never -1. Derived from outcome.

pub fn timed_out(&self) -> bool

Whether the run was killed because it exceeded its timeout. Derived from outcome.

pub fn signal(&self) -> Option<i32>

The signal number if the process was terminated by a signal with a known number (Unix only; None otherwise — a clean exit, a timeout, or a signal the kernel did not expose). Derived from outcome; the Outcome-level twin is Outcome::signal.

pub fn is_success(&self) -> bool

Whether the process exited with an accepted code — 0 by default, or any code in the set configured via Command::ok_codes.

pub fn ensure_success(self) -> Result<ProcessResult<T>, Error>

where T: StdoutText,

Return self unchanged when the run succeeded — an accepted exit code (0 by default; see Command::ok_codes) — otherwise the matching error.

Errors

• Error::Timeout if the run was killed by its deadline (checked first, so a run that both timed out and exited non-zero reports the timeout).
• Error::Signalled if it was terminated by a signal, with no exit code.
• Error::Exit for an exit code outside the accepted set, carrying the code and both captured streams in full (the Display impl bounds what it prints; the fields stay complete for classification).

pub fn duration(&self) -> Duration

The wall-clock duration of the run — spawn to exit (or kill). It is Duration::ZERO for synthetic results that didn’t time a real process (a scripted/replayed bulk output_string).

pub fn truncated(&self) -> bool

Whether a bounded OutputBufferPolicy discarded captured output lines (one or more lines were dropped by the buffer policy). Lines a streaming consumer popped are not truncation, so this stays false under the default unbounded policy even after a partial stdout_lines stream, and for the raw stdout of output_bytes (not line-buffered).

impl ProcessResult<String>

pub fn combined(&self) -> String

Standard output followed by standard error, concatenated — handy when a tool splits diagnostics across both streams. This is stdout then stderr (each captured in full), not a temporal interleaving of the two — the crate captures the streams separately, so their relative ordering is not preserved.

A \n separator is inserted between them only when both streams are non-empty and stdout does not already end with a newline, preventing the last stdout line from being glued to the first stderr line. (Matches Error::combined.)

pub fn output_contains_any( &self, needles: impl IntoIterator<Item = impl AsRef<str>>, ) -> bool

Whether either captured stream contains any of needles, matched case-insensitively (ASCII). For the lenient “a specific non-zero exit is benign when a known stderr/stdout marker is present” idiom — e.g. gh’s "no checks reported" or jj’s "no conflicts" — without re-lowercasing a stream by hand each time. Allocation-free (it never materializes a lowercased copy of a possibly-large captured stream). The two streams are searched independently, so a needle never matches across the stdout/stderr boundary. An empty needles iterator is false; an empty "" needle follows str::contains (always present).

Accepts any iterable of string-like items — &["a", "b"], Vec<String>, a single ["a"] array, … — matching the other multi-input builders (Command::args, Command::envs).

pub fn diagnostic(&self) -> &str

The best human-facing message from a captured run, trimmed of surrounding whitespace: standard error if it carries text, otherwise standard output — git/jj put CONFLICT … and nothing to commit on stdout, so a probe that captured the result (rather than erroring) can build the same friendly message Error::diagnostic gives the erroring path. For the raw, untrimmed streams use stdout / stderr.

Trait Implementations

impl<T> Clone for ProcessResult<T>

where T: Clone,

fn clone(&self) -> ProcessResult<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessResult<String>

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

Formats the value using the given formatter.

impl Debug for ProcessResult<Vec<u8>>

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

Formats the value using the given formatter.

impl<T> Eq for ProcessResult<T>

where T: Eq,

impl<T> PartialEq for ProcessResult<T>

where T: PartialEq,

fn eq(&self, other: &ProcessResult<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.