refactor: Move style building out of ColorableTerminal

Author: epage

src/cli/common.rs

@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
 use std::{cmp, env};
 
-use anstyle::AnsiColor;
+use anstyle::{AnsiColor, Style};
 use anyhow::{Context, Result, anyhow};
 use git_testament::{git_testament, render_testament};
 use tracing::{error, info, warn};
@@ -18,7 +18,7 @@ use crate::{
     dist::{TargetTriple, ToolchainDesc},
     errors::RustupError,
     install::UpdateStatus,
-    process::{Attr, Process},
+    process::Process,
     toolchain::{LocalToolchainName, Toolchain, ToolchainName},
     utils,
 };
@@ -203,11 +203,13 @@ fn show_channel_updates(
     for (pkg, banner, width, color, version, previous_version) in data {
         let padding = max_width - width;
         let padding: String = " ".repeat(padding);
-        let _ = write!(t.lock(), "  {padding}");
-        let _ = t.attr(Attr::Bold);
-        if let Some(color) = color {
-            let _ = t.fg(color);
+        let style = match color {
+            Some(color) => color.on_default(),
+            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}");
@@ -257,9 +259,10 @@ pub(super) fn list_items(
     process: &Process,
 ) -> Result<utils::ExitCode> {
     let mut t = process.stdout();
+    let bold = Style::new().bold();
     for (name, installed) in items {
         if installed && !installed_only && !quiet {
-            t.attr(Attr::Bold)?;
+            t.style(&bold)?;
             writeln!(t.lock(), "{name} (installed)")?;
             t.reset()?;
         } else if installed || !installed_only {

src/cli/markdown.rs

@@ -1,10 +1,10 @@
 // Write Markdown to the terminal
 use std::io::Write;
 
-use anstyle::AnsiColor;
+use anstyle::{AnsiColor, Style};
 use pulldown_cmark::{Event, Tag, TagEnd};
 
-use crate::process::{Attr, ColorableTerminal};
+use crate::process::ColorableTerminal;
 
 // Handles the wrapping of text written to the console
 struct LineWrapper<'a> {
@@ -96,6 +96,7 @@ struct LineFormatter<'a> {
     is_code_block: bool,
     wrapper: LineWrapper<'a>,
     attrs: Vec<Attr>,
+    style: Style,
 }
 
 impl<'a> LineFormatter<'a> {
@@ -104,18 +105,21 @@ impl<'a> LineFormatter<'a> {
             is_code_block: false,
             wrapper: LineWrapper::new(w, indent, margin),
             attrs: Vec::new(),
+            style: Style::new(),
         }
     }
     fn push_attr(&mut self, attr: Attr) {
         self.attrs.push(attr);
-        let _ = self.wrapper.w.attr(attr);
+        attr.apply_to(&mut self.style);
+        let _ = self.wrapper.w.style(&self.style);
     }
     fn pop_attr(&mut self) {
         self.attrs.pop();
-        let _ = self.wrapper.w.reset();
+        self.style = Style::new();
         for attr in &self.attrs {
-            let _ = self.wrapper.w.attr(*attr);
+            attr.apply_to(&mut self.style);
         }
+        let _ = self.wrapper.w.style(&self.style);
     }
 
     fn start_tag(&mut self, tag: Tag<'a>) {
@@ -240,6 +244,21 @@ impl<'a> LineFormatter<'a> {
     }
 }
 
+#[derive(Copy, Clone, Debug)]
+pub enum Attr {
+    Bold,
+    ForegroundColor(AnsiColor),
+}
+
+impl Attr {
+    fn apply_to(&self, style: &mut Style) {
+        match self {
+            Self::Bold => *style = style.bold(),
+            Self::ForegroundColor(color) => *style = style.fg_color(Some((*color).into())),
+        }
+    }
+}
+
 pub(crate) fn md<S: AsRef<str>>(t: &mut ColorableTerminal, content: S) {
     let mut f = LineFormatter::new(t, 0, 79);
     let parser = pulldown_cmark::Parser::new(content.as_ref());

src/cli/rustup_mode.rs

@@ -10,6 +10,7 @@ use std::{
     time::Duration,
 };
 
+use anstyle::Style;
 use anyhow::{Context, Error, Result, anyhow};
 use clap::{Args, CommandFactory, Parser, Subcommand, ValueEnum, builder::PossibleValue};
 use clap_complete::Shell;
@@ -39,7 +40,7 @@ use crate::{
     },
     errors::RustupError,
     install::{InstallMethod, UpdateStatus},
-    process::{Attr, ColorableTerminal, Process},
+    process::{ColorableTerminal, Process},
     toolchain::{
         CustomToolchainName, DistributableToolchain, LocalToolchainName,
         MaybeResolvableToolchainName, ResolvableLocalToolchainName, ResolvableToolchainName,
@@ -1072,10 +1073,12 @@ async fn which(
 async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
     common::warn_if_host_is_emulated(cfg.process);
 
+    let bold = Style::new().bold();
+
     // Print host triple
     {
         let mut t = cfg.process.stdout();
-        t.attr(Attr::Bold)?;
+        t.style(&bold)?;
         write!(t.lock(), "Default host: ")?;
         t.reset()?;
         writeln!(t.lock(), "{}", cfg.get_default_host_triple()?)?;
@@ -1084,7 +1087,7 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
     // Print rustup home directory
     {
         let mut t = cfg.process.stdout();
-        t.attr(Attr::Bold)?;
+        t.style(&bold)?;
         write!(t.lock(), "rustup home:  ")?;
         t.reset()?;
         writeln!(t.lock(), "{}", cfg.rustup_dir.display())?;
@@ -1193,7 +1196,8 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
     }
 
     fn print_header(t: &mut ColorableTerminal, s: &str) -> Result<(), Error> {
-        t.attr(Attr::Bold)?;
+        let bold = Style::new().bold();
+        t.style(&bold)?;
         {
             let mut term_lock = t.lock();
             writeln!(term_lock, "{s}")?;

src/cli/self_update.rs

@@ -40,7 +40,7 @@ use std::process::Command;
 use std::str::FromStr;
 use std::{fmt, fs};
 
-use anstyle::AnsiColor;
+use anstyle::{AnsiColor, Style};
 use anyhow::{Context, Result, anyhow};
 use cfg_if::cfg_if;
 use clap::ValueEnum;
@@ -63,7 +63,7 @@ use crate::{
     download::download_file,
     errors::RustupError,
     install::UpdateStatus,
-    process::{Attr, Process},
+    process::Process,
     toolchain::{
         DistributableToolchain, MaybeOfficialToolchainName, ResolvableToolchainName, Toolchain,
         ToolchainName,
@@ -1364,17 +1364,21 @@ pub(crate) async fn check_rustup_update(dl_cfg: &DownloadCfg<'_>) -> anyhow::Res
     // Get available rustup version
     let available_version = get_available_rustup_version(dl_cfg).await?;
 
-    let _ = t.attr(Attr::Bold);
+    let bold = Style::new().bold();
+    let yellow = AnsiColor::Yellow.on_default().bold();
+    let green = AnsiColor::Green.on_default().bold();
+
+    let _ = t.style(&bold);
     write!(t.lock(), "rustup - ")?;
 
     Ok(if current_version != available_version {
-        let _ = t.fg(AnsiColor::Yellow);
+        let _ = t.style(&yellow);
         write!(t.lock(), "Update available")?;
         let _ = t.reset();
         writeln!(t.lock(), " : {current_version} -> {available_version}")?;
         true
     } else {
-        let _ = t.fg(AnsiColor::Green);
+        let _ = t.style(&green);
         write!(t.lock(), "Up to date")?;
         let _ = t.reset();
         writeln!(t.lock(), " : {current_version}")?;

src/process.rs

@@ -28,7 +28,7 @@ use crate::cli::log;
 
 mod file_source;
 mod terminal_source;
-pub use terminal_source::{Attr, ColorableTerminal};
+pub use terminal_source::ColorableTerminal;
 
 /// Allows concrete types for the process abstraction.
 #[derive(Clone, Debug)]

src/process/terminal_source.rs

@@ -9,10 +9,10 @@ use std::{
     sync::{Arc, Mutex, MutexGuard},
 };
 
-use anstyle::AnsiColor;
-use anstyle_termcolor::to_termcolor_color;
+use anstyle::Style;
+use anstyle_termcolor::to_termcolor_spec;
 use termcolor::ColorChoice;
-use termcolor::{ColorSpec, StandardStream, StandardStreamLock, WriteColor};
+use termcolor::{StandardStream, StandardStreamLock, WriteColor};
 
 use super::Process;
 #[cfg(feature = "test")]
@@ -60,12 +60,8 @@ impl ColorableTerminal {
             _ => ColorChoice::Never,
         };
         let inner = match stream {
-            StreamSelector::Stdout => {
-                TerminalInner::StandardStream(StandardStream::stdout(choice), ColorSpec::new())
-            }
-            StreamSelector::Stderr => {
-                TerminalInner::StandardStream(StandardStream::stderr(choice), ColorSpec::new())
-            }
+            StreamSelector::Stdout => TerminalInner::StandardStream(StandardStream::stdout(choice)),
+            StreamSelector::Stderr => TerminalInner::StandardStream(StandardStream::stderr(choice)),
             #[cfg(feature = "test")]
             StreamSelector::TestWriter(w) => TerminalInner::TestWriter(w, choice),
             #[cfg(all(test, feature = "test"))]
@@ -99,7 +95,7 @@ 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, _) => {
+                TerminalInner::StandardStream(s) => {
                     let locked = s.lock();
                     TerminalInnerLocked::StandardStream(locked)
                 }
@@ -111,39 +107,17 @@ impl ColorableTerminal {
         }
     }
 
-    pub fn fg(&mut self, color: AnsiColor) -> io::Result<()> {
+    pub fn style(&mut self, new: &Style) -> io::Result<()> {
         match self.inner.lock().unwrap().deref_mut() {
-            TerminalInner::StandardStream(s, spec) => {
-                spec.set_fg(Some(to_termcolor_color(color.into())));
-                s.set_color(spec)
-            }
-            #[cfg(feature = "test")]
-            TerminalInner::TestWriter(_, _) => Ok(()),
-        }
-    }
-
-    pub fn attr(&mut self, attr: Attr) -> io::Result<()> {
-        match self.inner.lock().unwrap().deref_mut() {
-            TerminalInner::StandardStream(s, spec) => {
-                match attr {
-                    Attr::Bold => spec.set_bold(true),
-                    Attr::ForegroundColor(color) => {
-                        spec.set_fg(Some(to_termcolor_color(color.into())))
-                    }
-                };
-                s.set_color(spec)
-            }
+            TerminalInner::StandardStream(s) => s.set_color(&to_termcolor_spec(*new)),
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(_, _) => Ok(()),
         }
     }
 
     pub fn reset(&mut self) -> io::Result<()> {
         match self.inner.lock().unwrap().deref_mut() {
-            TerminalInner::StandardStream(s, color) => {
-                color.clear();
-                s.reset()
-            }
+            TerminalInner::StandardStream(s) => s.reset(),
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(_, _) => Ok(()),
         }
@@ -311,7 +285,7 @@ impl TerminalInnerLocked {
 
 /// Internal state for ColorableTerminal
 enum TerminalInner {
-    StandardStream(StandardStream, ColorSpec),
+    StandardStream(StandardStream),
     #[cfg(feature = "test")]
     #[allow(dead_code)] // ColorChoice only read in test code
     TestWriter(TestWriter, ColorChoice),
@@ -320,7 +294,7 @@ enum TerminalInner {
 impl TerminalInner {
     fn as_write(&mut self) -> &mut dyn io::Write {
         match self {
-            TerminalInner::StandardStream(s, _) => s,
+            TerminalInner::StandardStream(s) => s,
             #[cfg(feature = "test")]
             TerminalInner::TestWriter(w, _) => w,
         }
@@ -358,12 +332,6 @@ impl StreamSelector {
     }
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum Attr {
-    Bold,
-    ForegroundColor(AnsiColor),
-}
-
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;