Apply clippy suggestions

13 files changed, 122 insertions, 173 deletions

diff --git a/crates/utils/string_proc/src/format_path.rs b/crates/utils/string_proc/src/format_path.rs
index a3493f5..152b791 100644
--- a/crates/utils/string_proc/src/format_path.rs
+++ b/crates/utils/string_proc/src/format_path.rs
@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 /// Format path str
 pub fn format_path_str(path: impl Into<String>) -> Result<String, std::io::Error> {
@@ -42,7 +42,7 @@ pub fn format_path_str(path: impl Into<String>) -> Result<String, std::io::Error
 }
 
 /// Normalize path by resolving ".." components without requiring file system access
-fn normalize_path(path: &PathBuf) -> PathBuf {
+fn normalize_path(path: &Path) -> PathBuf {
     let mut components = Vec::new();
 
     for component in path.components() {
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()))
 }
diff --git a/crates/vcs_data/src/data/local.rs b/crates/vcs_data/src/data/local.rs
index e7c5bcf..22589fc 100644
--- a/crates/vcs_data/src/data/local.rs
+++ b/crates/vcs_data/src/data/local.rs
@@ -117,12 +117,12 @@ impl LocalWorkspace {
 
     /// Get the path to a local sheet.
     pub fn local_sheet_path(&self, member: &MemberId, sheet: &SheetName) -> PathBuf {
-        let result = self.local_path.join(
+        
+        self.local_path.join(
             CLIENT_FILE_LOCAL_SHEET
                 .replace(ACCOUNT_NAME, member)
                 .replace(SHEET_NAME, sheet),
-        );
-        result
+        )
     }
 
     /// Read or initialize a local sheet.
@@ -175,14 +175,12 @@ impl LocalWorkspace {
 
                     if path.is_dir() {
                         Box::pin(collect_sheet_paths(&path, suffix, paths)).await?;
-                    } else if path.is_file() {
-                        if let Some(extension) = path.extension() {
-                            if extension == suffix.trim_start_matches('.') {
+                    } else if path.is_file()
+                        && let Some(extension) = path.extension()
+                            && extension == suffix.trim_start_matches('.') {
                                 let formatted_path = format_path(path)?;
                                 paths.push(formatted_path);
                             }
-                        }
-                    }
                 }
             }
             Ok(())
diff --git a/crates/vcs_data/src/data/local/cached_sheet.rs b/crates/vcs_data/src/data/local/cached_sheet.rs
index e617922..39f9814 100644
--- a/crates/vcs_data/src/data/local/cached_sheet.rs
+++ b/crates/vcs_data/src/data/local/cached_sheet.rs
@@ -55,16 +55,14 @@ impl CachedSheet {
         while let Some(entry) = dir.next_entry().await? {
             let path = entry.path();
 
-            if path.is_file() {
-                if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
-                    if file_name.ends_with(CLIENT_SUFFIX_CACHED_SHEET_FILE) {
+            if path.is_file()
+                && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
+                    && file_name.ends_with(CLIENT_SUFFIX_CACHED_SHEET_FILE) {
                         let name_without_ext = file_name
                             .trim_end_matches(CLIENT_SUFFIX_CACHED_SHEET_FILE)
                             .to_string();
                         sheet_names.push(name_without_ext);
                     }
-                }
-            }
         }
 
         Ok(sheet_names)
@@ -84,13 +82,11 @@ impl CachedSheet {
         while let Some(entry) = dir.next_entry().await? {
             let path = entry.path();
 
-            if path.is_file() {
-                if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
-                    if file_name.ends_with(CLIENT_SUFFIX_CACHED_SHEET_FILE) {
+            if path.is_file()
+                && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
+                    && file_name.ends_with(CLIENT_SUFFIX_CACHED_SHEET_FILE) {
                         sheet_paths.push(format_path(workspace_path.join(path))?);
                     }
-                }
-            }
         }
 
         Ok(sheet_paths)
diff --git a/crates/vcs_data/src/data/local/config.rs b/crates/vcs_data/src/data/local/config.rs
index 5b288cc..28bd439 100644
--- a/crates/vcs_data/src/data/local/config.rs
+++ b/crates/vcs_data/src/data/local/config.rs
@@ -130,7 +130,7 @@ impl LocalConfig {
         }
 
         self.sheet_in_use = Some(sheet);
-        LocalConfig::write(&self).await?;
+        LocalConfig::write(self).await?;
 
         Ok(())
     }
@@ -153,8 +153,7 @@ impl LocalConfig {
 
         // Create the draft folder if it doesn't exist
         if !draft_folder.exists() {
-            std::fs::create_dir_all(&draft_folder)
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+            std::fs::create_dir_all(&draft_folder).map_err(std::io::Error::other)?;
         }
 
         // Move all files and folders (except .jv folder) to the draft folder with rollback support
@@ -162,7 +161,7 @@ impl LocalConfig {
 
         // Clear the sheet in use
         self.sheet_in_use = None;
-        LocalConfig::write(&self).await?;
+        LocalConfig::write(self).await?;
 
         Ok(())
     }
@@ -177,8 +176,7 @@ impl LocalConfig {
     /// Check if local path is empty (except for .jv folder)
     async fn check_local_path_empty(&self, local_path: &Path) -> Result<(), std::io::Error> {
         let jv_folder = local_path.join(CLIENT_PATH_WORKSPACE_ROOT);
-        let mut entries = std::fs::read_dir(local_path)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+        let mut entries = std::fs::read_dir(local_path).map_err(std::io::Error::other)?;
 
         if entries.any(|entry| {
             if let Ok(entry) = entry {
@@ -206,9 +204,9 @@ impl LocalConfig {
         local_path: &Path,
     ) -> Result<(), std::io::Error> {
         let draft_entries: Vec<_> = std::fs::read_dir(draft_folder)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?
+            .map_err(std::io::Error::other)?
             .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+            .map_err(std::io::Error::other)?;
 
         let mut moved_items: Vec<MovedItem> = Vec::new();
 
@@ -222,7 +220,7 @@ impl LocalConfig {
                 for moved_item in &moved_items {
                     let _ = std::fs::rename(&moved_item.target, &moved_item.source);
                 }
-                std::io::Error::new(std::io::ErrorKind::Other, e)
+                std::io::Error::other(e)
             })?;
 
             moved_items.push(MovedItem {
@@ -237,7 +235,7 @@ impl LocalConfig {
             for moved_item in &moved_items {
                 let _ = std::fs::rename(&moved_item.target, &moved_item.source);
             }
-            std::io::Error::new(std::io::ErrorKind::Other, e)
+            std::io::Error::other(e)
         })?;
 
         Ok(())
@@ -251,9 +249,9 @@ impl LocalConfig {
     ) -> Result<(), std::io::Error> {
         let jv_folder = local_path.join(CLIENT_PATH_WORKSPACE_ROOT);
         let entries: Vec<_> = std::fs::read_dir(local_path)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?
+            .map_err(std::io::Error::other)?
             .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+            .map_err(std::io::Error::other)?;
 
         let mut moved_items: Vec<MovedItem> = Vec::new();
 
@@ -276,7 +274,7 @@ impl LocalConfig {
                 for moved_item in &moved_items {
                     let _ = std::fs::rename(&moved_item.target, &moved_item.source);
                 }
-                std::io::Error::new(std::io::ErrorKind::Other, e)
+                std::io::Error::other(e)
             })?;
 
             moved_items.push(MovedItem {
@@ -344,9 +342,7 @@ impl LocalConfig {
             return None;
         };
 
-        let Some(current_dir) = current_local_path() else {
-            return None;
-        };
+        let current_dir = current_local_path()?;
 
         Some(self.draft_folder(&self.using_account, sheet_name, current_dir))
     }
diff --git a/crates/vcs_data/src/data/local/file_status.rs b/crates/vcs_data/src/data/local/file_status.rs
index ca5799f..b8b5952 100644
--- a/crates/vcs_data/src/data/local/file_status.rs
+++ b/crates/vcs_data/src/data/local/file_status.rs
@@ -67,7 +67,7 @@ impl<'a> AnalyzeResult<'a> {
         let local_path = workspace.local_path();
         let file_relative_paths = {
             let mut paths = HashSet::new();
-            for entry in WalkDir::new(&local_path) {
+            for entry in WalkDir::new(local_path) {
                 let entry = match entry {
                     Ok(entry) => entry,
                     Err(_) => continue,
@@ -78,25 +78,21 @@ impl<'a> AnalyzeResult<'a> {
                     continue;
                 }
 
-                if entry.file_type().is_file() {
-                    if let Ok(relative_path) = entry.path().strip_prefix(&local_path) {
+                if entry.file_type().is_file()
+                    && let Ok(relative_path) = entry.path().strip_prefix(local_path) {
                         let format = format_path(relative_path.to_path_buf());
                         let Ok(format) = format else {
                             continue;
                         };
                         paths.insert(format);
                     }
-                }
             }
 
             paths
         };
 
         // Read local sheet
-        let local_sheet = match workspace.local_sheet(&member, &sheet_name).await {
-            Ok(v) => Some(v),
-            Err(_) => None,
-        };
+        let local_sheet = (workspace.local_sheet(&member, &sheet_name).await).ok();
 
         // Read cached sheet
         let cached_sheet_data = match CachedSheet::cached_sheet_data(&sheet_name).await {
@@ -110,7 +106,7 @@ impl<'a> AnalyzeResult<'a> {
         };
 
         // Create new result
-        let mut result = Self::none_result(&workspace);
+        let mut result = Self::none_result(workspace);
 
         // Analyze entry
         let mut analyze_ctx = AnalyzeContext {
@@ -119,12 +115,12 @@ impl<'a> AnalyzeResult<'a> {
             local_sheet,
             cached_sheet_data,
         };
-        Self::analyze_moved(&mut result, &file_relative_paths, &analyze_ctx, &workspace).await?;
+        Self::analyze_moved(&mut result, &file_relative_paths, &analyze_ctx, workspace).await?;
         Self::analyze_modified(
             &mut result,
             &file_relative_paths,
             &mut analyze_ctx,
-            &workspace,
+            workspace,
         )
         .await?;
 
@@ -165,7 +161,7 @@ impl<'a> AnalyzeResult<'a> {
         let file_hashes: HashSet<(PathBuf, String)> =
             match calc_sha1_multi::<PathBuf, Vec<PathBuf>>(new_files_for_hash, 8192).await {
                 Ok(hash) => hash,
-                Err(e) => return Err(Error::new(std::io::ErrorKind::Other, e)),
+                Err(e) => return Err(Error::other(e)),
             }
             .iter()
             .map(|r| (r.file_path.clone(), r.hash.to_string()))
@@ -222,11 +218,7 @@ impl<'a> AnalyzeResult<'a> {
                     .as_ref()
                     .and_then(|local_sheet| local_sheet.mapping_data(from).ok())
                     .map(|mapping_data| mapping_data.mapping_vfid.clone());
-                if let Some(vfid) = vfid {
-                    Some((vfid, (from.clone(), to.clone())))
-                } else {
-                    None
-                }
+                vfid.map(|vfid| (vfid, (from.clone(), to.clone())))
             })
             .collect();
 
@@ -246,7 +238,7 @@ impl<'a> AnalyzeResult<'a> {
 
         for path in file_relative_paths {
             // Get mapping data
-            let Ok(mapping_data) = local_sheet.mapping_data_mut(&path) else {
+            let Ok(mapping_data) = local_sheet.mapping_data_mut(path) else {
                 continue;
             };
 
@@ -263,7 +255,7 @@ impl<'a> AnalyzeResult<'a> {
             let hash_calc = match sha1_hash::calc_sha1(workspace.local_path.join(path), 2048).await
             {
                 Ok(hash) => hash,
-                Err(e) => return Err(Error::new(std::io::ErrorKind::Other, e)),
+                Err(e) => return Err(Error::other(e)),
             };
 
             // If hash not match, mark as modified
@@ -289,7 +281,7 @@ impl<'a> AnalyzeResult<'a> {
     /// Generate a empty AnalyzeResult
     fn none_result(local_workspace: &'a LocalWorkspace) -> AnalyzeResult<'a> {
         AnalyzeResult {
-            local_workspace: local_workspace,
+            local_workspace,
             moved: HashMap::new(),
             created: HashSet::new(),
             lost: HashSet::new(),
diff --git a/crates/vcs_data/src/data/local/latest_info.rs b/crates/vcs_data/src/data/local/latest_info.rs
index 77d632e..99f423b 100644
--- a/crates/vcs_data/src/data/local/latest_info.rs
+++ b/crates/vcs_data/src/data/local/latest_info.rs
@@ -1,5 +1,5 @@
 use std::{
-    path::PathBuf,
+    path::{Path, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -10,7 +10,6 @@ use tokio::time::Instant;
 use crate::{
     constants::{CLIENT_FILE_LATEST_INFO, CLIENT_FILE_LATEST_INFO_NOSET},
     data::{
-        local::{LocalWorkspace, config::LocalConfig},
         member::{Member, MemberId},
         sheet::{SheetData, SheetName},
     },
@@ -46,7 +45,7 @@ pub struct LatestInfo {
 
 impl LatestInfo {
     /// Get the path to the latest info file for a given workspace and member ID
-    pub fn latest_info_path(local_workspace_path: &PathBuf, member_id: &MemberId) -> PathBuf {
+    pub fn latest_info_path(local_workspace_path: &Path, member_id: &MemberId) -> PathBuf {
         local_workspace_path.join(CLIENT_FILE_LATEST_INFO.replace(ACCOUNT, member_id))
     }
 }
diff --git a/crates/vcs_data/src/data/local/local_files.rs b/crates/vcs_data/src/data/local/local_files.rs
index 8444f97..9cc244f 100644
--- a/crates/vcs_data/src/data/local/local_files.rs
+++ b/crates/vcs_data/src/data/local/local_files.rs
@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use string_proc::format_path::format_path;
 use tokio::fs;
@@ -25,16 +25,13 @@ impl RelativeFiles {
 }
 
 /// Read the relative paths within the project from the input file list
-pub async fn get_relative_paths(
-    local_path: &PathBuf,
-    paths: &Vec<PathBuf>,
-) -> Option<RelativeFiles> {
+pub async fn get_relative_paths(local_path: &PathBuf, paths: &[PathBuf]) -> Option<RelativeFiles> {
     // Get Relative Paths
-    let Ok(paths) = format_input_paths_and_ignore_outside_paths(&local_path, &paths).await else {
+    let Ok(paths) = format_input_paths_and_ignore_outside_paths(local_path, paths).await else {
         return None;
     };
     let files: Vec<PathBuf> = abs_paths_to_abs_files(paths).await;
-    let Ok(files) = parse_to_relative(&local_path, files) else {
+    let Ok(files) = parse_to_relative(local_path, files) else {
         return None;
     };
     Some(RelativeFiles { files })
@@ -42,7 +39,7 @@ pub async fn get_relative_paths(
 
 /// Normalize the input paths
 async fn format_input_paths(
-    local_path: &PathBuf,
+    local_path: &Path,
     track_files: &[PathBuf],
 ) -> Result<Vec<PathBuf>, std::io::Error> {
     let current_dir = local_path;
@@ -54,8 +51,7 @@ async fn format_input_paths(
         // Skip paths that contain .jv directories
         if path.components().any(|component| {
             if let std::path::Component::Normal(name) = component {
-                name.to_str()
-                    .map_or(false, |s| s == CLIENT_FOLDER_WORKSPACE_ROOT_NAME)
+                name.to_str() == Some(CLIENT_FOLDER_WORKSPACE_ROOT_NAME)
             } else {
                 false
             }
@@ -109,10 +105,7 @@ fn parse_to_relative(
         })
         .collect();
 
-    match result {
-        Ok(paths) => Ok(paths),
-        Err(e) => Err(e),
-    }
+    result
 }
 
 /// Convert absolute paths to absolute file paths, expanding directories to their contained files
diff --git a/crates/vcs_data/src/data/local/local_sheet.rs b/crates/vcs_data/src/data/local/local_sheet.rs
index d1d889e..f1a2159 100644
--- a/crates/vcs_data/src/data/local/local_sheet.rs
+++ b/crates/vcs_data/src/data/local/local_sheet.rs
@@ -89,6 +89,7 @@ impl LocalSheetData {
 
 impl LocalMappingMetadata {
     /// Create a new MappingMetaData instance
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         hash_when_updated: String,
         time_when_updated: SystemTime,
diff --git a/crates/vcs_data/src/data/sheet.rs b/crates/vcs_data/src/data/sheet.rs
index d706c43..891888a 100644
--- a/crates/vcs_data/src/data/sheet.rs
+++ b/crates/vcs_data/src/data/sheet.rs
@@ -207,7 +207,7 @@ impl<'a> Sheet<'a> {
                 sheet_path,
                 SheetMappingMetadata {
                     id: virtual_file_id,
-                    version: version,
+                    version,
                 },
             );
             return Ok(());
@@ -287,9 +287,7 @@ impl<'a> Sheet<'a> {
         }
 
         // Check if the sheet has a holder
-        let Some(holder) = self.holder() else {
-            return None;
-        };
+        let holder = self.holder()?;
 
         // Check if the holder has edit rights to the virtual file
         match self
@@ -331,7 +329,7 @@ impl<'a> Sheet<'a> {
         }
 
         // Add write count
-        if self.data.write_count > i32::MAX {
+        if self.data.write_count >= i32::MAX - 1 {
             self.data.write_count = 0;
         }
         SheetData::write_to(&self.data, self.sheet_path()).await
diff --git a/crates/vcs_docs/build.rs b/crates/vcs_docs/build.rs
index a83d423..7a7c5d0 100644
--- a/crates/vcs_docs/build.rs
+++ b/crates/vcs_docs/build.rs
@@ -29,7 +29,7 @@ fn main() -> io::Result<()> {
     let mut documents = Vec::new();
 
     if docs_dir.exists() {
-        collect_markdown_files(&docs_dir, &mut documents)?;
+        collect_markdown_files(docs_dir, &mut documents)?;
     }
 
     // Read template file
@@ -64,18 +64,14 @@ fn main() -> io::Result<()> {
 
         // Generate constant name from relative path
         let document_constant_name = relative_path
-            .replace('/', "_")
-            .replace('\\', "_")
-            .replace('-', "_")
+            .replace(['/', '\\', '-'], "_")
             .replace(".md", "")
             .replace(".txt", "")
             .to_uppercase();
 
         // Generate snake_case name for function matching
         let document_path_snake_case = relative_path
-            .replace('/', "_")
-            .replace('\\', "_")
-            .replace('-', "_")
+            .replace(['/', '\\', '-'], "_")
             .replace(".md", "")
             .replace(".txt", "")
             .to_lowercase();
@@ -96,12 +92,12 @@ fn main() -> io::Result<()> {
             .replace(PARAM_DOCUMENT_CONSTANT_NAME, &document_constant_name);
 
         match_arms.push_str(&match_arm);
-        match_arms.push_str("\n");
+        match_arms.push('\n');
 
         // Generate list item for documents() function
         let list_item = format!("        \"{}\".to_string(),", document_path_snake_case);
         list_items.push_str(&list_item);
-        list_items.push_str("\n");
+        list_items.push('\n');
     }
 
     // Remove trailing newline from the last list item
@@ -122,23 +118,21 @@ fn main() -> io::Result<()> {
     output.push_str(&document_blocks);
 
     // Add function section
-    if let Some(func_section) = template_content.split(TEMPLATE_FUNC_BEGIN).next() {
-        if let Some(rest) = func_section.split(TEMPLATE_DOCUMENT_END).nth(1) {
+    if let Some(func_section) = template_content.split(TEMPLATE_FUNC_BEGIN).next()
+        && let Some(rest) = func_section.split(TEMPLATE_DOCUMENT_END).nth(1) {
             output.push_str(rest.trim());
-            output.push_str("\n");
+            output.push('\n');
         }
-    }
 
     // Add match arms
     output.push_str(&match_arms);
 
     // Add list items for documents() function
-    if let Some(list_section) = template_content.split(TEMPLATE_LIST_BEGIN).next() {
-        if let Some(rest) = list_section.split(TEMPLATE_FUNC_END).nth(1) {
+    if let Some(list_section) = template_content.split(TEMPLATE_LIST_BEGIN).next()
+        && let Some(rest) = list_section.split(TEMPLATE_FUNC_END).nth(1) {
             output.push_str(rest.trim());
-            output.push_str("\n");
+            output.push('\n');
         }
-    }
     output.push_str(&list_items);
 
     // Add footer
@@ -167,18 +161,15 @@ fn collect_markdown_files(dir: &Path, documents: &mut Vec<(String, String)>) ->
             collect_markdown_files(&path, documents)?;
         } else if path
             .extension()
-            .map_or(false, |ext| ext == "md" || ext == "txt")
-        {
-            if let Ok(relative_path) = path.strip_prefix("../../docs/Documents") {
-                if let Some(relative_path_str) = relative_path.to_str() {
+            .is_some_and(|ext| ext == "md" || ext == "txt")
+            && let Ok(relative_path) = path.strip_prefix("../../docs/Documents")
+                && let Some(relative_path_str) = relative_path.to_str() {
                     let content = fs::read_to_string(&path)?;
                     documents.push((
                         relative_path_str.trim_start_matches('/').to_string(),
                         content,
                     ));
                 }
-            }
-        }
     }
     Ok(())
 }