Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
git: Show submodule changes in commit diffs (#60479)
Eagl61ca0b3c92d7f3
diff --git a/crates/git/src/commit.rs b/crates/git/src/commit.rsindex 326c741ad19..62bf8b4a103 100644--- a/crates/git/src/commit.rs+++ b/crates/git/src/commit.rs@@ -100,22 +100,88 @@ async fn get_messages_impl(git: &GitBinary, shas: &[Oid]) -> Result<Vec<String>>.collect::<Vec<_>>())}-/// Parse the output of `git diff --name-status -z`-pub fn parse_git_diff_name_status(content: &str) -> impl Iterator<Item = (&str, StatusCode)> {+pub(crate) const GITLINK_MODE: &str = "160000";++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum CommitDiffObjectKind {+ Blob,+ Gitlink,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) struct CommitDiffObject<'a> {+ pub oid: &'a str,+ pub kind: CommitDiffObjectKind,+}++#[derive(Debug, PartialEq, Eq)]+pub(crate) struct CommitDiffEntry<'a> {+ pub path: &'a str,+ pub status: StatusCode,+ pub old_object: Option<CommitDiffObject<'a>>,+ pub new_object: Option<CommitDiffObject<'a>>,+}++/// Parses the output of `git diff --raw --no-abbrev -z`.+pub(crate) fn parse_git_diff_raw(+ content: &str,+) -> impl Iterator<Item = Result<CommitDiffEntry<'_>>> {let mut parts = content.split('\0');std::iter::from_fn(move || {- loop {- let status_str = parts.next()?;- let path = parts.next()?;- let status = match status_str {- "M" => StatusCode::Modified,- "T" => StatusCode::TypeChanged,- "A" => StatusCode::Added,- "D" => StatusCode::Deleted,- _ => continue,- };- return Some((path, status));+ let metadata = parts.next()?;+ if metadata.is_empty() {+ return None;}++ let path = match parts.next() {+ Some(path) => path,+ None => return Some(Err(anyhow::anyhow!("raw diff is missing the path"))),+ };+ Some(parse_git_diff_raw_entry(metadata, path))+ })+}++fn parse_git_diff_raw_entry<'a>(metadata: &'a str, path: &'a str) -> Result<CommitDiffEntry<'a>> {+ let mut fields = metadata+ .strip_prefix(':')+ .context("raw diff metadata is missing its ':' prefix")?+ .split_ascii_whitespace();+ let old_mode = fields.next().context("raw diff is missing the old mode")?;+ let new_mode = fields.next().context("raw diff is missing the new mode")?;+ let old_oid = fields+ .next()+ .context("raw diff is missing the old object ID")?;+ let new_oid = fields+ .next()+ .context("raw diff is missing the new object ID")?;+ let status = match fields.next() {+ Some("M") => StatusCode::Modified,+ Some("T") => StatusCode::TypeChanged,+ Some("A") => StatusCode::Added,+ Some("D") => StatusCode::Deleted,+ Some(status) => anyhow::bail!("unsupported raw diff status {status}"),+ None => anyhow::bail!("raw diff is missing the status"),+ };++ Ok(CommitDiffEntry {+ path,+ status,+ old_object: (!old_oid.bytes().all(|byte| byte == b'0')).then(|| CommitDiffObject {+ oid: old_oid,+ kind: if old_mode == GITLINK_MODE {+ CommitDiffObjectKind::Gitlink+ } else {+ CommitDiffObjectKind::Blob+ },+ }),+ new_object: (!new_oid.bytes().all(|byte| byte == b'0')).then(|| CommitDiffObject {+ oid: new_oid,+ kind: if new_mode == GITLINK_MODE {+ CommitDiffObjectKind::Gitlink+ } else {+ CommitDiffObjectKind::Blob+ },+ }),})}@@ -125,41 +191,59 @@ mod tests {use super::*;#[test]- fn test_parse_git_diff_name_status() {+ fn test_parse_git_diff_raw() {let input = concat!(- "M\x00Cargo.lock\x00",- "T\x00LICENSE-GPL\x00",- "M\x00crates/project/Cargo.toml\x00",- "M\x00crates/project/src/buffer_store.rs\x00",- "D\x00crates/project/src/git.rs\x00",- "A\x00crates/project/src/git_store.rs\x00",- "A\x00crates/project/src/git_store/git_traversal.rs\x00",- "M\x00crates/project/src/project.rs\x00",- "M\x00crates/project/src/worktree_store.rs\x00",- "M\x00crates/project_panel/src/project_panel.rs\x00",+ ":100644 100644 1111111111111111111111111111111111111111 2222222222222222222222222222222222222222 M\x00file.txt\x00",+ ":160000 160000 3333333333333333333333333333333333333333 4444444444444444444444444444444444444444 M\x00modules/example\x00",+ ":000000 100644 0000000000000000000000000000000000000000 5555555555555555555555555555555555555555 A\x00added.txt\x00",+ ":160000 000000 6666666666666666666666666666666666666666 0000000000000000000000000000000000000000 D\x00deleted-module\x00",+ ":100644 160000 7777777777777777777777777777777777777777 8888888888888888888888888888888888888888 T\x00type-change\x00",);- let output = parse_git_diff_name_status(input).collect::<Vec<_>>();+ let entries = parse_git_diff_raw(input)+ .collect::<Result<Vec<_>>>()+ .unwrap();+ let [file, gitlink, added, deleted, type_change] = entries.as_slice() else {+ panic!("expected five raw diff entries");+ };++ assert_eq!(file.path, "file.txt");+ assert_eq!(file.status, StatusCode::Modified);assert_eq!(- output,- &[- ("Cargo.lock", StatusCode::Modified),- ("LICENSE-GPL", StatusCode::TypeChanged),- ("crates/project/Cargo.toml", StatusCode::Modified),- ("crates/project/src/buffer_store.rs", StatusCode::Modified),- ("crates/project/src/git.rs", StatusCode::Deleted),- ("crates/project/src/git_store.rs", StatusCode::Added),- (- "crates/project/src/git_store/git_traversal.rs",- StatusCode::Added,- ),- ("crates/project/src/project.rs", StatusCode::Modified),- ("crates/project/src/worktree_store.rs", StatusCode::Modified),- (- "crates/project_panel/src/project_panel.rs",- StatusCode::Modified- ),- ]+ file.new_object.map(|object| object.kind),+ Some(CommitDiffObjectKind::Blob)+ );+ assert_eq!(gitlink.path, "modules/example");+ assert_eq!(gitlink.status, StatusCode::Modified);+ assert_eq!(+ gitlink.old_object.map(|object| object.kind),+ Some(CommitDiffObjectKind::Gitlink));+ assert_eq!(+ gitlink.new_object.map(|object| object.kind),+ Some(CommitDiffObjectKind::Gitlink)+ );+ assert!(added.old_object.is_none());+ assert_eq!(added.status, StatusCode::Added);+ assert!(deleted.new_object.is_none());+ assert_eq!(deleted.status, StatusCode::Deleted);+ assert_eq!(type_change.status, StatusCode::TypeChanged);+ assert_eq!(+ type_change.old_object.map(|object| object.kind),+ Some(CommitDiffObjectKind::Blob)+ );+ assert_eq!(+ type_change.new_object.map(|object| object.kind),+ Some(CommitDiffObjectKind::Gitlink)+ );+ }++ #[test]+ fn test_parse_git_diff_raw_rejects_malformed_metadata() {+ let error = parse_git_diff_raw(":100644\x00file.txt\x00")+ .next()+ .expect("expected a raw diff entry")+ .expect_err("expected malformed metadata to fail");+ assert!(error.to_string().contains("new mode"));}}diff --git a/crates/git/src/repository.rs b/crates/git/src/repository.rsindex 7bea8283d70..94d3fac855e 100644--- a/crates/git/src/repository.rs+++ b/crates/git/src/repository.rs@@ -1,6 +1,6 @@-use crate::commit::parse_git_diff_name_status;+use crate::commit::{CommitDiffObject, CommitDiffObjectKind, parse_git_diff_raw};use crate::stash::GitStash;-use crate::status::{DiffTreeType, GitStatus, StatusCode, TreeDiff};+use crate::status::{DiffTreeType, GitStatus, TreeDiff};use crate::{Oid, RunHook, SHORT_SHA_LENGTH};use anyhow::{Context as _, Result, anyhow, bail};use async_channel::Sender;@@ -572,6 +572,57 @@ pub fn is_binary_content(content: &[u8]) -> bool {content[..check_len].contains(&0)}+struct LoadedCommitObject {+ text: String,+ is_binary: bool,+}++async fn read_commit_blob<R: smol::io::AsyncBufRead + Unpin>(+ stdout: &mut R,+ info_line: &mut String,+ newline: &mut [u8; 1],+) -> Result<LoadedCommitObject> {+ info_line.clear();+ stdout.read_line(info_line).await?;++ let len = info_line+ .trim_end()+ .parse()+ .with_context(|| format!("invalid object size output from cat-file {info_line}"))?;++ let mut bytes = vec![0; len];+ stdout.read_exact(&mut bytes).await?;+ stdout.read_exact(newline).await?;++ let is_binary = is_binary_content(&bytes);+ Ok(LoadedCommitObject {+ text: if is_binary {+ String::new()+ } else {+ String::from_utf8_lossy(&bytes).to_string()+ },+ is_binary,+ })+}++async fn load_commit_object<R: smol::io::AsyncBufRead + Unpin>(+ object: Option<CommitDiffObject<'_>>,+ stdout: &mut R,+ info_line: &mut String,+ newline: &mut [u8; 1],+) -> Result<Option<LoadedCommitObject>> {+ match object {+ Some(object) if object.kind == CommitDiffObjectKind::Gitlink => {+ Ok(Some(LoadedCommitObject {+ text: format!("Subproject commit {}\n", object.oid),+ is_binary: false,+ }))+ }+ Some(_) => Ok(Some(read_commit_blob(stdout, info_line, newline).await?)),+ None => Ok(None),+ }+}+#[derive(Debug, Clone, Hash, PartialEq, Eq)]pub struct Remote {pub name: SharedString,@@ -1421,7 +1472,8 @@ impl GitRepository for RealGitRepository {"--format=","-z","--no-renames",- "--name-status",+ "--raw",+ "--no-abbrev","--first-parent",]).arg(&commit)@@ -1431,10 +1483,14 @@ impl GitRepository for RealGitRepository {.output().await.context("starting git show process")?;+ anyhow::ensure!(+ show_output.status.success(),+ "git show failed: {}",+ String::from_utf8_lossy(&show_output.stderr)+ );let show_stdout = String::from_utf8_lossy(&show_output.stdout);- let changes = parse_git_diff_name_status(&show_stdout);- let parent_sha = format!("{}^", commit);+ let changes = parse_git_diff_raw(&show_stdout);let mut cat_file_process = git.build_command(&["cat-file", "--batch=%(objectsize)"])@@ -1445,85 +1501,62 @@ impl GitRepository for RealGitRepository {.context("starting git cat-file process")?;let mut files = Vec::<CommitFile>::new();- let mut stdin = BufWriter::with_capacity(512, cat_file_process.stdin.take().unwrap());- let mut stdout = BufReader::new(cat_file_process.stdout.take().unwrap());+ let stdin = cat_file_process+ .stdin+ .take()+ .context("git cat-file process has no stdin")?;+ let stdout = cat_file_process+ .stdout+ .take()+ .context("git cat-file process has no stdout")?;+ let mut stdin = BufWriter::with_capacity(512, stdin);+ let mut stdout = BufReader::new(stdout);let mut info_line = String::new();let mut newline = [b'\0'];- for (path, status_code) in changes {+ for change in changes {+ let change = change?;+ let path = change.path;// git-show outputs `/`-delimited paths even on Windows.let Some(rel_path) = RelPath::unix(path).log_err() else {continue;};- match status_code {- StatusCode::Modified | StatusCode::TypeChanged => {- stdin.write_all(commit.as_bytes()).await?;- stdin.write_all(b":").await?;- stdin.write_all(path.as_bytes()).await?;- stdin.write_all(b"\n").await?;- stdin.write_all(parent_sha.as_bytes()).await?;- stdin.write_all(b":").await?;- stdin.write_all(path.as_bytes()).await?;- stdin.write_all(b"\n").await?;- }- StatusCode::Added => {- stdin.write_all(commit.as_bytes()).await?;- stdin.write_all(b":").await?;- stdin.write_all(path.as_bytes()).await?;+ let objects = [change.new_object, change.old_object];+ let mut has_blobs = false;+ for object in objects.iter().flatten() {+ if object.kind == CommitDiffObjectKind::Blob {+ stdin.write_all(object.oid.as_bytes()).await?;stdin.write_all(b"\n").await?;+ has_blobs = true;}- StatusCode::Deleted => {- stdin.write_all(parent_sha.as_bytes()).await?;- stdin.write_all(b":").await?;- stdin.write_all(path.as_bytes()).await?;- stdin.write_all(b"\n").await?;- }- _ => continue,}- stdin.flush().await?;-- info_line.clear();- stdout.read_line(&mut info_line).await?;-- let len = info_line.trim_end().parse().with_context(|| {- format!("invalid object size output from cat-file {info_line}")- })?;- let mut text_bytes = vec![0; len];- stdout.read_exact(&mut text_bytes).await?;- stdout.read_exact(&mut newline).await?;-- let mut old_text = None;- let mut new_text = None;- let mut is_binary = is_binary_content(&text_bytes);- let text = if is_binary {- String::new()- } else {- String::from_utf8_lossy(&text_bytes).to_string()- };+ if has_blobs {+ stdin.flush().await?;+ }- match status_code {- StatusCode::Modified | StatusCode::TypeChanged => {- info_line.clear();- stdout.read_line(&mut info_line).await?;- let len = info_line.trim_end().parse().with_context(|| {- format!("invalid object size output from cat-file {}", info_line)- })?;- let mut parent_bytes = vec![0; len];- stdout.read_exact(&mut parent_bytes).await?;- stdout.read_exact(&mut newline).await?;- is_binary = is_binary || is_binary_content(&parent_bytes);- if is_binary {- old_text = Some(String::new());- new_text = Some(String::new());- } else {- old_text = Some(String::from_utf8_lossy(&parent_bytes).to_string());- new_text = Some(text);- }+ let [new_object, old_object] = objects;+ let new_object =+ load_commit_object(new_object, &mut stdout, &mut info_line, &mut newline)+ .await?;+ let old_object =+ load_commit_object(old_object, &mut stdout, &mut info_line, &mut newline)+ .await?;+ let is_binary = new_object.as_ref().is_some_and(|object| object.is_binary)+ || old_object.as_ref().is_some_and(|object| object.is_binary);+ let new_text = new_object.map(|object| {+ if is_binary {+ String::new()+ } else {+ object.text}- StatusCode::Added => new_text = Some(text),- StatusCode::Deleted => old_text = Some(text),- _ => continue,- }+ });+ let old_text = old_object.map(|object| {+ if is_binary {+ String::new()+ } else {+ object.text+ }+ });files.push(CommitFile {path: RepoPath(Arc::from(rel_path)),@@ -4133,6 +4166,107 @@ mod tests {assert_eq!(file.status(), CommitFileStatus::Modified);}+ #[gpui::test]+ async fn test_load_commit_with_gitlink_changes(cx: &mut TestAppContext) {+ const FIRST_SUBMODULE_COMMIT: &str = "1111111111111111111111111111111111111111";+ const SECOND_SUBMODULE_COMMIT: &str = "2222222222222222222222222222222222222222";++ disable_git_global_config();+ cx.executor().allow_parking();++ let repo_dir = tempfile::tempdir().expect("failed to create temporary repository");+ git_init_repo(repo_dir.path());+ fs::write(repo_dir.path().join("README.md"), "parent repository\n")+ .expect("failed to write regular file");+ git_command(repo_dir.path(), ["add", "README.md"]);+ git_command(+ repo_dir.path(),+ [+ "update-index",+ "--add",+ "--cacheinfo",+ crate::commit::GITLINK_MODE,+ FIRST_SUBMODULE_COMMIT,+ "modules/example",+ ],+ );+ git_command(repo_dir.path(), ["commit", "-m", "add submodule"]);++ let repository = RealGitRepository::new(+ &repo_dir.path().join(".git"),+ None,+ Some("git".into()),+ cx.executor(),+ )+ .expect("failed to open repository");++ let commit_diff = repository+ .load_commit("HEAD".to_string(), cx.to_async())+ .await+ .expect("failed to load commit that adds a gitlink");+ assert_eq!(commit_diff.files.len(), 2);+ let gitlink = commit_diff+ .files+ .iter()+ .find(|file| file.path.as_unix_str() == "modules/example")+ .expect("gitlink should be present alongside the regular file");+ assert_eq!(gitlink.status(), CommitFileStatus::Added);+ assert_eq!(gitlink.old_text, None);+ assert_eq!(+ gitlink.new_text.as_deref(),+ Some("Subproject commit 1111111111111111111111111111111111111111\n")+ );+ assert!(!gitlink.is_binary);++ git_command(+ repo_dir.path(),+ [+ "update-index",+ "--cacheinfo",+ crate::commit::GITLINK_MODE,+ SECOND_SUBMODULE_COMMIT,+ "modules/example",+ ],+ );+ git_command(repo_dir.path(), ["commit", "-m", "update submodule"]);++ let commit_diff = repository+ .load_commit("HEAD".to_string(), cx.to_async())+ .await+ .expect("failed to load commit that updates a gitlink");+ let [gitlink] = commit_diff.files.as_slice() else {+ panic!("expected one updated gitlink");+ };+ assert_eq!(gitlink.status(), CommitFileStatus::Modified);+ assert_eq!(+ gitlink.old_text.as_deref(),+ Some("Subproject commit 1111111111111111111111111111111111111111\n")+ );+ assert_eq!(+ gitlink.new_text.as_deref(),+ Some("Subproject commit 2222222222222222222222222222222222222222\n")+ );+ assert!(!gitlink.is_binary);++ git_command(repo_dir.path(), ["rm", "--cached", "modules/example"]);+ git_command(repo_dir.path(), ["commit", "-m", "remove submodule"]);++ let commit_diff = repository+ .load_commit("HEAD".to_string(), cx.to_async())+ .await+ .expect("failed to load commit that deletes a gitlink");+ let [gitlink] = commit_diff.files.as_slice() else {+ panic!("expected one deleted gitlink");+ };+ assert_eq!(gitlink.status(), CommitFileStatus::Deleted);+ assert_eq!(+ gitlink.old_text.as_deref(),+ Some("Subproject commit 2222222222222222222222222222222222222222\n")+ );+ assert_eq!(gitlink.new_text, None);+ assert!(!gitlink.is_binary);+ }+#[gpui::test]async fn test_check_access(cx: &mut TestAppContext) {disable_git_global_config();