Simplify process access to environment variables

Author: djc

src/bin/rustup-init.rs

@@ -26,7 +26,7 @@ use rustup::cli::rustup_mode;
 #[cfg(windows)]
 use rustup::cli::self_update;
 use rustup::cli::setup_mode;
-use rustup::currentprocess::{process, varsource::VarSource, with, OSProcess};
+use rustup::currentprocess::{process, with, OSProcess};
 use rustup::env_var::RUST_RECURSION_COUNT_MAX;
 use rustup::is_proxyable_tools;
 use rustup::utils::utils;

src/cli/common.rs

@@ -14,7 +14,7 @@ use once_cell::sync::Lazy;
 
 use super::self_update;
 use crate::cli::download_tracker::DownloadTracker;
-use crate::currentprocess::{terminalsource, varsource::VarSource};
+use crate::currentprocess::terminalsource;
 use crate::dist::dist::{TargetTriple, ToolchainDesc};
 use crate::install::UpdateStatus;
 use crate::utils::notifications as util_notifications;

src/cli/log.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 use std::io::Write;
 
-use crate::currentprocess::{process, terminalsource, varsource::VarSource};
+use crate::currentprocess::{process, terminalsource};
 
 macro_rules! warn {
     ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::warn_fmt ( format_args ! ( $ ( $ arg ) * ) ) )

src/cli/rustup_mode.rs

@@ -1622,8 +1622,6 @@ fn doc(cfg: &Cfg, m: &ArgMatches) -> Result<utils::ExitCode> {
 
 #[cfg(not(windows))]
 fn man(cfg: &Cfg, m: &ArgMatches) -> Result<utils::ExitCode> {
-    use crate::currentprocess::varsource::VarSource;
-
     let command = m.get_one::<String>("command").unwrap();
 
     let toolchain = explicit_desc_or_dir_toolchain(cfg, m)?;

src/cli/self_update.rs

@@ -65,7 +65,6 @@ use crate::{
         errors::*,
         markdown::md,
     },
-    currentprocess::varsource::VarSource,
     dist::dist::{self, PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc},
     install::UpdateStatus,
     process,

src/cli/self_update/shell.rs

@@ -29,7 +29,7 @@ use std::path::PathBuf;
 use anyhow::{bail, Result};
 
 use super::utils;
-use crate::{currentprocess::varsource::VarSource, process};
+use crate::process;
 
 pub(crate) type Shell = Box<dyn UnixShell>;
 

src/cli/self_update/unix.rs

@@ -5,7 +5,6 @@ use anyhow::{bail, Context, Result};
 
 use super::install_bins;
 use super::shell;
-use crate::currentprocess::varsource::VarSource;
 use crate::process;
 use crate::utils::utils;
 use crate::utils::Notification;

src/config.rs

@@ -12,7 +12,6 @@ use thiserror::Error as ThisError;
 
 use crate::{
     cli::self_update::SelfUpdateMode,
-    currentprocess::varsource::VarSource,
     dist::{
         dist::{self, PartialToolchainDesc, Profile, ToolchainDesc},
         download::DownloadCfg,

src/currentprocess.rs

@@ -22,10 +22,8 @@ pub mod cwdsource;
 pub mod filesource;
 mod homethunk;
 pub mod terminalsource;
-pub mod varsource;
 
 use cwdsource::*;
-use varsource::*;
 
 use crate::utils::tty::{stderr_isatty, stdout_isatty};
 
@@ -64,11 +62,11 @@ use crate::utils::tty::{stderr_isatty, stdout_isatty};
 /// methods are in performance critical loops (except perhaps progress bars -
 /// and even there we should be doing debouncing and managing update rates).
 #[enum_dispatch]
-pub trait CurrentProcess: CurrentDirSource + VarSource + Debug {}
+pub trait CurrentProcess: CurrentDirSource + Debug {}
 
 /// Allows concrete types for the currentprocess abstraction.
 #[derive(Clone, Debug)]
-#[enum_dispatch(CurrentProcess, CurrentDirSource, VarSource)]
+#[enum_dispatch(CurrentProcess, CurrentDirSource)]
 pub enum Process {
     OSProcess(OSProcess),
     #[cfg(feature = "test")]
@@ -89,6 +87,25 @@ impl Process {
             .map(String::from)
     }
 
+    pub fn var(&self, key: &str) -> Result<String, env::VarError> {
+        match self {
+            Process::OSProcess(_) => env::var(key),
+            #[cfg(feature = "test")]
+            Process::TestProcess(p) => match p.vars.get(key) {
+                Some(val) => Ok(val.to_owned()),
+                None => Err(env::VarError::NotPresent),
+            },
+        }
+    }
+
+    pub(crate) fn var_os(&self, key: &str) -> Option<OsString> {
+        match self {
+            Process::OSProcess(_) => env::var_os(key),
+            #[cfg(feature = "test")]
+            Process::TestProcess(p) => p.vars.get(key).map(OsString::from),
+        }
+    }
+
     pub(crate) fn args(&self) -> Box<dyn Iterator<Item = String> + '_> {
         match self {
             Process::OSProcess(_) => Box::new(env::args()),

src/currentprocess/homethunk.rs

@@ -5,56 +5,30 @@ use std::path::PathBuf;
 
 use home::env as home;
 
-use super::OSProcess;
-use super::Process;
-#[cfg(feature = "test")]
-use super::{CurrentDirSource, TestProcess, VarSource};
+use super::{CurrentDirSource, Process};
 
 impl home::Env for Process {
     fn home_dir(&self) -> Option<PathBuf> {
         match self {
-            Process::OSProcess(p) => p.home_dir(),
+            Process::OSProcess(_) => self.var("HOME").ok().map(|v| v.into()),
             #[cfg(feature = "test")]
-            Process::TestProcess(p) => p.home_dir(),
+            Process::TestProcess(_) => home::OS_ENV.home_dir(),
         }
     }
+
     fn current_dir(&self) -> Result<PathBuf, io::Error> {
         match self {
-            Process::OSProcess(p) => home::Env::current_dir(p),
+            Process::OSProcess(_) => CurrentDirSource::current_dir(self),
             #[cfg(feature = "test")]
-            Process::TestProcess(p) => home::Env::current_dir(p),
+            Process::TestProcess(_) => home::OS_ENV.current_dir(),
         }
     }
+
     fn var_os(&self, key: &str) -> Option<OsString> {
         match self {
-            Process::OSProcess(p) => home::Env::var_os(p, key),
+            Process::OSProcess(_) => self.var_os(key),
             #[cfg(feature = "test")]
-            Process::TestProcess(p) => home::Env::var_os(p, key),
+            Process::TestProcess(_) => self.var_os(key),
         }
     }
 }
-
-#[cfg(feature = "test")]
-impl home::Env for TestProcess {
-    fn home_dir(&self) -> Option<PathBuf> {
-        self.var("HOME").ok().map(|v| v.into())
-    }
-    fn current_dir(&self) -> Result<PathBuf, io::Error> {
-        CurrentDirSource::current_dir(self)
-    }
-    fn var_os(&self, key: &str) -> Option<OsString> {
-        VarSource::var_os(self, key)
-    }
-}
-
-impl home::Env for OSProcess {
-    fn home_dir(&self) -> Option<PathBuf> {
-        home::OS_ENV.home_dir()
-    }
-    fn current_dir(&self) -> Result<PathBuf, io::Error> {
-        home::OS_ENV.current_dir()
-    }
-    fn var_os(&self, key: &str) -> Option<OsString> {
-        home::OS_ENV.var_os(key)
-    }
-}