🎨 Fix clippy.

examples/host-side/src/main.rs

@@ -116,7 +116,7 @@ async fn main() -> Result<()> {
                                     },
                                 );
                             }
-                            ret.push(map.into());
+                            ret.push(map);
                         }
                     }
                     _ => unreachable!("Unsupported payload: {:?}", payload),

packages/macro-types/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+authors = ["langyo <[email protected]>"]
+name = "tairitsu-macro-types"
+
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+anyhow = "^1"
+async-trait = "^0.1"
+base64 = "^0.21"
+derive_more = "*"
+serde = { version = "^1", features = ["derive"] }
+serde_json = "^1"
+strum = "^0.25"
+strum_macros = "^0.25"

packages/macro-types/src/lib.rs

@@ -0,0 +1 @@
+

packages/macro/Cargo.toml

@@ -8,3 +8,17 @@ publish = false
 
 [lib]
 proc-macro = true
+
+[dependencies]
+tairitsu-macro-types = { path = "../macro-types" }
+
+anyhow = "^1"
+derive_more = "*"
+serde = { version = "^1", features = ["derive"] }
+serde_json = "^1"
+strum = "^0.25"
+strum_macros = "^0.25"
+
+syn = { version = "^2", features = ["full"] }
+proc-macro2 = "^1"
+quote = "^1"

packages/router/src/routes/backend/functions/users.rs

@@ -18,20 +18,20 @@ async fn query(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode,
 
     let ret = functions::query(item.uuid)
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
 
     let ret = ResponsePackage::Data(vec![ResponseStruct::UserInfo(ret.into())]);
-    to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+    to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
 }
 
 async fn count() -> Result<String, (StatusCode, String)> {
     let ret = functions::count()
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
     let ret = Count { count: ret };
 
     let ret = ResponsePackage::Data(vec![ResponseStruct::Count(ret)]);
-    to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+    to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
 }
 
 async fn list(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode, String)> {
@@ -42,14 +42,14 @@ async fn list(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode, S
 
     let ret = functions::list(cond.offset, cond.limit)
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
 
     let ret = ResponsePackage::Data(
         ret.iter()
             .map(|item| ResponseStruct::UserInfo(item.clone().into()))
             .collect(),
     );
-    to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+    to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
 }
 
 async fn update(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode, String)> {
@@ -60,7 +60,7 @@ async fn update(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode,
 
     functions::update(item.into())
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
 
     generate_ok_message()
 }
@@ -73,7 +73,7 @@ async fn delete(Json(item): Json<RequestPackage>) -> Result<String, (StatusCode,
 
     functions::delete(item.uuid)
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
 
     generate_ok_message()
 }

packages/router/src/routes/backend/secure/login.rs

@@ -26,18 +26,18 @@ pub async fn login(Json(item): Json<RequestPackage>) -> Result<String, (StatusCo
 
     let mut storage = functions::filter_by_name(item.name)
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
     if crypt_verify(item.password_hash, storage.password_hash.clone())
-        .or_else(|e| Err(generate_error_message(e.to_string())))?
+        .map_err(|e| generate_error_message(e.to_string()))?
     {
         let new_token = Uuid::new_v4();
-        storage.token = new_token.clone();
+        storage.token = new_token.to_owned();
         functions::update(storage)
             .await
-            .or_else(|e| Err(generate_error_message(e.to_string())))?;
+            .map_err(|e| generate_error_message(e.to_string()))?;
 
         let ret = ResponsePackage::Data(vec![ResponseType(UuidData { uuid: new_token })]);
-        to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+        to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
     } else {
         Err(generate_error_message("Wrong password".to_string()))
     }

packages/router/src/routes/backend/secure/register.rs

@@ -23,20 +23,20 @@ pub async fn register(Json(item): Json<RequestPackage>) -> Result<String, (Statu
 
     let mut storage = functions::filter_by_name(item.name.clone())
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
     if storage.name == item.name.clone() {
         Err(generate_error_message("Name already exists".to_string()))
     } else {
         let new_token = Uuid::new_v4();
         storage.name = item.name;
         storage.password_hash = crypt_generate(item.password_hash)
-            .or_else(|e| Err(generate_error_message(e.to_string())))?;
-        storage.token = new_token.clone();
+            .map_err(|e| generate_error_message(e.to_string()))?;
+        storage.token = new_token.to_owned();
         functions::insert(storage)
             .await
-            .or_else(|e| Err(generate_error_message(e.to_string())))?;
+            .map_err(|e| generate_error_message(e.to_string()))?;
 
         let ret = ResponsePackage::Data(vec![ResponseType(UuidData { uuid: new_token })]);
-        to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+        to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
     }
 }

packages/router/src/routes/backend/secure/verify.rs

@@ -19,12 +19,12 @@ pub async fn verify(Json(item): Json<RequestPackage>) -> Result<String, (StatusC
 
     let storage = functions::filter_by_name(item.name)
         .await
-        .or_else(|e| Err(generate_error_message(e.to_string())))?;
+        .map_err(|e| generate_error_message(e.to_string()))?;
     if item.token == storage.token {
         let ret = ResponsePackage::Data(vec![ResponseType(UuidData {
             uuid: storage.token,
         })]);
-        to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+        to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
     } else {
         Err(generate_error_message("Invalid token".to_string()))
     }

packages/router/src/routes/mod.rs

@@ -21,7 +21,7 @@ lazy_static! {
     static ref ROOT_DIR: PathBuf = {
         let root_dir = std::env::var("ROOT_DIR")
             .ok()
-            .and_then(|dir| Some(Path::new(&dir).to_path_buf()))
+            .map(|dir| Path::new(&dir).to_path_buf())
             .unwrap_or(std::env::current_dir().unwrap().join("packages/router/res"));
         info!(r#"Root dir is "{}""#, root_dir.display());
         root_dir

packages/router/src/routes/utils.rs

@@ -6,7 +6,7 @@ use tairitsu_utils::types::proto::{ResponsePackage, ResponseStruct};
 
 pub fn generate_ok_message() -> Result<String, (StatusCode, String)> {
     let ret = ResponsePackage::Data(vec![ResponseStruct::Ok]);
-    to_string(&ret).or_else(|e| Err(generate_error_message(e.to_string())))
+    to_string(&ret).map_err(|e| generate_error_message(e.to_string()))
 }
 
 pub fn generate_error_message(message: String) -> (StatusCode, String) {

packages/vm/src/runtime.rs

@@ -91,7 +91,7 @@ impl Image {
                 .precompile_component(component.as_ref())
                 .expect("Cannot compile module"),
         );
-        let component = unsafe { Component::deserialize(&engine, &cwasm.as_ref()).unwrap() };
+        let component = unsafe { Component::deserialize(&engine, cwasm.as_ref()).unwrap() };
 
         Self { engine, component }
     }

packages/vm/src/stream.rs

@@ -63,7 +63,9 @@ impl HostOutputStream for OutputStream {
             self.buffer.clear();
             Ok(())
         } else {
-            Err(StreamError::LastOperationFailed(anyhow::anyhow!("Failed to parse message")).into())
+            Err(StreamError::LastOperationFailed(anyhow::anyhow!(
+                "Failed to parse message"
+            )))
         }
     }