Struct Host 

pub struct Host { /* private fields */ }

The machine a toolchain check probes.

A Host carries its own environment map (including PATH), a working directory for spawned processes and relative-path lookups, a home directory, and the roots that hold installed platform applications (macOS /Applications). Detection code must read all of those through this value so a declared host cannot leak real-machine state into a check.

Implementations

impl Host

pub fn current() -> Self

The real machine this process runs on.

Panics

Panics when the process has no current directory.

pub fn new<P, K, V>( path_dirs: impl IntoIterator<Item = P>, vars: impl IntoIterator<Item = (K, V)>, ) -> Self

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

A host declared entirely by the arguments.

PATH is exactly path_dirs; the environment contains exactly vars plus that PATH entry. The working directory defaults to the process cwd — override it with Host::with_cwd. The home directory is taken from the declared HOME/USERPROFILE; a host that declares neither has none. Declared hosts have no Host::app_dirs, so application- bundle fallbacks (e.g. Android Studio’s bundled JBR) cannot fire.

On Windows the process-spawn plumbing variables (SystemRoot, SystemDrive, windir, ComSpec, PATHEXT) are seeded from the running process because children cannot start without them; they describe how to launch a process, never what is installed.

Panics

Panics when path_dirs cannot be joined into a PATH string (e.g. an entry containing the platform separator).

pub fn with_cwd(self, cwd: impl Into<PathBuf>) -> Self

Override the working directory (builder-style).

pub fn with_app_dirs(self, app_dirs: impl IntoIterator<Item = PathBuf>) -> Self

Override the application-install roots (builder-style).

pub fn env(&self, key: impl AsRef<OsStr>) -> Option<&OsStr>

An environment variable on this host.

Lookup is case-sensitive on Unix and case-insensitive on Windows, matching the platform’s own environment semantics.

pub fn env_string(&self, key: impl AsRef<OsStr>) -> Option<String>

An environment variable decoded as UTF-8 text.

pub fn path_entries(&self) -> Vec<PathBuf>

This host’s PATH entries, in order.

Empty components are dropped: an empty PATH element historically means “the working directory”, which would let tools sitting in Host::cwd masquerade as installed on a declared host.

pub fn cwd(&self) -> &Path

Working directory for spawned processes and relative-path lookups.

pub fn home_dir(&self) -> Option<&Path>

This host’s home directory, when it declares one.

pub fn current_exe() -> Result<PathBuf>

Path of the running water executable.

A fact about this process rather than the declared machine — every Host reports the same binary, which is what RUSTC_WRAPPER self-wrapping must name. Associated with Host so the probe stays inside the seam.

Errors

Returns an error when the OS cannot report the executable’s path.

pub fn app_dirs(&self) -> &[PathBuf]

Roots holding installed platform application bundles.

/Applications on macOS, empty elsewhere and on declared hosts. Probes that look inside installed .app bundles read them under these roots so test machines do not leak real-machine installs.

pub async fn which(&self, name: impl AsRef<OsStr>) -> Result<PathBuf, Error>

Locate name on this host’s PATH.

Never consults the process PATH: a host with no PATH or an empty one reports every tool as missing.

Errors

• which::Error when no executable named name exists on this host.

pub fn with_env(&self, key: impl AsRef<OsStr>, value: impl AsRef<OsStr>) -> Self

A host whose environment additionally binds key to value.

Use for variables that must reach a single child tree (for example WATERUI_SKIP_RUST_BUILD on the xcodebuild invocation) instead of mutating the process environment.

pub fn command(&self, program: impl AsRef<OsStr>) -> Command

A Command that runs program under this host’s environment.

The child sees exactly this host’s variables and starts in Host::cwd; program is resolved against this host’s PATH. stdio configuration is left to the caller — see [crate::utils::command] for the CLI’s capture/inherit policy.

pub fn std_command(&self, program: impl AsRef<OsStr>) -> Command

A std::process::Command that runs program under this host.

Same environment and working directory as Host::command, for the places that need synchronous or std-only command features (process groups, spawning from a non-async thread).

pub async fn output( &self, program: impl AsRef<OsStr>, args: impl IntoIterator<Item = impl AsRef<OsStr>>, ) -> Result<Output, CommandError>

Spawn program with args under this host, capturing output.

stdout and stderr are piped and always collected for the returned Output; when the CLI’s --logs passthrough is active each chunk is additionally mirrored to the terminal as it arrives, matching the historical run_command_output_os behavior.

Errors

• CommandError::Spawn when the program cannot be spawned or awaited.

Panics

Panics if the piped-stdio invariant above is violated — both streams are configured piped immediately before spawn, so take() always sees Some.

pub async fn run( &self, program: impl AsRef<OsStr>, args: impl IntoIterator<Item = impl AsRef<OsStr>>, ) -> Result<String, CommandError>

Run program under this host and return stdout as text.

Errors

• CommandError::Spawn when the program cannot be spawned.
• CommandError::Failed when it exits non-zero; the error embeds the captured stderr/stdout tails.

pub async fn run_detached( &self, program: impl AsRef<OsStr>, args: impl IntoIterator<Item = impl AsRef<OsStr>>, ) -> Result<ExitStatus, CommandError>

Run program to completion with nothing of this process in its hands: no stdio and, on Windows, no inherited handles at all.

This is how a daemon launcher is run. A child spawned the ordinary way receives every inheritable handle this process holds — including strays our own parent passed down — and hands them on to whatever it spawns with inheritance on. adb start-server is the case that matters: its server outlives water, and a pipe it inherited stays open until the server exits. The exit status is the caller’s to judge, because a launcher’s own output is discarded here.

Errors

CommandError::Spawn when the program cannot be started or waited on.

Trait Implementations

impl Clone for Host

fn clone(&self) -> Host

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Host

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

Formats the value using the given formatter.