feat(async): use async-trait instead of blocking with tokio runtime everywhere

Author: clearloop

CHANGELOG.md

@@ -1,3 +1,8 @@
+## v0.3.0
+
++ Upgrade reqwest to async mode
++ Format code using clippy
+
 ## v0.2.23
 
 + support color display

Cargo.toml

@@ -4,7 +4,7 @@ path = "src/bin/lc.rs"
 
 [package]
 name = "leetcode-cli"
-version = "0.2.25"
+version = "0.3.0"
 authors = ["clearloop <cdr.today@foxmail.com>"]
 edition = "2018"
 description = "Leet your code in command-line."
@@ -16,6 +16,7 @@ keywords = ["cli", "games", "leetcode"]
 readme = './README.md'
 
 [dependencies]
+async-trait = "0.1.41"
 tokio = "0.2.22"
 clap = "2.33.0"
 colored = "1.9.1"

README.md

@@ -30,7 +30,7 @@ cargo install leetcode-cli
 **Please make sure you have logined in `leetcode.com` with `chrome`**, more info plz checkout [this](#cookies)
 
 ```sh
-leetcode 0.2.24
+leetcode 0.3.0
 May the Code be with You 👻
 
 USAGE:

src/bin/lc.rs

@@ -1,8 +1,14 @@
 use leetcode_cli::cli;
+use tokio::runtime::Builder;
 
 fn main() {
-    let r = cli::main();
-    if r.is_err() {
-        println!("{:?}", r.err().expect("This won't happend."));
+    if let Err(err) = Builder::new()
+        .basic_scheduler()
+        .enable_all()
+        .build()
+        .expect("Build tokio runtime failed")
+        .block_on(cli::main())
+    {
+        println!("{:?}", err);
     }
 }

src/cache/mod.rs

@@ -206,12 +206,12 @@ impl Cache {
         use std::fs::File;
         use std::io::Read;
 
-        let p = &self.get_problem(rfid)?;
-        // if p.desc.is_empty() {
-        //     trace!("Problem description does not exist, pull desc and exec again...");
-        //     self.get_question(rfid).await?;
-        //     return self.pre_run_code(run, rfid, testcase).await;
-        // }
+        let mut p = self.get_problem(rfid)?;
+        if p.desc.is_empty() {
+            trace!("Problem description does not exist, pull desc and exec again...");
+            self.get_question(rfid).await?;
+            p = self.get_problem(rfid)?;
+        }
 
         let d: Question = serde_json::from_str(&p.desc)?;
         let conf = &self.0.conf;
@@ -274,12 +274,6 @@ impl Cache {
         let debug_json: Result<VerifyResult, SJError> = from_str(&debug_raw);
         debug!("debug json deserializing: \n{:#?}", &debug_json);
 
-        // let mut res = debug_json?;
-        // res = match res.state.as_str() {
-        //     "SUCCESS" => res,
-        //     _ => self.recur_verify(rid).await?,
-        // };
-
         Ok(debug_json?)
     }
 
@@ -302,10 +296,13 @@ impl Cache {
             .json()
             .await?;
 
-        let mut res = match run {
-            Run::Test => self.recur_verify(run_res.interpret_id).await?,
-            Run::Submit => self.recur_verify(run_res.submission_id.to_string()).await?,
-        };
+        let mut res: VerifyResult = VerifyResult::default();
+        while res.state != "SUCCESS" {
+            res = match run {
+                Run::Test => self.recur_verify(run_res.interpret_id.clone()).await?,
+                Run::Submit => self.recur_verify(run_res.submission_id.to_string()).await?,
+            };
+        }
 
         res.name = json.get("name")?.to_string();
         res.data_input = json.get("data_input")?.to_string();

src/cache/models.rs

@@ -199,7 +199,7 @@ use super::parser::ssr;
 use crate::cache::Run;
 
 /// verify result model
-#[derive(Debug, Deserialize)]
+#[derive(Default, Debug, Deserialize)]
 pub struct VerifyResult {
     pub state: String,
     #[serde(skip)]

src/cli.rs

@@ -8,10 +8,9 @@ use crate::{
     flag::{Debug, Flag},
 };
 use clap::{crate_name, crate_version, App, AppSettings};
-use tokio::runtime::Builder;
 
 /// Get maches
-pub fn main() -> Result<(), Error> {
+pub async fn main() -> Result<(), Error> {
     let m = App::new(crate_name!())
         .version(crate_version!())
         .about("May the Code be with You 👻")
@@ -36,19 +35,14 @@ pub fn main() -> Result<(), Error> {
             .init();
     }
 
-    let mut runtime = Builder::new()
-        .basic_scheduler()
-        .enable_all()
-        .build()
-        .unwrap();
     match m.subcommand() {
-        ("data", Some(sub_m)) => Ok(DataCommand::handler(sub_m, &mut runtime)?),
-        ("edit", Some(sub_m)) => Ok(EditCommand::handler(sub_m, &mut runtime)?),
-        ("exec", Some(sub_m)) => Ok(ExecCommand::handler(sub_m, &mut runtime)?),
-        ("list", Some(sub_m)) => Ok(ListCommand::handler(sub_m, &mut runtime)?),
-        ("pick", Some(sub_m)) => Ok(PickCommand::handler(sub_m, &mut runtime)?),
-        ("stat", Some(sub_m)) => Ok(StatCommand::handler(sub_m, &mut runtime)?),
-        ("test", Some(sub_m)) => Ok(TestCommand::handler(sub_m, &mut runtime)?),
+        ("data", Some(sub_m)) => Ok(DataCommand::handler(sub_m).await?),
+        ("edit", Some(sub_m)) => Ok(EditCommand::handler(sub_m).await?),
+        ("exec", Some(sub_m)) => Ok(ExecCommand::handler(sub_m).await?),
+        ("list", Some(sub_m)) => Ok(ListCommand::handler(sub_m).await?),
+        ("pick", Some(sub_m)) => Ok(PickCommand::handler(sub_m).await?),
+        ("stat", Some(sub_m)) => Ok(StatCommand::handler(sub_m).await?),
+        ("test", Some(sub_m)) => Ok(TestCommand::handler(sub_m).await?),
         _ => Err(Error::MatchError),
     }
 }

src/cmds/data.rs

@@ -1,9 +1,9 @@
 //! Cache managger
 use super::Command;
 use crate::{cache::Cache, helper::Digit};
+use async_trait::async_trait;
 use clap::{App, Arg, ArgMatches, SubCommand};
 use colored::Colorize;
-use tokio::runtime::Runtime;
 
 /// Abstract `data` command
 ///
@@ -22,6 +22,7 @@ use tokio::runtime::Runtime;
 /// ```
 pub struct DataCommand;
 
+#[async_trait]
 impl Command for DataCommand {
     /// `data` command usage
     fn usage<'a, 'cache>() -> App<'a, 'cache> {
@@ -45,7 +46,7 @@ impl Command for DataCommand {
     }
 
     /// `data` handler
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), crate::err::Error> {
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), crate::err::Error> {
         use std::fs::File;
         use std::path::Path;
 
@@ -79,7 +80,7 @@ impl Command for DataCommand {
 
         if m.is_present("update") {
             flags += 1;
-            runtime.block_on(cache.update())?;
+            cache.update().await?;
             println!("{}", "ok!".bright_green());
         }
 

src/cmds/edit.rs

@@ -1,7 +1,7 @@
 //! Edit command
 use super::Command;
+use async_trait::async_trait;
 use clap::{App, ArgMatches};
-use tokio::runtime::Runtime;
 
 /// Abstract `edit` command
 ///
@@ -21,6 +21,7 @@ use tokio::runtime::Runtime;
 /// ```
 pub struct EditCommand;
 
+#[async_trait]
 impl Command for EditCommand {
     /// `edit` usage
     fn usage<'a, 'edit>() -> App<'a, 'edit> {
@@ -44,7 +45,7 @@ impl Command for EditCommand {
     }
 
     /// `edit` handler
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), crate::Error> {
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), crate::Error> {
         use crate::{cache::models::Question, Cache};
         use std::fs::File;
         use std::io::Write;
@@ -66,7 +67,7 @@ impl Command for EditCommand {
         if !Path::new(&path).exists() {
             let mut qr = serde_json::from_str(&target.desc);
             if qr.is_err() {
-                qr = Ok(runtime.block_on(cache.get_question(id))?);
+                qr = Ok(cache.get_question(id).await?);
             }
 
             let question: Question = qr?;

src/cmds/exec.rs

@@ -1,7 +1,7 @@
 //! Exec command
 use super::Command;
+use async_trait::async_trait;
 use clap::{App, ArgMatches};
-use tokio::runtime::Runtime;
 
 /// Abstract Exec Command
 ///
@@ -21,6 +21,7 @@ use tokio::runtime::Runtime;
 /// ```
 pub struct ExecCommand;
 
+#[async_trait]
 impl Command for ExecCommand {
     /// `exec` usage
     fn usage<'a, 'edit>() -> App<'a, 'edit> {
@@ -37,12 +38,12 @@ impl Command for ExecCommand {
     }
 
     /// `exec` handler
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), crate::Error> {
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), crate::Error> {
         use crate::cache::{Cache, Run};
 
         let id: i32 = m.value_of("id")?.parse()?;
         let cache = Cache::new()?;
-        let res = runtime.block_on(cache.exec_problem(id, Run::Submit, None))?;
+        let res = cache.exec_problem(id, Run::Submit, None).await?;
 
         println!("{}", res);
         Ok(())