Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Support blaming parent revisions (#62614)
Kirill Bulatovf0685e0a4f4e
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rsindex 9bbca16a392..96e051a6bc4 100644--- a/crates/collab/src/rpc.rs+++ b/crates/collab/src/rpc.rs@@ -372,6 +372,7 @@ impl Server {.add_request_handler(forward_read_only_project_request::<proto::DownloadFileByPath>).add_request_handler(forward_read_only_project_request::<proto::GitGetBranches>).add_request_handler(forward_read_only_project_request::<proto::GetDefaultBranch>)+ .add_request_handler(forward_read_only_project_request::<proto::BlameBufferAtRevision>).add_request_handler(forward_read_only_project_request::<proto::OpenUnstagedDiff>).add_request_handler(forward_read_only_project_request::<proto::OpenUncommittedDiff>).add_request_handler(forward_read_only_project_request::<proto::LspExtExpandMacro>)diff --git a/crates/collab/tests/integration/editor_tests.rs b/crates/collab/tests/integration/editor_tests.rsindex bb20e88d6b2..3b16f57d04a 100644--- a/crates/collab/tests/integration/editor_tests.rs+++ b/crates/collab/tests/integration/editor_tests.rs@@ -4214,7 +4214,10 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA.into_iter().map(|(sha, message)| (sha.parse().unwrap(), message.into())).collect(),- tag_names: Default::default(),+ tag_names: [("1b1b1b", vec!["v1.0.0".to_string()])]+ .into_iter()+ .map(|(sha, tag_names)| (sha.parse().unwrap(), tag_names))+ .collect(),};client_a.fs().set_blame_for_repo(Path::new(path!("/my-repo/.git")),@@ -4300,6 +4303,10 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestAlet details = blame.details_for_entry(*buffer, entry).unwrap();assert_eq!(details.message, format!("message for idx-{}", idx));}+ assert_eq!(+ blame.tag_names_for_entry(buffer_id_b, &blame_entry("1b1b1b", 0..1)),+ vec![SharedString::from("v1.0.0")]+ );});});@@ -4375,6 +4382,61 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA]);});++ let revision = "0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d"+ .parse::<git::Oid>()+ .unwrap();+ let content_at_revision = "old line1\nold line2\n";+ let blame_at_revision = git::blame::Blame {+ entries: vec![blame_entry("1b1b1b", 0..1), blame_entry("0d0d0d", 1..2)],+ messages: [+ ("1b1b1b", "message for idx-0"),+ ("0d0d0d", "message for idx-1"),+ ]+ .into_iter()+ .map(|(sha, message)| (sha.parse().unwrap(), message.into()))+ .collect(),+ tag_names: [("0d0d0d", vec!["v1.0.0".to_string()])]+ .into_iter()+ .map(|(sha, tag_names)| (sha.parse().unwrap(), tag_names))+ .collect(),+ };+ client_a+ .fs()+ .with_git_state(Path::new(path!("/my-repo/.git")), true, |state| {+ state.refs.insert("HEAD".into(), revision.to_string());+ state+ .head_contents+ .insert(repo_path("file.txt"), content_at_revision.to_string());+ state+ .blames_at_revision+ .insert((repo_path("file.txt"), revision), blame_at_revision.clone());+ })+ .unwrap();++ cx_a.executor().run_until_parked();+ cx_b.executor().run_until_parked();++ let repository_b = project_b.read_with(cx_b, |project, cx| {+ project+ .git_store()+ .read(cx)+ .repositories()+ .values()+ .next()+ .unwrap()+ .clone()+ });++ let (content, forwarded_blame) = repository_b+ .update(cx_b, |repository, cx| {+ repository.blame_buffer_at_revision(repo_path("file.txt"), revision, cx)+ })+ .await+ .unwrap();++ assert_eq!(content, content_at_revision);+ assert_eq!(forwarded_blame, blame_at_revision);}#[gpui::test(iterations = 30)]diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rsindex d88ca2200ff..7002e337f19 100644--- a/crates/editor/src/actions.rs+++ b/crates/editor/src/actions.rs@@ -876,6 +876,10 @@ actions!(ToggleGitBlameInline,/// Opens the git commit for the blame at cursor.OpenGitBlameCommit,+ /// Opens a blame of the file at the revision of the blame entry at cursor.+ BlameRevision,+ /// Opens a blame of the file at the revision preceding the blame entry at cursor.+ BlamePreviousRevision,/// Toggles the diagnostics panel.ToggleDiagnostics,/// Toggles indent guides display.diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rsindex 5e4d6551c8f..a720ce51519 100644--- a/crates/editor/src/editor.rs+++ b/crates/editor/src/editor.rs@@ -106,7 +106,7 @@ pub use element::{CursorLayout, EditorElement, HighlightedRange, HighlightedRangeLine, PointForPosition,file_status_label_color, render_breadcrumb_text,};-pub use git::blame::BlameRenderer;+pub use git::blame::{BlameRenderer, GitBlame};pub use git::{DiffHunkDelegate, ResolvedDiffHunk, ResolvedDiffHunks, RestoreOnlyDiffHunkDelegate,RestoreOnlyUnstagedDiffHunkDelegate, UncommittedDiffHunkDelegate, render_diff_hunk_controls,@@ -158,7 +158,7 @@ use futures::{future::{self, Shared},};use fuzzy::{StringMatch, StringMatchCandidate};-use git::blame::{GitBlame, GlobalBlameRenderer};+use git::blame::GlobalBlameRenderer;use gpui::{Action, Animation, AnimationExt, AnyElement, App, AppContext, AsyncWindowContext,AvailableSpace, Background, Bounds, ClickEvent, ClipboardEntry, ClipboardItem, Context,@@ -3330,7 +3330,12 @@ impl Editor {cx.notify();return;}- if self.show_git_blame_gutter {+ if self.show_git_blame_gutter+ && !self+ .blame+ .as_ref()+ .is_some_and(|blame| blame.read(cx).is_static())+ {self.show_git_blame_gutter = false;cx.notify();return;diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rsindex 71c2ce7b530..07e81acc821 100644--- a/crates/editor/src/element.rs+++ b/crates/editor/src/element.rs@@ -509,7 +509,11 @@ impl EditorElement {register_action(editor, window, Editor::copy_file_location);register_action(editor, window, Editor::toggle_git_blame);register_action(editor, window, Editor::toggle_git_blame_inline);- register_action(editor, window, Editor::open_git_blame_commit);+ if editor.read(cx).blame().is_some() {+ register_action(editor, window, Editor::open_git_blame_commit);+ register_action(editor, window, Editor::blame_revision);+ register_action(editor, window, Editor::blame_previous_revision);+ }register_action(editor, window, Editor::toggle_selected_diff_hunks);register_action(editor, window, Editor::toggle_staged_selected_diff_hunks);register_action(editor, window, Editor::stage_and_next);diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rsindex aa36ce648df..e6552a1d33e 100644--- a/crates/editor/src/git.rs+++ b/crates/editor/src/git.rs@@ -1,8 +1,12 @@pub(super) mod blame;use super::*;-use ::git::{Restore, blame::BlameEntry, commit::ParsedCommitMessage, status::FileStatus};+use ::git::{+ Oid, Restore, blame::BlameEntry, commit::ParsedCommitMessage, repository::RepoPath,+ status::FileStatus,+};use buffer_diff::{BufferDiff, DiffHunkStatus, DiffHunkStatusKind};+use project::git_store::Repository;#[derive(Clone)]pub struct ResolvedDiffHunk {@@ -2145,15 +2149,36 @@ impl Editor {})}+ pub fn set_blame(+ &mut self,+ blame: Entity<GitBlame>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ self.blame_subscription = Some(cx.observe_in(&blame, window, |_, _, _, cx| cx.notify()));+ self.blame = Some(blame);+ self.show_git_blame_gutter = true;+ cx.notify();+ }+fn start_git_blame(&mut self,user_triggered: bool,window: &mut Window,cx: &mut Context<Self>,) {+ if self+ .blame+ .as_ref()+ .is_some_and(|blame| blame.read(cx).is_static())+ {+ return;+ }if let Some(project) = self.project() {if let Some(buffer) = self.buffer().read(cx).as_singleton()- && buffer.read(cx).file().is_none()+ && buffer.read(cx).file().is_none_or(|file| {+ matches!(file.disk_state(), language::DiskState::Historic { .. })+ }){return;}@@ -2248,7 +2273,19 @@ impl Editor {window: &mut Window,cx: &mut Context<Self>,) -> Option<()> {- let blame = self.blame.as_ref()?;+ let (blame_entry, repo) = self.blame_entry_at_cursor(window, cx)?;+ let renderer = cx.global::<GlobalBlameRenderer>().0.clone();+ let workspace = self.workspace()?.downgrade();+ renderer.open_blame_commit(blame_entry, repo, workspace, window, cx);+ None+ }++ fn blame_entry_at_cursor(+ &mut self,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) -> Option<(BlameEntry, Entity<Repository>)> {+ let blame = self.blame.clone()?;let snapshot = self.snapshot(window, cx);let cursor = self.selections@@ -2269,11 +2306,93 @@ impl Editor {.next()}).flatten()?;+ let repository = blame.read(cx).repository(cx, buffer.remote_id())?;+ Some((blame_entry, repository))+ }++ pub(super) fn blame_revision(+ &mut self,+ _: &BlameRevision,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ let Some((blame_entry, repository)) = self.blame_entry_at_cursor(window, cx) else {+ self.show_blame_revision_toast("No blame entry for this line", cx);+ return;+ };+ if blame_entry.sha.is_zero() {+ self.show_blame_revision_toast("Cannot blame revision: the line is not committed", cx);+ return;+ }+ if self+ .blame+ .as_ref()+ .is_some_and(|blame| blame.read(cx).highlighted_sha() == Some(blame_entry.sha))+ {+ self.show_blame_revision_toast("Already blaming at this revision", cx);+ return;+ }+ let Some(path) = RepoPath::new(&blame_entry.filename).log_err() else {+ return;+ };+ self.open_blame_revision(path, blame_entry.sha, repository, window, cx);+ }++ pub(super) fn blame_previous_revision(+ &mut self,+ _: &BlamePreviousRevision,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ let Some((blame_entry, repository)) = self.blame_entry_at_cursor(window, cx) else {+ self.show_blame_revision_toast("No blame entry for this line", cx);+ return;+ };+ let Some((revision, filename)) = blame_entry.previous_sha_and_filename() else {+ self.show_blame_revision_toast("No previous revision for this line", cx);+ return;+ };+ let Some(path) = RepoPath::new(filename).log_err() else {+ return;+ };+ self.open_blame_revision(path, revision, repository, window, cx);+ }++ fn open_blame_revision(+ &mut self,+ path: RepoPath,+ revision: Oid,+ repository: Entity<Repository>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ let Some(workspace) = self.workspace() else {+ return;+ };let renderer = cx.global::<GlobalBlameRenderer>().0.clone();- let repo = blame.read(cx).repository(cx, buffer.remote_id())?;- let workspace = self.workspace()?.downgrade();- renderer.open_blame_commit(blame_entry, repo, workspace, window, cx);- None+ renderer.open_blame_revision(+ path,+ revision,+ repository,+ workspace.downgrade(),+ window,+ cx,+ );+ }++ fn show_blame_revision_toast(&self, message: &str, cx: &mut Context<Self>) {+ struct BlameRevisionToast;+ if let Some(workspace) = self.workspace() {+ workspace.update(cx, |workspace, cx| {+ workspace.show_toast(+ Toast::new(+ NotificationId::unique::<BlameRevisionToast>(),+ message.to_owned(),+ ),+ cx,+ );+ });+ }}fn has_blame_entries(&self, cx: &App) -> bool {diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rsindex 347a1e8dafc..7a4b0977592 100644--- a/crates/editor/src/git/blame.rs+++ b/crates/editor/src/git/blame.rs@@ -6,13 +6,14 @@ use git::{GitHostingProviderRegistry, Oid,blame::{Blame, BlameEntry},commit::ParsedCommitMessage,+ repository::RepoPath,};use gpui::{AnyElement, App, AppContext as _, Context, Entity, Hsla, Pixels, ScrollHandle, SharedString,Subscription, Task, TextStyle, WeakEntity, Window,};use itertools::Itertools;-use language::{Bias, BufferSnapshot, Edit};+use language::{Bias, Buffer, BufferSnapshot, Edit};use markdown::Markdown;use multi_buffer::{MultiBuffer, RowInfo};use project::{@@ -72,6 +73,26 @@ struct GitBlameBuffer {commit_tag_names: HashMap<Oid, Vec<SharedString>>,}+/// Determines where the blame data comes from and whether it is kept up to date.+enum GitBlameKind {+ /// Blame of the working copy of every buffer in the multibuffer, computed+ /// through the project's git state and regenerated on edits, saves, and+ /// repository changes. The repository is resolved per buffer through the+ /// project.+ Live,+ /// Precomputed per-buffer blames at a fixed revision, created via+ /// [`GitBlame::new_static`]. They are never regenerated. The annotated+ /// buffers are synthetic read-only buffers that do not belong to the+ /// project, so the repository cannot be resolved through them and is+ /// stored explicitly; all buffers must belong to the same repository.+ Static {+ repository: Entity<Repository>,+ /// The revision being viewed; gutter entries introduced by this commit+ /// are highlighted.+ highlighted_sha: Option<Oid>,+ },+}+pub struct GitBlame {project: Entity<Project>,multi_buffer: WeakEntity<MultiBuffer>,@@ -82,6 +103,7 @@ pub struct GitBlame {user_triggered: bool,regenerate_on_edit_task: Task<Result<()>>,_regenerate_subscriptions: Vec<Subscription>,+ kind: GitBlameKind,}pub trait BlameRenderer {@@ -134,6 +156,17 @@ pub trait BlameRenderer {_: &mut Window,_: &mut App,);++ fn open_blame_revision(+ &self,+ _: RepoPath,+ _: Oid,+ _: Entity<Repository>,+ _: WeakEntity<Workspace>,+ _: &mut Window,+ _: &mut App,+ ) {+ }}impl BlameRenderer for () {@@ -268,12 +301,80 @@ impl GitBlame {project_subscription,git_store_subscription,],+ kind: GitBlameKind::Live,};this.generate(cx);this}+ pub fn new_static(+ multi_buffer: Entity<MultiBuffer>,+ project: Entity<Project>,+ repository: Entity<Repository>,+ blames: impl IntoIterator<Item = (Entity<Buffer>, Blame)>,+ highlighted_sha: Option<Oid>,+ cx: &mut Context<Self>,+ ) -> Self {+ let remote_url = repository.read(cx).default_remote_url();+ let provider_registry = GitHostingProviderRegistry::default_global(cx);++ let mut buffers = HashMap::default();+ for (buffer, blame) in blames {+ let snapshot = buffer.read(cx).snapshot();+ let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe());+ let (commit_details, commit_tag_names) = parse_commit_details(+ blame.messages,+ blame.tag_names,+ remote_url.as_deref(),+ &provider_registry,+ );+ let entries = build_blame_entry_sum_tree(blame.entries, snapshot.max_point().row);+ buffers.insert(+ snapshot.remote_id(),+ GitBlameBuffer {+ entries,+ buffer_snapshot: snapshot,+ buffer_edits,+ commit_details,+ commit_tag_names,+ },+ );+ }++ Self {+ project,+ multi_buffer: multi_buffer.downgrade(),+ buffers,+ task: Task::ready(Ok(())),+ focused: true,+ changed_while_blurred: false,+ user_triggered: true,+ regenerate_on_edit_task: Task::ready(Ok(())),+ _regenerate_subscriptions: Vec::new(),+ kind: GitBlameKind::Static {+ repository,+ highlighted_sha,+ },+ }+ }++ pub fn is_static(&self) -> bool {+ matches!(self.kind, GitBlameKind::Static { .. })+ }++ pub fn highlighted_sha(&self) -> Option<Oid> {+ match &self.kind {+ GitBlameKind::Live => None,+ GitBlameKind::Static {+ highlighted_sha, ..+ } => *highlighted_sha,+ }+ }+pub fn repository(&self, cx: &App, id: BufferId) -> Option<Entity<Repository>> {+ if let GitBlameKind::Static { repository, .. } = &self.kind {+ return Some(repository.clone());+ }self.project.read(cx).git_store()@@ -507,6 +608,9 @@ impl GitBlame {#[ztracing::instrument(skip_all)]fn generate(&mut self, cx: &mut Context<Self>) {+ if self.is_static() {+ return;+ }if !self.focused {self.changed_while_blurred = true;return;@@ -583,31 +687,13 @@ impl GitBlame {entries,snapshot.max_point().row,);- let commit_details = messages- .into_iter()- .map(|(oid, message)| {- let parsed_commit_message =- ParsedCommitMessage::parse(- oid.to_string(),- message,- remote_url.as_deref(),- Some(provider_registry.clone()),- );- (oid, parsed_commit_message)- })- .collect();- let commit_tag_names = tag_names- .into_iter()- .map(|(oid, tag_names)| {- (- oid,- tag_names- .into_iter()- .map(SharedString::from)- .collect(),- )- })- .collect();+ let (commit_details, commit_tag_names) =+ parse_commit_details(+ messages,+ tag_names,+ remote_url.as_deref(),+ &provider_registry,+ );res.push((id,snapshot,@@ -698,6 +784,42 @@ impl GitBlame {const REGENERATE_ON_EDIT_DEBOUNCE_INTERVAL: Duration = Duration::from_secs(2);+fn parse_commit_details(+ messages: HashMap<Oid, String>,+ tag_names: HashMap<Oid, Vec<String>>,+ remote_url: Option<&str>,+ provider_registry: &Arc<GitHostingProviderRegistry>,+) -> (+ HashMap<Oid, ParsedCommitMessage>,+ HashMap<Oid, Vec<SharedString>>,+) {+ let commit_details = messages+ .into_iter()+ .map(|(oid, message)| {+ let parsed_commit_message = ParsedCommitMessage::parse(+ oid.to_string(),+ message,+ remote_url,+ Some(provider_registry.clone()),+ );+ (oid, parsed_commit_message)+ })+ .collect();+ let commit_tag_names = tag_names+ .into_iter()+ .map(|(oid, tag_names)| {+ (+ oid,+ tag_names+ .into_iter()+ .map(SharedString::from)+ .collect::<Vec<_>>(),+ )+ })+ .collect();+ (commit_details, commit_tag_names)+}+fn build_blame_entry_sum_tree(entries: Vec<BlameEntry>, max_row: u32) -> SumTree<GitBlameEntry> {let mut current_row = 0;let mut entries = SumTree::from_iter(@@ -740,7 +862,7 @@ mod tests {use super::*;use git::repository::repo_path;use gpui::Context;- use language::{Point, Rope};+ use language::{Capability, Point, Rope};use project::FakeFs;use rand::prelude::*;use serde_json::json;@@ -1049,6 +1171,157 @@ mod tests {});}+ #[gpui::test]+ async fn test_static_blame(cx: &mut gpui::TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/my-repo"),+ json!({+ ".git": {},+ "file_one.txt": "Line 1\nLine 2\nLine 3\n",+ "file_two.txt": "Other 1\nOther 2\n",+ }),+ )+ .await;++ let project = Project::test(fs, [path!("/my-repo").as_ref()], cx).await;+ let buffer_one = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/my-repo/file_one.txt"), cx)+ })+ .await+ .unwrap();+ let buffer_two = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/my-repo/file_two.txt"), cx)+ })+ .await+ .unwrap();+ let buffer_one_id = buffer_one.read_with(cx, |buffer, _| buffer.remote_id());+ let buffer_two_id = buffer_two.read_with(cx, |buffer, _| buffer.remote_id());+ let multi_buffer = cx.new(|cx| {+ let mut multi_buffer = MultiBuffer::new(Capability::ReadWrite);+ multi_buffer.set_excerpts_for_buffer(+ buffer_one.clone(),+ [Point::zero()..buffer_one.read(cx).max_point()],+ 0,+ cx,+ );+ multi_buffer.set_excerpts_for_buffer(+ buffer_two.clone(),+ [Point::zero()..buffer_two.read(cx).max_point()],+ 0,+ cx,+ );+ multi_buffer+ });+ cx.executor().run_until_parked();++ let repository = project.read_with(cx, |project, cx| {+ project+ .git_store()+ .read(cx)+ .repositories()+ .values()+ .next()+ .unwrap()+ .clone()+ });++ let highlighted_sha = "0d0d0d".parse::<Oid>().unwrap();+ let blame_one = Blame {+ entries: vec![blame_entry("1b1b1b", 0..1), blame_entry("0d0d0d", 1..2)],+ messages: [+ ("1b1b1b".parse::<Oid>().unwrap(), "commit one".to_string()),+ ("0d0d0d".parse::<Oid>().unwrap(), "commit two".to_string()),+ ]+ .into_iter()+ .collect(),+ tag_names: [("0d0d0d".parse::<Oid>().unwrap(), vec!["v1.0.0".to_string()])]+ .into_iter()+ .collect(),+ };+ let blame_two = Blame {+ entries: vec![blame_entry("0d0d0d", 0..2)],+ messages: [("0d0d0d".parse::<Oid>().unwrap(), "commit two".to_string())]+ .into_iter()+ .collect(),+ tag_names: HashMap::default(),+ };++ let git_blame = cx.new(|cx| {+ GitBlame::new_static(+ multi_buffer,+ project.clone(),+ repository.clone(),+ [+ (buffer_one.clone(), blame_one),+ (buffer_two.clone(), blame_two),+ ],+ Some(highlighted_sha),+ cx,+ )+ });++ git_blame.update(cx, |blame, cx| {+ assert!(blame.is_static());+ assert_eq!(blame.highlighted_sha(), Some(highlighted_sha));+ assert_eq!(+ blame.repository(cx, buffer_one_id),+ Some(repository.clone())+ );+ assert_eq!(+ blame.repository(cx, buffer_two_id),+ Some(repository.clone())+ );+ assert_blame_rows(+ blame,+ buffer_one_id,+ 0..3,+ vec![+ Some(blame_entry("1b1b1b", 0..1)),+ Some(blame_entry("0d0d0d", 1..2)),+ None,+ ],+ cx,+ );+ assert_blame_rows(+ blame,+ buffer_two_id,+ 0..2,+ vec![+ Some(blame_entry("0d0d0d", 0..2)),+ Some(blame_entry("0d0d0d", 0..2)),+ ],+ cx,+ );+ assert_eq!(+ blame+ .details_for_entry(buffer_one_id, &blame_entry("1b1b1b", 0..1))+ .unwrap()+ .message,+ "commit one"+ );+ assert_eq!(+ blame+ .details_for_entry(buffer_two_id, &blame_entry("0d0d0d", 0..2))+ .unwrap()+ .message,+ "commit two"+ );+ assert_eq!(+ blame.tag_names_for_entry(buffer_one_id, &blame_entry("0d0d0d", 1..2)),+ vec![SharedString::from("v1.0.0")]+ );+ assert_eq!(+ blame.tag_names_for_entry(buffer_two_id, &blame_entry("0d0d0d", 0..2)),+ Vec::<SharedString>::new()+ );+ });+ }+#[gpui::test]async fn test_blame_for_rows_with_edits(cx: &mut gpui::TestAppContext) {init_test(cx);diff --git a/crates/fs/src/fake_git_repo.rs b/crates/fs/src/fake_git_repo.rsindex 0a87c4584d0..543a11a9c2f 100644--- a/crates/fs/src/fake_git_repo.rs+++ b/crates/fs/src/fake_git_repo.rs@@ -66,6 +66,7 @@ pub struct FakeGitRepositoryState {pub merge_base_contents: HashMap<RepoPath, Oid>,pub oids: HashMap<Oid, String>,pub blames: HashMap<RepoPath, Blame>,+ pub blames_at_revision: HashMap<(RepoPath, Oid), Blame>,pub current_branch_name: Option<String>,pub branches: HashSet<String>,/// List of remotes, keys are names and values are URLs@@ -90,6 +91,7 @@ impl FakeGitRepositoryState {index_contents: Default::default(),unmerged_paths: Default::default(),blames: Default::default(),+ blames_at_revision: Default::default(),current_branch_name: Default::default(),branches: Default::default(),simulated_index_write_error_message: Default::default(),@@ -269,7 +271,14 @@ impl GitRepository for FakeGitRepository {match prefix {"" => state.index_contents.get(&repo_path).cloned(),"HEAD" => state.head_contents.get(&repo_path).cloned(),- _ => None,+ _ if state.refs.get("HEAD").map(String::as_str) == Some(prefix) => {+ state.head_contents.get(&repo_path).cloned()+ }+ _ => state+ .commit_history+ .iter()+ .find(|snapshot| snapshot.sha == prefix)+ .and_then(|snapshot| snapshot.head_contents.get(&repo_path).cloned()),}}).collect())@@ -989,6 +998,20 @@ impl GitRepository for FakeGitRepository {})}+ fn blame_at_revision(+ &self,+ path: RepoPath,+ revision: Oid,+ ) -> BoxFuture<'_, Result<git::blame::Blame>> {+ self.with_state_async(false, move |state| {+ state+ .blames_at_revision+ .get(&(path.clone(), revision))+ .with_context(|| format!("failed to get blame for {path:?} at {revision}"))+ .cloned()+ })+ }+fn stage_paths(&self,paths: Vec<RepoPath>,diff --git a/crates/git/src/blame.rs b/crates/git/src/blame.rsindex 6036e112e43..85c8f8a4ac0 100644--- a/crates/git/src/blame.rs+++ b/crates/git/src/blame.rs@@ -13,7 +13,7 @@ use time::UtcOffset;use time::macros::format_description;use util::command::Stdio;-#[derive(Debug, Clone, Default)]+#[derive(Debug, Clone, Default, PartialEq)]pub struct Blame {pub entries: Vec<BlameEntry>,pub messages: HashMap<Oid, String>,@@ -27,8 +27,20 @@ impl Blame {content: &Rope,line_ending: LineEnding,) -> Result<Self> {- let mut entries = run_git_blame(git, path, content, line_ending).await?;+ let entries = run_git_blame(git, path, BlameSource::Contents(content, line_ending)).await?;+ Self::with_commit_details(git, entries).await+ }++ pub(crate) async fn for_path_at_revision(+ git: &GitBinary,+ path: &RepoPath,+ revision: Oid,+ ) -> Result<Self> {+ let entries = run_git_blame(git, path, BlameSource::Revision(revision)).await?;+ Self::with_commit_details(git, entries).await+ }+ async fn with_commit_details(git: &GitBinary, mut entries: Vec<BlameEntry>) -> Result<Self> {let mut unique_shas = HashSet::default();for entry in entries.iter_mut() {@@ -63,18 +75,37 @@ const GIT_BLAME_NO_COMMIT_ERROR: &str = "fatal: no such ref: HEAD";const GIT_BLAME_NO_PATH: &str = "fatal: no such path";const BLAME_PARSE_YIELD_INTERVAL: usize = 512;+#[derive(Clone, Copy)]+enum BlameSource<'a> {+ Contents(&'a Rope, LineEnding),+ Revision(Oid),+}+async fn run_git_blame(git: &GitBinary,path: &RepoPath,- contents: &Rope,- line_ending: LineEnding,+ source: BlameSource<'_>,) -> Result<Vec<BlameEntry>> {let mut child = {let span = ztracing::debug_span!("spawning git-blame command", path = path.as_unix_str());let _enter = span.enter();- git.build_command(&["blame", "--incremental", "--contents", "-", "--"])+ let mut args = vec!["blame", "--incremental"];+ let revision_string;+ match source {+ BlameSource::Contents(..) => args.extend(["--contents", "-"]),+ BlameSource::Revision(revision) => {+ revision_string = revision.to_string();+ args.push(&revision_string);+ }+ }+ args.push("--");+ git.build_command(&args).arg(path.as_unix_str())- .stdin(Stdio::piped())+ .stdin(if matches!(source, BlameSource::Contents(..)) {+ Stdio::piped()+ } else {+ Stdio::null()+ }).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true)@@ -82,10 +113,7 @@ async fn run_git_blame(.context("starting git blame process")?};- let mut stdin = child- .stdin- .take()- .context("failed to get pipe to stdin of git blame command")?;+ let stdin = child.stdin.take();let stdout = child.stdout.take()@@ -96,10 +124,14 @@ async fn run_git_blame(.context("failed to get stderr from git blame command")?;let write_stdin = async move {- for chunk in text::chunks_with_line_ending(contents, line_ending) {- stdin.write_all(chunk.as_bytes()).await?;+ if let BlameSource::Contents(contents, line_ending) = source {+ let mut stdin = stdin.context("failed to get pipe to stdin of git blame command")?;+ for chunk in text::chunks_with_line_ending(contents, line_ending) {+ stdin.write_all(chunk.as_bytes()).await?;+ }+ stdin.flush().await?;}- stdin.flush().await.map_err(Into::into)+ anyhow::Ok(())};let read_stdout = async move {@@ -233,6 +265,11 @@ impl BlameEntry {})}+ pub fn previous_sha_and_filename(&self) -> Option<(Oid, &str)> {+ let (sha, filename) = self.previous.as_deref()?.split_once(' ')?;+ Some((sha.parse().ok()?, filename))+ }+pub fn author_offset_date_time(&self) -> Result<time::OffsetDateTime> {if let (Some(author_time), Some(author_tz)) = (self.author_time, &self.author_tz) {let format = format_description!("[offset_hour][offset_minute]");@@ -338,10 +375,17 @@ impl GitBlameParser {let is_committed = !entry.sha.is_zero();match key {"filename" => {- entry.filename = value.into();+ entry.filename = unquote_git_path(value);done = true;}- "previous" => entry.previous = Some(value.into()),+ "previous" => {+ entry.previous = Some(match value.split_once(' ') {+ Some((sha, filename)) => {+ format!("{sha} {}", unquote_git_path(filename))+ }+ None => value.into(),+ })+ }"summary" if is_committed => entry.summary = Some(value.into()),"author" if is_committed => entry.author = Some(value.into()),@@ -383,13 +427,55 @@ impl GitBlameParser {}}+fn unquote_git_path(value: &str) -> String {+ let Some(quoted) = value+ .strip_prefix('"')+ .and_then(|value| value.strip_suffix('"'))+ else {+ return value.to_owned();+ };+ let mut bytes = Vec::with_capacity(quoted.len());+ let mut input = quoted.bytes().peekable();+ while let Some(byte) = input.next() {+ if byte != b'\\' {+ bytes.push(byte);+ continue;+ }+ match input.next() {+ Some(b'a') => bytes.push(0x07),+ Some(b'b') => bytes.push(0x08),+ Some(b'f') => bytes.push(0x0c),+ Some(b'n') => bytes.push(b'\n'),+ Some(b'r') => bytes.push(b'\r'),+ Some(b't') => bytes.push(b'\t'),+ Some(b'v') => bytes.push(0x0b),+ Some(digit @ b'0'..=b'7') => {+ let mut octal = u32::from(digit - b'0');+ for _ in 0..2 {+ match input.peek() {+ Some(&next @ b'0'..=b'7') if octal * 8 + u32::from(next - b'0') <= 0xff => {+ octal = octal * 8 + u32::from(next - b'0');+ input.next();+ }+ _ => break,+ }+ }+ bytes.push(octal as u8);+ }+ Some(other) => bytes.push(other),+ None => {}+ }+ }+ String::from_utf8_lossy(&bytes).into_owned()+}+#[cfg(test)]mod tests {use std::path::PathBuf;use crate::blame::GitBlameParser;- use super::BlameEntry;+ use super::{BlameEntry, unquote_git_path};fn parse_git_blame(output: &str) -> anyhow::Result<Vec<BlameEntry>> {let mut parser = GitBlameParser::new();@@ -459,4 +545,43 @@ mod tests {let entries = parse_git_blame(&output).unwrap();assert_eq_golden(&entries, "blame_incremental_complex");}++ #[test]+ fn test_parse_git_blame_quoted_filename() {+ let output = r#"6ad46b5257ba16d12c5ca9f0d4900320959df7f4 2 2 1+author Joe Schmoe+author-mail <[email protected]>+author-time 1709741400+author-tz +0100+committer Joe Schmoe+committer-mail <[email protected]>+committer-time 1709741400+committer-tz +0100+summary Joe's cool commit+previous 486c2409237a2c627230589e567024a96751d475 "\303\274rlich \"file\".txt"+filename "\303\274rlich \"file\".txt"+"#;+ let entries = parse_git_blame(output).unwrap();+ assert_eq!(entries.len(), 1);+ assert_eq!(entries[0].filename, "ürlich \"file\".txt");+ assert_eq!(+ entries[0].previous.as_deref(),+ Some("486c2409237a2c627230589e567024a96751d475 ürlich \"file\".txt")+ );+ assert_eq!(+ entries[0].previous_sha_and_filename(),+ Some((+ "486c2409237a2c627230589e567024a96751d475".parse().unwrap(),+ "ürlich \"file\".txt"+ ))+ );+ }++ #[test]+ fn test_unquote_git_path() {+ assert_eq!(unquote_git_path("plain file.txt"), "plain file.txt");+ assert_eq!(unquote_git_path(r#""a\\b\"c\td""#), "a\\b\"c\td");+ assert_eq!(unquote_git_path(r#""\1\12\123""#), "\u{1}\nS");+ assert_eq!(unquote_git_path(r#""\777""#), "?7");+ }}diff --git a/crates/git/src/git.rs b/crates/git/src/git.rsindex bb74142139e..9d8f658a6b2 100644--- a/crates/git/src/git.rs+++ b/crates/git/src/git.rs@@ -225,7 +225,7 @@ impl Oid {&self.bytes[..self.format.byte_len()]}- pub(crate) fn is_zero(&self) -> bool {+ pub fn is_zero(&self) -> bool {self.as_bytes().iter().all(|byte| *byte == 0)}diff --git a/crates/git/src/repository.rs b/crates/git/src/repository.rsindex 9d3e4086f30..7cddc70b1a5 100644--- a/crates/git/src/repository.rs+++ b/crates/git/src/repository.rs@@ -889,6 +889,12 @@ pub trait GitRepository: Send + Sync {line_ending: LineEnding,) -> BoxFuture<'_, Result<crate::blame::Blame>>;+ fn blame_at_revision(+ &self,+ path: RepoPath,+ revision: Oid,+ ) -> BoxFuture<'_, Result<crate::blame::Blame>>;+/// Returns the absolute path to the repository. For worktrees, this will be the path to the/// worktree's gitdir within the main repository (typically `.git/worktrees/<name>`).fn path(&self) -> PathBuf;@@ -1723,6 +1729,11 @@ impl GitRepository for RealGitRepository {if revisions.is_empty() {return Ok(Vec::new());}+ if let Some(revision) = revisions.iter().find(|revision| revision.contains('\n')) {+ anyhow::bail!(+ "revision spec {revision:?} contains a newline and cannot be passed to git cat-file --batch"+ );+ }let mut process = git.build_command(&["cat-file", "--batch"])@@ -2373,6 +2384,21 @@ impl GitRepository for RealGitRepository {.boxed()}+ fn blame_at_revision(+ &self,+ path: RepoPath,+ revision: Oid,+ ) -> BoxFuture<'_, Result<crate::blame::Blame>> {+ let git = self.git_binary_in_worktree();++ self.executor+ .spawn(async move {+ let git = git?;+ crate::blame::Blame::for_path_at_revision(&git, &path, revision).await+ })+ .boxed()+ }+fn diff(&self, diff: DiffType) -> BoxFuture<'_, Result<String>> {let git = self.git_binary_in_worktree();self.executor@@ -5449,6 +5475,74 @@ mod tests {);}+ #[gpui::test]+ async fn test_blame_at_revision(cx: &mut TestAppContext) {+ disable_git_global_config();+ cx.executor().allow_parking();++ let repo_dir = tempfile::tempdir().unwrap();+ git_init_repo(repo_dir.path());+ let repo = RealGitRepository::new(+ &repo_dir.path().join(".git"),+ None,+ Some("git".into()),+ cx.executor(),+ )+ .unwrap();++ let file_name = "ürlich file1";+ fs::write(repo_dir.path().join(file_name), "line one\n").unwrap();+ git_command(repo_dir.path(), ["add", "-A"]);+ git_command(repo_dir.path(), ["commit", "-m", "First commit"]);+ let first_sha = git_command_output(repo_dir.path(), ["rev-parse", "HEAD"]);++ fs::write(repo_dir.path().join(file_name), "line one\nline two\n").unwrap();+ git_command(repo_dir.path(), ["add", "-A"]);+ git_command(repo_dir.path(), ["commit", "-m", "Second commit"]);+ let second_sha = git_command_output(repo_dir.path(), ["rev-parse", "HEAD"]);++ let blame_at_head = repo+ .blame_at_revision(repo_path(file_name), second_sha.parse().unwrap())+ .await+ .unwrap();+ assert_eq!(+ blame_at_head+ .entries+ .iter()+ .map(|entry| {+ (+ entry.sha.to_string(),+ entry.range.clone(),+ entry.filename.clone(),+ entry.previous.clone(),+ )+ })+ .collect::<Vec<_>>(),+ vec![+ (first_sha.clone(), 0..1, file_name.to_owned(), None),+ (+ second_sha.clone(),+ 1..2,+ file_name.to_owned(),+ Some(format!("{first_sha} {file_name}"))+ ),+ ]+ );++ let blame_at_first = repo+ .blame_at_revision(repo_path(file_name), first_sha.parse().unwrap())+ .await+ .unwrap();+ assert_eq!(+ blame_at_first+ .entries+ .iter()+ .map(|entry| (entry.sha.to_string(), entry.range.clone()))+ .collect::<Vec<_>>(),+ vec![(first_sha.clone(), 0..1)]+ );+ }+#[gpui::test]async fn test_checkpoint_empty_repo(cx: &mut TestAppContext) {disable_git_global_config();diff --git a/crates/git_ui/src/blame_ui.rs b/crates/git_ui/src/blame_ui.rsindex 07097e21092..7413f40c7fb 100644--- a/crates/git_ui/src/blame_ui.rs+++ b/crates/git_ui/src/blame_ui.rs@@ -1,9 +1,15 @@use crate::{commit_tooltip::{CommitAvatar, CommitTooltip, commit_tag_chips},- commit_view::CommitView,+ commit_view::{CommitView, GitBlob, build_buffer, worktree_id_for_repo_path},+};+use anyhow::Context as _;+use editor::{BlameRenderer, Editor, GitBlame, MultiBuffer, hover_markdown_style};+use git::{+ Oid,+ blame::BlameEntry,+ commit::ParsedCommitMessage,+ repository::{CommitSummary, RepoPath},};-use editor::{BlameRenderer, Editor, hover_markdown_style};-use git::{blame::BlameEntry, commit::ParsedCommitMessage, repository::CommitSummary};use gpui::{ClipboardItem, Entity, Hsla, MouseButton, Pixels, Rems, ScrollHandle, Subscription, TextStyle,TextStyleRefinement, UnderlineStyle, WeakEntity, prelude::*,@@ -14,10 +20,12 @@ use project::{project_settings::{InlineBlameLocation, ProjectSettings},};use settings::Settings as _;+use std::sync::Arc;use theme_settings::ThemeSettings;use time::OffsetDateTime;use ui::{ContextMenu, CopyButton, Divider, prelude::*, tooltip_container};-use workspace::Workspace;+use util::paths::PathStyle;+use workspace::{Workspace, notifications::NotifyTaskExt as _};const GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED: usize = 20;const GIT_BLAME_GUTTER_MARGIN: Rems = rems(0.5);@@ -160,6 +168,10 @@ impl BlameRenderer for GitBlameRenderer {let short_commit_id = blame_entry.sha.display_short();let author_name = blame_entry.author.as_deref().unwrap_or("<no name>");let name = util::truncate_and_trailoff(author_name, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED);+ let is_highlighted = editor+ .read(cx)+ .blame()+ .is_some_and(|blame| blame.read(cx).highlighted_sha() == Some(blame_entry.sha));let avatar = if ProjectSettings::get_global(cx).git.blame.show_avatar {let author_email = blame_entry.author_mail.as_ref().map(|email| {@@ -195,6 +207,9 @@ impl BlameRenderer for GitBlameRenderer {.font(style.font()).line_height(style.line_height).text_color(cx.theme().status().hint)+ .when(is_highlighted, |this| {+ this.bg(cx.theme().colors().element_selected)+ }).child(h_flex().gap_2()@@ -209,6 +224,8 @@ impl BlameRenderer for GitBlameRenderer {let blame_entry = blame_entry.clone();let details = details.clone();let editor = editor.clone();+ let repository = repository.clone();+ let workspace = workspace.clone();move |event, window, cx| {cx.stop_propagation();@@ -216,6 +233,8 @@ impl BlameRenderer for GitBlameRenderer {&blame_entry,details.as_ref(),editor.clone(),+ repository.clone(),+ workspace.clone(),event.position,window,cx,@@ -506,18 +525,44 @@ impl BlameRenderer for GitBlameRenderer {cx,)}++ fn open_blame_revision(+ &self,+ path: RepoPath,+ revision: Oid,+ repository: Entity<Repository>,+ workspace: WeakEntity<Workspace>,+ window: &mut Window,+ cx: &mut App,+ ) {+ open_buffer_blame_at_revision(repository, workspace, path, revision, window, cx);+ }}fn deploy_blame_entry_context_menu(blame_entry: &BlameEntry,details: Option<&ParsedCommitMessage>,editor: Entity<Editor>,+ repository: Entity<Repository>,+ workspace: WeakEntity<Workspace>,position: gpui::Point<Pixels>,window: &mut Window,cx: &mut App,) {+ let highlighted_sha = editor+ .read(cx)+ .blame()+ .and_then(|blame| blame.read(cx).highlighted_sha());let context_menu = ContextMenu::build(window, cx, move |menu, _, _| {let sha = format!("{}", blame_entry.sha);+ let blame_revision = (!blame_entry.sha.is_zero()+ && Some(blame_entry.sha) != highlighted_sha)+ .then_some(blame_entry.sha)+ .zip(RepoPath::new(&blame_entry.filename).ok());+ let blame_previous_revision = blame_entry+ .previous_sha_and_filename()+ .and_then(|(sha, filename)| Some((sha, RepoPath::new(filename).ok()?)));+ let has_blame_targets = blame_revision.is_some() || blame_previous_revision.is_some();menu.on_blur_subscription(Subscription::new(|| {})).entry("Copy Commit SHA", None, move |_, cx| {cx.write_to_clipboard(ClipboardItem::new_string(sha.clone()));@@ -530,6 +575,35 @@ fn deploy_blame_entry_context_menu(})},)+ .when(has_blame_targets, |this| this.separator())+ .when_some(blame_revision, |this, (revision, path)| {+ let repository = repository.clone();+ let workspace = workspace.clone();+ this.entry("Blame Revision", None, move |window, cx| {+ open_buffer_blame_at_revision(+ repository.clone(),+ workspace.clone(),+ path.clone(),+ revision,+ window,+ cx,+ );+ })+ })+ .when_some(blame_previous_revision, |this, (revision, path)| {+ let repository = repository.clone();+ let workspace = workspace.clone();+ this.entry("Blame Previous Revision", None, move |window, cx| {+ open_buffer_blame_at_revision(+ repository.clone(),+ workspace.clone(),+ path.clone(),+ revision,+ window,+ cx,+ );+ })+ })});editor.update(cx, move |editor, cx| {@@ -539,6 +613,152 @@ fn deploy_blame_entry_context_menu(});}+fn open_buffer_blame_at_revision(+ repository: Entity<Repository>,+ workspace: WeakEntity<Workspace>,+ path: RepoPath,+ revision: Oid,+ window: &mut Window,+ cx: &mut App,+) {+ window+ .spawn(cx, {+ let workspace = workspace.clone();+ async move |cx| {+ let (language_registry, worktree_id) =+ workspace.read_with(cx, |workspace, cx| {+ let project = workspace.project().read(cx);+ (+ project.languages().clone(),+ worktree_id_for_repo_path(repository.read(cx), project, &path, cx),+ )+ })?;+ let worktree_id = worktree_id.context("project has no worktrees")?;++ let file_name = path+ .file_name()+ .map(|name| name.to_string())+ .unwrap_or_else(|| path.display(PathStyle::local()).to_string());+ let display_name = format!("{file_name} @ {}", revision.display_short());++ let activated_existing = workspace.update_in(cx, |workspace, window, cx| {+ activate_existing_blame_editor(+ workspace,+ &repository,+ &path,+ revision,+ window,+ cx,+ )+ })?;+ if activated_existing {+ return Ok(());+ }++ let (content, blame) = repository+ .update(cx, |repository, cx| {+ repository.blame_buffer_at_revision(path.clone(), revision, cx)+ })+ .await?;++ let file = Arc::new(GitBlob {+ path: path.clone(),+ worktree_id,+ is_deleted: false,+ is_binary: false,+ display_name: display_name.clone(),+ }) as Arc<dyn language::File>;++ let buffer = build_buffer(content, file, &language_registry, cx).await?;++ workspace.update_in(cx, |workspace, window, cx| {+ if activate_existing_blame_editor(+ workspace,+ &repository,+ &path,+ revision,+ window,+ cx,+ ) {+ return;+ }++ let project = workspace.project().clone();+ let multi_buffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ let editor = cx.new(|cx| {+ let mut editor = Editor::for_multibuffer(+ multi_buffer.clone(),+ Some(project.clone()),+ window,+ cx,+ );+ editor.set_read_only(true);+ editor.set_should_serialize(false, cx);+ editor+ });+ let git_blame = cx.new(|cx| {+ GitBlame::new_static(+ multi_buffer,+ project,+ repository,+ [(buffer, blame)],+ Some(revision),+ cx,+ )+ });+ editor.update(cx, |editor, cx| editor.set_blame(git_blame, window, cx));+ workspace.add_item_to_active_pane(Box::new(editor), None, true, window, cx);+ })+ }+ })+ .detach_and_notify_err(workspace, window, cx);+}++fn activate_existing_blame_editor(+ workspace: &mut Workspace,+ repository: &Entity<Repository>,+ path: &RepoPath,+ revision: Oid,+ window: &mut Window,+ cx: &mut Context<Workspace>,+) -> bool {+ match existing_blame_editor(workspace, repository, path, revision, cx) {+ Some(existing) => {+ workspace.activate_item(&existing, true, true, window, cx);+ true+ }+ None => false,+ }+}++fn existing_blame_editor(+ workspace: &Workspace,+ repository: &Entity<Repository>,+ path: &RepoPath,+ revision: Oid,+ cx: &App,+) -> Option<Entity<Editor>> {+ workspace+ .panes()+ .iter()+ .flat_map(|pane| pane.read(cx).items())+ .find_map(|item| {+ let editor = item.downcast::<Editor>()?;+ let blame = editor.read(cx).blame()?;+ if blame.read(cx).highlighted_sha() != Some(revision) {+ return None;+ }+ let buffer = editor.read(cx).buffer().read(cx).as_singleton()?;+ let buffer_id = buffer.read(cx).remote_id();+ if blame.read(cx).repository(cx, buffer_id).as_ref() != Some(repository) {+ return None;+ }+ let file = buffer.read(cx).file()?;+ let blob = (file.as_ref() as &dyn std::any::Any).downcast_ref::<GitBlob>()?;+ (blob.path == *path).then_some(editor)+ })+}+fn blame_entry_relative_timestamp(blame_entry: &BlameEntry) -> String {match blame_entry.author_offset_date_time() {Ok(timestamp) => {diff --git a/crates/git_ui/src/commit_view.rs b/crates/git_ui/src/commit_view.rsindex a595af730b6..009aa368add 100644--- a/crates/git_ui/src/commit_view.rs+++ b/crates/git_ui/src/commit_view.rs@@ -85,14 +85,36 @@ pub struct CommitView {project: Entity<Project>,workspace: WeakEntity<Workspace>,remote: Option<GitRemote>,+ _load_diff_task: Task<Result<()>>,}-struct GitBlob {- path: RepoPath,- worktree_id: WorktreeId,- is_deleted: bool,- is_binary: bool,- display_name: String,+pub(crate) struct GitBlob {+ pub(crate) path: RepoPath,+ pub(crate) worktree_id: WorktreeId,+ pub(crate) is_deleted: bool,+ pub(crate) is_binary: bool,+ pub(crate) display_name: String,+}++pub(crate) fn worktree_id_for_repo_path(+ repository: &Repository,+ project: &Project,+ path: &RepoPath,+ cx: &App,+) -> Option<WorktreeId> {+ repository+ .repo_path_to_project_path(path, cx)+ .map(|project_path| project_path.worktree_id)+ .or_else(|| {+ let (worktree, _) = project.find_worktree(&repository.work_directory_abs_path, cx)?;+ Some(worktree.read(cx).id())+ })+ .or_else(|| {+ project+ .worktrees(cx)+ .next()+ .map(|worktree| worktree.read(cx).id())+ })}struct CommitDiffAddon {@@ -287,15 +309,10 @@ impl CommitView {});let commit_sha = Arc::<str>::from(commit.sha.as_ref());- let first_worktree_id = project- .read(cx)- .worktrees(cx)- .next()- .map(|worktree| worktree.read(cx).id());-let repository_clone = repository.clone();+ let project_clone = project.clone();- cx.spawn_in(window, async move |this, cx| {+ let load_diff_task = cx.spawn_in(window, async move |this, cx| {let mut binary_buffer_ids: HashSet<language::BufferId> = HashSet::default();let mut file_statuses: HashMap<language::BufferId, FileStatus> = HashMap::default();@@ -318,11 +335,13 @@ impl CommitView {};let old_text = if is_binary { None } else { raw_old_text };let worktree_id = repository_clone- .update(cx, |repository, cx| {- repository- .repo_path_to_project_path(&file.path, cx)- .map(|path| path.worktree_id)- .or(first_worktree_id)+ .read_with(cx, |repository, cx| {+ worktree_id_for_repo_path(+ repository,+ project_clone.read(cx),+ &file.path,+ cx,+ )}).context("project has no worktrees")?;let short_sha = commit_sha@@ -453,8 +472,7 @@ impl CommitView {})?;anyhow::Ok(())- })- .detach();+ });let snapshot = repository.read(cx).snapshot();let remote_url = snapshot@@ -483,6 +501,7 @@ impl CommitView {project,workspace,remote,+ _load_diff_task: load_diff_task,}}@@ -957,7 +976,7 @@ impl language::File for GitBlob {}}-async fn build_buffer(+pub(crate) async fn build_buffer(mut text: String,blob: Arc<dyn File>,language_registry: &Arc<language::LanguageRegistry>,@@ -1235,6 +1254,7 @@ impl Item for CommitView {project: self.project.clone(),workspace: self.workspace.clone(),remote: self.remote.clone(),+ _load_diff_task: Task::ready(Ok(())),}})))}diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rsindex 5338528a551..c4f77c78784 100644--- a/crates/project/src/git_store.rs+++ b/crates/project/src/git_store.rs@@ -39,7 +39,7 @@ use git::{FileHistoryChangedFileSets, GitCommitTemplate, GitRepository, GitRepositoryCheckpoint,InitialGraphCommitData, LogOrder, LogSource, PushOptions, Remote, RemoteCommandOutput,RepoPath, ResetMode, SearchCommitArgs, UpstreamTrackingStatus, Worktree as GitWorktree,- delete_branch_flag,+ delete_branch_flag, is_binary_content,},stash::{GitStash, StashEntry},status::{@@ -860,6 +860,7 @@ impl GitStore {client.add_entity_message_handler(Self::handle_update_diff_bases);client.add_entity_request_handler(Self::handle_get_permalink_to_line);client.add_entity_request_handler(Self::handle_blame_buffer);+ client.add_entity_request_handler(Self::handle_blame_buffer_at_revision);client.add_entity_message_handler(Self::handle_update_repository);client.add_entity_message_handler(Self::handle_remove_repository);client.add_entity_request_handler(Self::handle_git_clone);@@ -4628,6 +4629,39 @@ impl GitStore {Ok(serialize_blame_buffer_response(blame))}+ async fn handle_blame_buffer_at_revision(+ this: Entity<Self>,+ envelope: TypedEnvelope<proto::BlameBufferAtRevision>,+ mut cx: AsyncApp,+ ) -> Result<proto::BlameBufferAtRevisionResponse> {+ let repository_id = RepositoryId(envelope.payload.repository_id);+ let path = RepoPath::from_proto(&envelope.payload.path)?;+ let revision = envelope+ .payload+ .revision+ .parse::<git::Oid>()+ .with_context(|| format!("invalid revision {:?}", envelope.payload.revision))?;+ let (content, blame) = this+ .update(&mut cx, |this, cx| {+ let repository = this.repositories().get(&repository_id)?;+ Some(repository.update(cx, |repository, cx| {+ repository.blame_buffer_at_revision(path, revision, cx)+ }))+ })+ .context("missing repository")?+ .await?;+ Ok(proto::BlameBufferAtRevisionResponse {+ content,+ entries: blame+ .entries+ .into_iter()+ .map(serialize_blame_entry)+ .collect(),+ messages: serialize_commit_messages(blame.messages),+ tag_names: serialize_commit_tag_names(blame.tag_names),+ })+ }+async fn handle_get_permalink_to_line(this: Entity<Self>,envelope: TypedEnvelope<proto::GetPermalinkToLine>,@@ -9810,6 +9844,60 @@ impl Repository {)}+ pub fn blame_buffer_at_revision(+ &mut self,+ path: RepoPath,+ revision: Oid,+ cx: &App,+ ) -> Task<Result<(String, git::blame::Blame)>> {+ let repository_id = self.snapshot.id;+ let rx = self.send_job("blame_buffer_at_revision", None, {+ let path = path.clone();+ move |state, _| async move {+ match state {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ let content_task = backend+ .load_revisions(vec![format!("{revision}:{}", path.as_unix_str())]);+ let blame_task = backend.blame_at_revision(path.clone(), revision);+ let (mut contents, blame) = futures::try_join!(content_task, blame_task)?;+ let content = contents.pop().flatten().with_context(|| {+ format!(+ "cannot load {:?} at revision {revision}: the file is missing or binary",+ path.as_ref()+ )+ })?;+ anyhow::Ok((content, blame))+ }+ RepositoryState::Remote(RemoteRepositoryState { client, project_id }) => {+ let response = client+ .request(proto::BlameBufferAtRevision {+ project_id: project_id.to_proto(),+ repository_id: repository_id.0,+ path: path.as_unix_str().to_owned(),+ revision: revision.to_string(),+ })+ .await?;+ let blame = blame_from_proto(+ response.entries,+ response.messages,+ response.tag_names,+ );+ Ok((response.content, blame))+ }+ }+ }+ });+ cx.spawn(move |_: &mut AsyncApp| async move {+ let (content, blame) = rx.await??;+ anyhow::ensure!(+ !is_binary_content(content.as_bytes()),+ "cannot blame binary file {:?} at revision {revision}",+ path.as_ref()+ );+ Ok((content, blame))+ })+ }+fn load_blob_content(&mut self, oid: Oid, cx: &App) -> Task<Result<String>> {let repository_id = self.snapshot.id;let rx = self.send_job("load_blob_content", None, move |state, _| async move {@@ -10373,36 +10461,112 @@ fn serialize_blame_buffer_response(blame: Option<git::blame::Blame>) -> proto::Blet entries = blame.entries.into_iter()- .map(|entry| proto::BlameEntry {- sha: entry.sha.as_bytes().into(),- start_line: entry.range.start,- end_line: entry.range.end,- original_line_number: entry.original_line_number,- author: entry.author,- author_mail: entry.author_mail,- author_time: entry.author_time,- author_tz: entry.author_tz,- committer: entry.committer_name,- committer_mail: entry.committer_email,- committer_time: entry.committer_time,- committer_tz: entry.committer_tz,- summary: entry.summary,- previous: entry.previous,- filename: entry.filename,- })+ .map(serialize_blame_entry).collect::<Vec<_>>();+ let messages = serialize_commit_messages(blame.messages);+ let tag_names = serialize_commit_tag_names(blame.tag_names);++ proto::BlameBufferResponse {+ blame_response: Some(proto::blame_buffer_response::BlameResponse {+ entries,+ messages,+ tag_names,+ }),+ }+}- let messages = blame- .messages+fn serialize_blame_entry(entry: git::blame::BlameEntry) -> proto::BlameEntry {+ proto::BlameEntry {+ sha: entry.sha.as_bytes().into(),+ start_line: entry.range.start,+ end_line: entry.range.end,+ original_line_number: entry.original_line_number,+ author: entry.author,+ author_mail: entry.author_mail,+ author_time: entry.author_time,+ author_tz: entry.author_tz,+ committer: entry.committer_name,+ committer_mail: entry.committer_email,+ committer_time: entry.committer_time,+ committer_tz: entry.committer_tz,+ summary: entry.summary,+ previous: entry.previous,+ filename: entry.filename,+ }+}++fn deserialize_blame_entry(entry: proto::BlameEntry) -> Option<git::blame::BlameEntry> {+ Some(git::blame::BlameEntry {+ sha: git::Oid::from_bytes(&entry.sha).ok()?,+ range: entry.start_line..entry.end_line,+ original_line_number: entry.original_line_number,+ committer_name: entry.committer,+ committer_time: entry.committer_time,+ committer_tz: entry.committer_tz,+ committer_email: entry.committer_mail,+ author: entry.author,+ author_mail: entry.author_mail,+ author_time: entry.author_time,+ author_tz: entry.author_tz,+ summary: entry.summary,+ previous: entry.previous,+ filename: entry.filename,+ })+}++fn serialize_commit_messages(messages: HashMap<git::Oid, String>) -> Vec<proto::CommitMessage> {+ messages.into_iter().map(|(oid, message)| proto::CommitMessage {oid: oid.as_bytes().into(),message,})- .collect::<Vec<_>>();+ .collect()+}- proto::BlameBufferResponse {- blame_response: Some(proto::blame_buffer_response::BlameResponse { entries, messages }),+fn deserialize_commit_message(message: proto::CommitMessage) -> Option<(git::Oid, String)> {+ Some((git::Oid::from_bytes(&message.oid).ok()?, message.message))+}++fn serialize_commit_tag_names(+ tag_names: HashMap<git::Oid, Vec<String>>,+) -> Vec<proto::CommitTagNames> {+ tag_names+ .into_iter()+ .map(|(oid, tag_names)| proto::CommitTagNames {+ oid: oid.as_bytes().into(),+ tag_names,+ })+ .collect()+}++fn deserialize_commit_tag_names(+ tag_names: proto::CommitTagNames,+) -> Option<(git::Oid, Vec<String>)> {+ Some((+ git::Oid::from_bytes(&tag_names.oid).ok()?,+ tag_names.tag_names,+ ))+}++fn blame_from_proto(+ entries: Vec<proto::BlameEntry>,+ messages: Vec<proto::CommitMessage>,+ tag_names: Vec<proto::CommitTagNames>,+) -> git::blame::Blame {+ git::blame::Blame {+ entries: entries+ .into_iter()+ .filter_map(deserialize_blame_entry)+ .collect(),+ messages: messages+ .into_iter()+ .filter_map(deserialize_commit_message)+ .collect(),+ tag_names: tag_names+ .into_iter()+ .filter_map(deserialize_commit_tag_names)+ .collect(),}}@@ -10410,40 +10574,11 @@ fn deserialize_blame_buffer_response(response: proto::BlameBufferResponse,) -> Option<git::blame::Blame> {let response = response.blame_response?;- let entries = response- .entries- .into_iter()- .filter_map(|entry| {- Some(git::blame::BlameEntry {- sha: git::Oid::from_bytes(&entry.sha).ok()?,- range: entry.start_line..entry.end_line,- original_line_number: entry.original_line_number,- committer_name: entry.committer,- committer_time: entry.committer_time,- committer_tz: entry.committer_tz,- committer_email: entry.committer_mail,- author: entry.author,- author_mail: entry.author_mail,- author_time: entry.author_time,- author_tz: entry.author_tz,- summary: entry.summary,- previous: entry.previous,- filename: entry.filename,- })- })- .collect::<Vec<_>>();-- let messages = response- .messages- .into_iter()- .filter_map(|message| Some((git::Oid::from_bytes(&message.oid).ok()?, message.message)))- .collect::<HashMap<_, _>>();-- Some(Blame {- entries,- messages,- tag_names: Default::default(),- })+ Some(blame_from_proto(+ response.entries,+ response.messages,+ response.tag_names,+ ))}fn log_source_to_proto(log_source: &LogSource) -> proto::GitLogSource {diff --git a/crates/proto/proto/git.proto b/crates/proto/proto/git.protoindex eb5bb543235..1d0ff18b5db 100644--- a/crates/proto/proto/git.proto+++ b/crates/proto/proto/git.proto@@ -525,6 +525,7 @@ message BlameBufferResponse {repeated CommitMessage messages = 2;reserved 3;reserved 4;+ repeated CommitTagNames tag_names = 5;}optional BlameResponse blame_response = 5;@@ -532,6 +533,25 @@ message BlameBufferResponse {reserved 1 to 4;}+message BlameBufferAtRevision {+ uint64 project_id = 1;+ uint64 repository_id = 2;+ string path = 3;+ string revision = 4;+}++message BlameBufferAtRevisionResponse {+ string content = 1;+ repeated BlameEntry entries = 2;+ repeated CommitMessage messages = 3;+ repeated CommitTagNames tag_names = 4;+}++message CommitTagNames {+ bytes oid = 1;+ repeated string tag_names = 2;+}+message GetDefaultBranch {uint64 project_id = 1;uint64 repository_id = 2;diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.protoindex 47895a18d29..077602d479d 100644--- a/crates/proto/proto/zed.proto+++ b/crates/proto/proto/zed.proto@@ -505,7 +505,9 @@ message Envelope {RefreshDocumentColors refresh_document_colors = 474;RefreshDocumentLinks refresh_document_links = 475;RefreshFoldingRanges refresh_folding_ranges = 476;- RefreshDocumentSymbols refresh_document_symbols = 477; // current max+ RefreshDocumentSymbols refresh_document_symbols = 477;+ BlameBufferAtRevision blame_buffer_at_revision = 478;+ BlameBufferAtRevisionResponse blame_buffer_at_revision_response = 479; // current max}reserved 87 to 88;diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rsindex 37aaa42504a..dc735c2aab9 100644--- a/crates/proto/src/proto.rs+++ b/crates/proto/src/proto.rs@@ -358,6 +358,8 @@ messages!((GetTreeDiffResponse, Background),(GetBlobContent, Background),(GetBlobContentResponse, Background),+ (BlameBufferAtRevision, Background),+ (BlameBufferAtRevisionResponse, Background),(LoadCommitTemplate, Background),(LoadCommitTemplateResponse, Background),(GitClone, Background),@@ -603,6 +605,7 @@ request_messages!((PullWorkspaceDiagnostics, Ack),(GetDefaultBranch, GetDefaultBranchResponse),(GetBlobContent, GetBlobContentResponse),+ (BlameBufferAtRevision, BlameBufferAtRevisionResponse),(LoadCommitTemplate, LoadCommitTemplateResponse),(GetTreeDiff, GetTreeDiffResponse),(GitClone, GitCloneResponse),@@ -827,6 +830,7 @@ entity_messages!(GetDefaultBranch,GetTreeDiff,GetBlobContent,+ BlameBufferAtRevision,LoadCommitTemplate,GitClone,GetAgentServerCommand,