Struct StackIoGuard 

pub struct StackIoGuard<'a> { /* private fields */ }

Methods from Deref<Target = Stack>

pub fn with_env( &mut self, env_vars: &[Arc<EnvVars>], env_hidden: &Arc<HashMap<String, HashSet<EnvName>>>, )

pub fn get_var(&self, var_id: VarId, span: Span) -> Result<Value, ShellError>

Lookup a variable, erroring if it is not found

The passed-in span will be used to tag the value

pub fn get_var_with_origin( &self, var_id: VarId, span: Span, ) -> Result<Value, ShellError>

Lookup a variable, erroring if it is not found

While the passed-in span will be used for errors, the returned value has the span from where it was originally defined

pub fn get_config(&self, engine_state: &EngineState) -> Arc<Config>

Get the local config if set, otherwise the config from the engine state.

This is the canonical way to get Config when Stack is available.

pub fn update_config( &mut self, engine_state: &EngineState, ) -> Result<(), ShellError>

Update the local config with the config stored in the config environment variable. Run this after assigning to $env.config.

The config will be updated with successfully parsed values even if an error occurs.

pub fn add_var(&mut self, var_id: VarId, value: Value)

pub fn remove_var(&mut self, var_id: VarId)

pub fn add_env_var(&mut self, var: String, value: Value)

pub fn set_last_exit_code(&mut self, code: i32, span: Span)

pub fn set_last_error(&mut self, error: &ShellError)

pub fn last_overlay_name(&self) -> Result<String, ShellError>

pub fn captures_to_stack(&self, captures: Vec<(VarId, Value)>) -> Stack

Like [captures_to_stack_preserve_out_dest], but sets the new scope up to collect output into a Value.

pub fn captures_to_stack_preserve_out_dest( &self, captures: Vec<(VarId, Value)>, ) -> Stack

Creates a derived stack for a new scope, with the given captures.

pub fn gather_captures( &self, engine_state: &EngineState, captures: &[(VarId, Span)], ) -> Stack

pub fn get_env_vars(&self, engine_state: &EngineState) -> HashMap<String, Value>

Flatten the env var scope frames into one frame

pub fn get_stack_env_vars(&self) -> HashMap<String, Value>

Get flattened environment variables only from the stack

pub fn get_stack_overlay_env_vars( &self, overlay_name: &str, ) -> HashMap<String, Value>

Get flattened environment variables only from the stack and one overlay

pub fn get_hidden_env_vars( &self, excluded_overlay_name: &str, engine_state: &EngineState, ) -> HashMap<String, Value>

Get hidden envs, but without envs defined previously in excluded_overlay_name.

pub fn get_env_var_names(&self, engine_state: &EngineState) -> HashSet<String>

Same as get_env_vars, but returns only the names as a HashSet

pub fn get_env_var<'a>( &'a self, engine_state: &'a EngineState, name: &str, ) -> Option<&'a Value>

pub fn has_env_var(&self, engine_state: &EngineState, name: &str) -> bool

pub fn remove_env_var(&mut self, engine_state: &EngineState, name: &str) -> bool

Removes name from the stack. If it was not on the stack and lives in engine_state, marks it hidden in env_hidden. Returns true if the variable was found and removed.

Use this for temporary bookkeeping removals (e.g. FILE_PWD, canary variables) where the goal is to clean up a stack-level value without necessarily hiding the engine-state baseline. Use Self::hide_env_var when the intent is to make the variable invisible to subsequent lookups (e.g. hide-env).

pub fn hide_env_var(&mut self, engine_state: &EngineState, name: &str) -> bool

Hides name so it is no longer visible to subsequent lookups. Removes it from the stack and, if no stack shadowing remains, also marks the engine_state baseline as hidden in env_hidden. Returns true if the variable was found.

This is the correct method for hide-env and redirect_env; it ensures that a variable set in engine_state (from a previous REPL merge) cannot be seen after hiding even when a stack-level override (e.g. an empty-string assignment) was present at hide time.

pub fn has_env_overlay(&self, name: &str, engine_state: &EngineState) -> bool

pub fn is_overlay_active(&self, name: &str) -> bool

pub fn add_overlay(&mut self, name: String)

pub fn remove_overlay(&mut self, name: &str)

pub fn stdout(&self) -> &OutDest

Returns the OutDest to use for the current command’s stdout.

This will be the pipe redirection if one is set, otherwise it will be the current file redirection, otherwise it will be the process’s stdout indicated by OutDest::Inherit.

pub fn stderr(&self) -> &OutDest

Returns the OutDest to use for the current command’s stderr.

This will be the pipe redirection if one is set, otherwise it will be the current file redirection, otherwise it will be the process’s stderr indicated by OutDest::Inherit.

pub fn pipe_stdout(&self) -> Option<&OutDest>

Returns the OutDest of the pipe redirection applied to the current command’s stdout.

pub fn pipe_stderr(&self) -> Option<&OutDest>

Returns the OutDest of the pipe redirection applied to the current command’s stderr.

pub fn start_collect_value(&mut self) -> StackCollectValueGuard<'_>

Temporarily set the pipe stdout redirection to OutDest::Value.

This is used before evaluating an expression into a Value.

pub fn use_call_arg_out_dest(&mut self) -> StackCallArgGuard<'_>

Temporarily use the output redirections in the parent scope.

This is used before evaluating an argument to a call.

pub fn push_redirection( &mut self, stdout: Option<Redirection>, stderr: Option<Redirection>, ) -> StackIoGuard<'_>

Temporarily apply redirections to stdout and/or stderr.

pub fn set_cwd(&mut self, path: impl AsRef<Path>) -> Result<(), ShellError>

Set the PWD environment variable to path.

This method accepts path with trailing slashes, but they’re removed before writing the value into PWD.

Trait Implementations

impl Deref for StackIoGuard<'_>

type Target = Stack

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for StackIoGuard<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for StackIoGuard<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.