Ensure task processing order by using Vec instead of HashSet

The change from HashSet to Vec for task collections maintains the order
of file operations, which is important for consistent processing
behavior. This affects created_task, update_task, and sync_task
variables throughout the code.

1 files changed, 24 insertions, 26 deletions

diff --git a/crates/vcs_actions/src/actions/virtual_file_actions.rs b/crates/vcs_actions/src/actions/virtual_file_actions.rs
index fa74873..967f573 100644
--- a/crates/vcs_actions/src/actions/virtual_file_actions.rs
+++ b/crates/vcs_actions/src/actions/virtual_file_actions.rs
@@ -4,7 +4,7 @@ use action_system::{action::ActionContext, macros::action_gen};
 use cfg_file::config::ConfigFile;
 use serde::{Deserialize, Serialize};
 use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
-use tokio::{sync::Mutex, time::Instant};
+use tokio::sync::Mutex;
 use vcs_data::data::{
     local::{
         cached_sheet::CachedSheet, file_status::AnalyzeResult, local_sheet::LocalMappingMetadata,
@@ -107,22 +107,26 @@ pub async fn track_file_action(
             .modified
             .intersection(&relative_pathes)
             .cloned()
-            .collect::<HashSet<_>>();
+            .collect::<Vec<_>>();
 
         // Filter out created files
         let created_task = analyzed
             .created
             .intersection(&relative_pathes)
             .cloned()
-            .collect::<HashSet<_>>();
+            .collect::<Vec<_>>();
 
         // Filter out modified files that need to be updated
-        let update_task: HashSet<PathBuf> = {
+        let update_task: Vec<PathBuf> = {
             let result = modified.iter().filter_map(|p| {
-                if let Ok(data) = local_sheet.mapping_data(p) {
-                    let id = data.mapping_vfid();
+                if let (Ok(local_data), Some(cached_data)) =
+                    (local_sheet.mapping_data(p), cached_sheet.mapping().get(p))
+                {
+                    let id = local_data.mapping_vfid();
+                    let local_ver = local_data.version_when_updated();
                     if let Some(held_member) = member_held.file_holder(id) {
-                        if held_member == &member_id {
+                        // Check if holder and version match
+                        if held_member == &member_id && local_ver == &cached_data.version {
                             return Some(p.clone());
                         }
                     }
@@ -133,14 +137,12 @@ pub async fn track_file_action(
         };
 
         // Filter out files that do not exist locally or have version inconsistencies and need to be synchronized
-        let sync_task: HashSet<PathBuf> = {
-            let other = relative_pathes
-                .difference(&created_task)
-                .cloned()
-                .collect::<HashSet<_>>()
-                .difference(&update_task)
+        let sync_task: Vec<PathBuf> = {
+            let other: Vec<PathBuf> = relative_pathes
+                .iter()
+                .filter(|p| !created_task.contains(p) && !update_task.contains(p))
                 .cloned()
-                .collect::<HashSet<_>>();
+                .collect();
 
             let result = other.iter().filter_map(|p| {
                 // In cached sheet
@@ -167,7 +169,7 @@ pub async fn track_file_action(
         };
 
         // Package tasks
-        let tasks: (HashSet<PathBuf>, HashSet<PathBuf>, HashSet<PathBuf>) =
+        let tasks: (Vec<PathBuf>, Vec<PathBuf>, Vec<PathBuf>) =
             (created_task, update_task, sync_task);
 
         // Send to remote
@@ -230,11 +232,7 @@ pub async fn track_file_action(
 
     if ctx.is_proc_on_remote() {
         // Read tasks
-        let (created_task, update_task, sync_task): (
-            HashSet<PathBuf>,
-            HashSet<PathBuf>,
-            HashSet<PathBuf>,
-        ) = {
+        let (created_task, update_task, sync_task): (Vec<PathBuf>, Vec<PathBuf>, Vec<PathBuf>) = {
             let mut mut_instance = instance.lock().await;
             mut_instance.read_large_msgpack(1024u16).await?
         };
@@ -311,7 +309,7 @@ async fn proc_create_tasks_local(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<CreateTaskResult, TcpTargetError> {
     let workspace = try_get_local_workspace(&ctx)?;
     let mut mut_instance = instance.lock().await;
@@ -380,7 +378,7 @@ async fn proc_create_tasks_remote(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<CreateTaskResult, TcpTargetError> {
     let vault = try_get_vault(&ctx)?;
     let mut mut_instance = instance.lock().await;
@@ -445,7 +443,7 @@ async fn proc_update_tasks_local(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<UpdateTaskResult, TcpTargetError> {
     Ok(UpdateTaskResult::Success(Vec::new()))
 }
@@ -455,7 +453,7 @@ async fn proc_update_tasks_remote(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<UpdateTaskResult, TcpTargetError> {
     Ok(UpdateTaskResult::Success(Vec::new()))
 }
@@ -465,7 +463,7 @@ async fn proc_sync_tasks_local(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<SyncTaskResult, TcpTargetError> {
     Ok(SyncTaskResult::Success(Vec::new()))
 }
@@ -475,7 +473,7 @@ async fn proc_sync_tasks_remote(
     instance: Arc<Mutex<ConnectionInstance>>,
     member_id: &MemberId,
     sheet_name: &SheetName,
-    relative_paths: HashSet<PathBuf>,
+    relative_paths: Vec<PathBuf>,
 ) -> Result<SyncTaskResult, TcpTargetError> {
     Ok(SyncTaskResult::Success(Vec::new()))
 }