chore: introduce env_logger to make debug easier

Author: h3n4l

Cargo.toml

@@ -7,10 +7,14 @@ edition = "2021"
 
 [dependencies]
 
+
 reqwest = { version = "0.11.6", features = ["blocking", "json"] }
 serde_json = { version = "1.0" }
 serde = { version = "1.0", features = ["derive"] }
 anyhow = { version = "1.0" }
 inquire = { version = "0.6.1" }
 colored = { version = "2" }
 indicatif = { version = "0.17" }
+log = { version = "0.4" }
+env_logger = { version = "0.10" }
+chrono = { version = "0.4" }

src/app.rs

@@ -45,50 +45,69 @@ impl App {
         }
     }
 
+    // begin_converting_progress_bar beginning displaying the progress bar on the screen, and
+    // return a function to stop the progress bar.
+    fn begin_converting_progress_bar() -> impl FnOnce() {
+        let spinner_style = ProgressStyle::with_template("{prefix:.bold.dim} {spinner} {wide_msg}")
+            .unwrap()
+            .tick_chars("⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈✔");
+        let progress_bar = ProgressBar::new_spinner();
+        progress_bar.set_style(spinner_style);
+        progress_bar.set_prefix("Converting");
+        progress_bar.enable_steady_tick(std::time::Duration::from_millis(25));
+        move || {
+            progress_bar.finish_and_clear();
+        }
+    }
+
     pub fn run(&mut self) {
         loop {
             match &self.status {
-                Status::Begin(hello) => {
-                    println!("{}", hello);
+                Status::Begin(hello_msg) => {
+                    println!("{}", hello_msg);
                     self.status = Status::WaitingText;
                 }
                 Status::WaitingText => {
                     let question = Text::new("Text: ")
-                        .with_help_message("Input 'exit' or 'quit' to end the program.")
+                        .with_help_message("Input 'quit' to quit the program.")
                         .prompt()
                         .unwrap();
 
-                    if question == "exit" || question == "quit" {
+                    if question == "quit" {
                         self.status = Status::End;
                         continue;
                     }
 
-                    let spinner_style =
-                        ProgressStyle::with_template("{prefix:.bold.dim} {spinner} {wide_msg}")
-                            .unwrap()
-                            .tick_chars("⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈✔");
-                    let progress_bar = ProgressBar::new_spinner();
-                    progress_bar.set_style(spinner_style);
-                    progress_bar.enable_steady_tick(std::time::Duration::from_millis(25));
-                    progress_bar.set_prefix("Converting");
+                    let progress_bar_stopper = Self::begin_converting_progress_bar();
 
                     let detail = self.converter.convert(&question);
-                    progress_bar.finish_and_clear();
-                    if let Err(e) = detail {
-                        println!("Error: {}", e.to_string().red());
+                    progress_bar_stopper();
+
+                    if detail.is_err() {
+                        log::error!(
+                            "Cannot convert the text to command detail, error: {}",
+                            detail.err().unwrap()
+                        );
+                        self.status = Status::WaitingText;
                         continue;
                     }
+
                     let detail = detail.unwrap();
+
                     println!("{}:", "Description".bold());
                     for (index, desc) in detail.descriptions.iter().enumerate() {
                         println!("{}. {}", (index + 1).to_string().bold(), desc);
                     }
                     println!("{}: {}", "Command".bold(), detail.command.bold());
+
                     self.last_detail = Some(detail);
                     self.status = Status::WaitingUserChoice;
                 }
                 Status::WaitingUserChoice => {
-                    let last_detail = self.last_detail.as_ref().unwrap();
+                    let last_detail = self
+                        .last_detail
+                        .as_ref()
+                        .expect("Expecting get the last detail in WaitingUserChoice status.");
 
                     let options = vec![
                         UserChoice::ExecuteCommand,
@@ -99,6 +118,7 @@ impl App {
                     let ans = Select::new("What do you want to do next?", options)
                         .prompt()
                         .unwrap();
+
                     match ans {
                         UserChoice::ExecuteCommand => {
                             let result = execute_command(last_detail.command.as_str());

src/converter/openai.rs

@@ -97,7 +97,7 @@ pub mod gpt35_turbo {
             let prompt_response: PromptResponse = serde_json::from_str(&choice.message.content)
                 .map_err(|e| {
                     anyhow::anyhow!(
-                        "Failed to deserialize prompt response from gpt-3.5-turbo response: {}, err: {}",
+                        "Failed to deserialize prompt response from gpt-3.5-turbo, response: {}, err: {}",
                         choice.message.content,
                         e,
                     )

src/main.rs

@@ -1,18 +1,15 @@
-use colored::*;
-use std::env;
-
 use chatsh::app;
+use chrono::Local;
+use std::env;
+use std::io::Write;
 
 fn main() {
+    init_logger();
     let openai_key = env::var("OPENAI_KEY");
     if openai_key.is_err() {
-        println!(
-            "{}",
-            format!(
-                "Cannot get OPENAI_KEY environment variable, error: {}",
-                openai_key.err().unwrap()
-            )
-            .red()
+        log::error!(
+            "Cannot get OPENAI_KEY environment variable, error: {}",
+            openai_key.err().unwrap()
         );
         std::process::exit(1);
     }
@@ -21,3 +18,36 @@ fn main() {
     let mut app = app::App::new(openai_key.as_str());
     app.run();
 }
+
+fn init_logger() {
+    env_logger::Builder::new()
+        .format(|buf, record| {
+            let mut level_style = buf.style();
+            match record.level() {
+                log::Level::Error => level_style
+                    .set_color(env_logger::fmt::Color::Red)
+                    .set_bold(true),
+                log::Level::Warn => level_style
+                    .set_color(env_logger::fmt::Color::Yellow)
+                    .set_bold(true),
+                log::Level::Info => level_style
+                    .set_color(env_logger::fmt::Color::Green)
+                    .set_bold(true),
+                log::Level::Debug => level_style
+                    .set_color(env_logger::fmt::Color::Blue)
+                    .set_bold(true),
+                log::Level::Trace => level_style
+                    .set_color(env_logger::fmt::Color::Magenta)
+                    .set_bold(true),
+            };
+            writeln!(
+                buf,
+                "{} [{}] {}",
+                Local::now().format("%Y-%m-%dT%H:%M:%S"),
+                level_style.value(record.level()),
+                record.args()
+            )
+        })
+        .filter_level(log::LevelFilter::Info)
+        .init();
+}