Fix hang bug, beatify logs

mindeng · mindeng · commit 3d7ae4983aad · 2024-09-04T23:08:57.000+08:00
diff --git a/notion-async-api/src/api.rs b/notion-async-api/src/api.rs
@@ -41,12 +41,13 @@ impl RequestError {
 
 impl Display for RequestError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            RequestError::InvalidRequest(s) => write!(f, "invalid request: {s}"),
-            RequestError::InvalidResponse(s) => write!(f, "invalid response: {s}"),
-            RequestError::RetryAfter(s) => write!(f, "retry after: {s}"),
-            RequestError::Other(e) => write!(f, "request error: {e:?}"),
-        }
+        let s = match self {
+            RequestError::InvalidRequest(s) => format!("invalid request: {s}"),
+            RequestError::InvalidResponse(s) => format!("invalid response: {s}"),
+            RequestError::RetryAfter(s) => format!("retry after: {s}"),
+            RequestError::Other(e) => format!("request error: {e:?}"),
+        };
+        Display::fmt(&s, f)
     }
 }
 
diff --git a/notion-async-api/src/block.rs b/notion-async-api/src/block.rs
@@ -6,7 +6,10 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_with::serde_as;
 
-use crate::object::{Object, ObjectCommon};
+use crate::{
+    misc::Unquotes,
+    object::{Object, ObjectCommon},
+};
 
 /// Refer to:
 /// - [Notion JSON conventions](https://developers.notion.com/reference/intro#json-conventions)
@@ -78,7 +81,7 @@ pub enum BlockType {
 impl Display for BlockType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = serde_json::to_string(self).unwrap_or("".to_owned());
-        f.write_str(&s)
+        s.unquotes().fmt(f)
     }
 }
 
diff --git a/notion-async-api/src/error.rs b/notion-async-api/src/error.rs
@@ -33,7 +33,7 @@ impl NotionError {
 impl Display for NotionError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            NotionError::InvalidObject(s) => write!(f, "invalid notion object: {s}"),
+            NotionError::InvalidObject(s) => format!("invalid notion object: {s}").fmt(f),
             NotionError::RequestFailed(e) => e.fmt(f),
         }
     }
diff --git a/notion-async-api/src/fetcher.rs b/notion-async-api/src/fetcher.rs
@@ -152,13 +152,17 @@ impl Fetcher {
         async move {
             let (task_tx, mut task_rx) = channel(10);
 
-            this.do_task(task, res_tx.clone(), task_tx).await;
+            {
+                let this = this.clone();
+                let res_tx = res_tx.clone();
+                spawn(async move {
+                    while let Some(task) = task_rx.next().await {
+                        this.do_task_recurs(task, res_tx.clone()).await;
+                    }
+                });
+            }
 
-            spawn(async move {
-                while let Some(task) = task_rx.next().await {
-                    this.do_task_recurs(task, res_tx.clone()).await;
-                }
-            });
+            this.do_task(task, res_tx.clone(), task_tx).await;
         }
         .boxed()
     }
diff --git a/notion-async-api/src/misc.rs b/notion-async-api/src/misc.rs
@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::ops::Deref;
 use std::{fmt::Display, str::FromStr};
 
 use chrono::{DateTime, Utc};
@@ -33,7 +34,7 @@ pub enum Icon {
 impl Display for Icon {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = serde_json::to_string(self).unwrap();
-        f.write_str(&s)
+        s.unquotes().fmt(f)
     }
 }
 
@@ -47,7 +48,7 @@ pub enum NotionFile {
 impl Display for NotionFile {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = serde_json::to_string(self).unwrap();
-        f.write_str(&s)
+        s.unquotes().fmt(f)
     }
 }
 
@@ -69,7 +70,7 @@ impl Display for NotionFileType {
             NotionFileType::File => "file",
             NotionFileType::External => "external",
         };
-        f.write_str(s)
+        s.fmt(f)
     }
 }
 
@@ -105,3 +106,29 @@ pub struct DateProperty {
 pub struct UrlData {
     url: String,
 }
+
+pub(crate) trait Unquotes {
+    fn unquotes(&self) -> &str;
+}
+
+// impl Unquotes for &str {
+//     fn unquotes(&self) -> String {
+//         let s = match self.strip_prefix("\"").and_then(|x| x.strip_suffix("\"")) {
+//             Some(ss) => ss,
+//             None => self,
+//         };
+//         s.to_owned()
+//     }
+// }
+
+impl<T> Unquotes for T
+where
+    T: Deref<Target = str>,
+{
+    fn unquotes(&self) -> &str {
+        match self.strip_prefix("\"").and_then(|x| x.strip_suffix("\"")) {
+            Some(ss) => ss,
+            None => self,
+        }
+    }
+}
diff --git a/notion-async-api/src/object.rs b/notion-async-api/src/object.rs
@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 use thiserror::Error;
 
+use crate::misc::Unquotes;
 use crate::user::User;
 
 pub trait Object: Send {
@@ -58,7 +59,15 @@ pub enum ObjectType {
 
 impl Display for ObjectType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&serde_json::to_string(self).unwrap())
+        let s = match self {
+            ObjectType::Block => "block",
+            ObjectType::Page => "page",
+            ObjectType::Database => "database",
+            ObjectType::User => "user",
+            ObjectType::Comment => "comment",
+            ObjectType::List => "list",
+        };
+        s.fmt(f)
     }
 }
 
@@ -150,7 +159,8 @@ pub enum ParentType {
 
 impl Display for ParentType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&serde_json::to_string(self).unwrap())
+        let s = serde_json::to_string(self).unwrap();
+        s.unquotes().fmt(f)
     }
 }
 
@@ -159,7 +169,7 @@ pub struct ImpossibleParseError;
 
 impl Display for ImpossibleParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("ImpossibleParseError")
+        "ImpossibleParseError".fmt(f)
     }
 }
 
@@ -172,6 +182,6 @@ pub struct JsonObject {
 impl Display for JsonObject {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = serde_json::to_string(self).unwrap();
-        f.write_str(&s)
+        s.unquotes().fmt(f)
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -130,33 +130,38 @@ async fn run_sync(token: &str, page_id: &str, db: &mut SqliteConnection) {
                     // println!("⏬ {} {}", obj.object_type(), obj.id());
                     // save_object(&obj, "testdata").await?;
                 } else {
-                    println!("🔁 repeated {} {}", obj.object_type(), obj.id());
+                    eprintln!("➡️ 🔁 repeated {} {}", obj.object_type(), obj.id());
                 }
 
                 match obj {
                     notion_async_api::AnyObject::Block(block) => {
-                        println!("⏬ 🆎 block {} {}", block.id(), block.block_type);
+                        println!(
+                            "✔   {:8} {} {}",
+                            block.object_type(),
+                            block.id(),
+                            block.block_type
+                        );
                         insert_or_update_block(db, block).await.unwrap();
                     }
                     notion_async_api::AnyObject::Page(page) => {
-                        println!("⏬ 📃 page {}", page.id());
+                        println!("✔ 📃 {:8} {}", page.object_type(), page.id());
                         insert_or_update_page(db, page).await.unwrap();
                     }
                     notion_async_api::AnyObject::Database(database) => {
-                        println!("⏬ 🗐 database {}", database.id());
+                        println!("✔   {:8} {}", database.object_type(), database.id());
                         insert_or_update_database(db, database).await.unwrap();
                     }
                     notion_async_api::AnyObject::User(user) => {
-                        println!("⏬ 👤 user {}", user.id());
+                        println!("✔️ 👤 {:8} {}", user.object_type(), user.id());
                     }
                     notion_async_api::AnyObject::Comment(comment) => {
-                        println!("⏬ 📝 comment {}", comment.id(),);
+                        println!("✔   {:8} {}", comment.object_type(), comment.id(),);
                         insert_or_update_comment(db, comment).await.unwrap();
                     }
                 };
             }
             Err(e) => {
-                println!("❌ {e}");
+                eprintln!("❌ error {e}");
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ impl NotionError {`
`33`	`33`	`impl Display for NotionError {`
`34`	`34`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`35`	`35`	`match self {`
`36`		`- NotionError::InvalidObject(s) => write!(f, "invalid notion object: {s}"),`
	`36`	`+ NotionError::InvalidObject(s) => format!("invalid notion object: {s}").fmt(f),`
`37`	`37`	`NotionError::RequestFailed(e) => e.fmt(f),`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};`
`7`	`7`	`use serde_with::serde_as;`
`8`	`8`	`use thiserror::Error;`
`9`	`9`
	`10`	`+use crate::misc::Unquotes;`
`10`	`11`	`use crate::user::User;`
`11`	`12`
`12`	`13`	`pub trait Object: Send {`
`@@ -58,7 +59,15 @@ pub enum ObjectType {`
`58`	`59`
`59`	`60`	`impl Display for ObjectType {`
`60`	`61`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`61`		`- f.write_str(&serde_json::to_string(self).unwrap())`
	`62`	`+ let s = match self {`
	`63`	`+ ObjectType::Block => "block",`
	`64`	`+ ObjectType::Page => "page",`
	`65`	`+ ObjectType::Database => "database",`
	`66`	`+ ObjectType::User => "user",`
	`67`	`+ ObjectType::Comment => "comment",`
	`68`	`+ ObjectType::List => "list",`
	`69`	`+ };`
	`70`	`+ s.fmt(f)`
`62`	`71`	`}`
`63`	`72`	`}`
`64`	`73`
`@@ -150,7 +159,8 @@ pub enum ParentType {`
`150`	`159`
`151`	`160`	`impl Display for ParentType {`
`152`	`161`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`153`		`- f.write_str(&serde_json::to_string(self).unwrap())`
	`162`	`+ let s = serde_json::to_string(self).unwrap();`
	`163`	`+ s.unquotes().fmt(f)`
`154`	`164`	`}`
`155`	`165`	`}`
`156`	`166`
`@@ -159,7 +169,7 @@ pub struct ImpossibleParseError;`
`159`	`169`
`160`	`170`	`impl Display for ImpossibleParseError {`
`161`	`171`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`162`		`- f.write_str("ImpossibleParseError")`
	`172`	`+ "ImpossibleParseError".fmt(f)`
`163`	`173`	`}`
`164`	`174`	`}`
`165`	`175`
`@@ -172,6 +182,6 @@ pub struct JsonObject {`
`172`	`182`	`impl Display for JsonObject {`
`173`	`183`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`174`	`184`	`let s = serde_json::to_string(self).unwrap();`
`175`		`- f.write_str(&s)`
	`185`	`+ s.unquotes().fmt(f)`
`176`	`186`	`}`
`177`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,33 +130,38 @@ async fn run_sync(token: &str, page_id: &str, db: &mut SqliteConnection) {`
`130`	`130`	`// println!("⏬ {} {}", obj.object_type(), obj.id());`
`131`	`131`	`// save_object(&obj, "testdata").await?;`
`132`	`132`	`} else {`
`133`		`- println!("🔁 repeated {} {}", obj.object_type(), obj.id());`
	`133`	`+ eprintln!("➡️ 🔁 repeated {} {}", obj.object_type(), obj.id());`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`match obj {`
`137`	`137`	`notion_async_api::AnyObject::Block(block) => {`
`138`		`- println!("⏬ 🆎 block {} {}", block.id(), block.block_type);`
	`138`	`+ println!(`
	`139`	`+ "✔  {:8} {} {}",`
	`140`	`+ block.object_type(),`
	`141`	`+ block.id(),`
	`142`	`+ block.block_type`
	`143`	`+ );`
`139`	`144`	`insert_or_update_block(db, block).await.unwrap();`
`140`	`145`	`}`
`141`	`146`	`notion_async_api::AnyObject::Page(page) => {`
`142`		`- println!("⏬ 📃 page {}", page.id());`
	`147`	`+ println!("✔ 📃 {:8} {}", page.object_type(), page.id());`
`143`	`148`	`insert_or_update_page(db, page).await.unwrap();`
`144`	`149`	`}`
`145`	`150`	`notion_async_api::AnyObject::Database(database) => {`
`146`		`- println!("⏬ 🗐 database {}", database.id());`
	`151`	`+ println!("✔  {:8} {}", database.object_type(), database.id());`
`147`	`152`	`insert_or_update_database(db, database).await.unwrap();`
`148`	`153`	`}`
`149`	`154`	`notion_async_api::AnyObject::User(user) => {`
`150`		`- println!("⏬ 👤 user {}", user.id());`
	`155`	`+ println!("✔️ 👤 {:8} {}", user.object_type(), user.id());`
`151`	`156`	`}`
`152`	`157`	`notion_async_api::AnyObject::Comment(comment) => {`
`153`		`- println!("⏬ 📝 comment {}", comment.id(),);`
	`158`	`+ println!("✔  {:8} {}", comment.object_type(), comment.id(),);`
`154`	`159`	`insert_or_update_comment(db, comment).await.unwrap();`
`155`	`160`	`}`
`156`	`161`	`};`
`157`	`162`	`}`
`158`	`163`	`Err(e) => {`
`159`		`- println!("❌ {e}");`
	`164`	`+ eprintln!("❌ error {e}");`
`160`	`165`	`}`
`161`	`166`	`}`
`162`	`167`	`}`