Implement the TraitLike trait for ColorableTerminal

The `ColorableTerminal` now has the `TermLike` trait.
If we are not in a *tty* the progress will be hidden and will instead be
printed after every channel is checked for updates.

NB: since we are using `indicatif` to display progress, when running in
a *tty*, we can use `buffer_unordered` instead of `buffered`, as
`indicatif` already handles the output in the correct order.

Author: FranciscoTGouveia

Cargo.lock

@@ -46,6 +46,7 @@ cfg-if = "1.0"
 chrono = { version = "0.4", default-features = false, features = ["std"] }
 clap = { version = "4", features = ["derive", "wrap_help"] }
 clap_complete = "4"
+console = "0.16"
 curl = { version = "0.4.44", optional = true }
 effective-limits = "0.5.5"
 enum-map = "2.5.0"

Cargo.toml

@@ -792,12 +792,17 @@ async fn default_(
 }
 
 async fn check_updates(cfg: &Cfg<'_>, opts: CheckOpts) -> Result<utils::ExitCode> {
+    let t = cfg.process.stdout().terminal(cfg.process);
+    let is_a_tty = t.is_a_tty();
     let mut update_available = false;
     let channels = cfg.list_channels()?;
     let num_channels = channels.len();
     if num_channels > 0 {
-        let mp = MultiProgress::with_draw_target(ProgressDrawTarget::stdout());
-
+        let mp = if is_a_tty {
+            MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(t)))
+        } else {
+            MultiProgress::with_draw_target(ProgressDrawTarget::hidden())
+        };
         let progress_bars: Vec<_> = channels
             .iter()
             .map(|(name, _)| {
@@ -819,40 +824,40 @@ async fn check_updates(cfg: &Cfg<'_>, opts: CheckOpts) -> Result<utils::ExitCode
                 let dist_version = distributable.show_dist_version().await?;
                 let mut update_a = false;
 
-                let (message, style) = match (current_version, dist_version) {
+                let message = match (current_version, dist_version) {
                     (None, None) => {
-                        let msg =
-                            format!("{} - Cannot identify installed or update versions", name);
-                        let style = ProgressStyle::with_template("{msg}").unwrap();
-                        (msg, style)
+                        format!("{} - Cannot identify installed or update versions", name)
                     }
                     (Some(cv), None) => {
-                        let msg = format!("{} - Up to date : {}", name, cv);
-                        let style = ProgressStyle::with_template("{msg}").unwrap();
-                        (msg, style)
+                        format!("{} - Up to date : {}", name, cv)
                     }
                     (Some(cv), Some(dv)) => {
                         update_a = true;
-                        let msg = format!("{} - Update available : {} -> {}", name, cv, dv);
-                        let style = ProgressStyle::with_template("{msg}").unwrap();
-                        (msg, style)
+                        format!("{} - Update available : {} -> {}", name, cv, dv)
                     }
                     (None, Some(dv)) => {
                         update_a = true;
-                        let msg =
-                            format!("{} - Update available : (Unknown version) -> {}", name, dv);
-                        let style = ProgressStyle::with_template("{msg}").unwrap();
-                        (msg, style)
+                        format!("{} - Update available : (Unknown version) -> {}", name, dv)
                     }
                 };
-                pb.set_style(style);
-                pb.finish_with_message(message);
-                Ok::<bool, Error>(update_a)
+                pb.set_style(ProgressStyle::with_template("{msg}").unwrap());
+                pb.finish_with_message(message.clone());
+                Ok::<(bool, String), Error>((update_a, message))
             })
-            .buffered(num_channels)
+            .buffered(num_channels) //TODO: this could be buffer_unordered as we are using `indicatif`
             .collect::<Vec<_>>()
             .await;
-        update_available = channels.into_iter().any(|r| r.unwrap_or(false));
+
+        let t = cfg.process.stdout().terminal(cfg.process);
+        for result in channels.into_iter() {
+            let (update_a, message) = result?;
+            if update_a {
+                update_available = true;
+            }
+            if !is_a_tty {
+                writeln!(t.lock(), "{}", message)?;
+            }
+        }
     }
     let self_update_mode = cfg.get_self_update_mode()?;
     // Priority: no-self-update feature > self_update_mode > no-self-update args.

src/cli/rustup_mode.rs

@@ -1,3 +1,5 @@
+use console::Term;
+use indicatif::TermLike;
 use std::{
     io::{self, Write},
     mem::MaybeUninit,
@@ -53,6 +55,7 @@ pub struct ColorableTerminal {
     // source is important because otherwise parallel constructed terminals
     // would not be locked out.
     inner: Arc<Mutex<TerminalInner>>,
+    is_a_tty: bool,
 }
 
 /// Internal state for ColorableTerminal
@@ -84,10 +87,11 @@ impl ColorableTerminal {
     /// then color commands will be sent to the stream.
     /// Otherwise color commands are discarded.
     pub(super) fn new(stream: StreamSelector, process: &Process) -> Self {
+        let is_a_tty = stream.is_a_tty(process);
         let choice = match process.var("RUSTUP_TERM_COLOR") {
             Ok(s) if s.eq_ignore_ascii_case("always") => ColorChoice::Always,
             Ok(s) if s.eq_ignore_ascii_case("never") => ColorChoice::Never,
-            _ if stream.is_a_tty(process) => ColorChoice::Auto,
+            _ if is_a_tty => ColorChoice::Auto,
             _ => ColorChoice::Never,
         };
         let inner = match stream {
@@ -104,6 +108,7 @@ impl ColorableTerminal {
         };
         ColorableTerminal {
             inner: Arc::new(Mutex::new(inner)),
+            is_a_tty,
         }
     }
 
@@ -179,6 +184,10 @@ impl ColorableTerminal {
         };
         Ok(())
     }
+
+    pub fn is_a_tty(&self) -> bool {
+        self.is_a_tty
+    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -223,6 +232,81 @@ impl io::Write for ColorableTerminalLocked {
     }
 }
 
+impl TermLike for ColorableTerminal {
+    fn width(&self) -> u16 {
+        Term::stdout().size().1
+    }
+
+    fn move_cursor_up(&self, n: usize) -> io::Result<()> {
+        // As the ProgressBar may try to move the cursor up by 0 lines,
+        // we need to handle that case to avoid writing an escape sequence
+        // that would mess up the terminal.
+        if n == 0 {
+            return Ok(());
+        }
+        let mut t = self.lock();
+        write!(t, "\x1b[{}A", n)?;
+        t.flush()
+    }
+
+    fn move_cursor_down(&self, n: usize) -> io::Result<()> {
+        if n == 0 {
+            return Ok(());
+        }
+        let mut t = self.lock();
+        write!(t, "\x1b[{}B", n)?;
+        t.flush()
+    }
+
+    fn move_cursor_right(&self, n: usize) -> io::Result<()> {
+        if n == 0 {
+            return Ok(());
+        }
+        let mut t = self.lock();
+        write!(t, "\x1b[{}C", n)?;
+        t.flush()
+    }
+
+    fn move_cursor_left(&self, n: usize) -> io::Result<()> {
+        if n == 0 {
+            return Ok(());
+        }
+        let mut t = self.lock();
+        write!(t, "\x1b[{}D", n)?;
+        t.flush()
+    }
+
+    fn write_line(&self, line: &str) -> io::Result<()> {
+        let mut t = self.lock();
+        t.write_all(line.as_bytes())?;
+        t.write_all(b"\n")?;
+        t.flush()
+    }
+
+    fn write_str(&self, s: &str) -> io::Result<()> {
+        let mut t = self.lock();
+        t.write_all(s.as_bytes())?;
+        t.flush()
+    }
+
+    fn clear_line(&self) -> io::Result<()> {
+        let mut t = self.lock();
+        t.write_all(b"\r\x1b[2K")?;
+        t.flush()
+    }
+
+    fn flush(&self) -> io::Result<()> {
+        let mut t = self.lock();
+        t.flush()
+    }
+}
+
+impl std::fmt::Debug for ColorableTerminal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ColorableTerminal {{ inner: ... }}")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;