Apply clippy suggestions

3 files changed, 57 insertions, 72 deletions

diff --git a/crates/vcs_actions/src/actions.rs b/crates/vcs_actions/src/actions.rs
index 81dcd96..87c0231 100644
--- a/crates/vcs_actions/src/actions.rs
+++ b/crates/vcs_actions/src/actions.rs
@@ -167,26 +167,24 @@ pub async fn get_current_sheet_name(
         return Err(TcpTargetError::NotFound("Sheet not found".to_string()));
     }
     if ctx.is_proc_on_remote() {
-        let vault = try_get_vault(&ctx)?;
+        let vault = try_get_vault(ctx)?;
 
         // Read sheet name
         let sheet_name: SheetName = mut_instance.read_msgpack().await?;
 
         // Check if sheet exists
-        if let Ok(sheet) = vault.sheet(&sheet_name).await {
-            if let Some(holder) = sheet.holder() {
-                if holder == member_id {
+        if let Ok(sheet) = vault.sheet(&sheet_name).await
+            && let Some(holder) = sheet.holder()
+                && holder == member_id {
                     // Tell local the check is passed
                     mut_instance.write_msgpack(true).await?;
                     return Ok(sheet_name.clone());
                 }
-            }
-        }
         // Tell local the check is not passed
         mut_instance.write_msgpack(false).await?;
         return Err(TcpTargetError::NotFound("Sheet not found".to_string()));
     }
-    return Err(TcpTargetError::NoResult("NoResult".to_string()));
+    Err(TcpTargetError::NoResult("NoResult".to_string()))
 }
 
 /// The macro to write and return a result.
diff --git a/crates/vcs_actions/src/actions/local_actions.rs b/crates/vcs_actions/src/actions/local_actions.rs
index f48cf6c..e1c7dd9 100644
--- a/crates/vcs_actions/src/actions/local_actions.rs
+++ b/crates/vcs_actions/src/actions/local_actions.rs
@@ -163,10 +163,7 @@ pub async fn update_to_latest_info_action(
                 } else {
                     member_visible.push(SheetInfo {
                         sheet_name: sheet.name().clone(),
-                        holder_name: match sheet.holder() {
-                            Some(holder) => Some(holder.clone()),
-                            None => None,
-                        },
+                        holder_name: sheet.holder().cloned(),
                     });
                 }
             }
@@ -186,7 +183,7 @@ pub async fn update_to_latest_info_action(
             instance
                 .lock()
                 .await
-                .write_large_msgpack(latest_info, 512 as u16)
+                .write_large_msgpack(latest_info, 512_u16)
                 .await?;
         }
 
@@ -195,7 +192,7 @@ pub async fn update_to_latest_info_action(
             let mut latest_info = instance
                 .lock()
                 .await
-                .read_large_msgpack::<LatestInfo>(512 as u16)
+                .read_large_msgpack::<LatestInfo>(512_u16)
                 .await?;
             latest_info.update_instant = Some(Instant::now());
             LatestInfo::write_to(
@@ -257,13 +254,14 @@ pub async fn update_to_latest_info_action(
 
                     for (sheet_name, local_write_count) in local_versions.iter() {
                         let sheet = vault.sheet(sheet_name).await?;
-                        if let Some(holder) = sheet.holder() {
-                            if holder == &member_id && &sheet.write_count() != local_write_count {
-                                mut_instance.write_msgpack(true).await?;
-                                mut_instance
-                                    .write_large_msgpack((sheet_name, sheet.to_data()), 1024u16)
-                                    .await?;
-                            }
+                        if let Some(holder) = sheet.holder()
+                            && holder == &member_id
+                            && &sheet.write_count() != local_write_count
+                        {
+                            mut_instance.write_msgpack(true).await?;
+                            mut_instance
+                                .write_large_msgpack((sheet_name, sheet.to_data()), 1024u16)
+                                .await?;
                         }
                     }
                     mut_instance.write_msgpack(false).await?;
@@ -299,13 +297,14 @@ pub async fn update_to_latest_info_action(
 
             for (sheet_name, version) in local_versions.iter() {
                 let sheet = vault.sheet(sheet_name).await?;
-                if let Some(holder) = sheet.holder() {
-                    if holder == &member_id && &sheet.write_count() != version {
-                        mut_instance.write_msgpack(true).await?;
-                        mut_instance
-                            .write_large_msgpack((sheet_name, sheet.to_data()), 1024u16)
-                            .await?;
-                    }
+                if let Some(holder) = sheet.holder()
+                    && holder == &member_id
+                    && &sheet.write_count() != version
+                {
+                    mut_instance.write_msgpack(true).await?;
+                    mut_instance
+                        .write_large_msgpack((sheet_name, sheet.to_data()), 1024u16)
+                        .await?;
                 }
             }
             mut_instance.write_msgpack(false).await?;
@@ -351,10 +350,8 @@ pub async fn update_to_latest_info_action(
 
             // Read configuration file
             let path = LatestFileData::data_path(&member_id)?;
-            let mut latest_file_data = match LatestFileData::read_from(&path).await {
-                Ok(r) => r,
-                Err(_) => LatestFileData::default(),
-            };
+            let mut latest_file_data: LatestFileData =
+                LatestFileData::read_from(&path).await.unwrap_or_default();
 
             // Write the received information
             latest_file_data.update_info(result);
@@ -434,8 +431,8 @@ pub async fn update_to_latest_info_action(
 
                 // If path not match, try to move
                 let move_result = local_sheet.move_mapping(&local_path, cached_item_path);
-                match move_result {
-                    Err(e) => match e.kind() {
+                if let Err(e) = move_result {
+                    match e.kind() {
                         ErrorKind::AlreadyExists => {
                             return Ok(UpdateToLatestInfoResult::SyncCachedSheetFail(
                                 SyncCachedSheetFailReason::PathAlreadyExist(
@@ -444,8 +441,7 @@ pub async fn update_to_latest_info_action(
                             ));
                         }
                         _ => return Err(e.into()),
-                    },
-                    _ => {}
+                    }
                 }
                 local_sheet.write().await?;
             }
diff --git a/crates/vcs_actions/src/actions/virtual_file_actions.rs b/crates/vcs_actions/src/actions/virtual_file_actions.rs
index dff31fb..3760444 100644
--- a/crates/vcs_actions/src/actions/virtual_file_actions.rs
+++ b/crates/vcs_actions/src/actions/virtual_file_actions.rs
@@ -6,7 +6,6 @@ use std::{
 
 use action_system::{action::ActionContext, macros::action_gen};
 use cfg_file::config::ConfigFile;
-use log::info;
 use serde::{Deserialize, Serialize};
 use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
 use tokio::sync::Mutex;
@@ -159,7 +158,7 @@ pub async fn track_file_action(
                         }
                     }
                 };
-                return None;
+                None
             });
             result.collect()
         };
@@ -174,9 +173,7 @@ pub async fn track_file_action(
 
             let result = other.iter().filter_map(|p| {
                 // In cached sheet
-                let Some(cached_sheet_mapping) = cached_sheet.mapping().get(p) else {
-                    return None;
-                };
+                let cached_sheet_mapping = cached_sheet.mapping().get(p)?;
 
                 // Check if path mapping at local sheet
                 if let Ok(data) = local_sheet.mapping_data(p) {
@@ -191,7 +188,7 @@ pub async fn track_file_action(
                     }
                 }
 
-                return None;
+                None
             });
             result.collect()
         };
@@ -263,9 +260,6 @@ pub async fn track_file_action(
         {
             Ok(r) => match r {
                 SyncTaskResult::Success(relative_pathes) => relative_pathes,
-                _ => {
-                    return Ok(TrackFileActionResult::SyncTaskFailed(r));
-                }
             },
             Err(e) => return Err(e),
         };
@@ -335,9 +329,6 @@ pub async fn track_file_action(
         {
             Ok(r) => match r {
                 SyncTaskResult::Success(relative_pathes) => relative_pathes,
-                _ => {
-                    return Ok(TrackFileActionResult::SyncTaskFailed(r));
-                }
             },
             Err(e) => return Err(e),
         };
@@ -360,7 +351,7 @@ async fn proc_create_tasks_local(
     relative_paths: Vec<PathBuf>,
     print_infos: bool,
 ) -> Result<CreateTaskResult, TcpTargetError> {
-    let workspace = try_get_local_workspace(&ctx)?;
+    let workspace = try_get_local_workspace(ctx)?;
     let mut mut_instance = instance.lock().await;
     let mut local_sheet = workspace.local_sheet(member_id, sheet_name).await?;
 
@@ -383,7 +374,7 @@ async fn proc_create_tasks_local(
         let full_path = workspace.local_path().join(&path);
 
         // Send file
-        if let Err(_) = mut_instance.write_file(&full_path).await {
+        if mut_instance.write_file(&full_path).await.is_err() {
             continue;
         }
 
@@ -434,7 +425,7 @@ async fn proc_create_tasks_remote(
     sheet_name: &SheetName,
     relative_paths: Vec<PathBuf>,
 ) -> Result<CreateTaskResult, TcpTargetError> {
-    let vault = try_get_vault(&ctx)?;
+    let vault = try_get_vault(ctx)?;
     let mut mut_instance = instance.lock().await;
 
     // Sheet check
@@ -501,14 +492,14 @@ async fn proc_update_tasks_local(
     print_infos: bool,
     file_update_info: HashMap<PathBuf, (NextVersion, UpdateDescription)>,
 ) -> Result<UpdateTaskResult, TcpTargetError> {
-    let workspace = try_get_local_workspace(&ctx)?;
+    let workspace = try_get_local_workspace(ctx)?;
     let mut mut_instance = instance.lock().await;
     let mut local_sheet = workspace.local_sheet(member_id, sheet_name).await?;
 
     let mut success = Vec::new();
 
     for path in relative_paths.iter() {
-        let Ok(mapping) = local_sheet.mapping_data(&path) else {
+        let Ok(mapping) = local_sheet.mapping_data(path) else {
             // Is mapping not found, write empty
             mut_instance.write_msgpack("".to_string()).await?;
             continue;
@@ -610,7 +601,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Sheet not found
         };
         let Ok(mut sheet) = vault.sheet(sheet_name).await else {
@@ -619,7 +610,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Sheet not found
         };
         let Some(mapping_data) = sheet.mapping_mut().get_mut(path) else {
@@ -628,7 +619,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Mapping not found
         };
         let Ok(vf) = vault.virtual_file(&mapping_data.id) else {
@@ -637,7 +628,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Virtual file not found
         };
         let Ok(vf_metadata) = vf.read_meta().await else {
@@ -646,7 +637,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Read virtual file metadata failed
         };
         if vf_metadata.versions().contains(next_version) {
@@ -655,7 +646,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // VersionAlreadyExist
         }
         if vf_metadata.hold_member() != member_id {
@@ -664,7 +655,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Member not held it
         };
         if mapping_data.version != version {
@@ -674,7 +665,7 @@ async fn proc_update_tasks_remote(
             mut_instance.write_msgpack(reason.clone()).await?;
             return Ok(UpdateTaskResult::VerifyFailed {
                 path: path.clone(),
-                reason: reason,
+                reason,
             }); // Version does not match
         };
         mut_instance.write_msgpack(true).await?; // Verified
@@ -691,7 +682,7 @@ async fn proc_update_tasks_remote(
                 &mut mut_instance,
                 member_id,
                 &mapping_data.id,
-                &next_version,
+                next_version,
                 VirtualFileVersionDescription {
                     creator: member_id.clone(),
                     description: description.clone(),
@@ -720,22 +711,22 @@ async fn proc_update_tasks_remote(
 }
 
 async fn proc_sync_tasks_local(
-    ctx: &ActionContext,
-    instance: Arc<Mutex<ConnectionInstance>>,
-    member_id: &MemberId,
-    sheet_name: &SheetName,
-    relative_paths: Vec<PathBuf>,
-    print_infos: bool,
+    _ctx: &ActionContext,
+    _instance: Arc<Mutex<ConnectionInstance>>,
+    _member_id: &MemberId,
+    _sheet_name: &SheetName,
+    _relative_paths: Vec<PathBuf>,
+    _print_infos: bool,
 ) -> Result<SyncTaskResult, TcpTargetError> {
     Ok(SyncTaskResult::Success(Vec::new()))
 }
 
 async fn proc_sync_tasks_remote(
-    ctx: &ActionContext,
-    instance: Arc<Mutex<ConnectionInstance>>,
-    member_id: &MemberId,
-    sheet_name: &SheetName,
-    relative_paths: Vec<PathBuf>,
+    _ctx: &ActionContext,
+    _instance: Arc<Mutex<ConnectionInstance>>,
+    _member_id: &MemberId,
+    _sheet_name: &SheetName,
+    _relative_paths: Vec<PathBuf>,
 ) -> Result<SyncTaskResult, TcpTargetError> {
     Ok(SyncTaskResult::Success(Vec::new()))
 }