Rename currentprocess module to process

djc · djc · commit 5c986946cb24 · 2024-04-09T16:17:23.000+02:00
diff --git a/src/bin/rustup-init.rs b/src/bin/rustup-init.rs
@@ -26,9 +26,9 @@ use rustup::cli::rustup_mode;
 #[cfg(windows)]
 use rustup::cli::self_update;
 use rustup::cli::setup_mode;
-use rustup::currentprocess::{process, with, Process};
 use rustup::env_var::RUST_RECURSION_COUNT_MAX;
 use rustup::is_proxyable_tools;
+use rustup::process::{process, with, Process};
 use rustup::utils::utils;
 
 fn main() {
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -14,9 +14,9 @@ use once_cell::sync::Lazy;
 
 use super::self_update;
 use crate::cli::download_tracker::DownloadTracker;
-use crate::currentprocess::terminalsource;
 use crate::dist::dist::{TargetTriple, ToolchainDesc};
 use crate::install::UpdateStatus;
+use crate::process::terminalsource;
 use crate::utils::notifications as util_notifications;
 use crate::utils::notify::NotificationLevel;
 use crate::utils::utils;
diff --git a/src/cli/download_tracker.rs b/src/cli/download_tracker.rs
@@ -4,8 +4,8 @@ use std::io::Write;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use crate::currentprocess::{process, terminalsource};
 use crate::dist::Notification as In;
+use crate::process::{process, terminalsource};
 use crate::utils::units::{Size, Unit, UnitMode};
 use crate::utils::Notification as Un;
 use crate::Notification;
diff --git a/src/cli/log.rs b/src/cli/log.rs
@@ -1,7 +1,7 @@
 use std::fmt;
 use std::io::Write;
 
-use crate::currentprocess::{process, terminalsource};
+use crate::process::{process, terminalsource};
 
 macro_rules! warn {
     ( $ ( $ arg : tt ) * ) => ( $crate::cli::log::warn_fmt ( format_args ! ( $ ( $ arg ) * ) ) )
diff --git a/src/cli/markdown.rs b/src/cli/markdown.rs
@@ -3,7 +3,7 @@ use std::io::Write;
 
 use pulldown_cmark::{Event, Tag, TagEnd};
 
-use crate::currentprocess::terminalsource::{Attr, Color, ColorableTerminal};
+use crate::process::terminalsource::{Attr, Color, ColorableTerminal};
 
 // Handles the wrapping of text written to the console
 struct LineWrapper<'a> {
diff --git a/src/cli/self_update.rs b/src/cli/self_update.rs
@@ -58,7 +58,7 @@ use anyhow::{anyhow, Context, Result};
 use cfg_if::cfg_if;
 use same_file::Handle;
 
-use crate::currentprocess::terminalsource;
+use crate::process::terminalsource;
 use crate::{
     cli::{
         common::{self, ignorable_error, report_error, Confirm, PackageUpdate},
@@ -1306,18 +1306,18 @@ mod tests {
     use crate::cli::common;
     use crate::dist::dist::PartialToolchainDesc;
     use crate::test::{test_dir, with_rustup_home, Env};
-    use crate::{currentprocess, for_host};
+    use crate::{for_host, process};
 
     #[test]
     fn default_toolchain_is_stable() {
         with_rustup_home(|home| {
             let mut vars = HashMap::new();
             home.apply(&mut vars);
-            let tp = currentprocess::TestProcess {
+            let tp = process::TestProcess {
                 vars,
                 ..Default::default()
             };
-            currentprocess::with(tp.clone().into(), || -> Result<()> {
+            process::with(tp.clone().into(), || -> Result<()> {
                 // TODO: we could pass in a custom cfg to get notification
                 // callbacks rather than output to the tp sink.
                 let mut cfg = common::set_globals(false, false).unwrap();
@@ -1360,11 +1360,11 @@ info: default host triple is {0}
         let cargo_home = root_dir.path().join("cargo");
         let mut vars = HashMap::new();
         vars.env("CARGO_HOME", cargo_home.to_string_lossy().to_string());
-        let tp = currentprocess::TestProcess {
+        let tp = process::TestProcess {
             vars,
             ..Default::default()
         };
-        currentprocess::with(tp.into(), || -> Result<()> {
+        process::with(tp.into(), || -> Result<()> {
             super::install_bins().unwrap();
             Ok(())
         })
diff --git a/src/cli/self_update/windows.rs b/src/cli/self_update/windows.rs
@@ -712,7 +712,7 @@ mod tests {
 
     use rustup_macros::unit_test as test;
 
-    use crate::currentprocess;
+    use crate::process;
     use crate::test::with_saved_path;
 
     fn wide(str: &str) -> Vec<u16> {
@@ -753,9 +753,9 @@ mod tests {
     #[test]
     fn windows_path_regkey_type() {
         // per issue #261, setting PATH should use REG_EXPAND_SZ.
-        let tp = currentprocess::TestProcess::default();
+        let tp = process::TestProcess::default();
         with_saved_path(&mut || {
-            currentprocess::with(tp.clone().into(), || {
+            process::with(tp.clone().into(), || {
                 let root = RegKey::predef(HKEY_CURRENT_USER);
                 let environment = root
                     .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
@@ -783,9 +783,9 @@ mod tests {
         use std::io;
         // during uninstall the PATH key may end up empty; if so we should
         // delete it.
-        let tp = currentprocess::TestProcess::default();
+        let tp = process::TestProcess::default();
         with_saved_path(&mut || {
-            currentprocess::with(tp.clone().into(), || {
+            process::with(tp.clone().into(), || {
                 let root = RegKey::predef(HKEY_CURRENT_USER);
                 let environment = root
                     .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
@@ -818,15 +818,15 @@ mod tests {
     #[test]
     fn windows_doesnt_mess_with_a_non_string_path() {
         // This writes an error, so we want a sink for it.
-        let tp = currentprocess::TestProcess {
+        let tp = process::TestProcess {
             vars: [("HOME".to_string(), "/unused".to_string())]
                 .iter()
                 .cloned()
                 .collect(),
             ..Default::default()
         };
         with_saved_path(&mut || {
-            currentprocess::with(tp.clone().into(), || {
+            process::with(tp.clone().into(), || {
                 let root = RegKey::predef(HKEY_CURRENT_USER);
                 let environment = root
                     .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
@@ -853,9 +853,9 @@ mod tests {
     #[test]
     fn windows_treat_missing_path_as_empty() {
         // during install the PATH key may be missing; treat it as empty
-        let tp = currentprocess::TestProcess::default();
+        let tp = process::TestProcess::default();
         with_saved_path(&mut || {
-            currentprocess::with(tp.clone().into(), || {
+            process::with(tp.clone().into(), || {
                 let root = RegKey::predef(HKEY_CURRENT_USER);
                 let environment = root
                     .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
diff --git a/src/diskio/test.rs b/src/diskio/test.rs
@@ -7,7 +7,7 @@ use rustup_macros::unit_test as test;
 use crate::test::test_dir;
 
 use super::{get_executor, Executor, Item, Kind};
-use crate::currentprocess;
+use crate::process;
 
 impl Item {
     /// The length of the file, for files (for stats)
@@ -23,11 +23,11 @@ fn test_incremental_file(io_threads: &str) -> Result<()> {
     let work_dir = test_dir()?;
     let mut vars = HashMap::new();
     vars.insert("RUSTUP_IO_THREADS".to_string(), io_threads.to_string());
-    let tp = currentprocess::TestProcess {
+    let tp = process::TestProcess {
         vars,
         ..Default::default()
     };
-    currentprocess::with(tp.into(), || -> Result<()> {
+    process::with(tp.into(), || -> Result<()> {
         let mut written = 0;
         let mut file_finished = false;
         let mut io_executor: Box<dyn Executor> = get_executor(None, 32 * 1024 * 1024)?;
@@ -96,11 +96,11 @@ fn test_complete_file(io_threads: &str) -> Result<()> {
     let work_dir = test_dir()?;
     let mut vars = HashMap::new();
     vars.insert("RUSTUP_IO_THREADS".to_string(), io_threads.to_string());
-    let tp = currentprocess::TestProcess {
+    let tp = process::TestProcess {
         vars,
         ..Default::default()
     };
-    currentprocess::with(tp.into(), || -> Result<()> {
+    process::with(tp.into(), || -> Result<()> {
         let mut io_executor: Box<dyn Executor> = get_executor(None, 32 * 1024 * 1024)?;
         let mut chunk = io_executor.get_buffer(10);
         chunk.extend(b"0123456789");
diff --git a/src/diskio/threaded.rs b/src/diskio/threaded.rs
@@ -305,7 +305,7 @@ impl<'a> Executor for Threaded<'a> {
         self.tx
             .send(Task::Sentinel)
             .expect("must still be listening");
-        if crate::currentprocess::process().var("RUSTUP_DEBUG").is_ok() {
+        if crate::process::process().var("RUSTUP_DEBUG").is_ok() {
             // debug! is in the cli layer. erg. And notification stack is still terrible.
             debug!("");
             for (bucket, pool) in &self.vec_pools {
diff --git a/src/dist/manifestation/tests.rs b/src/dist/manifestation/tests.rs
@@ -16,7 +16,6 @@ use url::Url;
 use rustup_macros::unit_test as test;
 
 use crate::{
-    currentprocess,
     dist::{
         dist::{Profile, TargetTriple, ToolchainDesc, DEFAULT_DIST_SERVER},
         download::DownloadCfg,
@@ -26,6 +25,7 @@ use crate::{
         temp, Notification,
     },
     errors::RustupError,
+    process,
     test::mock::{dist::*, MockComponentBuilder, MockFile, MockInstallerBuilder},
     utils::{raw as utils_raw, utils},
 };
@@ -556,8 +556,8 @@ fn setup_from_dist_server(
         },
     };
 
-    currentprocess::with(
-        currentprocess::TestProcess::new(
+    process::with(
+        process::TestProcess::new(
             env::current_dir().unwrap(),
             &["rustup"],
             HashMap::default(),
diff --git a/src/env_var.rs b/src/env_var.rs
@@ -44,7 +44,7 @@ mod tests {
     use rustup_macros::unit_test as test;
 
     use super::*;
-    use crate::currentprocess;
+    use crate::process;
     use crate::test::{with_saved_path, Env};
 
     #[test]
@@ -54,12 +54,12 @@ mod tests {
             "PATH",
             env::join_paths(["/home/a/.cargo/bin", "/home/b/.cargo/bin"].iter()).unwrap(),
         );
-        let tp = currentprocess::TestProcess {
+        let tp = process::TestProcess {
             vars,
             ..Default::default()
         };
         with_saved_path(&mut || {
-            currentprocess::with(tp.clone().into(), || {
+            process::with(tp.clone().into(), || {
                 let mut path_entries = vec![];
                 let mut cmd = Command::new("test");
 
diff --git a/src/errors.rs b/src/errors.rs
@@ -11,8 +11,8 @@ use thiserror::Error as ThisError;
 use url::Url;
 
 use crate::{
-    currentprocess::process,
     dist::dist::{TargetTriple, ToolchainDesc},
+    process::process,
 };
 use crate::{
     dist::manifest::{Component, Manifest},
diff --git a/src/lib.rs b/src/lib.rs
@@ -11,9 +11,9 @@
 #![recursion_limit = "1024"]
 
 pub(crate) use crate::config::*;
-use crate::currentprocess::*;
 pub use crate::errors::*;
 pub(crate) use crate::notifications::*;
+use crate::process::*;
 pub(crate) use crate::utils::toml_utils;
 use anyhow::{anyhow, Result};
 use itertools::{chain, Itertools};
@@ -80,14 +80,14 @@ fn component_for_bin(binary: &str) -> Option<&'static str> {
 pub mod cli;
 mod command;
 mod config;
-pub mod currentprocess;
 mod diskio;
 pub mod dist;
 pub mod env_var;
 pub mod errors;
 mod fallback_settings;
 mod install;
 pub mod notifications;
+pub mod process;
 mod settings;
 #[cfg(feature = "test")]
 pub mod test;
diff --git a/src/process/filesource.rs b/src/process/filesource.rs
@@ -1,7 +1,7 @@
 use std::io::{self, BufRead, Cursor, Read, Result, Write};
 use std::sync::{Arc, Mutex, MutexGuard};
 
-use crate::currentprocess::process;
+use crate::process::process;
 
 use super::terminalsource::{ColorableTerminal, StreamSelector};
 
@@ -93,9 +93,9 @@ impl WriterLock for io::StdoutLock<'_> {}
 impl Writer for io::Stdout {
     fn is_a_tty(&self) -> bool {
         match process() {
-            crate::currentprocess::Process::Os(p) => p.stdout_is_a_tty,
+            crate::process::Process::Os(p) => p.stdout_is_a_tty,
             #[cfg(feature = "test")]
-            crate::currentprocess::Process::Test(_) => unreachable!(),
+            crate::process::Process::Test(_) => unreachable!(),
         }
     }
 
@@ -113,9 +113,9 @@ impl WriterLock for io::StderrLock<'_> {}
 impl Writer for io::Stderr {
     fn is_a_tty(&self) -> bool {
         match process() {
-            crate::currentprocess::Process::Os(p) => p.stderr_is_a_tty,
+            crate::process::Process::Os(p) => p.stderr_is_a_tty,
             #[cfg(feature = "test")]
-            crate::currentprocess::Process::Test(_) => unreachable!(),
+            crate::process::Process::Test(_) => unreachable!(),
         }
     }
 
diff --git a/src/process/mod.rs b/src/process/mod.rs
diff --git a/src/process/terminalsource.rs b/src/process/terminalsource.rs
@@ -244,18 +244,18 @@ mod tests {
     use rustup_macros::unit_test as test;
 
     use super::*;
-    use crate::{currentprocess, test::Env};
+    use crate::{process, test::Env};
 
     #[test]
     fn term_color_choice() {
         fn assert_color_choice(env_val: &str, stream: StreamSelector, color_choice: ColorChoice) {
             let mut vars = HashMap::new();
             vars.env("RUSTUP_TERM_COLOR", env_val);
-            let tp = currentprocess::TestProcess {
+            let tp = process::TestProcess {
                 vars,
                 ..Default::default()
             };
-            currentprocess::with(tp.into(), || {
+            process::with(tp.into(), || {
                 let term = ColorableTerminal::new(stream);
                 let inner = term.inner.lock().unwrap();
                 assert!(matches!(
diff --git a/src/test.rs b/src/test.rs
@@ -16,8 +16,8 @@ use std::process::Command;
 use anyhow::Result;
 
 pub use crate::cli::self_update::test::{get_path, with_saved_path};
-use crate::currentprocess;
 use crate::dist::dist::TargetTriple;
+use crate::process;
 
 // Things that can have environment variables applied to them.
 pub trait Env {
@@ -124,8 +124,8 @@ pub fn this_host_triple() -> String {
         // For windows, this host may be different to the target: we may be
         // building with i686 toolchain, but on an x86_64 host, so run the
         // actual detection logic and trust it.
-        let tp = currentprocess::TestProcess::default();
-        return currentprocess::with(tp.into(), || TargetTriple::from_host().unwrap().to_string());
+        let tp = process::TestProcess::default();
+        return process::with(tp.into(), || TargetTriple::from_host().unwrap().to_string());
     }
     let arch = if cfg!(target_arch = "x86") {
         "i686"
diff --git a/src/test/mock/clitools.rs b/src/test/mock/clitools.rs
@@ -19,7 +19,7 @@ use once_cell::sync::Lazy;
 use url::Url;
 
 use crate::cli::rustup_mode;
-use crate::currentprocess;
+use crate::process;
 use crate::test as rustup_test;
 use crate::test::const_dist_dir;
 use crate::test::this_host_triple;
@@ -721,13 +721,13 @@ impl Config {
                     .into_boxed_str(),
             );
         }
-        let tp = currentprocess::TestProcess::new(&*self.workdir.borrow(), &arg_strings, vars, "");
-        let process_res = currentprocess::with(tp.clone().into(), rustup_mode::main);
+        let tp = process::TestProcess::new(&*self.workdir.borrow(), &arg_strings, vars, "");
+        let process_res = process::with(tp.clone().into(), rustup_mode::main);
         // convert Err's into an ec
         let ec = match process_res {
             Ok(process_res) => process_res,
             Err(e) => {
-                currentprocess::with(tp.clone().into(), || crate::cli::common::report_error(&e));
+                process::with(tp.clone().into(), || crate::cli::common::report_error(&e));
                 utils::ExitCode(1)
             }
         };
diff --git a/src/toolchain/toolchain.rs b/src/toolchain/toolchain.rs
