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(())

src/cmds/list.rs

@@ -35,8 +35,8 @@
 //! ```
 use super::Command;
 use crate::{cache::Cache, err::Error, helper::Digit};
+use async_trait::async_trait;
 use clap::{App, Arg, ArgMatches, SubCommand};
-use tokio::runtime::Runtime;
 /// Abstract `list` command
 ///
 /// ## handler
@@ -63,11 +63,12 @@ static LIST_AFTER_HELP: &str = r#"EXAMPLES:
     leetcode list                   List all questions
     leetcode list array             List questions that has "array" in name
     leetcode list -c database       List questions that in database category
-    leetcode list -q eD             List questions that with easy level and not done    
+    leetcode list -q eD             List questions that with easy level and not done
     leetcode list -t linked-list    List questions that under tag "linked-list"
 "#;
 
 /// implement Command trait for `list`
+#[async_trait]
 impl Command for ListCommand {
     /// `list` command usage
     fn usage<'a, 'list>() -> App<'a, 'list> {
@@ -121,16 +122,16 @@ impl Command for ListCommand {
     /// List commands contains "-c", "-q", "-s" flags.
     /// + matches with `-c` will override the default <all> keyword.
     /// + `-qs`
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), Error> {
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), Error> {
         trace!("Input list command...");
 
         let cache = Cache::new()?;
         let mut ps = cache.get_problems()?;
 
         // if cache doesn't exist, request a new copy
         if ps.is_empty() {
-            runtime.block_on(cache.download_problems())?;
-            return Self::handler(m, runtime);
+            cache.download_problems().await?;
+            return Self::handler(m).await;
         }
 
         // filtering...
@@ -145,8 +146,9 @@ impl Command for ListCommand {
 
         // filter tag
         if m.is_present("tag") {
-            let ids =
-                runtime.block_on(cache.get_tagged_questions(m.value_of("tag").unwrap_or("")))?;
+            let ids = cache
+                .get_tagged_questions(m.value_of("tag").unwrap_or(""))
+                .await?;
             crate::helper::squash(&mut ps, ids)?;
         }
 

src/cmds/mod.rs

@@ -11,16 +11,17 @@
 //!     help    Prints this message or the help of the given subcommand(s)
 //! ```
 use crate::err::Error;
+use async_trait::async_trait;
 use clap::{App, ArgMatches};
-use tokio::runtime::Runtime;
 
 /// Abstract commands' trait.
+#[async_trait]
 pub trait Command {
     /// Usage of the spefic command
     fn usage<'a, 'c>() -> App<'a, 'c>;
 
     /// The handler will deal [args, options,...] from the command-line
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), Error>;
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), Error>;
 }
 
 mod data;

src/cmds/pick.rs

@@ -1,8 +1,8 @@
 //! Pick command
 use super::Command;
 use crate::err::Error;
+use async_trait::async_trait;
 use clap::{App, Arg, ArgMatches, SubCommand};
-use tokio::runtime::Runtime;
 /// Abstract pick command
 ///
 /// ```sh
@@ -40,6 +40,7 @@ d = done     D = not done
 l = locked   L = not locked
 s = starred  S = not starred"#;
 
+#[async_trait]
 impl Command for PickCommand {
     /// `pick` usage
     fn usage<'a, 'pick>() -> App<'a, 'pick> {
@@ -71,15 +72,15 @@ impl Command for PickCommand {
     }
 
     /// `pick` handler
-    fn handler(m: &ArgMatches, runtime: &mut Runtime) -> Result<(), Error> {
+    async fn handler(m: &ArgMatches<'_>) -> Result<(), Error> {
         use crate::cache::Cache;
         use rand::Rng;
 
         let cache = Cache::new()?;
         let mut problems = cache.get_problems()?;
         if problems.is_empty() {
-            runtime.block_on(cache.download_problems())?;
-            Self::handler(m, runtime)?;
+            cache.download_problems().await?;
+            Self::handler(m).await?;
             return Ok(());
         }
 
@@ -95,11 +96,10 @@ impl Command for PickCommand {
 
         // tag filter
         if m.is_present("tag") {
-            let ids = runtime.block_on(
-                cache
-                    .clone()
-                    .get_tagged_questions(m.value_of("tag").unwrap_or("")),
-            )?;
+            let ids = cache
+                .clone()
+                .get_tagged_questions(m.value_of("tag").unwrap_or(""))
+                .await?;
             crate::helper::squash(&mut problems, ids)?;
         }
 
@@ -118,12 +118,12 @@ impl Command for PickCommand {
                 problem.fid
             });
 
-        let r = runtime.block_on(cache.get_question(fid));
+        let r = cache.get_question(fid).await;
         if r.is_err() {
             let e = r.err()?;
             eprintln!("{:?}", &e);
             if let Error::FeatureError(_) | Error::NetworkError(_) = e {
-                Self::handler(m, runtime)?;
+                Self::handler(m).await?;
             }
         } else {
             println!("{}", r?);