refactor: Directly apply styling

Author: epage

src/cli/common.rs

@@ -193,7 +193,8 @@ fn show_channel_updates(
         Ok((pkg, banner, width, color, version, previous_version))
     });
 
-    let mut t = cfg.process.stdout();
+    let t = cfg.process.stdout();
+    let mut t = t.lock();
 
     let data: Vec<_> = data.collect::<Result<_>>()?;
     let max_width = data
@@ -208,17 +209,13 @@ fn show_channel_updates(
             None => Style::new(),
         }
         .bold();
-        let _ = write!(t.lock(), "  {padding}");
-        let _ = t.style(&style);
-        let _ = write!(t.lock(), "{pkg} {banner}");
-        let _ = t.reset();
-        let _ = write!(t.lock(), " - {version}");
+        let _ = write!(t, "  {padding}{style}{pkg} {banner}{style:#} - {version}");
         if let Some(previous_version) = previous_version {
-            let _ = write!(t.lock(), " (from {previous_version})");
+            let _ = write!(t, " (from {previous_version})");
         }
-        let _ = writeln!(t.lock());
+        let _ = writeln!(t);
     }
-    let _ = writeln!(t.lock());
+    let _ = writeln!(t);
 
     Ok(())
 }
@@ -258,15 +255,14 @@ pub(super) fn list_items(
     quiet: bool,
     process: &Process,
 ) -> Result<utils::ExitCode> {
-    let mut t = process.stdout();
+    let t = process.stdout();
+    let mut t = t.lock();
     let bold = Style::new().bold();
     for (name, installed) in items {
         if installed && !installed_only && !quiet {
-            t.style(&bold)?;
-            writeln!(t.lock(), "{name} (installed)")?;
-            t.reset()?;
+            writeln!(t, "{bold}{name} (installed){bold:#}")?;
         } else if installed || !installed_only {
-            writeln!(t.lock(), "{name}")?;
+            writeln!(t, "{name}")?;
         }
     }
     Ok(utils::ExitCode(0))

src/cli/markdown.rs

@@ -1,7 +1,7 @@
 // Write Markdown to the terminal
 use std::io::Write;
 
-use anstyle::{AnsiColor, Style};
+use anstyle::{AnsiColor, Reset, Style};
 use pulldown_cmark::{Event, Tag, TagEnd};
 
 use crate::process::ColorableTerminal;
@@ -111,15 +111,15 @@ impl<'a> LineFormatter<'a> {
     fn push_attr(&mut self, attr: Attr) {
         self.attrs.push(attr);
         attr.apply_to(&mut self.style);
-        let _ = self.wrapper.w.style(&self.style);
+        let _ = write!(self.wrapper.w.lock(), "{Reset}{}", self.style);
     }
     fn pop_attr(&mut self) {
         self.attrs.pop();
         self.style = Style::new();
         for attr in &self.attrs {
             attr.apply_to(&mut self.style);
         }
-        let _ = self.wrapper.w.style(&self.style);
+        let _ = write!(self.wrapper.w.lock(), "{Reset}{}", self.style);
     }
 
     fn start_tag(&mut self, tag: Tag<'a>) {

src/cli/rustup_mode.rs

@@ -1077,21 +1077,25 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
 
     // Print host triple
     {
-        let mut t = cfg.process.stdout();
-        t.style(&bold)?;
-        write!(t.lock(), "Default host: ")?;
-        t.reset()?;
-        writeln!(t.lock(), "{}", cfg.get_default_host_triple()?)?;
+        let t = cfg.process.stdout();
+        let mut t = t.lock();
+        writeln!(
+            t,
+            "{bold}Default host: {bold:#}{}",
+            cfg.get_default_host_triple()?
+        )?;
     }
 
     // Print rustup home directory
     {
-        let mut t = cfg.process.stdout();
-        t.style(&bold)?;
-        write!(t.lock(), "rustup home:  ")?;
-        t.reset()?;
-        writeln!(t.lock(), "{}", cfg.rustup_dir.display())?;
-        writeln!(t.lock())?;
+        let t = cfg.process.stdout();
+        let mut t = t.lock();
+        writeln!(
+            t,
+            "{bold}rustup home:  {bold:#}{}",
+            cfg.rustup_dir.display()
+        )?;
+        writeln!(t)?;
     }
 
     let installed_toolchains = cfg.list_toolchains()?;
@@ -1195,15 +1199,12 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
         }
     }
 
-    fn print_header(t: &mut ColorableTerminal, s: &str) -> Result<(), Error> {
+    fn print_header(t: &mut ColorableTerminal, text: &str) -> Result<(), Error> {
         let bold = Style::new().bold();
-        t.style(&bold)?;
-        {
-            let mut term_lock = t.lock();
-            writeln!(term_lock, "{s}")?;
-            writeln!(term_lock, "{}", "-".repeat(s.len()))?;
-        } // drop the term_lock
-        t.reset()?;
+        let divider = "-".repeat(text.len());
+        let mut term_lock = t.lock();
+        writeln!(term_lock, "{bold}{text}{bold:#}")?;
+        writeln!(term_lock, "{bold}{divider}{bold:#}")?;
         Ok(())
     }
 

src/cli/self_update.rs

@@ -1357,7 +1357,8 @@ impl fmt::Display for SchemaVersion {
 
 /// Returns whether an update was available
 pub(crate) async fn check_rustup_update(dl_cfg: &DownloadCfg<'_>) -> anyhow::Result<bool> {
-    let mut t = dl_cfg.process.stdout();
+    let t = dl_cfg.process.stdout();
+    let mut t = t.lock();
     // Get current rustup version
     let current_version = env!("CARGO_PKG_VERSION");
 
@@ -1368,20 +1369,16 @@ pub(crate) async fn check_rustup_update(dl_cfg: &DownloadCfg<'_>) -> anyhow::Res
     let yellow = AnsiColor::Yellow.on_default().bold();
     let green = AnsiColor::Green.on_default().bold();
 
-    let _ = t.style(&bold);
-    write!(t.lock(), "rustup - ")?;
+    write!(t, "{bold}rustup - {bold:#}")?;
 
     Ok(if current_version != available_version {
-        let _ = t.style(&yellow);
-        write!(t.lock(), "Update available")?;
-        let _ = t.reset();
-        writeln!(t.lock(), " : {current_version} -> {available_version}")?;
+        writeln!(
+            t,
+            "{yellow}Update available{yellow:#} : {current_version} -> {available_version}"
+        )?;
         true
     } else {
-        let _ = t.style(&green);
-        write!(t.lock(), "Up to date")?;
-        let _ = t.reset();
-        writeln!(t.lock(), " : {current_version}")?;
+        writeln!(t, "{green}Up to date{green:#} : {current_version}")?;
         false
     })
 }

src/process/terminal_source.rs

@@ -9,8 +9,9 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
+#[cfg(feature = "test")]
+use anstream::StripStream;
 use anstream::{AutoStream, ColorChoice};
-use anstyle::{Reset, Style};
 
 use super::Process;
 #[cfg(feature = "test")]
@@ -102,38 +103,15 @@ impl ColorableTerminal {
                     TerminalInnerLocked::Stderr(AutoStream::new(locked, self.color_choice))
                 }
                 #[cfg(feature = "test")]
-                TerminalInner::TestWriter(w, _) => TerminalInnerLocked::TestWriter(w.clone()),
+                TerminalInner::TestWriter(w, _) => {
+                    TerminalInnerLocked::TestWriter(StripStream::new(Box::new(w.clone())))
+                }
             });
             // ColorableTerminalLocked { inner, guard, locked }
             uninit.assume_init()
         }
     }
 
-    pub fn style(&mut self, new: &Style) -> io::Result<()> {
-        match self.inner.lock().unwrap().deref_mut() {
-            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::Stdout(s) => {
-                write!(s, "{Reset}")
-            }
-            TerminalInner::Stderr(s) => {
-                write!(s, "{Reset}")
-            }
-            #[cfg(feature = "test")]
-            TerminalInner::TestWriter(_, _) => Ok(()),
-        }
-    }
-
     pub fn is_a_tty(&self) -> bool {
         self.is_a_tty
     }
@@ -282,7 +260,7 @@ enum TerminalInnerLocked {
     Stdout(AutoStream<io::StdoutLock<'static>>),
     Stderr(AutoStream<io::StderrLock<'static>>),
     #[cfg(feature = "test")]
-    TestWriter(TestWriter),
+    TestWriter(StripStream<Box<dyn Write>>),
 }
 
 impl TerminalInnerLocked {