Replace term with termcolor

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

Author: 0xPoe

Cargo.lock

@@ -16,12 +16,7 @@ version = "1.26.0"
 
 [features]
 curl-backend = ["download/curl-backend"]
-default = [
-    "curl-backend",
-    "reqwest-backend",
-    "reqwest-default-tls",
-    "reqwest-rustls-tls",
-]
+default = ["curl-backend", "reqwest-backend", "reqwest-default-tls", "reqwest-rustls-tls"]
 
 reqwest-backend = ["download/reqwest-backend"]
 vendored-openssl = ['openssl/vendored']
@@ -33,13 +28,7 @@ reqwest-rustls-tls = ["download/reqwest-rustls-tls"]
 no-self-update = []
 
 # Include an Opentelemetry sink for tracing events
-otel = [
-    "dep:opentelemetry-otlp",
-    "dep:tracing-opentelemetry",
-    "dep:tracing-subscriber",
-    "dep:opentelemetry",
-    "dep:tokio",
-]
+otel = ["dep:opentelemetry-otlp", "dep:tracing-opentelemetry", "dep:tracing-subscriber", "dep:opentelemetry", "dep:tokio"]
 
 # Sorted by alphabetic order
 [dependencies]
@@ -78,8 +67,7 @@ sharded-slab = "0.1.1"
 strsim = "0.10"
 tar = "0.4.26"
 tempfile.workspace = true
-# FIXME(issue #1818, #1826, and friends)
-term = "=0.5.1"
+termcolor = "1.2"
 thiserror.workspace = true
 threadpool = "1"
 tokio = { workspace = true, optional = true }
@@ -93,6 +81,7 @@ url.workspace = true
 wait-timeout = "0.2"
 xz2 = "0.1.3"
 zstd = "0.12"
+atty = "0.2.14"
 
 [dependencies.retry]
 default-features = false

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

@@ -9,10 +9,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::dist::notifications as dist_notifications;
 use crate::process;
 use crate::toolchain::DistributableToolchain;
@@ -195,7 +194,7 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
         match result {
             Ok(UpdateStatus::Installed) => {
                 banner = "installed";
-                color = Some(term2::color::GREEN);
+                color = Some(term::Color::Green);
             }
             Ok(UpdateStatus::Updated(v)) => {
                 if name == "rustup" {
@@ -205,7 +204,7 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
                     previous_version = Some(v);
                 }
                 banner = "updated";
-                color = Some(term2::color::GREEN);
+                color = Some(term::Color::Green);
             }
             Ok(UpdateStatus::Unchanged) => {
                 if name == "rustup" {
@@ -216,7 +215,7 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
             }
             Err(_) => {
                 banner = "update failed";
-                color = Some(term2::color::RED);
+                color = Some(term::Color::Red);
             }
         }
 
@@ -225,7 +224,7 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
         Ok((name, 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
@@ -236,7 +235,7 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
         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);
         }
@@ -343,7 +342,7 @@ where
 }
 
 pub(crate) fn list_targets(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let distributable = DistributableToolchain::new_for_components(toolchain)?;
     let components = distributable.list_components()?;
     for component in components {
@@ -354,7 +353,7 @@ pub(crate) fn list_targets(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode>
                 .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 {
@@ -367,7 +366,7 @@ pub(crate) fn list_targets(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode>
 }
 
 pub(crate) fn list_installed_targets(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let distributable = DistributableToolchain::new_for_components(toolchain)?;
     let components = distributable.list_components()?;
     for component in components {
@@ -386,13 +385,13 @@ pub(crate) fn list_installed_targets(toolchain: &Toolchain<'_>) -> Result<utils:
 }
 
 pub(crate) fn list_components(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let distributable = DistributableToolchain::new_for_components(toolchain)?;
     let components = distributable.list_components()?;
     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 {
@@ -404,7 +403,7 @@ pub(crate) fn list_components(toolchain: &Toolchain<'_>) -> Result<utils::ExitCo
 }
 
 pub(crate) fn list_installed_components(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode> {
-    let mut t = term2::stdout();
+    let mut t = term::stdout();
     let distributable = DistributableToolchain::new_for_components(toolchain)?;
     let components = distributable.list_components()?;
     for component in components {

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 {