feat: coloured output

using --no-color flag to disable colours
fixed a bug with duration formatting

Author: bartekjaszczak

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "practicestuff"
-version = "0.3.3"
+version = "0.3.4"
 description = "Simple CLI trainer for improving calculation and memorisation skills"
 authors = ["Bartłomiej Jaszczak"]
 repository = "https://gitlab.com/bartekjaszczak/practicestuff"

Cargo.toml

@@ -3,9 +3,11 @@ use std::io::{self, Write};
 use std::process;
 use std::sync::Arc;
 
+use crossterm::style::Color;
 use rand::Rng;
 
 use crate::args::prelude::*;
+use crate::colour;
 use crate::config::{BehaviourOnError, Config, NumberOfQuestions};
 use crate::question::{Generator, Question};
 use crate::skill::doomsday_algorithm;
@@ -142,8 +144,15 @@ impl AppImpl {
     }
 
     fn handle_question(&self, question: &Question) {
-        println!("\nQ: {}", question.prompt());
-        print!("A: ");
+        println!(
+            "\n{}{}",
+            colour::format_text("Q: ", self.use_colour(), Color::DarkYellow),
+            question.prompt()
+        );
+        print!(
+            "{}",
+            colour::format_text("A: ", self.use_colour(), Color::DarkYellow)
+        );
         io::stdout().flush().expect("IO operation failed (flush)");
 
         self.stats.start_new_question();
@@ -190,25 +199,38 @@ impl AppImpl {
             }
         };
 
-        println!("{number_of_questions}. Use Ctrl+C to exit.");
+        let number_of_questions =
+            colour::format_text(number_of_questions, self.use_colour(), Color::DarkYellow);
+        let ctrl_c = colour::format_text("Ctrl+C", self.use_colour(), Color::Yellow);
+
+        println!("{number_of_questions}. Use {ctrl_c} to exit.");
     }
 
     fn print_stats_in_between(&self) {
-        match self.number_of_questions() {
-            NumberOfQuestions::Infinite => println!(
-                "Time taken: {}, current accuracy: {} ({})",
-                self.stats.get_last_question_time(),
-                self.stats.get_current_accuracy(),
-                self.stats.get_number_of_correct_answers(),
+        let text = match self.number_of_questions() {
+            NumberOfQuestions::Infinite => colour::format_text(
+                &format!(
+                    "Time taken: {}, current accuracy: {} ({})",
+                    self.stats.get_last_question_time(),
+                    self.stats.get_current_accuracy(),
+                    self.stats.get_number_of_correct_answers()
+                ),
+                self.use_colour(),
+                Color::Grey,
             ),
-            NumberOfQuestions::Limited(_) => println!(
-                "Time taken: {}, current accuracy: {} ({}), questions left: {}",
-                self.stats.get_last_question_time(),
-                self.stats.get_current_accuracy(),
-                self.stats.get_number_of_correct_answers(),
-                self.stats.get_number_of_remaining_questions(),
+            NumberOfQuestions::Limited(_) => colour::format_text(
+                &format!(
+                    "Time taken: {}, current accuracy: {} ({}), questions left: {}",
+                    self.stats.get_last_question_time(),
+                    self.stats.get_current_accuracy(),
+                    self.stats.get_number_of_correct_answers(),
+                    self.stats.get_number_of_remaining_questions(),
+                ),
+                self.use_colour(),
+                Color::Grey,
             ),
-        }
+        };
+        println!("{text}");
     }
 
     fn print_stats_post_game(&self) {
@@ -251,9 +273,17 @@ impl AppImpl {
     fn print_answer_feedback(&self, correct: bool, correct_answer: &str) {
         let mut feedback = String::new();
         if correct {
-            feedback.push_str(&Self::random_feedback_correct());
+            feedback.push_str(&colour::format_text(
+                &Self::random_feedback_correct(),
+                self.use_colour(),
+                Color::Green,
+            ));
         } else {
-            feedback.push_str(&Self::random_feedback_incorrect());
+            feedback.push_str(&colour::format_text(
+                &Self::random_feedback_incorrect(),
+                self.use_colour(),
+                Color::Red,
+            ));
             match self.config.options.behaviour_on_error {
                 BehaviourOnError::ShowCorrect => {
                     feedback.push_str(&format!(" Correct answer: {correct_answer}"));
@@ -388,4 +418,8 @@ impl AppImpl {
     fn number_of_questions(&self) -> NumberOfQuestions {
         self.config.options.number_of_questions
     }
+
+    fn use_colour(&self) -> bool {
+        self.config.options.use_colour
+    }
 }

src/application.rs

@@ -0,0 +1,9 @@
+use crossterm::style::{Color, Stylize};
+
+pub fn format_text(text: &str, apply: bool, colour: Color) -> String {
+    if apply {
+        text.with(colour).to_string()
+    } else {
+        text.to_string()
+    }
+}

src/colour.rs

@@ -1,5 +1,6 @@
 mod application;
 mod args;
+mod colour;
 mod config;
 mod question;
 mod skill;

src/lib.rs

@@ -231,8 +231,8 @@ impl Stats {
         let mut time = String::new();
         if hours > 0 {
             time.push_str(&format!("{hours}h "));
-        }
-        if minutes > 0 {
+            time.push_str(&format!("{minutes}m "));
+        } else if minutes > 0 {
             time.push_str(&format!("{minutes}m "));
         }
         time.push_str(&format!("{seconds}.{milliseconds}s"));
@@ -241,7 +241,7 @@ impl Stats {
     }
 
     fn truncate_trailing_zeros(number: u32) -> String {
-        let mut number = number.to_string();
+        let mut number = format!("{number:0>3}");
         while number.ends_with('0') && number.len() > 1 {
             number.pop();
         }
@@ -487,4 +487,51 @@ mod tests {
         assert_ne!(min_time, "0.0s", "Should be **more or less** 0.05s");
         assert_ne!(avg_time, "0.0s", "Should be **more or less** 0.225s");
     }
+
+    #[test]
+    fn duration_format() {
+        assert_eq!(Stats::format_duration(&Duration::from_millis(0)), "0.0s");
+        assert_eq!(Stats::format_duration(&Duration::from_millis(1)), "0.001s");
+        assert_eq!(Stats::format_duration(&Duration::from_millis(10)), "0.01s");
+        assert_eq!(Stats::format_duration(&Duration::from_millis(11)), "0.011s");
+        assert_eq!(Stats::format_duration(&Duration::from_millis(100)), "0.1s");
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(101)),
+            "0.101s"
+        );
+        assert_eq!(Stats::format_duration(&Duration::from_millis(110)), "0.11s");
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(111)),
+            "0.111s"
+        );
+        assert_eq!(Stats::format_duration(&Duration::from_millis(1000)), "1.0s");
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(1001)),
+            "1.001s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(10 * 1000)),
+            "10.0s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(60 * 1000)),
+            "1m 0.0s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(10 * 60 * 1000)),
+            "10m 0.0s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(60 * 60 * 1000)),
+            "1h 0m 0.0s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(168 * 60 * 60 * 1000)),
+            "168h 0m 0.0s"
+        );
+        assert_eq!(
+            Stats::format_duration(&Duration::from_millis(3 * 60 * 60 * 1000 + 5 * 60 * 1000 + 7 * 1000 + 93)),
+            "3h 5m 7.093s"
+        );
+    }
 }