Struct Env 

pub struct Env<A, FM, L, V, EX, WD, B, N: Eq + Hash, ERR> { /* private fields */ }

A shell environment implementation which delegates work to other environment implementations.

Implementations

impl<A, FM, L, V, EX, WD, B, N, ERR> Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq,

pub fn with_config(cfg: EnvConfig<A, FM, L, V, EX, WD, B, N, ERR>) -> Self

where V: ExportedVariableEnvironment, V::VarName: From<String>, V::Var: Borrow<String> + From<String> + Clone, WD: WorkingDirectoryEnvironment,

Creates an environment using the provided configuration of subcomponents.

See EnvConfig for the kinds of overrides possible. DefaultEnvConfig comes with provided implementations to get you up and running.

General recommendations:

• The result of evaluating a shell word will often be copied and reused in many different places. It’s strongly recommened that an Arc wrapper (e.g. Arc<String>) is used to minimize having to reallocate and copy the same data.
• Whatever type represents a shell function body needs to be cloned to get around borrow restrictions and potential recursive executions and (re-)definitions. Since this type is probably an AST (which may be arbitrarily large), Arc is your friend.

impl<T> Env<ArgsEnv<T>, TokioFileDescManagerEnv, LastStatusEnv, VarEnv<T, T>, TokioExecEnv, VirtualWorkingDirEnv, BuiltinEnv<T>, T, RuntimeError>

where T: StringWrapper,

pub fn new() -> Result<Self>

Creates a new default environment.

See the definition of DefaultEnvConfig for what configuration will be used.

Trait Implementations

impl<A, FM, L, V, EX, WD, B, N, ERR> ArgumentsEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: ArgumentsEnvironment, A::Arg: Clone, N: Hash + Eq,

type Arg = <A as ArgumentsEnvironment>::Arg

The type of arguments this environment holds.

fn name(&self) -> &Self::Arg

Get the name of the shell.

fn arg(&self, idx: usize) -> Option<&Self::Arg>

Get an argument at any index. Arguments are 1-indexed since the shell variable $0 refers to the shell’s name. Thus the first real argument starts at index 1.

fn args_len(&self) -> usize

Get the number of current arguments, NOT including the shell name.

fn args(&self) -> Cow<'_, [Self::Arg]>

Get all current arguments as a possibly owned slice.

impl<A, FM, L, V, EX, WD, B, N, ERR> AsyncIoEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where FM: AsyncIoEnvironment, N: Hash + Eq,

type IoHandle = <FM as AsyncIoEnvironment>::IoHandle

The underlying handle (e.g. FileDesc) with which to perform the async I/O.

fn read_all( &mut self, fd: Self::IoHandle, ) -> BoxFuture<'static, Result<Vec<u8>>>

Asynchronously read all data from the specified handle.

fn write_all<'a>( &mut self, fd: Self::IoHandle, data: Cow<'a, [u8]>, ) -> BoxFuture<'a, Result<()>>

Asynchronously write data into the specified handle.

fn write_all_best_effort(&mut self, fd: Self::IoHandle, data: Vec<u8>)

Asynchronously write the contents of data to a file handle in the background on a best effort basis (e.g. the implementation can give up due to any (appropriately) unforceen errors like broken pipes).

impl<A, FM, L, V, EX, WD, B, N, ERR> BuiltinEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq, B: BuiltinEnvironment,

type BuiltinName = <B as BuiltinEnvironment>::BuiltinName

The name for looking up a builtin utility.

type Builtin = <B as BuiltinEnvironment>::Builtin

The type of the builtin utility.

fn builtin(&self, name: &Self::BuiltinName) -> Option<Self::Builtin>

Lookup and get a particular builtin by its name.

impl<A, FM, L, V, EX, WD, B, N, ERR> ChangeWorkingDirectoryEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq, V: VariableEnvironment, V::VarName: From<String>, V::Var: From<String>, WD: WorkingDirectoryEnvironment + ChangeWorkingDirectoryEnvironment,

fn change_working_dir<'a>(&mut self, path: Cow<'a, Path>) -> Result<()>

Changes the environment’s current working directory to the following path.

impl<A, FM, L, V, EX, WD, B, N, ERR> Clone for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: Clone, FM: Clone, L: Clone, V: Clone, B: Clone, N: Hash + Eq, EX: Clone, WD: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, FM, L, V, EX, WD, B, N, ERR> Debug for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: Debug, FM: Debug, L: Debug, V: Debug, B: Debug, N: Hash + Eq + Ord + Debug, EX: Debug, WD: Debug,

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

Formats the value using the given formatter.

impl<A, FM, L, V, EX, WD, B, N, ERR> ExecutableEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq, EX: ExecutableEnvironment,

fn spawn_executable( &self, data: ExecutableData<'_>, ) -> Result<BoxFuture<'static, ExitStatus>, CommandError>

Attempt to spawn the executable command.

impl<A, FM, L, V, EX, WD, B, N, ERR> ExportedVariableEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where V: ExportedVariableEnvironment, N: Hash + Eq,

fn exported_var(&self, name: &Self::VarName) -> Option<(&Self::Var, bool)>

Get the value of some variable and whether it is exported.

fn set_exported_var( &mut self, name: Self::VarName, val: Self::Var, exported: bool, )

Set the value of some variable, and set it’s exported status as specified.

impl<A, FM, L, V, EX, WD, B, N, ERR> FileDescEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where FM: FileDescEnvironment, N: Hash + Eq,

type FileHandle = <FM as FileDescEnvironment>::FileHandle

A file handle (or wrapper) to associate with shell file descriptors.

fn file_desc(&self, fd: Fd) -> Option<(&Self::FileHandle, Permissions)>

Get the permissions and a handle associated with an opened file descriptor.

fn set_file_desc(&mut self, fd: Fd, fdes: Self::FileHandle, perms: Permissions)

Associate a file descriptor with a given handle and permissions.

fn close_file_desc(&mut self, fd: Fd)

Treat the specified file descriptor as closed for the current environment.

impl<A, FM, L, V, EX, WD, B, N, ERR> FileDescOpener for Env<A, FM, L, V, EX, WD, B, N, ERR>

where FM: FileDescOpener, N: Hash + Eq,

type OpenedFileHandle = <FM as FileDescOpener>::OpenedFileHandle

A type which represents an opened file descriptor.

fn open_path( &mut self, path: &Path, opts: &OpenOptions, ) -> Result<Self::OpenedFileHandle>

Open a provided path with the specified OpenOptions.

fn open_pipe(&mut self) -> Result<Pipe<Self::OpenedFileHandle>>

Create a new Pipe pair.

impl<A, FM, L, V, EX, WD, B, N, ERR> From<EnvConfig<A, FM, L, V, EX, WD, B, N, ERR>> for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq, V: ExportedVariableEnvironment, V::VarName: From<String>, V::Var: Borrow<String> + From<String> + Clone, WD: WorkingDirectoryEnvironment,

fn from(cfg: EnvConfig<A, FM, L, V, EX, WD, B, N, ERR>) -> Self

Converts to this type from the input type.

impl<A, FM, L, V, EX, WD, B, N, ERR> FunctionEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq + Clone,

type FnName = N

The name to be associated with a function.

type Fn = Arc<dyn Spawn<Env<A, FM, L, V, EX, WD, B, N, ERR>, Error = ERR> + Send + Sync>

The type of the function.

fn function(&self, name: &Self::FnName) -> Option<&Self::Fn>

Get a particularly named function if it was registered.

fn set_function(&mut self, name: Self::FnName, func: Self::Fn)

Register a shell function with a given name.

fn has_function(&self, name: &Self::FnName) -> bool

Check if a particularly named function was registered.

impl<A, FM, L, V, EX, WD, B, N, ERR> FunctionFrameEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq + Clone,

fn push_fn_frame(&mut self)

Denote that a new function has been invoked and is currently executing.

fn pop_fn_frame(&mut self)

Denote that a function has completed and is no longer executing.

fn is_fn_running(&self) -> bool

Determines if there is at least one function being currently executed.

impl<A, FM, L, V, EX, WD, B, N, ERR> IsInteractiveEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq,

fn is_interactive(&self) -> bool

Indicates if running in interactive mode.

impl<A, FM, L, V, EX, WD, B, N, ERR> LastStatusEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where L: LastStatusEnvironment, N: Hash + Eq,

fn last_status(&self) -> ExitStatus

Get the exit status of the previous command.

fn set_last_status(&mut self, status: ExitStatus)

Set the exit status of the previously run command.

impl<A, FM, L, V, EX, WD, B, N, ERR> ReportErrorEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: ArgumentsEnvironment, A::Arg: Display, FM: AsyncIoEnvironment + FileDescEnvironment, FM::FileHandle: Clone, FM::IoHandle: From<FM::FileHandle>, N: Hash + Eq,

fn report_error<'a>( &mut self, fail: &'a (dyn Error + Sync + Send + 'static), ) -> BoxFuture<'a, ()>

Reports any Error as appropriate, e.g. print to stderr.

impl<A, FM, L, V, EX, WD, B, N, ERR> SetArgumentsEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: SetArgumentsEnvironment, N: Hash + Eq,

type Args = <A as SetArgumentsEnvironment>::Args

A collection of arguments to set.

fn set_args(&mut self, new_args: Self::Args) -> Self::Args

Changes the environment’s arguments to new_args and returns the old arguments.

impl<A, FM, L, V, EX, WD, B, N, ERR> ShiftArgumentsEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: ShiftArgumentsEnvironment, N: Hash + Eq,

fn shift_args(&mut self, amt: usize)

Shift parameters such that the positional parameter n will hold the value of the positional parameter n + amt.

impl<A, FM, L, V, EX, WD, B, N, ERR> SubEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where A: SubEnvironment, FM: SubEnvironment, L: SubEnvironment, V: SubEnvironment, B: SubEnvironment, N: Hash + Eq, EX: SubEnvironment, WD: SubEnvironment,

fn sub_env(&self) -> Self

Create a new sub-environment, which starts out idential to its parent, but any changes on the new environment will not be reflected on the parent.

impl<A, FM, L, V, EX, WD, B, N, ERR> UnsetFunctionEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq + Clone,

fn unset_function(&mut self, name: &Self::FnName)

Removes the definition of a function if it was registered.

impl<A, FM, L, V, EX, WD, B, N, ERR> UnsetVariableEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where V: UnsetVariableEnvironment, N: Hash + Eq,

fn unset_var(&mut self, name: &V::VarName)

Unset the value of some variable (including environment variables).

impl<A, FM, L, V, EX, WD, B, N, ERR> VariableEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where V: VariableEnvironment, N: Hash + Eq,

type VarName = <V as VariableEnvironment>::VarName

The type of the name this environment associates for a variable.

type Var = <V as VariableEnvironment>::Var

The type of variables this environment holds.

fn var<Q>(&self, name: &Q) -> Option<&Self::Var>

where Self::VarName: Borrow<Q>, Q: Hash + Eq + ?Sized,

Get the value of some variable. The values of both shell-only and environment variables will be looked up and returned.

fn set_var(&mut self, name: Self::VarName, val: Self::Var)

Set the value of some variable, maintaining its status as an environment variable if previously set as such.

fn env_vars(&self) -> Cow<'_, [(&Self::VarName, &Self::Var)]>

Unset the value of some variable (including environment variables). Get all current pairs of environment variables and their values.

impl<A, FM, L, V, EX, WD, B, N, ERR> WorkingDirectoryEnvironment for Env<A, FM, L, V, EX, WD, B, N, ERR>

where N: Hash + Eq, WD: WorkingDirectoryEnvironment,

fn path_relative_to_working_dir<'a>(&self, path: Cow<'a, Path>) -> Cow<'a, Path>

Converts the specified path to one relative to the environment’s working directory.

fn current_working_dir(&self) -> &Path

Retrieves the current working directory of this environment.