Improve error handling for utils.rs and others

Author: nozwock

Cargo.toml

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

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),
             };
         }
     }

src/handlers/leetcode/api/question.rs

@@ -135,17 +135,19 @@ impl LeetCode<Authorized> {
         Ok(data.json::<Data>().map(|op| op.data.question)?)
     }
 
-    pub fn question_metadata(&self, title_slug: &str) -> Result<Question, &str> {
+    pub fn question_metadata(&self, title_slug: &str) -> Result<Question> {
         let client = &self.client;
         let url = "https://leetcode.com/graphql";
 
         let query = GraphqlRequest {
             query: "\n query consolePanelConfig($titleSlug: String!) {\n question(titleSlug: $titleSlug) {\n questionId\n questionFrontendId\n questionTitle\n enableDebugger\n enableRunCode\n enableSubmit\n enableTestMode\n exampleTestcaseList\n metaData\n }\n}\n".to_string(),
             variables: serde_json::to_string(&Variables { titleSlug: title_slug.to_string() }).unwrap(),
         };
-        let Ok(data) = client.post(url).json(&query).send() else {
-            return Err("Failed to fetch question id from leetcode!");
-        };
+        let data = client
+            .post(url)
+            .json(&query)
+            .send()
+            .wrap_err("Failed to fetch question id from LeetCode")?;
 
         #[derive(Debug, Deserialize)]
         struct QuestionWrapper {
@@ -158,7 +160,7 @@ impl LeetCode<Authorized> {
         }
 
         data.json::<Data>()
-            .map_err(|_| "Failed to parse question id from leetcode!")
+            .wrap_err("Failed to parse question id from LeetCode")
             .map(|opt| opt.data.question)
     }
 }

src/handlers/leetcode/api/submit.rs

@@ -1,7 +1,9 @@
 use crate::handlers::leetcode::*;
 
+use eyre::{bail, Context, Result};
+
 impl LeetCode<Authorized> {
-    pub fn submit(&self, codefile: &CodeFile) -> Result<SubmissionResult, &str> {
+    pub fn submit(&self, codefile: &CodeFile) -> Result<SubmissionResult> {
         let question_title = codefile.question_title.clone();
         let ques = self.question_metadata(&question_title)?;
         let question_id = ques.questionId;
@@ -19,68 +21,59 @@ impl LeetCode<Authorized> {
         question_id: String,
         question_title: String,
         typed_code: String,
-    ) -> Result<SubmissionResult, &str> {
+    ) -> Result<SubmissionResult> {
+        #[derive(Debug, Deserialize)]
+        struct SubmissionID {
+            submission_id: u32,
+        }
+
         let client = &self.client;
         let url = format!("https://leetcode.com/problems/{}/submit/", question_title);
         let submission = SubmitCode {
             lang,
             question_id,
             typed_code,
         };
-        let Ok(data)= client.post(&url).json(&submission).send() else {
-            return Err("Failed to parse arguments");
-        };
-        #[derive(Debug, Deserialize)]
-        struct SubmissionID {
-            submission_id: u32,
-        }
-        // println!("{}", data.text().unwrap());
-        let Ok(data) = data.json::<SubmissionID>() else {
-            return Err("Failed to fetch submission id from leetcode! Check your submissions manually on leetcode");
-        };
+        let data = client.post(&url).json(&submission).send()?.json::<SubmissionID>().wrap_err("Failed to fetch submission id from LeetCode, Check your submissions manually on leetcode")?;
+
         println!("Evaluating solution...");
         let submission_id = data.submission_id;
         let mut last_state = PendingState::Unknown;
 
         loop {
             let url = format!("https://leetcode.com/submissions/detail/{submission_id}/check/");
-            let Ok(data) = client.get(&url).send() else {
-                return Err("Failed to parse arguments!");
-            };
+            let data = client
+                .get(&url)
+                .send()?
+                .json::<SubmissionResult>()
+                .wrap_err(
+                    "Failed to fetch from leetcode! Try again after sometime or renew cookie",
+                )?;
 
-            let Ok(data) = data.json::<SubmissionResult>() else  {
-                return Err("Failed to fetch from leetcode! Try again after sometime or renew cookie");
-            };
             match data {
                 SubmissionResult::PendingResult(data) => {
                     let curr_state = data.state();
                     match curr_state {
-                        PendingState::Pending => {
-                            if last_state != PendingState::Pending {
-                                println!("Status : Evaluation Pending");
-                            }
+                        PendingState::Pending if last_state != PendingState::Pending => {
+                            println!("Status : Evaluation Pending");
                         }
-                        PendingState::Started => {
-                            if last_state != PendingState::Started {
-                                println!("Status : Execution Started");
-                            }
+                        PendingState::Started if last_state != PendingState::Started => {
+                            println!("Status : Execution Started");
                         }
                         PendingState::Success => {
-                            println!("Your code was executed successfully but we failed to parse result\nCheck on leetcode manually");
-                            std::process::exit(1);
+                            bail!("Your 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()
+                                data.state
                             );
-                            std::process::exit(1);
                         }
+                        _ => {}
                     };
                     last_state = curr_state;
-                    continue;
                 }
-                data => return Ok(data),
+                not_pending_data => return Ok(not_pending_data),
             };
         }
     }

src/main.rs

@@ -62,16 +62,11 @@ fn main() -> Result<()> {
             testcases,
             filename,
         }) => {
-            let success = execute_testcases(filename, Some(testcases), &lc).0;
-            if !success {
-                bail!("Failed to execute Testcases");
-            };
+            _ = execute_testcases(filename, Some(testcases), &lc)?;
+            // bail if `is_correct == false`?
         }
         Some(Commands::Run { filename }) => {
-            let success = execute_testcases(filename, None, &lc).0;
-            if !success {
-                bail!("Failed to execute"); // TODO: Fill the err message
-            };
+            _ = execute_testcases(filename, None, &lc)?;
         }
         Some(Commands::FastSubmit { filename }) => {
             let code_file = if let Some(path) = filename {
@@ -80,18 +75,16 @@ fn main() -> Result<()> {
                 CodeFile::from_dir()
             };
 
-            submit(&lc, code_file); // TODO(nozwock): Use thiserror for SubmissionResult
+            submit(&lc, code_file)?;
         }
         Some(Commands::Submit { filename }) => {
-            let (testcase_result, code_file) = execute_testcases(filename, None, &lc);
-            if testcase_result {
-                submit(&lc, code_file);
+            let (is_correct, code_file) = execute_testcases(filename, None, &lc)?;
+            if is_correct {
+                submit(&lc, code_file)?;
             } else {
                 bail!(
                     "{}",
-                    "Aborting submission due to failed testcase(s)!"
-                        .red()
-                        .bold()
+                    "Aborting submission due to failed testcase(s)".red().bold()
                 );
             }
         }