Struct bkt::CommandDesc

pub struct CommandDesc { /* fields omitted */ }

Describes a command to be executed and cached. This struct also serves as the cache key. It consists of a command line invocation and, optionally, a working directory to execute in and environment variables to set. When set these fields contribute to the cache key, therefore two invocations with different working directories set will be cached separately.

let cmd = bkt::CommandDesc::new(&["echo", "Hello World!"]);
let with_cwd = bkt::CommandDesc::new(&["ls"]).with_working_dir("/tmp");
let with_env = bkt::CommandDesc::new(&["date"]).with_env_value("TZ", "America/New_York");

Implementations

impl CommandDesc

pub fn new<I, S>(command: I) -> Self where
    I: IntoIterator<Item = S>,
    S: Into<OsString>, 

Constructs a CommandDesc instance for the given command line.

let cmd = bkt::CommandDesc::new(&["echo", "Hello World!"]);

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

Sets the working directory the command should be run from, and causes the 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"]).with_working_dir("/tmp");

pub fn with_cwd(self) -> Result<Self>

Sets the working directory to the current process’ working directory. This has no effect on the subprocess that will be executed (assuming the current process’ working directory remains unchanged) but does cause the working directory to be included in the cache key. Commands that depend on the working directory should call this in order to cache executions in different working directories separately.

Errors

This delegates to std::env::current_dir() and will fail if it does.

Examples

let cmd = bkt::CommandDesc::new(&["pwd"]).with_cwd()?;

pub fn with_env_value<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"]).with_env_value("FOO", "bar");

pub fn with_env<K>(self, key: K) -> Self where
    K: AsRef<OsStr>, 

Looks up the given environment variable in the current process’ environment and, if set, adds that key/value pair to the environment the command should be run from, and causes this pair to be included in the cache key. This has no effect on the subprocess that will be executed (assuming the current process’ environment remains unchanged).

If the given variable name is not found in the current process’ environment this call is a no-op, and the cache key will remain unchanged.

let cmd = bkt::CommandDesc::new(&["date"]).with_env("TZ");

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(&["..."]).with_envs(&important_envs);

Trait Implementations

impl Clone for CommandDesc

fn clone(&self) -> CommandDesc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CommandDesc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommandDesc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<&'_ CommandDesc> for Command

fn from(desc: &CommandDesc) -> Self

Performs the conversion.

impl Hash for CommandDesc

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<CommandDesc> for CommandDesc

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for CommandDesc

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

Serialize this value into the given Serde serializer.

impl Eq for CommandDesc

impl StructuralEq for CommandDesc

impl StructuralPartialEq for CommandDesc