refactor: .rustfmt changes, code cleaning

Author: dfayd0

.rustfmt.toml

@@ -2,21 +2,22 @@
 indent_style = "Block"
 unstable_features = true
 max_width = 80
+use_small_heuristics = "Max"
 color = "Always"
 format_strings = true
 space_after_colon = true
 
 # structs
-struct_field_align_threshold = 20
-struct_lit_single_line = false
+struct_field_align_threshold = 30
+struct_lit_single_line = true
 use_field_init_shorthand = true
 
 
 # Functions
 fn_params_layout = "Compressed"
 fn_call_width = 80
 brace_style = "PreferSameLine"
-empty_item_single_line = false
+empty_item_single_line = true
 
 # imports
 imports_granularity = "Crate"
@@ -38,5 +39,8 @@ overflow_delimited_expr = true
 comment_width = 80
 wrap_comments = true
 format_code_in_doc_comments = true
-
 normalize_comments = true
+
+# if
+single_line_if_else_max_width = 80
+single_line_let_else_max_width = 80

src/code_signature.rs

@@ -1,6 +1,7 @@
 use core::panic;
 
 use leetcoderustapi::ProgrammingLanguage;
+use thiserror;
 
 #[derive(Debug, Clone)]
 pub struct CodeSignature {
@@ -10,6 +11,12 @@ pub struct CodeSignature {
     pub return_type:   Option<String>,
 }
 
+#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CodeSignatureError {
+    #[error("Error parsing code signature")]
+    ParseError,
+}
+
 impl CodeSignature {
     pub fn new_function(name: String, params: Vec<String>) -> Self {
         Self {
@@ -31,21 +38,21 @@ impl CodeSignature {
 
     pub fn parse_code_signature(
         lang: &ProgrammingLanguage, starter_code: &str,
-    ) -> Result<CodeSignature, String> {
+    ) -> Result<CodeSignature, CodeSignatureError> {
         match lang {
             ProgrammingLanguage::Python => {
                 Self::parse_python_signature(&starter_code)
             },
             ProgrammingLanguage::Rust => {
                 Self::parse_rust_signature(&starter_code)
             },
-            _ => Err("Unsupported language".to_string()),
+            _ => Err(CodeSignatureError::ParseError),
         }
     }
 
     fn parse_python_signature(
         starter_code: &str,
-    ) -> Result<CodeSignature, String> {
+    ) -> Result<CodeSignature, CodeSignatureError> {
         if let Some(class_start) = starter_code.find("class ") {
             let class_end = starter_code[class_start..].find(':').unwrap_or(0)
                 + class_start;
@@ -83,12 +90,12 @@ impl CodeSignature {
             return Ok(CodeSignature::new_function(fn_name, parameters));
         }
 
-        Err("No function or class definition found in Python code".to_string())
+        Err(CodeSignatureError::ParseError)
     }
 
     fn parse_rust_signature(
         starter_code: &str,
-    ) -> Result<CodeSignature, String> {
+    ) -> Result<CodeSignature, CodeSignatureError> {
         if let Some(start) = starter_code.find("fn ") {
             let end = starter_code[start..].find('(').unwrap_or(0) + start;
             let fn_name = starter_code[start + 3..end].trim().to_string();
@@ -101,7 +108,7 @@ impl CodeSignature {
                 .collect::<Vec<String>>();
             return Ok(CodeSignature::new_function(fn_name, parameters));
         }
-        Err("No function definition found in Rust code".to_string())
+        Err(CodeSignatureError::ParseError)
     }
 
     pub fn resolve_declaration(

src/config.rs

@@ -31,8 +31,7 @@ impl Default for RuntimeConfigSetup {
 
 impl RuntimeConfigSetup {
     pub fn new() -> Self {
-        let home_dir =
-            dirs::home_dir().expect("Unable to determine home directory");
+        let home_dir = dirs::home_dir().expect("no home directory");
         let config_dir = home_dir.join(".config/leetcode-cli");
         let config_file = config_dir.join("config.toml");
         let default_leetcode_dir = home_dir.join("leetcode");

src/leetcode_api_runner.rs

@@ -1,4 +1,10 @@
-use std::io;
+use std::{
+    io,
+    path::{
+        Path,
+        PathBuf,
+    },
+};
 
 use colored::Colorize;
 use leetcoderustapi::{
@@ -39,19 +45,14 @@ impl LeetcodeApiRunner {
         })
     }
 
-    pub async fn get_problem_info(&self, id: u32) -> io::Result<String> {
-        let pb = self.api.set_problem_by_id(id).await.unwrap();
+    pub async fn get_problem_info(&self, id: u32) -> io::Result<()> {
+        let pb = self.api.set_problem_by_id(id).await?;
 
-        let title = pb.description().unwrap().name.bold().cyan();
-        let difficulty = match pb.difficulty().as_str() {
-            "Easy" => "Easy".green(),
-            "Medium" => "Medium".yellow(),
-            "Hard" => "Hard".red(),
-            _ => "Unknown".normal(),
-        };
-        let description = html2text(&pb.description().unwrap().content);
+        let title = pb.description()?.name.bold().cyan();
+        let difficulty = difficulty_color(&pb.difficulty());
+        let description = html2text(&pb.description()?.content);
 
-        Ok(format!("{} {}: {}\n{}", id, difficulty, title, description))
+        Ok(println!("{} {}: {}\n{}", id, difficulty, title, description))
     }
 
     /// Fetches the problem name by its ID.
@@ -76,54 +77,48 @@ impl LeetcodeApiRunner {
 
     pub async fn start_problem(
         &self, id: u32, lang: ProgrammingLanguage,
-    ) -> io::Result<String> {
+    ) -> io::Result<()> {
         let pb = self.api.set_problem_by_id(id).await?;
-        let pb_desc = pb.description().unwrap();
+        let pb_desc = pb.description()?;
         let pb_name = pb_desc.name.replace(" ", "_");
         let md_desc = html2md::parse_html(&pb_desc.content);
-        let pb_dir = self.prepare_problem_directory(id, &pb_name, &lang)?;
+        let (pb_dir, src_dir) =
+            self.prepare_problem_dir(id, &pb_name, &lang)?;
 
         let mut starter_code = self.get_starter_code(&lang, &pb)?;
         starter_code = inject_default_return_value(&starter_code, &lang);
 
-        let test_data =
-            LeetcodeReadmeParser::new(&md_desc).parse().map_err(|e| {
-                io::Error::new(io::ErrorKind::InvalidData, e.to_string())
-            })?;
-        let tests = TestGenerator::new(&starter_code, test_data)
-            .run(&lang)
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+        let test_data = LeetcodeReadmeParser::new(&md_desc).parse()?;
+        let tests = TestGenerator::new(&starter_code, test_data).run(&lang)?;
 
         let mut file_content = format!("{}\n\n{}", starter_code, tests);
         file_content = prefix_code(&file_content, &lang);
         file_content = postfix_code(&file_content, &lang);
         write_readme(&pb_dir, id, &pb_name, &md_desc)?;
-        let src_dir = pb_dir.join("src");
-        ensure_directory_exists(&src_dir)?;
         write_to_file(&src_dir, &get_file_name(&lang), &file_content)?;
 
-        Ok(format!(
-            "Problem {}: {} has been created at {} with the {} programming \
-             language.",
+        Ok(println!(
+            "{}: {} created at {} in {}.",
             id,
-            pb_name,
+            pb_name.green().bold(),
             pb_dir.display(),
             language_to_string(&lang)
         ))
     }
 
     /// Prepares the problem directory.
-    fn prepare_problem_directory(
+    fn prepare_problem_dir(
         &self, id: u32, pb_name: &str, language: &ProgrammingLanguage,
-    ) -> io::Result<std::path::PathBuf> {
+    ) -> io::Result<(PathBuf, PathBuf)> {
         let leetcode_dir = self.rcs.resolve_leetcode_dir()?;
         let problem_dir = leetcode_dir.join(format!("{}_{}", id, pb_name));
+        let src_dir = problem_dir.join("src");
+
         ensure_directory_exists(&problem_dir)?;
+        ensure_directory_exists(&src_dir)?;
 
-        // Initialize language-specific project structure
         self.initialize_language_project(&problem_dir, pb_name, language)?;
-
-        Ok(problem_dir)
+        Ok((problem_dir, src_dir))
     }
 
     /// Generates starter code for the specified programming language.
@@ -154,41 +149,32 @@ impl LeetcodeApiRunner {
     }
 
     pub async fn test_response(
-        &self, id: u32, path_to_file: String,
-    ) -> io::Result<String> {
-        let problem_info = self.api.set_problem_by_id(id).await.unwrap();
+        &self, id: u32, path_to_file: &String,
+    ) -> io::Result<()> {
+        let problem_info = self.api.set_problem_by_id(id).await?;
         let file_content = std::fs::read_to_string(&path_to_file)
             .expect("Unable to read the file");
         let language = get_language_from_extension(&path_to_file);
 
-        let test_response = problem_info
-            .send_test(language, &file_content)
-            .await
-            .unwrap();
-        Ok(format!("Test response for problem {}: {:#?}", id, test_response))
+        let test_res = problem_info.send_test(language, &file_content).await?;
+        Ok(println!("Test response for problem {}: {:?}", id, test_res))
     }
 
     pub async fn submit_response(
-        &self, id: u32, path_to_file: String,
-    ) -> io::Result<String> {
-        let problem_info = self.api.set_problem_by_id(id).await.unwrap();
+        &self, id: u32, path_to_file: &String,
+    ) -> io::Result<()> {
+        let pb = self.api.set_problem_by_id(id).await?;
         let file_content = std::fs::read_to_string(&path_to_file)
             .expect("Unable to read the file");
         let language = get_language_from_extension(&path_to_file);
 
-        let test_response = problem_info
-            .send_subm(language, &file_content)
-            .await
-            .unwrap();
-        Ok(format!(
-            "Here's your submit response for problem {}: {:#?}",
-            id, test_response
-        ))
+        let sub_res = pb.send_subm(language, &file_content).await?;
+        Ok(println!("{}: submit result {:?}", id, sub_res))
     }
 
     /// Initializes language-specific project structure.
     fn initialize_language_project(
-        &self, problem_dir: &std::path::Path, pb_name: &str,
+        &self, problem_dir: &Path, pb_name: &str,
         language: &ProgrammingLanguage,
     ) -> io::Result<()> {
         use std::process::Command;

src/main.rs

@@ -19,21 +19,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let api_runner = LeetcodeApiRunner::new(&rcs).await?;
 
     match &cli.command {
-        Commands::Info {
-            id,
-        } => {
+        Commands::Info { id } => {
             let mut spin = spin_the_spinner("Fetching problem info...");
             let result = api_runner.get_problem_info(*id).await;
             spin.stop();
             match result {
-                Ok(info) => println!("{}", info),
+                Ok(_) => (),
                 Err(e) => eprintln!("Error fetching problem info: {}", e),
             }
         },
-        Commands::Start {
-            id,
-            language,
-        } => {
+        Commands::Start { id, language } => {
             let default_lang = rcs
                 .config
                 .default_language
@@ -61,33 +56,27 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             let start_problem = api_runner.start_problem(*id, lang).await;
             spin.stop();
             match start_problem {
-                Ok(message) => println!("{}\n\nHappy coding :)", message),
+                Ok(_) => println!("\n\nHappy coding :)"),
                 Err(e) => eprintln!("Error starting problem: {}", e),
             }
         },
-        Commands::Test {
-            id,
-            path_to_file,
-        } => {
+        Commands::Test { id, path_to_file } => {
             let mut spin = spin_the_spinner("Running tests...");
             let test_result =
-                api_runner.test_response(*id, path_to_file.clone()).await;
+                api_runner.test_response(*id, &path_to_file.clone()).await;
             spin.stop();
             match test_result {
-                Ok(result) => println!("Test result: {}", result),
+                Ok(_) => println!("Test result"),
                 Err(e) => eprintln!("Error running tests: {}", e),
             }
         },
-        Commands::Submit {
-            id,
-            path_to_file,
-        } => {
+        Commands::Submit { id, path_to_file } => {
             let mut spin = spin_the_spinner("Submitting solution...");
             let submit_result =
-                api_runner.submit_response(*id, path_to_file.clone()).await;
+                api_runner.submit_response(*id, &path_to_file.clone()).await;
             spin.stop();
             match submit_result {
-                Ok(result) => println!("Submit result: {}", result),
+                Ok(_) => println!("Submit result"),
                 Err(e) => eprintln!("Error submitting solution: {}", e),
             }
         },

src/readme_parser.rs

@@ -17,11 +17,15 @@ pub enum LeetcodeReadmeParserError {
     EmptyReadme,
 }
 
+impl From<LeetcodeReadmeParserError> for std::io::Error {
+    fn from(e: LeetcodeReadmeParserError) -> Self {
+        std::io::Error::new(std::io::ErrorKind::InvalidData, e)
+    }
+}
+
 impl LeetcodeReadmeParser {
     pub fn new(readme: &str) -> Self {
-        LeetcodeReadmeParser {
-            raw: readme.to_string(),
-        }
+        LeetcodeReadmeParser { raw: readme.to_string() }
     }
 
     pub fn parse(&self) -> Result<ProblemTestData, LeetcodeReadmeParserError> {
@@ -36,10 +40,7 @@ impl LeetcodeReadmeParser {
     }
 
     fn count_examples(&self) -> usize {
-        self.raw
-            .lines()
-            .filter(|line| line.starts_with("**Example"))
-            .count()
+        self.raw.lines().filter(|line| line.starts_with("**Example")).count()
     }
 
     fn extract_inputs(&self) -> Vec<String> {