fix: handle untracked diffs and hunk mapping after deletions

Author: Austin Emmons

src-tauri/src/shared/git_ui_core/diff.rs

@@ -199,19 +199,32 @@ fn source_diff_for_path(
     path: &str,
     cached: bool,
     ignore_whitespace_changes: bool,
+    is_untracked_worktree_file: bool,
 ) -> Option<String> {
     let git_bin = resolve_git_binary().ok()?;
     let mut args = vec!["diff"];
-    if cached {
-        args.push("--cached");
-    }
-    args.push("--no-color");
-    args.push("-U0");
-    if ignore_whitespace_changes {
-        args.push("-w");
+    if is_untracked_worktree_file && !cached {
+        args.push("--no-index");
+        args.push("--no-color");
+        args.push("-U0");
+        if ignore_whitespace_changes {
+            args.push("-w");
+        }
+        args.push("--");
+        args.push(if cfg!(windows) { "NUL" } else { "/dev/null" });
+        args.push(path);
+    } else {
+        if cached {
+            args.push("--cached");
+        }
+        args.push("--no-color");
+        args.push("-U0");
+        if ignore_whitespace_changes {
+            args.push("-w");
+        }
+        args.push("--");
+        args.push(path);
     }
-    args.push("--");
-    args.push(path);
 
     let output = std_command(git_bin)
         .args(args)
@@ -370,7 +383,7 @@ fn map_new_to_old_line_clamped(hunks: &[ParsedPatchHunk], new_line: usize) -> us
             if new_line < insertion_point {
                 break;
             }
-            delta -= hunk.old_count as isize;
+            delta += hunk.old_count as isize;
             continue;
         }
 
@@ -719,6 +732,42 @@ mod display_hunk_tests {
 
         assert!(display_hunks[0].start_display_line_index < display_hunks[1].start_display_line_index);
     }
+
+    #[test]
+    fn build_display_hunks_maps_unstaged_hunks_after_staged_deletions() {
+        let diff = concat!(
+            "@@ -2,1 +2,0 @@\n",
+            "-line two\n",
+            "@@ -5,1 +4,1 @@\n",
+            "-line five\n",
+            "+line five updated\n"
+        );
+        let staged_diff = concat!(
+            "diff --git a/example.txt b/example.txt\n",
+            "index 1111111..2222222 100644\n",
+            "--- a/example.txt\n",
+            "+++ b/example.txt\n",
+            "@@ -2,1 +2,0 @@\n",
+            "-line two\n"
+        );
+        let unstaged_diff = concat!(
+            "diff --git a/example.txt b/example.txt\n",
+            "index 2222222..3333333 100644\n",
+            "--- a/example.txt\n",
+            "+++ b/example.txt\n",
+            "@@ -4,1 +4,1 @@\n",
+            "-line five\n",
+            "+line five updated\n"
+        );
+
+        let display_hunks = build_display_hunks(diff, Some(staged_diff), Some(unstaged_diff));
+
+        assert_eq!(display_hunks.len(), 2);
+        assert_eq!(display_hunks[0].id, "staged:2:1:2:0");
+        assert_eq!(display_hunks[1].id, "unstaged:4:1:4:1");
+        assert_eq!(display_hunks[1].start_display_line_index, 3);
+        assert_eq!(display_hunks[1].end_display_line_index, 4);
+    }
 }
 
 fn has_ignored_parent_directory(repo: &Repository, path: &Path) -> bool {
@@ -1132,11 +1181,15 @@ pub(super) async fn get_git_diffs_inner(
             let is_image = old_image_mime.is_some() || new_image_mime.is_some();
             let is_deleted = delta.status() == git2::Delta::Deleted;
             let is_added = delta.status() == git2::Delta::Added;
+            let file_status = repo.status_file(display_path).unwrap_or(Status::empty());
+            let is_untracked_worktree_file =
+                file_status.contains(Status::WT_NEW) && !file_status.contains(Status::INDEX_NEW);
             let staged_diff = source_diff_for_path(
                 &repo_root,
                 normalized_path.as_str(),
                 true,
                 ignore_whitespace_changes,
+                is_untracked_worktree_file,
             )
             .and_then(|diff| {
                 if diff.trim().is_empty() {
@@ -1150,6 +1203,7 @@ pub(super) async fn get_git_diffs_inner(
                 normalized_path.as_str(),
                 false,
                 ignore_whitespace_changes,
+                is_untracked_worktree_file,
             )
             .and_then(|diff| {
                 if diff.trim().is_empty() {

src-tauri/src/shared/git_ui_core/tests.rs

@@ -226,6 +226,70 @@ fn get_git_diffs_omits_global_ignored_paths() {
     assert!(!has_ignored, "ignored files should not appear in diff list");
 }
 
+#[test]
+fn get_git_diffs_populates_untracked_file_unstaged_diff_and_display_hunks() {
+    let (root, repo) = create_temp_repo();
+    let tracked_path = root.join("tracked.txt");
+    fs::write(&tracked_path, "tracked\n").expect("write tracked file");
+    let mut index = repo.index().expect("repo index");
+    index.add_path(Path::new("tracked.txt")).expect("add tracked path");
+    index.write().expect("write index");
+    let tree_id = index.write_tree().expect("write tree");
+    let tree = repo.find_tree(tree_id).expect("find tree");
+    let sig = git2::Signature::now("Test", "test@example.com").expect("signature");
+    repo.commit(Some("HEAD"), &sig, &sig, "init", &tree, &[])
+        .expect("commit");
+
+    fs::write(root.join("new-file.txt"), "first line\nsecond line\n").expect("write new file");
+
+    let workspace = WorkspaceEntry {
+        id: "w1".to_string(),
+        name: "w1".to_string(),
+        path: root.to_string_lossy().to_string(),
+        kind: WorkspaceKind::Main,
+        parent_id: None,
+        worktree: None,
+        settings: WorkspaceSettings::default(),
+    };
+    let mut entries = HashMap::new();
+    entries.insert("w1".to_string(), workspace);
+    let workspaces = Mutex::new(entries);
+    let app_settings = Mutex::new(AppSettings::default());
+
+    let runtime = Runtime::new().expect("create tokio runtime");
+    let diffs = runtime
+        .block_on(diff::get_git_diffs_inner(
+            &workspaces,
+            &app_settings,
+            "w1".to_string(),
+        ))
+        .expect("get git diffs");
+
+    let diff = diffs
+        .iter()
+        .find(|diff| diff.path == "new-file.txt")
+        .expect("find new file diff");
+    let unstaged_diff = diff
+        .unstaged_diff
+        .as_deref()
+        .expect("untracked file should have unstaged diff");
+
+    assert!(
+        unstaged_diff.contains("+++ b/new-file.txt"),
+        "expected relative untracked diff header, got: {unstaged_diff}"
+    );
+    assert!(
+        unstaged_diff.contains("+first line\n+second line"),
+        "expected untracked diff body, got: {unstaged_diff}"
+    );
+    assert!(
+        !diff.display_hunks.is_empty(),
+        "untracked file should expose display hunks"
+    );
+    assert_eq!(diff.display_hunks[0].source, "unstaged");
+    assert_eq!(diff.display_hunks[0].action, "stage");
+}
+
 #[test]
 fn check_ignore_with_git_respects_negated_rule_for_specific_file() {
     let (root, repo) = create_temp_repo();