refactor(leetcode): use async

Author: bestgopher

Cargo.lock

@@ -10,16 +10,21 @@ members = ["./sort"]
 
 [dependencies]
 git2 = "0.14.4"
-reqwest = { version = "0.11.11", features = ["blocking", "json"] }
+reqwest = { version = "0.11.11", features = ["json"] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 clap = "3.0.0-beta.2"
 tera = "1.12.1"
 lazy_static = "1.4.0"
 regex = "1"
 rand = "0.8.4"
+tokio = { version = "1.33.0", features = ["fs", "macros", "rt-multi-thread"] }
+tokio-stream = { version = "0.1.14", features = ["fs"] }
 
 
 [[bin]]
 name = "leetcode"
 path = "src/main.rs"
+
+[dev-dependencies]
+tokio = { version = "1.33.0", features = ["macros", "rt"] }

Cargo.toml

@@ -1,12 +1,11 @@
-use crate::file;
+use std::sync::{Arc, Mutex};
 
+use crate::file;
 use crate::http::Resp;
-use std::sync::{Arc, Mutex};
-use std::thread;
 
 /// 重新格式化
-pub fn all() {
-    let files = file::get_all_bin_file();
+pub async fn all() {
+    let files = file::get_all_bin_file().await;
 
     let v = Vec::<Resp>::with_capacity(files.len());
 
@@ -23,18 +22,18 @@ pub fn all() {
 
         let x = x.clone();
 
-        handlers.push(thread::spawn(move || {
+        handlers.push(tokio::spawn(async move {
             for i in files {
                 println!("{} downloading", i);
-                let resp = crate::http::get_question_info(&i);
+                let resp = crate::http::get_question_info(&i).await;
                 x.lock().unwrap().push(resp);
             }
         }))
     }
 
     for i in handlers {
-        i.join().unwrap();
+        i.await.unwrap();
     }
 
-    crate::file::write_readme(&mut *x.lock().unwrap());
+    file::write_readme(&mut *x.lock().unwrap()).await;
 }

src/all.rs

@@ -1,7 +1,9 @@
 use lazy_static::lazy_static;
 use regex::Regex;
-use std::fs::{self, File};
-use std::io::Write;
+use tokio::fs::{self, File};
+use tokio::io::AsyncWriteExt;
+use tokio_stream::wrappers::ReadDirStream;
+use tokio_stream::StreamExt;
 
 use crate::http::{Data, Difficulty, Ques, Resp};
 
@@ -12,7 +14,7 @@ lazy_static! {
 }
 
 /// 将结果写入README.md中
-pub fn write_readme(r: &mut Vec<Resp>) {
+pub async fn write_readme(r: &mut Vec<Resp>) {
     // 先按id排序
     r.sort_by(|x, y| {
         let x_id = x.data.question.question_id.parse::<i32>().unwrap();
@@ -21,36 +23,39 @@ pub fn write_readme(r: &mut Vec<Resp>) {
     });
     let s = crate::render::render(r).unwrap();
 
-    match std::fs::write("README.md", s) {
+    match tokio::fs::write("README.md", s).await {
         Ok(_) => (),
         Err(e) => eprintln!("写入 README.md 失败，err{}", e.to_string()),
     }
 }
 
 /// 获取 src/bin 目录下所有文件的名称
-pub fn get_all_bin_file() -> Vec<String> {
-    let dir = fs::read_dir("src/bin/").unwrap();
-    dir.into_iter()
-        .map(|x| {
+pub async fn get_all_bin_file() -> Vec<String> {
+    let mut dir = ReadDirStream::new(fs::read_dir("src/bin/").await.unwrap());
+    let mut v = vec![];
+    while let Some(x) = dir.next().await {
+        v.push(
             x.unwrap()
                 .file_name()
                 .to_str()
                 .unwrap()
                 .trim_end_matches(".rs")
-                .to_string()
-        })
-        .collect()
+                .to_string(),
+        );
+    }
+
+    v
 }
 
 /// 创建 bin/{quest_name}.rs 文件
-pub fn write_question(resp: Resp) {
+pub async fn write_question(resp: Resp) {
     let file = format!("src/bin/{}.rs", resp.data.question.title_slug);
     if std::path::Path::new(file.as_str()).exists() {
         eprintln!("{} exists", file);
         return;
     }
 
-    let mut f = File::create(file.as_str()).unwrap();
+    let mut f = File::create(file.as_str()).await.unwrap();
     let mut s = String::new();
     s.push_str("#![allow(dead_code, unused, unused_variables, non_snake_case)]\n\n");
     s.push_str("fn main() {}\n\n");
@@ -64,12 +69,12 @@ pub fn write_question(resp: Resp) {
         }
     }
 
-    f.write_all(s.as_bytes()).unwrap();
+    f.write_all(s.as_bytes()).await.unwrap();
 }
 
 /// 解析README.md
-pub fn parse_readme() -> Vec<Resp> {
-    let contents = fs::read_to_string("README.md").unwrap();
+pub async fn parse_readme() -> Vec<Resp> {
+    let contents = fs::read_to_string("README.md").await.unwrap();
     parse(&contents)
 }
 
@@ -96,11 +101,12 @@ fn parse(contents: &str) -> Vec<Resp> {
 
 #[cfg(test)]
 mod tests {
-    use crate::file::{get_all_bin_file, parse};
+    use super::get_all_bin_file;
+    use super::parse;
 
-    #[test]
-    fn test_parse_readme() {
-        let contents = std::fs::read_to_string("README.md").unwrap();
+    #[tokio::test]
+    async fn test_parse_readme() {
+        let contents = tokio::fs::read_to_string("README.md").await.unwrap();
         let x = parse(&contents);
         println!("{:?}", x);
         println!("{}", x.len());
@@ -116,8 +122,8 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_get_all_bin_file() {
-        println!("{:?}", get_all_bin_file());
+    #[tokio::test]
+    async fn test_get_all_bin_file() {
+        println!("{:?}", get_all_bin_file().await);
     }
 }

src/file.rs

@@ -1,20 +1,20 @@
-use git2::{Repository, StatusOptions};
-
 use std::process::Command;
 
+use git2::{Repository, StatusOptions};
+
 /// 把新文件加入到git中
-pub fn push() {
+pub async fn push() {
     // 解析readme.md文件
-    let mut r = crate::file::parse_readme();
+    let mut r = crate::file::parse_readme().await;
     let new_file = get_uncommit_files();
     for i in new_file.iter() {
         let x = i.trim_end_matches(".rs"); // 去掉后缀
         let x = x.trim_start_matches("src/bin/"); // 去掉路径
         git_add(i);
-        r.push(crate::http::get_question_info(x));
+        r.push(crate::http::get_question_info(x).await);
     }
 
-    crate::file::write_readme(&mut r);
+    crate::file::write_readme(&mut r).await;
     git_add("README.md");
     push_to_origin();
 }

src/git.rs

@@ -2,9 +2,9 @@ use std::fmt;
 
 use lazy_static::lazy_static;
 use regex::Regex;
-use reqwest::blocking::Client;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use reqwest::Client;
 use serde::de::{Error, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 lazy_static! {
     static ref RE: Regex = Regex::new(r".*?/problems/(.*?)/").unwrap();
@@ -32,8 +32,8 @@ impl Difficulty {
 
 impl Serialize for Difficulty {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
+    where
+        S: Serializer,
     {
         match self {
             Self::Easy => serializer.serialize_str("Easy"),
@@ -45,8 +45,8 @@ impl Serialize for Difficulty {
 
 impl<'de> Deserialize<'de> for Difficulty {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
+    where
+        D: Deserializer<'de>,
     {
         struct DifficultyVisitor;
 
@@ -58,8 +58,8 @@ impl<'de> Deserialize<'de> for Difficulty {
             }
 
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
+            where
+                E: Error,
             {
                 match v {
                     "Easy" => Ok(Self::Value::Easy),
@@ -110,7 +110,7 @@ pub struct Resp {
     pub data: Data,
 }
 
-pub fn get_question_info(mut ques: &str) -> Resp {
+pub async fn get_question_info(mut ques: &str) -> Resp {
     if ques.starts_with("http") {
         ques = RE
             .captures_iter(ques)
@@ -131,21 +131,23 @@ pub fn get_question_info(mut ques: &str) -> Resp {
         .header("content-type", "application/json")
         .body(data)
         .send()
+        .await
         .unwrap()
         .json::<Resp>()
+        .await
         .expect(format!("{} download failed", ques).as_str())
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::http::get_question_info;
+    use super::get_question_info;
 
-    #[test]
-    fn test_get_question_info() {
-        println!("{:?}", get_question_info("container-with-most-water"));
+    #[tokio::test]
+    async fn test_get_question_info() {
+        println!("{:?}", get_question_info("container-with-most-water").await);
         println!(
             "{:?}",
-            get_question_info("https://leetcode-cn.com/problems/container-with-most-water/")
+            get_question_info("https://leetcode-cn.com/problems/container-with-most-water/").await
         );
     }
 }

src/http.rs

@@ -1,15 +1,15 @@
+use std::process;
+
+use clap::{App, Arg};
+
 mod all;
 mod file;
 mod git;
 mod http;
 mod new;
 mod render;
 
-use clap::{App, Arg};
-
-use std::process;
-
-pub fn run() {
+pub async fn run() {
     let matches = App::new("leetcode")
         .version("0.0.1")
         .author("bestgopher <84328409@qq.com>")
@@ -26,15 +26,15 @@ pub fn run() {
 
     if let Some(matches) = matches.subcommand_matches("new") {
         match matches.value_of_t::<String>("question_name") {
-            Ok(x) => new::new(x),
+            Ok(x) => new::new(x).await,
             Err(_) => {
                 eprintln!("please input the name of question");
                 process::exit(1);
             }
         }
     } else if matches.subcommand_matches("all").is_some() {
-        all::all();
+        all::all().await;
     } else {
-        git::push();
+        git::push().await;
     }
 }

src/lib.rs

@@ -1,3 +1,4 @@
-fn main() {
-    leetcode::run();
+#[tokio::main]
+async fn main() {
+    leetcode::run().await;
 }

src/main.rs

@@ -2,7 +2,7 @@
 /// 2.如果name是url，就不需要拼装，不是就需要拼装
 /// 3.请求结构，获取数据
 /// 4.将数据写入bin/{question_name}.rs文件中
-pub fn new(ques: String) {
-    let r = crate::http::get_question_info(ques.as_str());
-    crate::file::write_question(r);
+pub async fn new(ques: String) {
+    let r = crate::http::get_question_info(ques.as_str()).await;
+    crate::file::write_question(r).await;
 }