refactor: Replace termcolor with anstream

Author: epage

Cargo.lock

@@ -41,8 +41,8 @@ test = ["dep:snapbox", "dep:walkdir"]
 
 # Sorted by alphabetic order
 [dependencies]
+anstream = "0.6.20"
 anstyle = "1.0.11"
-anstyle-termcolor = "1.1.4"
 anyhow = "1.0.69"
 cfg-if = "1.0"
 chrono = { version = "0.4", default-features = false, features = ["std"] }
@@ -87,7 +87,6 @@ sharded-slab = "0.1.1"
 strsim = "0.11"
 tar = "0.4.26"
 tempfile = "3.8"
-termcolor = "1.2"
 thiserror = "2"
 threadpool = "1"
 tokio = { version = "1.26.0", default-features = false, features = ["macros", "rt-multi-thread", "sync"] }

Cargo.toml

@@ -10,6 +10,7 @@ use std::{
     time::Duration,
 };
 
+use anstream::ColorChoice;
 use anstyle::Style;
 use anyhow::{Context, Error, Result, anyhow};
 use clap::{Args, CommandFactory, Parser, Subcommand, ValueEnum, builder::PossibleValue};
@@ -18,7 +19,6 @@ use console::style;
 use futures_util::stream::StreamExt;
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use itertools::Itertools;
-use termcolor::ColorChoice;
 use tokio::sync::Semaphore;
 use tracing::{info, trace, warn};
 use tracing_subscriber::{EnvFilter, Registry, reload::Handle};

src/cli/rustup_mode.rs

@@ -9,10 +9,8 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
-use anstyle::Style;
-use anstyle_termcolor::to_termcolor_spec;
-use termcolor::ColorChoice;
-use termcolor::{StandardStream, StandardStreamLock, WriteColor};
+use anstream::{AutoStream, ColorChoice};
+use anstyle::{Reset, Style};
 
 use super::Process;
 #[cfg(feature = "test")]
@@ -60,8 +58,8 @@ impl ColorableTerminal {
             _ => ColorChoice::Never,
         };
         let inner = match stream {
-            StreamSelector::Stdout => TerminalInner::StandardStream(StandardStream::stdout(choice)),
-            StreamSelector::Stderr => TerminalInner::StandardStream(StandardStream::stderr(choice)),
+            StreamSelector::Stdout => TerminalInner::Stdout(AutoStream::new(io::stdout(), choice)),
+            StreamSelector::Stderr => TerminalInner::Stderr(AutoStream::new(io::stderr(), choice)),
             #[cfg(feature = "test")]
             StreamSelector::TestWriter(w) => TerminalInner::TestWriter(w, choice),
             #[cfg(all(test, feature = "test"))]
@@ -95,9 +93,13 @@ impl ColorableTerminal {
             addr_of_mut!((*ptr).guard).write((*ptr).inner.lock().unwrap());
             // let locked = match *guard {....}
             addr_of_mut!((*ptr).locked).write(match (*ptr).guard.deref_mut() {
-                TerminalInner::StandardStream(s) => {
-                    let locked = s.lock();
-                    TerminalInnerLocked::StandardStream(locked)
+                TerminalInner::Stdout(_) => {
+                    let locked = io::stdout().lock();
+                    TerminalInnerLocked::Stdout(AutoStream::new(locked, self.color_choice))
+                }
+                TerminalInner::Stderr(_) => {
+                    let locked = io::stderr().lock();
+                    TerminalInnerLocked::Stderr(AutoStream::new(locked, self.color_choice))
                 }
                 #[cfg(feature = "test")]
                 TerminalInner::TestWriter(w, _) => TerminalInnerLocked::TestWriter(w.lock()),
@@ -109,15 +111,24 @@ impl ColorableTerminal {
 
     pub fn style(&mut self, new: &Style) -> io::Result<()> {
         match self.inner.lock().unwrap().deref_mut() {
-            TerminalInner::StandardStream(s) => s.set_color(&to_termcolor_spec(*new)),
+            TerminalInner::Stdout(s) => {
+                write!(s, "{Reset}{new}")
+            }
+            TerminalInner::Stderr(s) => {
+                write!(s, "{Reset}{new}")
+            }
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(_, _) => Ok(()),
         }
     }
-
     pub fn reset(&mut self) -> io::Result<()> {
         match self.inner.lock().unwrap().deref_mut() {
-            TerminalInner::StandardStream(s) => s.reset(),
+            TerminalInner::Stdout(s) => {
+                write!(s, "{Reset}")
+            }
+            TerminalInner::Stderr(s) => {
+                write!(s, "{Reset}")
+            }
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(_, _) => Ok(()),
         }
@@ -268,15 +279,17 @@ impl io::Write for ColorableTerminalLocked {
 }
 
 enum TerminalInnerLocked {
-    StandardStream(StandardStreamLock<'static>),
+    Stdout(AutoStream<io::StdoutLock<'static>>),
+    Stderr(AutoStream<io::StderrLock<'static>>),
     #[cfg(feature = "test")]
     TestWriter(TestWriterLock<'static>),
 }
 
 impl TerminalInnerLocked {
     fn as_write(&mut self) -> &mut dyn io::Write {
         match self {
-            TerminalInnerLocked::StandardStream(s) => s,
+            TerminalInnerLocked::Stdout(s) => s,
+            TerminalInnerLocked::Stderr(s) => s,
             #[cfg(feature = "test")]
             TerminalInnerLocked::TestWriter(w) => w,
         }
@@ -285,7 +298,8 @@ impl TerminalInnerLocked {
 
 /// Internal state for ColorableTerminal
 enum TerminalInner {
-    StandardStream(StandardStream),
+    Stdout(AutoStream<io::Stdout>),
+    Stderr(AutoStream<io::Stderr>),
     #[cfg(feature = "test")]
     #[allow(dead_code)] // ColorChoice only read in test code
     TestWriter(TestWriter, ColorChoice),
@@ -294,7 +308,8 @@ enum TerminalInner {
 impl TerminalInner {
     fn as_write(&mut self) -> &mut dyn io::Write {
         match self {
-            TerminalInner::StandardStream(s) => s,
+            TerminalInner::Stdout(s) => s,
+            TerminalInner::Stderr(s) => s,
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(w, _) => w,
         }