Merge pull request #11 from nozwock/error-handling

Improve error handling

Author: dvishal485

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 clap = { version = "4.2.1", features = ["derive"] }
 colored = "2.0.0"
-reqwest ={version =  "0.11.16", features=["blocking", "json"]}
-serde = {version="1.0.159", features=["derive"]}
+eyre = "0.6.8"
+reqwest = { version = "0.11.16", features = ["blocking", "json"] }
+serde = { version = "1.0.159", features = ["derive"] }
 serde_json = "1.0.95"

src/file_parser/codefile.rs

@@ -1,3 +1,5 @@
+use eyre::Result;
+
 use super::language::*;
 use std::path::PathBuf;
 
@@ -20,43 +22,42 @@ impl Default for CodeFile {
 }
 
 impl CodeFile {
-    pub fn from_dir() -> Self {
+    pub fn from_file(path: &str) -> Result<Self> {
+        let path = PathBuf::from(&path);
+        let (_file_name, mut code_file) =
+            Self::is_valid_file(&path).ok_or_else(|| eyre::eyre!("Invalid file"))?;
+        let code = std::fs::read_to_string(&path)?;
+
+        let (question_title, parsed_code) = Self::parse_code(&code, code_file.language)?;
+
+        code_file.question_title = question_title;
+        code_file.code = parsed_code;
+
+        Ok(code_file)
+    }
+
+    pub fn from_dir() -> Result<Self> {
         let mut code_file: Option<CodeFile> = None;
-        let Ok(files) = std::fs::read_dir("./") else {
-            eprintln!("Error reading the current directory!");
-            std::process::exit(1);
-        };
-        for file in files {
-            let Ok(file) = file else {
-                // Bad path
-                continue
-            };
+        for file in std::fs::read_dir(".")?.filter_map(|f| f.ok()) {
             let path = file.path();
-            let Some(valid_file) = Self::is_valid_file(&path) else {continue};
-            let file_name = valid_file.0;
-            code_file = Some(valid_file.1);
-
-            if file_name.starts_with("main") {
-                break;
+            if let Some((file_name, code_file_)) = Self::is_valid_file(&path) {
+                code_file = Some(code_file_);
+                if file_name.starts_with("main") {
+                    break;
+                }
             }
         }
-        let mut code_file = code_file.unwrap_or_else(|| {
-            eprintln!("No code file found! Try creating a file named with proper extension",);
-            std::process::exit(1);
-        });
-        let Ok(code) = std::fs::read_to_string(&code_file.path) else {
-            eprintln!("Error reading the code file!");
-            std::process::exit(1);
-        };
-
-        let parsed_file = Self::parse_code(&code, code_file.language);
-        let Ok((question_title, parsed_code)) = parsed_file else{
-            eprintln!("Error parsing the code file!\n{}", parsed_file.unwrap_err());
-            std::process::exit(1);
-        };
+        let mut code_file = code_file.ok_or_else(|| {
+            eyre::eyre!("No code file found! Try creating a file named with proper extension")
+        })?;
+        let code = std::fs::read_to_string(&code_file.path)?;
+
+        let (question_title, parsed_code) = Self::parse_code(&code, code_file.language)?;
+
         code_file.question_title = question_title;
         code_file.code = parsed_code;
-        code_file
+
+        Ok(code_file)
     }
 
     fn is_valid_file<'a>(path: &'a std::path::PathBuf) -> Option<(&'a str, Self)> {
@@ -75,9 +76,7 @@ impl CodeFile {
         ))
     }
 
-    fn parse_code(code: &str, language: Language) -> Result<(String, String), &str> {
-        let question_title: String;
-        let parsed_code: String;
+    fn parse_code(code: &str, language: Language) -> Result<(String, String)> {
         let start = code
             .find("#LCSTART")
             .map(|idx| idx + code[idx..].find('\n').unwrap_or(0))
@@ -87,40 +86,26 @@ impl CodeFile {
             .unwrap_or(0);
 
         let end = code.find("#LCEND").unwrap_or(code.len());
-        if let Some(problem) = code.find("leetcode.com/problems/") {
-            let problem = (&code[problem..]).split_whitespace().next().unwrap();
-            let problem = problem.split('/').skip(2).next().unwrap();
-            question_title = problem.to_string();
-        } else {
-            return Err("No leetcode problem found in the code file. Please add the problem link in the code file using comments.");
-        }
-        let code = code[start..end].trim();
-        let code = code
+        let question_title = code[code.find("leetcode.com/problems/").ok_or_else(|| {
+            eyre::eyre!(
+                "No leetcode problem found in the code file. \
+        Please add the problem link in the code file using comments."
+            )
+        })?..]
+            .split_whitespace()
+            .next()
+            .expect("Should be Some since the find method succeed")
+            .split('/')
+            .skip(2)
+            .next()
+            .ok_or_else(|| eyre::eyre!("Invalid link, expected question identifier"))?
+            .to_string();
+        let parsed_code = code[start..end]
+            .trim()
             .trim_end_matches(language.inline_comment_start())
-            .trim_end();
-        parsed_code = code.to_string();
+            .trim_end()
+            .to_string();
 
         Ok((question_title, parsed_code))
     }
-
-    pub fn from_file(path: &str) -> Self {
-        let path = PathBuf::from(&path);
-        let Some(file) =  Self::is_valid_file(&path) else {
-            eprintln!("Invalid file!");
-            std::process::exit(1);
-        };
-        let (_, mut valid_file) = file;
-        let Ok(code) = std::fs::read_to_string(&path) else {
-            eprintln!("Error while reading file {}!", path.display());
-            std::process::exit(1);
-        };
-        let parsed_file = Self::parse_code(&code, valid_file.language);
-        let Ok((question_title, parsed_code)) = parsed_file else{
-            eprintln!("Error parsing the code file!\n{}", parsed_file.unwrap_err());
-            std::process::exit(1);
-        };
-        valid_file.question_title = question_title;
-        valid_file.code = parsed_code;
-        valid_file
-    }
 }

src/handlers/leetcode.rs

@@ -3,6 +3,7 @@ use super::user::*;
 use super::utils::*;
 use crate::file_parser::codefile::CodeFile;
 
+use eyre::Result;
 use serde::Deserialize;
 
 mod api;
@@ -27,36 +28,34 @@ impl LeetCode {
 impl LeetCode<Unauthorized> {
     /// # Authenticate with cookie
     /// Builds a new reqwest client with the cookie
-    pub fn authenticate(&self, cookie: &str) -> Result<LeetCode<Authorized>, &str> {
+    pub fn authenticate(&self, cookie: &str) -> Result<LeetCode<Authorized>> {
         let mut headers = reqwest::header::HeaderMap::with_capacity(5);
-        let Some(csrf_token) = cookie
+        let csrf_token = cookie
             .split(';')
             .find(|s| s.contains("csrftoken"))
-        else {
-            return  Err("No csrf token found");
-        };
-        let Some(csrf_token) = csrf_token.split('=').last() else{return Err("No csrf token found"); };
-        let csrf_token = csrf_token.to_string();
+            .map(|s| s.split('=').last())
+            .flatten()
+            .ok_or_else(|| eyre::eyre!("No csrf token found"))?;
+
         headers.insert(
             reqwest::header::COOKIE,
-            reqwest::header::HeaderValue::from_str(&cookie).unwrap(),
+            reqwest::header::HeaderValue::from_str(&cookie)?,
         );
         headers.insert(
                 reqwest::header::USER_AGENT,
-                reqwest::header::HeaderValue::from_str("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36").unwrap(),
+                reqwest::header::HeaderValue::from_str("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36")?,
         );
         headers.insert(
             reqwest::header::REFERER,
-            reqwest::header::HeaderValue::from_str("https://leetcode.com/").unwrap(),
+            reqwest::header::HeaderValue::from_str("https://leetcode.com/")?,
         );
         headers.insert(
             reqwest::header::HeaderName::from_static("x-csrftoken"),
-            reqwest::header::HeaderValue::from_str(csrf_token.as_str()).unwrap(),
+            reqwest::header::HeaderValue::from_str(csrf_token)?,
         );
         let client = reqwest::blocking::Client::builder()
             .default_headers(headers.clone())
-            .build()
-            .unwrap();
+            .build()?;
         Ok(LeetCode {
             state: std::marker::PhantomData::<Authorized>,
             client,

src/handlers/leetcode/api/execute.rs

@@ -1,30 +1,25 @@
 use crate::handlers::{leetcode::*, utils::ExecutionResult};
 
+use eyre::{bail, Context, Result};
+
 impl LeetCode<Authorized> {
-    pub fn execute_default(&self, codefile: &CodeFile) -> Result<ExecutionResult, &str> {
+    pub fn execute_default(&self, codefile: &CodeFile) -> Result<ExecutionResult> {
         self.execute(codefile, String::new())
     }
-    pub fn execute(
-        &self,
-        codefile: &CodeFile,
-        mut data_input: String,
-    ) -> Result<ExecutionResult, &str> {
+    pub fn execute(&self, codefile: &CodeFile, mut data_input: String) -> Result<ExecutionResult> {
         let question_title = codefile.question_title.clone();
         let ques = self.question_metadata(&question_title)?;
-        if data_input == "" {
+        if data_input.is_empty() {
             data_input = ques.exampleTestcaseList.join("\n");
+
             // write this to testcase.txt
-            if let Ok(mut file) = std::fs::File::create("testcase.txt") {
-                if let Ok(_) = std::io::Write::write_all(&mut file, data_input.as_bytes()) {
-                    println!("Wrote default testcases to testcase.txt");
-                } else {
-                    eprintln!("Failed to write default testcases to testcase.txt!");
-                }
-            } else {
-                eprintln!("Failed to create testcase.txt!");
-            }
+            let mut file = std::fs::File::create("testcase.txt")?;
+            std::io::Write::write_all(&mut file, data_input.as_bytes())?;
+            println!("Wrote default testcases to testcase.txt");
         }
+
         let question_id = ques.questionId;
+
         self._execute(
             codefile.language.to_string(),
             question_id,
@@ -41,39 +36,45 @@ impl LeetCode<Authorized> {
         question_title: String,
         typed_code: String,
         data_input: String,
-    ) -> Result<ExecutionResult, &str> {
+    ) -> Result<ExecutionResult> {
         let client = &self.client;
         let url = format!(
             "https://leetcode.com/problems/{}/interpret_solution/",
             question_title
         );
+
         let testcase = TestCaseExec {
             lang,
             question_id,
             question_title,
             typed_code,
             data_input,
         };
-        let Ok(data)= client.post(&url).json(&testcase).send() else {
-            return Err("Failed to parse arguments!");
-        };
-        let Ok(data) = data.json::<InterpretID>() else{
-            return Err("Failed to parse JSON from leetcode! Try again after sometime or renew cookie");
-        };
+
+        let data = client
+            .post(&url)
+            .json(&testcase)
+            .send()?
+            .json::<InterpretID>()
+            .wrap_err(
+                "Failed to parse JSON from LeetCode, Try again after sometime or renew your cookie",
+            )?;
 
         let interpret_id = data.interpret_id;
+
         println!("Executing testcases...");
         let mut last_state = PendingState::Unknown;
         loop {
             let url = format!("https://leetcode.com/submissions/detail/{interpret_id}/check/");
             // std::thread::sleep(std::time::Duration::from_secs(7));
-            let Ok(data) = client.get(&url).send() else {
-                return Err("Failed to parse arguments!");
-            };
+            let data = client
+                .get(&url)
+                .send()?
+                .json::<ExecutionResult>()
+                .wrap_err(
+                "Failed to parse JSON from LeetCode, Try again after sometime or renew your cookie",
+            )?;
 
-            let Ok(data) = data.json::<ExecutionResult>() else  {
-                return Err("Failed to parse JSON from leetcode! Try again after sometime or renew cookie");
-            };
             match data {
                 ExecutionResult::PendingResult(data) => {
                     let curr_state = data.state();
@@ -89,22 +90,18 @@ impl LeetCode<Authorized> {
                             }
                         }
                         PendingState::Success => {
-                            println!("Your code was executed successfully but we failed to parse result\nCheck on leetcode manually");
-                            std::process::exit(1);
+                            bail!("our code was executed successfully but we failed to parse result\nCheck on leetcode manually");
                         }
                         PendingState::Unknown => {
-                            println!(
+                            bail!(
                                 "Status : {}\nKindly report this state to developer",
                                 data.state.as_str()
                             );
-                            std::process::exit(1);
                         }
                     };
                     last_state = curr_state;
-
-                    continue;
                 }
-                data => return Ok(data),
+                not_pending_data => return Ok(not_pending_data),
             };
         }
     }