wip

Author: malcolmgreaves

oxen-rust/src/lib/src/core/v_latest/entries.rs

@@ -285,17 +285,8 @@ pub fn dir_entries_with_depth(
     Ok(entries)
 }
 
-/// Public wrapper for getting a directory's own metadata entry (without appending resource).
-pub fn dir_node_to_metadata_entry_public(
-    repo: &LocalRepository,
-    node: &MerkleTreeNode,
-    parsed_resource: &ParsedResource,
-    found_commits: &mut HashMap<MerkleHash, Commit>,
-) -> Result<Option<MetadataEntry>, OxenError> {
-    dir_node_to_metadata_entry(repo, node, parsed_resource, found_commits, false)
-}
-
-fn dir_node_to_metadata_entry(
+/// Getting a directory's own metadata entry.
+pub(crate) fn dir_node_to_metadata_entry(
     repo: &LocalRepository,
     node: &MerkleTreeNode,
     parsed_resource: &ParsedResource,
@@ -310,29 +301,33 @@ fn dir_node_to_metadata_entry(
         return Ok(None);
     };
 
-    if let std::collections::hash_map::Entry::Vacant(e) =
-        found_commits.entry(*dir_node.last_commit_id())
-    {
+    let commit = match found_commits.entry(*dir_node.last_commit_id()) {
+      std::collections::hash_map::Entry::Vacant(e) => {
         let _perf_commit = crate::perf_guard!("core::entries::get_commit_by_hash");
         let commit = repositories::commits::get_by_hash(repo, dir_node.last_commit_id())?.ok_or(
             OxenError::commit_id_does_not_exist(dir_node.last_commit_id().to_string()),
         )?;
-        e.insert(commit);
-    }
+        let v = e.insert(commit);
+        v.as_ref()
+      },
+      std::collections::hash_map::Entry::Occupied(e) => e.get(),
+    };
 
-    let commit = found_commits.get(dir_node.last_commit_id()).unwrap();
-    let mut parsed_resource = parsed_resource.clone();
-    if should_append_resource {
-        parsed_resource.resource = parsed_resource.resource.join(dir_node.name());
-        parsed_resource.path = parsed_resource.path.join(dir_node.name());
-    }
+    let parsed_resource = {
+      let mut parsed_resource = parsed_resource.clone();
+      if should_append_resource {
+          parsed_resource.resource = parsed_resource.resource.join(dir_node.name());
+          parsed_resource.path = parsed_resource.path.join(dir_node.name());
+      }
+      parsed_resource
+    };
 
     Ok(Some(MetadataEntry {
         filename: dir_node.name().to_string(),
         hash: dir_node.hash().to_string(),
         is_dir: true,
         latest_commit: Some(commit.clone()),
-        resource: Some(parsed_resource.clone()),
+        resource: Some(parsed_resource),
         size: dir_node.num_bytes(),
         data_type: EntryDataType::Dir,
         mime_type: "inode/directory".to_string(),

oxen-rust/src/lib/src/core/v_latest/workspaces/files.rs

@@ -76,25 +76,57 @@ pub fn list(
         repositories::workspaces::status::status_from_dir(workspace, directory)?;
 
     // Step 3: Build status maps from staged files
-    let mut additions_map: HashMap<String, StagedEntryStatus> = HashMap::new();
-    let mut other_changes_map: HashMap<String, StagedEntryStatus> = HashMap::new();
-
-    for (file_path, entry) in workspace_changes.staged_files.iter() {
-        let status = entry.status.clone();
-        if status == StagedEntryStatus::Added {
-            // For added files, use the full path as key (relative to repo root)
-            let key = file_path.to_str().unwrap().to_string();
-            additions_map.insert(key, status);
-        } else {
-            // For modified or removed files, use the filename as key
-            let key = file_path.file_name().unwrap().to_string_lossy().to_string();
-            other_changes_map.insert(key, status);
+    let (additions, removed, modified) = {
+      workspace_changes.staged_files.iter().fold(
+        (HashMap::new(), HashMap::new(), HashMap::new()),
+        |(mut additions, mut removed, mut modified), (file_path, entry)| {
+
+          if let Some(maybe_map_to_be_modified) = match entry.status {
+            StagedEntryStatus::Added => Some(&mut additions),
+            StagedEntryStatus::Modified => Some(&mut modified),
+            StagedEntryStatus::Removed => Some(&mut removed),
+            StagedEntryStatus::Unmodified => None,
+          } {
+            let Some(key) = file_path.file_name() {
+              map_to_be_modified.insert(key, status);
+            } else {
+              log::warn!("[skip] Could not retrieve file name for: '{file_path:?}' in workspace: {}", workspace.id)
+            }
+          }
+
+          (additions, removed, modified
         }
-    }
+      )
+    };
 
     // Step 4: Apply workspace changes to commit entries
     let mut merged_entries: Vec<EMetadataEntry> = Vec::new();
 
+    let merged_entries = commit_entries.into_iter()
+      .filter_map(|entry| {
+
+        let filename = &entry.filename;
+        if let Some(status) = other_changes_map.get(filename) {
+            match status {
+                // Don't show removed files
+                StagedEntryStatus::Removed => None,
+                _ => {
+                    // Still present => must be modified (either modified or unmodified)
+                    let mut ws_entry = WorkspaceMetadataEntry::from_metadata_entry(entry);
+                    ws_entry.changes = Some(WorkspaceChanges {
+                        status: status.clone(),
+                    });
+                    Some(EMetadataEntry::WorkspaceMetadataEntry(ws_entry))
+                }
+            }
+        } else {
+            // Unmodified commit entry
+            let ws_entry = WorkspaceMetadataEntry::from_metadata_entry(entry);
+            merged_entries.push(EMetadataEntry::WorkspaceMetadataEntry(ws_entry));
+        }
+
+      });
+
     for entry in commit_entries {
         let filename = &entry.filename;
         if let Some(status) = other_changes_map.get(filename) {
@@ -171,11 +203,12 @@ pub fn list(
 
     // Step 8: Build dir metadata entry for the directory itself
     let dir_entry = if let Some(ref dir) = maybe_dir {
-        let dir_metadata = core::v_latest::entries::dir_node_to_metadata_entry_public(
+        let dir_metadata = core::v_latest::entries::dir_node_to_metadata_entry(
             base_repo,
             dir,
             &parsed_resource,
             &mut found_commits,
+            false,
         )?;
         dir_metadata.map(|e| {
             EMetadataEntry::WorkspaceMetadataEntry(WorkspaceMetadataEntry::from_metadata_entry(e))