Struct CommandState

pub struct CommandState { /* private fields */ }

The stateful sibling of CommandDesc which represents a command to be executed and cached along with environment state (e.g. the current working directory) at the time the CommandState instance is constructed. It consists of a command line invocation and application state determining how the command should be cached and executed. Additional with_* methods are provided on this type for further modifying how the subprocess will be executed.

Calling any of these methods changes how the invocation’s cache key will be constructed, therefore two invocations with different configured state will be cached separately, in the same manner as the with_* methods on CommandDesc.

Examples

let cmd = bkt::CommandDesc::new(["echo", "Hello World!"]).capture_state();
let with_custom_wd = bkt::CommandDesc::new(["ls"]).capture_state()?.with_working_dir("/");
let with_env = bkt::CommandDesc::new(["date"]).capture_state()?.with_env("TZ", "UTC");

Implementations

impl CommandState

pub fn with_working_dir<P: AsRef<Path>>(self, cwd: P) -> Self

Sets the working directory the command should be run from, and causes this working directory to be included in the cache key. If unset the working directory will be inherited from the current process’ and will not be used to differentiate invocations in separate working directories.

let cmd = bkt::CommandDesc::new(["pwd"]);
let state = cmd.capture_state()?.with_working_dir("/tmp");

pub fn with_env<K, V>(self, key: K, value: V) -> Self

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

Adds the given key/value pair to the environment the command should be run from, and causes this pair to be included in the cache key.

let cmd = bkt::CommandDesc::new(["pwd"]);
let state = cmd.capture_state()?.with_env("FOO", "bar");

pub fn with_envs<I, K, V>(self, envs: I) -> Self

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

Adds the given key/value pairs to the environment the command should be run from, and causes these pair to be included in the cache key.

use std::env;
use std::collections::HashMap;

let important_envs : HashMap<String, String> =
    env::vars().filter(|&(ref k, _)|
        k == "TERM" || k == "TZ" || k == "LANG" || k == "PATH"
    ).collect();
let cmd = bkt::CommandDesc::new(["..."]);
let state = cmd.capture_state()?.with_envs(&important_envs);

Trait Implementations

impl Clone for CommandState

fn clone(&self) -> CommandState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CommandState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommandState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&CommandState> for Command

fn from(cmd: &CommandState) -> Self

Converts to this type from the input type.

impl Hash for CommandState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CommandState

fn eq(&self, other: &CommandState) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CommandState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&CommandDesc> for CommandState

type Error = Error

The type returned in the event of a conversion error.

fn try_from(desc: &CommandDesc) -> Result<Self>

Performs the conversion.

impl Eq for CommandState

impl StructuralPartialEq for CommandState