Replace non_empty_env_var() with Process::var_opt()

Author: djc

src/cli/self_update.rs

@@ -56,7 +56,7 @@ use crate::{
         errors::*,
         markdown::md,
     },
-    config::{Cfg, non_empty_env_var},
+    config::Cfg,
     dist::{self, PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc},
     errors::RustupError,
     install::UpdateStatus,
@@ -1174,11 +1174,12 @@ pub(crate) async fn prepare_update(process: &Process) -> Result<Option<PathBuf>>
 
     // Get available version
     info!("checking for self-update (current version: {current_version})");
-    let available_version = if let Some(ver) = non_empty_env_var("RUSTUP_VERSION", process)? {
-        info!("`RUSTUP_VERSION` has been set to `{ver}`");
-        ver
-    } else {
-        get_available_rustup_version(process).await?
+    let available_version = match process.var_opt("RUSTUP_VERSION")? {
+        Some(ver) => {
+            info!("`RUSTUP_VERSION` has been set to `{ver}`");
+            ver
+        }
+        None => get_available_rustup_version(process).await?,
     };
 
     // If up-to-date

src/config.rs

@@ -1,8 +1,8 @@
 use std::fmt::{self, Debug, Display};
+use std::io;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
-use std::{env, io};
 
 use anyhow::{Context, Result, anyhow, bail};
 use serde::Deserialize;
@@ -282,11 +282,12 @@ impl<'a> Cfg<'a> {
         let default_host_triple =
             settings_file.with(|s| Ok(get_default_host_triple(s, process)))?;
         // Environment override
-        let env_override = non_empty_env_var("RUSTUP_TOOLCHAIN", process)?
-            .map(ResolvableLocalToolchainName::try_from)
-            .transpose()?
-            .map(|t| t.resolve(&default_host_triple))
-            .transpose()?;
+        let env_override = match process.var_opt("RUSTUP_TOOLCHAIN")? {
+            Some(tc) => {
+                Some(ResolvableLocalToolchainName::try_from(&tc)?.resolve(&default_host_triple)?)
+            }
+            None => None,
+        };
 
         let dist_root_server = dist_root_server(process)?;
 
@@ -982,22 +983,21 @@ impl<'a> Cfg<'a> {
 /// The root path of the release server, without the `/dist` suffix.
 /// By default, it points to [`dist::DEFAULT_DIST_SERVER`].
 pub(crate) fn dist_root_server(process: &Process) -> Result<String> {
-    Ok(
-        if let Some(s) = non_empty_env_var("RUSTUP_DIST_SERVER", process)? {
-            trace!("`RUSTUP_DIST_SERVER` has been set to `{s}`");
-            s
-        }
-        // For backwards compatibility
-        else if let Some(mut root) = non_empty_env_var("RUSTUP_DIST_ROOT", process)? {
-            trace!("`RUSTUP_DIST_ROOT` has been set to `{root}`");
-            if let Some(stripped) = root.strip_suffix("/dist") {
-                root.truncate(stripped.len());
-            }
-            root
-        } else {
-            dist::DEFAULT_DIST_SERVER.to_owned()
-        },
-    )
+    if let Some(s) = process.var_opt("RUSTUP_DIST_SERVER")? {
+        trace!("`RUSTUP_DIST_SERVER` has been set to `{s}`");
+        return Ok(s);
+    }
+
+    // For backwards compatibility
+    let Some(mut root) = process.var_opt("RUSTUP_DIST_ROOT")? else {
+        return Ok(dist::DEFAULT_DIST_SERVER.to_owned());
+    };
+
+    trace!("`RUSTUP_DIST_ROOT` has been set to `{root}`");
+    if let Some(stripped) = root.strip_suffix("/dist") {
+        root.truncate(stripped.len());
+    }
+    Ok(root)
 }
 
 impl Debug for Cfg<'_> {
@@ -1043,15 +1043,6 @@ fn get_default_host_triple(s: &Settings, process: &Process) -> TargetTriple {
         .unwrap_or_else(|| TargetTriple::from_host_or_build(process))
 }
 
-pub(crate) fn non_empty_env_var(name: &str, process: &Process) -> anyhow::Result<Option<String>> {
-    match process.var(name) {
-        Ok(s) if !s.is_empty() => Ok(Some(s)),
-        Ok(_) => Ok(None),
-        Err(env::VarError::NotPresent) => Ok(None),
-        Err(err) => Err(err.into()),
-    }
-}
-
 fn no_toolchain_error(process: &Process) -> anyhow::Error {
     RustupError::ToolchainNotSelected(process.name().unwrap_or_else(|| "Rust".into())).into()
 }

src/process.rs

@@ -87,6 +87,14 @@ impl Process {
         })
     }
 
+    pub fn var_opt(&self, key: &str) -> Result<Option<String>, env::VarError> {
+        match self.var(key) {
+            Ok(val) => Ok(Some(val)),
+            Err(env::VarError::NotPresent) => Ok(None),
+            Err(err) => Err(err),
+        }
+    }
+
     pub fn var(&self, key: &str) -> Result<String, env::VarError> {
         let value = match self {
             Process::OsProcess(_) => env::var(key)?,