Replace term with termcolor

Signed-off-by: hi-rustin <rustin.liu@gmail.com>

Author: 0xPoe

Cargo.lock

@@ -42,11 +42,12 @@ otel = [
 ]
 
 # Exports code dependent on private interfaces for the integration test suite
-test = ["dep:once_cell", "dep:walkdir"]
+test = ["dep:walkdir"]
 
 # Sorted by alphabetic order
 [dependencies]
 anyhow.workspace = true
+atty = "0.2.14"
 cfg-if = "1.0"
 chrono = "0.4"
 clap = { version = "3", features = ["wrap_help"] }
@@ -62,7 +63,7 @@ home = "0.5.4"
 lazy_static.workspace = true
 libc = "0.2"
 num_cpus = "1.15"
-once_cell = { workspace = true, optional = true }
+once_cell = { workspace = true }
 opener = "0.6.0"
 opentelemetry = { workspace = true, optional = true }
 opentelemetry-otlp = { workspace = true, optional = true }
@@ -79,7 +80,7 @@ sharded-slab = "0.1.1"
 strsim = "0.10"
 tar = "0.4.26"
 tempfile.workspace = true
-term = "=0.5.1" # FIXME(issue #1818, #1826, and friends)
+termcolor = "1.2"
 thiserror.workspace = true
 threadpool = "1"
 tokio = { workspace = true, optional = true }

Cargo.toml

@@ -11,5 +11,5 @@ pub mod proxy_mode;
 pub mod rustup_mode;
 pub mod self_update;
 pub mod setup_mode;
-mod term2;
+pub(crate) mod term;
 mod topical_doc;

src/cli.rs

@@ -10,10 +10,9 @@ use std::{cmp, env};
 use anyhow::{anyhow, Context, Result};
 use git_testament::{git_testament, render_testament};
 use lazy_static::lazy_static;
-use term2::Terminal;
 
 use super::self_update;
-use super::term2;
+use super::term;
 use crate::utils::notifications as util_notifications;
 use crate::utils::notify::NotificationLevel;
 use crate::utils::utils;
@@ -207,10 +206,10 @@ fn show_channel_updates(
 ) -> Result<()> {
     let data = updates.into_iter().map(|(pkg, result)| {
         let (banner, color) = match &result {
-            Ok(UpdateStatus::Installed) => ("installed", Some(term2::color::GREEN)),
-            Ok(UpdateStatus::Updated(_)) => ("updated", Some(term2::color::GREEN)),
+            Ok(UpdateStatus::Installed) => ("installed", Some(term::Color::Green)),
+            Ok(UpdateStatus::Updated(_)) => ("updated", Some(term::Color::Green)),
             Ok(UpdateStatus::Unchanged) => ("unchanged", None),
-            Err(_) => ("update failed", Some(term2::color::RED)),
+            Err(_) => ("update failed", Some(term::Color::Red)),
         };
 
         let (previous_version, version) = match &pkg {
@@ -248,7 +247,7 @@ fn show_channel_updates(
         Ok((pkg, banner, width, color, version, previous_version))
     });
 
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
 
     let data: Vec<_> = data.collect::<Result<_>>()?;
     let max_width = data
@@ -259,7 +258,7 @@ fn show_channel_updates(
         let padding = max_width - width;
         let padding: String = " ".repeat(padding);
         let _ = write!(t, "  {padding}");
-        let _ = t.attr(term2::Attr::Bold);
+        let _ = t.attr(term::Attr::Bold);
         if let Some(color) = color {
             let _ = t.fg(color);
         }
@@ -369,7 +368,7 @@ where
 }
 
 pub(crate) fn list_targets(distributable: DistributableToolchain<'_>) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
@@ -382,7 +381,7 @@ pub(crate) fn list_targets(distributable: DistributableToolchain<'_>) -> Result<
                 .as_ref()
                 .expect("rust-std should have a target");
             if component.installed {
-                let _ = t.attr(term2::Attr::Bold);
+                let _ = t.attr(term::Attr::Bold);
                 let _ = writeln!(t, "{target} (installed)");
                 let _ = t.reset();
             } else if component.available {
@@ -397,7 +396,7 @@ pub(crate) fn list_targets(distributable: DistributableToolchain<'_>) -> Result<
 pub(crate) fn list_installed_targets(
     distributable: DistributableToolchain<'_>,
 ) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
@@ -420,15 +419,15 @@ pub(crate) fn list_installed_targets(
 pub(crate) fn list_components(
     distributable: DistributableToolchain<'_>,
 ) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
     let components = manifest.query_components(distributable.desc(), &config)?;
     for component in components {
         let name = component.name;
         if component.installed {
-            t.attr(term2::Attr::Bold)?;
+            t.attr(term::Attr::Bold)?;
             writeln!(t, "{name} (installed)")?;
             t.reset()?;
         } else if component.available {
@@ -440,7 +439,7 @@ pub(crate) fn list_components(
 }
 
 pub(crate) fn list_installed_components(distributable: DistributableToolchain<'_>) -> Result<()> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;

src/cli/common.rs

@@ -1,11 +1,8 @@
 use std::collections::VecDeque;
 use std::fmt;
-use std::io::Write;
 use std::time::{Duration, Instant};
 
-use term::Terminal;
-
-use super::term2;
+use super::term;
 use crate::dist::Notification as In;
 use crate::utils::tty;
 use crate::utils::units::{Size, Unit, UnitMode};
@@ -31,11 +28,7 @@ pub(crate) struct DownloadTracker {
     last_sec: Option<Instant>,
     /// Time stamp of the start of the download
     start_sec: Option<Instant>,
-    /// The terminal we write the information to.
-    /// XXX: Could be a term trait, but with #1818 on the horizon that
-    ///      is a pointless change to make - better to let that transition
-    ///      happen and take stock after that.
-    term: term2::StdoutTerminal,
+    term: Box<dyn term::Terminal>,
     /// Whether we displayed progress for the download or not.
     ///
     /// If the download is quick enough, we don't have time to
@@ -61,7 +54,7 @@ impl DownloadTracker {
             downloaded_last_few_secs: VecDeque::with_capacity(DOWNLOAD_TRACK_COUNT),
             start_sec: None,
             last_sec: None,
-            term: term2::stdout(),
+            term: term::stdout(),
             displayed_charcount: None,
             units: vec![Unit::B],
             display_progress: true,

src/cli/download_tracker.rs

@@ -1,8 +1,7 @@
 use std::fmt;
 use std::io::Write;
-use term2::Terminal;
 
-use super::term2;
+use super::term;
 use crate::process;
 
 macro_rules! warn {
@@ -24,38 +23,38 @@ macro_rules! debug {
 }
 
 pub(crate) fn warn_fmt(args: fmt::Arguments<'_>) {
-    let mut t = term2::stderr();
-    let _ = t.fg(term2::color::YELLOW);
-    let _ = t.attr(term2::Attr::Bold);
+    let mut t = term::stderr();
+    let _ = t.fg(term::Color::Yellow);
+    let _ = t.attr(term::Attr::Bold);
     let _ = write!(t, "warning: ");
     let _ = t.reset();
     let _ = t.write_fmt(args);
     let _ = writeln!(t);
 }
 
 pub(crate) fn err_fmt(args: fmt::Arguments<'_>) {
-    let mut t = term2::stderr();
-    let _ = t.fg(term2::color::RED);
-    let _ = t.attr(term2::Attr::Bold);
+    let mut t = term::stderr();
+    let _ = t.fg(term::Color::Red);
+    let _ = t.attr(term::Attr::Bold);
     let _ = write!(t, "error: ");
     let _ = t.reset();
     let _ = t.write_fmt(args);
     let _ = writeln!(t);
 }
 
 pub(crate) fn info_fmt(args: fmt::Arguments<'_>) {
-    let mut t = term2::stderr();
-    let _ = t.attr(term2::Attr::Bold);
+    let mut t = term::stderr();
+    let _ = t.attr(term::Attr::Bold);
     let _ = write!(t, "info: ");
     let _ = t.reset();
     let _ = t.write_fmt(args);
     let _ = writeln!(t);
 }
 
 pub(crate) fn verbose_fmt(args: fmt::Arguments<'_>) {
-    let mut t = term2::stderr();
-    let _ = t.fg(term2::color::MAGENTA);
-    let _ = t.attr(term2::Attr::Bold);
+    let mut t = term::stderr();
+    let _ = t.fg(term::Color::Magenta);
+    let _ = t.attr(term::Attr::Bold);
     let _ = write!(t, "verbose: ");
     let _ = t.reset();
     let _ = t.write_fmt(args);
@@ -64,9 +63,9 @@ pub(crate) fn verbose_fmt(args: fmt::Arguments<'_>) {
 
 pub(crate) fn debug_fmt(args: fmt::Arguments<'_>) {
     if process().var("RUSTUP_DEBUG").is_ok() {
-        let mut t = term2::stderr();
-        let _ = t.fg(term2::color::BLUE);
-        let _ = t.attr(term2::Attr::Bold);
+        let mut t = term::stderr();
+        let _ = t.fg(term::Color::Blue);
+        let _ = t.attr(term::Attr::Bold);
         let _ = write!(t, "debug: ");
         let _ = t.reset();
         let _ = t.write_fmt(args);

src/cli/log.rs

@@ -1,20 +1,17 @@
 // Write Markdown to the terminal
-
-use std::io;
-
 use pulldown_cmark::{Event, Tag};
 
-use super::term2::{color, Attr, Terminal};
+use super::term::{Attr, Color, Terminal};
 
 // Handles the wrapping of text written to the console
-struct LineWrapper<'a, T: Terminal> {
+struct LineWrapper<'a> {
     indent: u32,
     margin: u32,
     pos: u32,
-    w: &'a mut T,
+    w: &'a mut dyn Terminal,
 }
 
-impl<'a, T: Terminal + 'a> LineWrapper<'a, T> {
+impl<'a> LineWrapper<'a> {
     // Just write a newline
     fn write_line(&mut self) {
         let _ = writeln!(self.w);
@@ -81,7 +78,7 @@ impl<'a, T: Terminal + 'a> LineWrapper<'a, T> {
         }
     }
     // Constructor
-    fn new(w: &'a mut T, indent: u32, margin: u32) -> Self {
+    fn new(w: &'a mut dyn Terminal, indent: u32, margin: u32) -> Self {
         LineWrapper {
             indent,
             margin,
@@ -92,14 +89,14 @@ impl<'a, T: Terminal + 'a> LineWrapper<'a, T> {
 }
 
 // Handles the formatting of text
-struct LineFormatter<'a, T: Terminal + io::Write> {
+struct LineFormatter<'a> {
     is_code_block: bool,
-    wrapper: LineWrapper<'a, T>,
+    wrapper: LineWrapper<'a>,
     attrs: Vec<Attr>,
 }
 
-impl<'a, T: Terminal + io::Write + 'a> LineFormatter<'a, T> {
-    fn new(w: &'a mut T, indent: u32, margin: u32) -> Self {
+impl<'a> LineFormatter<'a> {
+    fn new(w: &'a mut dyn Terminal, indent: u32, margin: u32) -> Self {
         LineFormatter {
             is_code_block: false,
             wrapper: LineWrapper::new(w, indent, margin),
@@ -145,7 +142,7 @@ impl<'a, T: Terminal + io::Write + 'a> LineFormatter<'a, T> {
                 self.wrapper.write_line();
             }
             Tag::Emphasis => {
-                self.push_attr(Attr::ForegroundColor(color::RED));
+                self.push_attr(Attr::ForegroundColor(Color::Red));
             }
             Tag::Strong => {}
             Tag::Strikethrough => {}
@@ -221,7 +218,7 @@ impl<'a, T: Terminal + io::Write + 'a> LineFormatter<'a, T> {
     }
 }
 
-pub(crate) fn md<'a, S: AsRef<str>, T: Terminal + io::Write + 'a>(t: &'a mut T, content: S) {
+pub(crate) fn md<S: AsRef<str>>(t: &mut dyn Terminal, content: S) {
     let mut f = LineFormatter::new(t, 0, 79);
     let parser = pulldown_cmark::Parser::new(content.as_ref());
     for event in parser {