Use queue instead of Stylize

Author: mo8it

src/app_state.rs

@@ -338,7 +338,7 @@ impl AppState {
     /// Mark the current exercise as done and move on to the next pending exercise if one exists.
     /// If all exercises are marked as done, run all of them to make sure that they are actually
     /// done. If an exercise which is marked as done fails, mark it as pending and continue on it.
-    pub fn done_current_exercise(&mut self, writer: &mut StdoutLock) -> Result<ExercisesProgress> {
+    pub fn done_current_exercise(&mut self, stdout: &mut StdoutLock) -> Result<ExercisesProgress> {
         let exercise = &mut self.exercises[self.current_exercise_ind];
         if !exercise.done {
             exercise.done = true;
@@ -350,7 +350,7 @@ impl AppState {
             return Ok(ExercisesProgress::NewPending);
         }
 
-        writer.write_all(RERUNNING_ALL_EXERCISES_MSG)?;
+        stdout.write_all(RERUNNING_ALL_EXERCISES_MSG)?;
 
         let n_exercises = self.exercises.len();
 
@@ -368,12 +368,12 @@ impl AppState {
                 .collect::<Vec<_>>();
 
             for (exercise_ind, handle) in handles.into_iter().enumerate() {
-                write!(writer, "\rProgress: {exercise_ind}/{n_exercises}")?;
-                writer.flush()?;
+                write!(stdout, "\rProgress: {exercise_ind}/{n_exercises}")?;
+                stdout.flush()?;
 
                 let success = handle.join().unwrap()?;
                 if !success {
-                    writer.write_all(b"\n\n")?;
+                    stdout.write_all(b"\n\n")?;
                     return Ok(Some(exercise_ind));
                 }
             }
@@ -395,13 +395,13 @@ impl AppState {
         // Write that the last exercise is done.
         self.write()?;
 
-        clear_terminal(writer)?;
-        writer.write_all(FENISH_LINE.as_bytes())?;
+        clear_terminal(stdout)?;
+        stdout.write_all(FENISH_LINE.as_bytes())?;
 
         let final_message = self.final_message.trim_ascii();
         if !final_message.is_empty() {
-            writer.write_all(final_message.as_bytes())?;
-            writer.write_all(b"\n")?;
+            stdout.write_all(final_message.as_bytes())?;
+            stdout.write_all(b"\n")?;
         }
 
         Ok(ExercisesProgress::AllDone)

src/exercise.rs

@@ -1,15 +1,27 @@
 use anyhow::Result;
-use crossterm::style::{style, StyledContent, Stylize};
-use std::{
-    fmt::{self, Display, Formatter},
-    io::Write,
+use crossterm::{
+    style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor},
+    QueueableCommand,
 };
+use std::io::{self, StdoutLock, Write};
 
-use crate::{cmd::CmdRunner, terminal_link::TerminalFileLink};
+use crate::{
+    cmd::CmdRunner,
+    term::{terminal_file_link, write_ansi},
+};
 
 /// The initial capacity of the output buffer.
 pub const OUTPUT_CAPACITY: usize = 1 << 14;
 
+pub fn solution_link_line(stdout: &mut StdoutLock, solution_path: &str) -> io::Result<()> {
+    stdout.queue(SetAttribute(Attribute::Bold))?;
+    stdout.write_all(b"Solution")?;
+    stdout.queue(ResetColor)?;
+    stdout.write_all(b" for comparison: ")?;
+    terminal_file_link(stdout, solution_path, Color::Cyan)?;
+    stdout.write_all(b"\n")
+}
+
 // Run an exercise binary and append its output to the `output` buffer.
 // Compilation must be done before calling this method.
 fn run_bin(
@@ -18,7 +30,9 @@ fn run_bin(
     cmd_runner: &CmdRunner,
 ) -> Result<bool> {
     if let Some(output) = output.as_deref_mut() {
-        writeln!(output, "{}", "Output".underlined())?;
+        write_ansi(output, SetAttribute(Attribute::Underlined));
+        output.extend_from_slice(b"Output\n");
+        write_ansi(output, ResetColor);
     }
 
     let success = cmd_runner.run_debug_bin(bin_name, output.as_deref_mut())?;
@@ -28,13 +42,10 @@ fn run_bin(
             // This output is important to show the user that something went wrong.
             // Otherwise, calling something like `exit(1)` in an exercise without further output
             // leaves the user confused about why the exercise isn't done yet.
-            writeln!(
-                output,
-                "{}",
-                "The exercise didn't run successfully (nonzero exit code)"
-                    .bold()
-                    .red(),
-            )?;
+            write_ansi(output, SetAttribute(Attribute::Bold));
+            write_ansi(output, SetForegroundColor(Color::Red));
+            output.extend_from_slice(b"The exercise didn't run successfully (nonzero exit code)\n");
+            write_ansi(output, ResetColor);
         }
     }
 
@@ -53,18 +64,6 @@ pub struct Exercise {
     pub done: bool,
 }
 
-impl Exercise {
-    pub fn terminal_link(&self) -> StyledContent<TerminalFileLink<'_>> {
-        style(TerminalFileLink(self.path)).underlined().blue()
-    }
-}
-
-impl Display for Exercise {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.path.fmt(f)
-    }
-}
-
 pub trait RunnableExercise {
     fn name(&self) -> &str;
     fn strict_clippy(&self) -> bool;

src/init.rs

@@ -1,5 +1,8 @@
 use anyhow::{bail, Context, Result};
-use crossterm::style::Stylize;
+use crossterm::{
+    style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor},
+    QueueableCommand,
+};
 use serde::Deserialize;
 use std::{
     env::set_current_dir,
@@ -144,12 +147,13 @@ pub fn init() -> Result<()> {
             .status();
     }
 
-    writeln!(
-        stdout,
-        "{}\n\n{}",
-        "Initialization done ✓".green(),
-        POST_INIT_MSG.bold(),
-    )?;
+    stdout.queue(SetForegroundColor(Color::Green))?;
+    stdout.write_all("Initialization done ✓\n\n".as_bytes())?;
+    stdout
+        .queue(ResetColor)?
+        .queue(SetAttribute(Attribute::Bold))?;
+    stdout.write_all(POST_INIT_MSG)?;
+    stdout.queue(ResetColor)?;
 
     Ok(())
 }
@@ -182,5 +186,6 @@ You probably already initialized Rustlings.
 Run `cd rustlings`
 Then run `rustlings` again";
 
-const POST_INIT_MSG: &str = "Run `cd rustlings` to go into the generated directory.
-Then run `rustlings` to get started.";
+const POST_INIT_MSG: &[u8] = b"Run `cd rustlings` to go into the generated directory.
+Then run `rustlings` to get started.
+";

src/main.rs

@@ -22,7 +22,6 @@ mod init;
 mod list;
 mod run;
 mod term;
-mod terminal_link;
 mod watch;
 
 const CURRENT_FORMAT_VERSION: u8 = 1;

src/run.rs

@@ -1,11 +1,17 @@
-use anyhow::{bail, Result};
-use crossterm::style::{style, Stylize};
-use std::io::{self, Write};
+use anyhow::Result;
+use crossterm::{
+    style::{Color, ResetColor, SetForegroundColor},
+    QueueableCommand,
+};
+use std::{
+    io::{self, Write},
+    process::exit,
+};
 
 use crate::{
     app_state::{AppState, ExercisesProgress},
-    exercise::{RunnableExercise, OUTPUT_CAPACITY},
-    terminal_link::TerminalFileLink,
+    exercise::{solution_link_line, RunnableExercise, OUTPUT_CAPACITY},
+    term::terminal_file_link,
 };
 
 pub fn run(app_state: &mut AppState) -> Result<()> {
@@ -19,35 +25,31 @@ pub fn run(app_state: &mut AppState) -> Result<()> {
     if !success {
         app_state.set_pending(app_state.current_exercise_ind())?;
 
-        bail!(
-            "Ran {} with errors",
-            app_state.current_exercise().terminal_link(),
-        );
+        stdout.write_all(b"Ran ")?;
+        terminal_file_link(&mut stdout, app_state.current_exercise().path, Color::Blue)?;
+        stdout.write_all(b" with errors\n")?;
+        exit(1);
     }
 
-    writeln!(
-        stdout,
-        "{}{}",
-        "✓ Successfully ran ".green(),
-        exercise.path.green(),
-    )?;
+    stdout.queue(SetForegroundColor(Color::Green))?;
+    stdout.write_all("✓ Successfully ran ".as_bytes())?;
+    stdout.write_all(exercise.path.as_bytes())?;
+    stdout.queue(ResetColor)?;
+    stdout.write_all(b"\n")?;
 
     if let Some(solution_path) = app_state.current_solution_path()? {
-        writeln!(
-            stdout,
-            "\n{} for comparison: {}\n",
-            "Solution".bold(),
-            style(TerminalFileLink(&solution_path)).underlined().cyan(),
-        )?;
+        stdout.write_all(b"\n")?;
+        solution_link_line(&mut stdout, &solution_path)?;
+        stdout.write_all(b"\n")?;
     }
 
     match app_state.done_current_exercise(&mut stdout)? {
+        ExercisesProgress::CurrentPending | ExercisesProgress::NewPending => {
+            stdout.write_all(b"Next exercise: ")?;
+            terminal_file_link(&mut stdout, app_state.current_exercise().path, Color::Blue)?;
+            stdout.write_all(b"\n")?;
+        }
         ExercisesProgress::AllDone => (),
-        ExercisesProgress::CurrentPending | ExercisesProgress::NewPending => writeln!(
-            stdout,
-            "Next exercise: {}",
-            app_state.current_exercise().terminal_link(),
-        )?,
     }
 
     Ok(())

src/term.rs

@@ -1,10 +1,13 @@
-use std::io::{self, BufRead, StdoutLock, Write};
+use std::{
+    fmt, fs,
+    io::{self, BufRead, StdoutLock, Write},
+};
 
 use crossterm::{
     cursor::MoveTo,
-    style::{Color, ResetColor, SetForegroundColor},
+    style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor},
     terminal::{Clear, ClearType},
-    QueueableCommand,
+    Command, QueueableCommand,
 };
 
 /// Terminal progress bar to be used when not using Ratataui.
@@ -68,3 +71,43 @@ pub fn press_enter_prompt(stdout: &mut StdoutLock) -> io::Result<()> {
     stdout.write_all(b"\n")?;
     Ok(())
 }
+
+pub fn terminal_file_link(stdout: &mut StdoutLock, path: &str, color: Color) -> io::Result<()> {
+    let canonical_path = fs::canonicalize(path).ok();
+
+    let Some(canonical_path) = canonical_path.as_deref().and_then(|p| p.to_str()) else {
+        return stdout.write_all(path.as_bytes());
+    };
+
+    // Windows itself can't handle its verbatim paths.
+    #[cfg(windows)]
+    let canonical_path = if canonical_path.len() > 5 && &canonical_path[0..4] == r"\\?\" {
+        &canonical_path[4..]
+    } else {
+        canonical_path
+    };
+
+    stdout
+        .queue(SetForegroundColor(color))?
+        .queue(SetAttribute(Attribute::Underlined))?;
+    write!(
+        stdout,
+        "\x1b]8;;file://{canonical_path}\x1b\\{path}\x1b]8;;\x1b\\",
+    )?;
+    stdout.queue(ResetColor)?;
+
+    Ok(())
+}
+
+pub fn write_ansi(output: &mut Vec<u8>, command: impl Command) {
+    struct FmtWriter<'a>(&'a mut Vec<u8>);
+
+    impl fmt::Write for FmtWriter<'_> {
+        fn write_str(&mut self, s: &str) -> fmt::Result {
+            self.0.extend_from_slice(s.as_bytes());
+            Ok(())
+        }
+    }
+
+    let _ = command.write_ansi(&mut FmtWriter(output));
+}