refactor(cli): Simplify palette handling

This did include a couple of tweaks to make it closer to rustc

crates/typos-cli/src/bin/typos-cli/args.rs

@@ -13,21 +13,11 @@ pub enum Format {
 }
 
 impl Format {
-    pub(crate) fn reporter(
-        self,
-        stdout_palette: crate::report::Palette,
-        stderr_palette: crate::report::Palette,
-    ) -> Box<dyn typos_cli::report::Report> {
+    pub(crate) fn reporter(self) -> Box<dyn typos_cli::report::Report> {
         match self {
             Format::Silent => Box::new(crate::report::PrintSilent),
-            Format::Brief => Box::new(crate::report::PrintBrief {
-                stdout_palette,
-                stderr_palette,
-            }),
-            Format::Long => Box::new(crate::report::PrintLong {
-                stdout_palette,
-                stderr_palette,
-            }),
+            Format::Brief => Box::new(crate::report::PrintBrief),
+            Format::Long => Box::new(crate::report::PrintLong),
             Format::Json => Box::new(crate::report::PrintJson),
         }
     }

crates/typos-cli/src/bin/typos-cli/main.rs

@@ -255,9 +255,7 @@ fn run_checks(args: &args::Args) -> proc_exit::ExitResult {
         let output_reporter = if args.diff {
             Box::new(crate::report::PrintSilent)
         } else {
-            let stdout_palette = report::Palette::colored();
-            let stderr_palette = report::Palette::colored();
-            args.format.reporter(stdout_palette, stderr_palette)
+            args.format.reporter()
         };
         let status_reporter = report::MessageStatus::new(output_reporter.as_ref());
         let reporter: &dyn typos_cli::report::Report = &status_reporter;

crates/typos-cli/src/bin/typos-cli/report.rs

@@ -8,60 +8,9 @@ use unicode_width::UnicodeWidthStr;
 
 use typos_cli::report::{Context, Message, Report, Typo};
 
-#[derive(Copy, Clone, Debug, Default)]
-pub struct Palette {
-    error: anstyle::Style,
-    info: anstyle::Style,
-    strong: anstyle::Style,
-}
-
-impl Palette {
-    pub fn colored() -> Self {
-        Self {
-            error: anstyle::AnsiColor::Red.on_default(),
-            info: anstyle::AnsiColor::Blue.on_default(),
-            strong: anstyle::Effects::BOLD.into(),
-        }
-    }
-
-    pub(crate) fn error<D: std::fmt::Display>(self, display: D) -> Styled<D> {
-        Styled::new(display, self.error)
-    }
-
-    pub(crate) fn info<D: std::fmt::Display>(self, display: D) -> Styled<D> {
-        Styled::new(display, self.info)
-    }
-
-    pub(crate) fn strong<D: std::fmt::Display>(self, display: D) -> Styled<D> {
-        Styled::new(display, self.strong)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Styled<D> {
-    display: D,
-    style: anstyle::Style,
-}
-
-impl<D: std::fmt::Display> Styled<D> {
-    pub(crate) fn new(display: D, style: anstyle::Style) -> Self {
-        Self { display, style }
-    }
-}
-
-impl<D: std::fmt::Display> std::fmt::Display for Styled<D> {
-    #[inline]
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if f.alternate() {
-            write!(f, "{}", self.style.render())?;
-            self.display.fmt(f)?;
-            write!(f, "{}", self.style.render_reset())?;
-            Ok(())
-        } else {
-            self.display.fmt(f)
-        }
-    }
-}
+const ERROR: anstyle::Style = anstyle::AnsiColor::Red.on_default();
+const INFO: anstyle::Style = anstyle::AnsiColor::Blue.on_default();
+const STRONG: anstyle::Style = anstyle::Style::new().effects(anstyle::Effects::BOLD);
 
 pub struct MessageStatus<'r> {
     typos_found: atomic::AtomicBool,
@@ -108,10 +57,7 @@ impl Report for PrintSilent {
     }
 }
 
-pub struct PrintBrief {
-    pub stdout_palette: Palette,
-    pub stderr_palette: Palette,
-}
+pub struct PrintBrief;
 
 impl Report for PrintBrief {
     fn report(&self, msg: Message) -> Result<(), std::io::Error> {
@@ -119,7 +65,7 @@ impl Report for PrintBrief {
             Message::BinaryFile(msg) => {
                 log::info!("{}", msg);
             }
-            Message::Typo(msg) => print_brief_correction(msg, self.stdout_palette)?,
+            Message::Typo(msg) => print_brief_correction(msg)?,
             Message::FileType(msg) => {
                 writeln!(
                     stdout().lock(),
@@ -143,10 +89,7 @@ impl Report for PrintBrief {
     }
 }
 
-pub struct PrintLong {
-    pub stdout_palette: Palette,
-    pub stderr_palette: Palette,
-}
+pub struct PrintLong;
 
 impl Report for PrintLong {
     fn report(&self, msg: Message) -> Result<(), std::io::Error> {
@@ -154,7 +97,7 @@ impl Report for PrintLong {
             Message::BinaryFile(msg) => {
                 log::info!("{}", msg);
             }
-            Message::Typo(msg) => print_long_correction(msg, self.stdout_palette)?,
+            Message::Typo(msg) => print_long_correction(msg)?,
             Message::FileType(msg) => {
                 writeln!(
                     stdout().lock(),
@@ -178,7 +121,11 @@ impl Report for PrintLong {
     }
 }
 
-fn print_brief_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::Error> {
+fn print_brief_correction(msg: &Typo) -> Result<(), std::io::Error> {
+    let info = INFO.render();
+    let strong = STRONG.render();
+    let reset = anstyle::Reset.render();
+
     let start = String::from_utf8_lossy(&msg.buffer[0..msg.byte_offset]);
     let column_number =
         unicode_segmentation::UnicodeSegmentation::graphemes(start.as_ref(), true).count() + 1;
@@ -188,26 +135,19 @@ fn print_brief_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::E
             let divider = ":";
             writeln!(
                 stdout().lock(),
-                "{:#}{:#}{:#}: {:#}",
-                palette.info(context_display(&msg.context)),
-                palette.info(divider),
-                palette.info(column_number),
-                palette.strong(format_args!("`{}` is disallowed:", msg.typo)),
+                "{info}{}{divider}{column_number}{reset}: {strong}`{}` is disallowed{reset}",
+                context_display(&msg.context),
+                msg.typo,
             )?;
         }
         typos::Status::Corrections(corrections) => {
             let divider = ":";
             writeln!(
                 stdout().lock(),
-                "{:#}{:#}{:#}: {:#}",
-                palette.info(context_display(&msg.context)),
-                palette.info(divider),
-                palette.info(column_number),
-                palette.strong(format_args!(
-                    "`{}` -> {}",
+                "{info}{}{divider}{column_number}{reset}: {strong}`{}` -> {}{reset}",
+                context_display(&msg.context),
                 msg.typo,
                 itertools::join(corrections.iter().map(|s| format!("`{}`", s)), ", ")
-                )),
             )?;
         }
     }
@@ -215,7 +155,12 @@ fn print_brief_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::E
     Ok(())
 }
 
-fn print_long_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::Error> {
+fn print_long_correction(msg: &Typo) -> Result<(), std::io::Error> {
+    let error = ERROR.render();
+    let info = INFO.render();
+    let strong = STRONG.render();
+    let reset = anstyle::Reset.render();
+
     let stdout = stdout();
     let mut handle = stdout.lock();
 
@@ -229,36 +174,30 @@ fn print_long_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::Er
         typos::Status::Invalid => {
             writeln!(
                 handle,
-                "{:#}: {:#}",
-                palette.error("error"),
-                palette.strong(format_args!("`{}` is disallowed", msg.typo))
+                "{error}error{reset}: {strong}`{}` is disallowed{reset}",
+                msg.typo,
             )?;
         }
         typos::Status::Corrections(corrections) => {
             writeln!(
                 handle,
-                "{:#}: {:#}",
-                palette.error("error"),
-                palette.strong(format_args!(
-                    "`{}` should be {}",
+                "{error}error{reset}: {strong}`{}` should be {}{reset}",
                 msg.typo,
                 itertools::join(corrections.iter().map(|s| format!("`{}`", s)), ", ")
-                ))
             )?;
         }
     }
     let divider = ":";
     writeln!(
         handle,
-        "  --> {:#}{:#}{:#}",
-        palette.info(context_display(&msg.context)),
-        palette.info(divider),
-        palette.info(column_number)
+        "{info}  --> {reset}{}{divider}{column_number}",
+        context_display(&msg.context),
     )?;
 
     if let Some(Context::File(context)) = &msg.context {
         let line_num = context.line_num.to_string();
         let line_indent: String = itertools::repeat_n(" ", line_num.len()).collect();
+        let line = line.trim_end();
 
         let visible_column = calculate_visible_column_width(start.as_ref());
         let visible_len = calculate_visible_column_width(msg.typo);
@@ -266,16 +205,13 @@ fn print_long_correction(msg: &Typo, palette: Palette) -> Result<(), std::io::Er
         let hl_indent: String = itertools::repeat_n(" ", visible_column).collect();
         let hl: String = itertools::repeat_n("^", visible_len).collect();
 
-        writeln!(handle, "{} |", line_indent)?;
-        writeln!(handle, "{:#} | {}", palette.info(line_num), line.trim_end())?;
+        writeln!(handle, "{info}{line_indent} |{reset}")?;
+        writeln!(handle, "{info}{line_num} |{reset} {line}")?;
         writeln!(
             handle,
-            "{} | {}{:#}",
-            line_indent,
-            hl_indent,
-            palette.error(hl)
+            "{info}{line_indent} |{reset} {hl_indent}{error}{hl}{reset}",
         )?;
-        writeln!(handle, "{} |", line_indent)?;
+        writeln!(handle, "{info}{line_indent} |{reset}")?;
     }
 
     Ok(())