Attach Process-dependent utils to Process

Author: djc

src/cli/self_update.rs

@@ -504,9 +504,10 @@ fn update_root(process: &Process) -> String {
 /// `CARGO_HOME` suitable for display, possibly with $HOME
 /// substituted for the directory prefix
 fn canonical_cargo_home(process: &Process) -> Result<Cow<'static, str>> {
-    let path = utils::cargo_home(process)?;
+    let path = process.cargo_home()?;
 
-    let default_cargo_home = utils::home_dir(process)
+    let default_cargo_home = process
+        .home_dir()
         .unwrap_or_else(|| PathBuf::from("."))
         .join(".cargo");
     Ok(if default_cargo_home == path {
@@ -727,7 +728,7 @@ fn check_existence_of_rustc_or_cargo_in_path(no_prompt: bool, process: &Process)
 fn do_pre_install_sanity_checks(no_prompt: bool, process: &Process) -> Result<()> {
     let rustc_manifest_path = PathBuf::from("/usr/local/lib/rustlib/manifest-rustc");
     let uninstaller_path = PathBuf::from("/usr/local/lib/rustlib/uninstall.sh");
-    let rustup_sh_path = utils::home_dir(process).unwrap().join(".rustup");
+    let rustup_sh_path = process.home_dir().unwrap().join(".rustup");
     let rustup_sh_version_path = rustup_sh_path.join("rustup-version");
 
     let rustc_exists = rustc_manifest_path.exists() && uninstaller_path.exists();
@@ -761,7 +762,7 @@ fn do_pre_install_sanity_checks(no_prompt: bool, process: &Process) -> Result<()
 }
 
 fn pre_install_msg(no_modify_path: bool, process: &Process) -> Result<String> {
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     let cargo_home_bin = cargo_home.join("bin");
     let rustup_home = home::rustup_home()?;
 
@@ -824,7 +825,7 @@ fn current_install_opts(opts: &InstallOpts<'_>, process: &Process) -> String {
 }
 
 fn install_bins(process: &Process) -> Result<()> {
-    let bin_path = utils::cargo_home(process)?.join("bin");
+    let bin_path = process.cargo_home()?.join("bin");
     let this_exe_path = utils::current_exe()?;
     let rustup_path = bin_path.join(format!("rustup{EXE_SUFFIX}"));
 
@@ -840,7 +841,7 @@ fn install_bins(process: &Process) -> Result<()> {
 }
 
 pub(crate) fn install_proxies(process: &Process) -> Result<()> {
-    let bin_path = utils::cargo_home(process)?.join("bin");
+    let bin_path = process.cargo_home()?.join("bin");
     let rustup_path = bin_path.join(format!("rustup{EXE_SUFFIX}"));
 
     let rustup = Handle::from_path(&rustup_path)?;
@@ -938,7 +939,8 @@ async fn maybe_install_rust(
 
     // If RUSTUP_HOME is not set, make sure it exists
     if process.var_os("RUSTUP_HOME").is_none() {
-        let home = utils::home_dir(process)
+        let home = process
+            .home_dir()
             .map(|p| p.join(".rustup"))
             .ok_or_else(|| anyhow::anyhow!("could not find home dir to put .rustup in"))?;
 
@@ -988,7 +990,7 @@ pub(crate) fn uninstall(no_prompt: bool, process: &Process) -> Result<utils::Exi
         return Ok(utils::ExitCode(1));
     }
 
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
 
     if !cargo_home.join(format!("bin/rustup{EXE_SUFFIX}")).exists() {
         return Err(CLIError::NotSelfInstalled { p: cargo_home }.into());
@@ -1178,7 +1180,7 @@ fn parse_new_rustup_version(version: String) -> String {
 }
 
 pub(crate) async fn prepare_update(process: &Process) -> Result<Option<PathBuf>> {
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     let rustup_path = cargo_home.join(format!("bin{MAIN_SEPARATOR}rustup{EXE_SUFFIX}"));
     let setup_path = cargo_home.join(format!("bin{MAIN_SEPARATOR}rustup-init{EXE_SUFFIX}"));
 
@@ -1319,7 +1321,7 @@ pub(crate) async fn check_rustup_update(process: &Process) -> Result<()> {
 
 #[cfg_attr(feature = "otel", tracing::instrument)]
 pub(crate) fn cleanup_self_updater(process: &Process) -> Result<()> {
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     let setup = cargo_home.join(format!("bin/rustup-init{EXE_SUFFIX}"));
 
     if setup.exists() {

src/cli/self_update/shell.rs

@@ -41,7 +41,7 @@ pub(crate) struct ShellScript {
 
 impl ShellScript {
     pub(crate) fn write(&self, process: &Process) -> Result<()> {
-        let home = utils::cargo_home(process)?;
+        let home = process.cargo_home()?;
         let cargo_bin = format!("{}/bin", cargo_home_str(process)?);
         let env_name = home.join(self.name);
         let env_file = self.content.replace("{cargo_bin}", &cargo_bin);
@@ -52,9 +52,10 @@ impl ShellScript {
 
 // TODO: Update into a bytestring.
 pub(crate) fn cargo_home_str(process: &Process) -> Result<Cow<'static, str>> {
-    let path = utils::cargo_home(process)?;
+    let path = process.cargo_home()?;
 
-    let default_cargo_home = utils::home_dir(process)
+    let default_cargo_home = process
+        .home_dir()
         .unwrap_or_else(|| PathBuf::from("."))
         .join(".cargo");
     Ok(if default_cargo_home == path {
@@ -117,7 +118,7 @@ impl UnixShell for Posix {
     }
 
     fn rcfiles(&self, process: &Process) -> Vec<PathBuf> {
-        match utils::home_dir(process) {
+        match process.home_dir() {
             Some(dir) => vec![dir.join(".profile")],
             _ => vec![],
         }
@@ -142,7 +143,7 @@ impl UnixShell for Bash {
         // .profile as part of POSIX and always does setup for POSIX shells.
         [".bash_profile", ".bash_login", ".bashrc"]
             .iter()
-            .filter_map(|rc| utils::home_dir(process).map(|dir| dir.join(rc)))
+            .filter_map(|rc| process.home_dir().map(|dir| dir.join(rc)))
             .collect()
     }
 
@@ -186,7 +187,7 @@ impl UnixShell for Zsh {
     }
 
     fn rcfiles(&self, process: &Process) -> Vec<PathBuf> {
-        [Zsh::zdotdir(process).ok(), utils::home_dir(process)]
+        [Zsh::zdotdir(process).ok(), process.home_dir()]
             .iter()
             .filter_map(|dir| dir.as_ref().map(|p| p.join(".zshenv")))
             .collect()
@@ -226,7 +227,7 @@ impl UnixShell for Fish {
             path
         });
 
-        let p1 = utils::home_dir(process).map(|mut path| {
+        let p1 = process.home_dir().map(|mut path| {
             path.push(".config/fish/conf.d/rustup.fish");
             path
         });
@@ -257,11 +258,11 @@ impl UnixShell for Fish {
 pub(crate) fn legacy_paths(process: &Process) -> impl Iterator<Item = PathBuf> + '_ {
     let zprofiles = Zsh::zdotdir(process)
         .into_iter()
-        .chain(utils::home_dir(process))
+        .chain(process.home_dir())
         .map(|d| d.join(".zprofile"));
     let profiles = [".bash_profile", ".profile"]
         .iter()
-        .filter_map(|rc| utils::home_dir(process).map(|d| d.join(rc)));
+        .filter_map(|rc| process.home_dir().map(|d| d.join(rc)));
 
     profiles.chain(zprofiles)
 }

src/cli/self_update/unix.rs

@@ -48,7 +48,7 @@ pub(crate) fn do_anti_sudo_check(no_prompt: bool, process: &Process) -> Result<u
 }
 
 pub(crate) fn delete_rustup_and_cargo_home(process: &Process) -> Result<()> {
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     utils::remove_dir("cargo_home", &cargo_home, &|_: Notification<'_>| ())
 }
 

src/cli/self_update/windows.rs

@@ -279,7 +279,7 @@ pub fn complete_windows_uninstall(process: &Process) -> Result<utils::ExitCode>
     wait_for_parent()?;
 
     // Now that the parent has exited there are hopefully no more files open in CARGO_HOME
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     utils::remove_dir("cargo_home", &cargo_home, &|_: Notification<'_>| ())?;
 
     // Now, run a *system* binary to inherit the DELETE_ON_CLOSE
@@ -492,7 +492,7 @@ where
     F: FnOnce(Vec<u16>, Vec<u16>) -> Option<Vec<u16>>,
 {
     let windows_path = get_windows_path_var()?;
-    let mut path_str = utils::cargo_home(process)?;
+    let mut path_str = process.cargo_home()?;
     path_str.push("bin");
     Ok(windows_path
         .and_then(|old_path| f(old_path, OsString::from(path_str).encode_wide().collect())))
@@ -535,7 +535,7 @@ pub(crate) fn do_add_to_programs(process: &Process) -> Result<()> {
         }
     }
 
-    let mut path = utils::cargo_home(process)?;
+    let mut path = process.cargo_home()?;
     path.push("bin\\rustup.exe");
     let mut uninstall_cmd = OsString::from("\"");
     uninstall_cmd.push(path);
@@ -657,7 +657,7 @@ pub(crate) fn delete_rustup_and_cargo_home(process: &Process) -> Result<()> {
     };
 
     // CARGO_HOME, hopefully empty except for bin/rustup.exe
-    let cargo_home = utils::cargo_home(process)?;
+    let cargo_home = process.cargo_home()?;
     // The rustup.exe bin
     let rustup_path = cargo_home.join(format!("bin/rustup{EXE_SUFFIX}"));
 

src/config.rs

@@ -258,7 +258,7 @@ impl<'a> Cfg<'a> {
         process: &'a Process,
     ) -> Result<Self> {
         // Set up the rustup home directory
-        let rustup_dir = utils::rustup_home(process)?;
+        let rustup_dir = process.rustup_home()?;
 
         utils::ensure_dir_exists("home", &rustup_dir, notify_handler.as_ref())?;
 

src/currentprocess.rs

@@ -12,6 +12,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+use anyhow::{Context, Result};
 #[cfg(feature = "test")]
 use tracing::subscriber::DefaultGuard;
 use tracing_subscriber::util::SubscriberInitExt;
@@ -45,6 +46,18 @@ impl Process {
             .map(String::from)
     }
 
+    pub(crate) fn home_dir(&self) -> Option<PathBuf> {
+        home::env::home_dir_with_env(self)
+    }
+
+    pub(crate) fn cargo_home(&self) -> Result<PathBuf> {
+        home::env::cargo_home_with_env(self).context("failed to determine cargo home")
+    }
+
+    pub(crate) fn rustup_home(&self) -> Result<PathBuf> {
+        home::env::rustup_home_with_env(self).context("failed to determine rustup home dir")
+    }
+
     pub fn var(&self, key: &str) -> Result<String, env::VarError> {
         match self {
             Process::OSProcess(_) => env::var(key),

src/toolchain/toolchain.rs

@@ -185,7 +185,7 @@ impl<'a> Toolchain<'a> {
         // versions of Cargo did. Rustup and Cargo should be in sync now (both
         // using the same `home` crate), but this is retained to ensure cargo
         // and rustup agree in older versions.
-        if let Ok(cargo_home) = utils::cargo_home(self.cfg.process) {
+        if let Ok(cargo_home) = self.cfg.process.cargo_home() {
             cmd.env("CARGO_HOME", &cargo_home);
         }
 
@@ -243,7 +243,7 @@ impl<'a> Toolchain<'a> {
         // proxy bins don't exist. We'll just be running whatever happens to
         // be on the PATH.
         let mut path_entries = vec![];
-        if let Ok(cargo_home) = utils::cargo_home(self.cfg.process) {
+        if let Ok(cargo_home) = self.cfg.process.cargo_home() {
             path_entries.push(cargo_home.join("bin"));
         }
 

src/utils/utils.rs

@@ -5,7 +5,6 @@ use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
 
 use anyhow::{anyhow, bail, Context, Result};
-use home::env as home;
 use retry::delay::{jitter, Fibonacci};
 use retry::{retry, OperationResult};
 use sha2::Sha256;
@@ -483,18 +482,6 @@ pub fn current_exe() -> Result<PathBuf> {
     env::current_exe().context(RustupError::LocatingWorkingDir)
 }
 
-pub(crate) fn home_dir(process: &Process) -> Option<PathBuf> {
-    home::home_dir_with_env(process)
-}
-
-pub(crate) fn cargo_home(process: &Process) -> Result<PathBuf> {
-    home::cargo_home_with_env(process).context("failed to determine cargo home")
-}
-
-pub(crate) fn rustup_home(process: &Process) -> Result<PathBuf> {
-    home::rustup_home_with_env(process).context("failed to determine rustup home dir")
-}
-
 pub(crate) fn format_path_for_display(path: &str) -> String {
     let unc_present = path.find(r"\\?\");