Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
git_ui: Add context menu to folders in tree view (#59853)
Sondeyyadc8d7918e4c
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rsindex 54582fcb0ec..31c7e55cb4e 100644--- a/crates/git_ui/src/git_panel.rs+++ b/crates/git_ui/src/git_panel.rs@@ -39,7 +39,8 @@ use git::repository::{use git::stash::GitStash;use git::status::{DiffStat, StageStatus};use git::{- Amend, Commit, Signoff, SkipHooks, ToggleStaged, repository::RepoPath, status::FileStatus,+ AddToGitInfoExclude, AddToGitignore, Amend, Commit, RestoreFile, Signoff, SkipHooks,+ ToggleStaged, repository::RepoPath, status::FileStatus,};use git::{ExpandCommitEditor, GitHostingProviderRegistry, GitRemote, RestoreTrackedFiles, StageAll,@@ -758,6 +759,15 @@ enum RowMark {Directory(TreeKey),}+/// Identifies whether the current operation targets one file, one directory, or+/// multiple marked entries.+#[derive(Copy, Clone, PartialEq)]+enum SelectionTargetKind {+ File,+ Directory,+ Multiple,+}+/// A live shift-range gesture. Marks are recomputed as the base set plus/// everything between the anchor and the cursor on every extension, so/// reversing direction shrinks the range instead of growing it.@@ -1611,28 +1621,136 @@ impl GitPanel {marked}+ fn selection_target_kind(&self) -> Option<SelectionTargetKind> {+ if self.use_selected_entry() {+ return match self.selected_entry.and_then(|ix| self.entries.get(ix)) {+ Some(GitListEntry::Status(_) | GitListEntry::TreeStatus(_)) => {+ Some(SelectionTargetKind::File)+ }+ Some(GitListEntry::Directory(_)) => Some(SelectionTargetKind::Directory),+ _ => None,+ };+ }++ match (self.marked_entries.len(), self.marked_directories.len()) {+ (0, 0) => None,+ (0, 1) => Some(SelectionTargetKind::Directory),+ (1, 0) => Some(SelectionTargetKind::File),+ _ => Some(SelectionTargetKind::Multiple),+ }+ }++ /// Returns whether activating the staging function for the current target+ /// should unstage its affected entries.+ fn should_unstage(+ &self,+ target_kind: SelectionTargetKind,+ entries: &[GitStatusEntry],+ cx: &App,+ ) -> bool {+ if entries.is_empty() {+ return false;+ }++ let Some(repo) = self.active_repository.as_ref().map(|repo| repo.read(cx)) else {+ return false;+ };++ let Some(ix) = self.selected_entry else {+ return false;+ };++ let Some(entry) = self.entries.get(ix) else {+ return false;+ };++ let stage_status = match target_kind {+ SelectionTargetKind::Multiple => {+ let all_staged = entries+ .iter()+ .all(|entry| Self::stage_status_for_entry(entry, repo).is_fully_staged());++ if all_staged {+ StageStatus::Staged+ } else {+ StageStatus::Unstaged+ }+ }+ SelectionTargetKind::File => {+ let Some(entry) = entry.status_entry() else {+ return false;+ };++ Self::stage_status_for_entry(entry, repo)+ }+ SelectionTargetKind::Directory => {+ let Some(entry) = entry.directory_entry() else {+ return false;+ };++ self.stage_status_for_directory(entry, repo)+ }+ };++ let stage_intent = self.stage_intent_for_entry_index(ix);+ !stage_intent.resolve_with(|| stage_status)+ }++ /// Determines whether file operations should use the currently selected+ /// entry or the marked entries.+ fn use_selected_entry(&self) -> bool {+ let marked_count = self.marked_entries.len() + self.marked_directories.len();+ let selected_is_marked = self+ .selected_entry+ .is_some_and(|index| self.row_is_marked(index));++ match marked_count {+ 0 => true,+ 1 => !selected_is_marked,+ _ => false,+ }+ }++ /// Checks whether the entry at `index` is explicitly marked.+ fn row_is_marked(&self, index: usize) -> bool {+ self.entries.get(index).is_some_and(|entry| match entry {+ GitListEntry::Status(entry) => self.marked_entries.contains(&entry.repo_path),+ GitListEntry::TreeStatus(entry) => self.marked_entries.contains(&entry.entry.repo_path),+ GitListEntry::Directory(entry) => self.marked_directories.contains(&entry.key),+ GitListEntry::Header(_) | GitListEntry::EmptySection(_) => false,+ })+ }+/// The entries a file operation should act on: the marked set when a/// multi-selection exists, the selected entry otherwise. A single mark on/// another row does not override the selection, matching the project panel.fn effective_status_entries(&self) -> Vec<GitStatusEntry> {- let selected = self- .selected_entry- .and_then(|ix| self.entries.get(ix))- .and_then(|entry| entry.status_entry());- if let Some(selected) = selected {- let use_selection = match self.marked_entries.len() + self.marked_directories.len() {- 0 => true,- 1 => {- !(self.marked_directories.is_empty()- && self.marked_entries.contains(&selected.repo_path))- }- _ => false,- };- if use_selection {- return vec![selected.clone()];+ let entry = self.selected_entry.and_then(|ix| self.entries.get(ix));++ if self.use_selected_entry() {+ if let Some(status_entry) = entry.and_then(|entry| entry.status_entry()) {+ return vec![status_entry.clone()];+ }++ // If using the selected entry and it is a directory, we'll want to+ // return the directory's descendants instead.+ if entry.and_then(GitListEntry::directory_entry).is_some() {+ return self+ .selected_entry+ .and_then(|ix| self.directory_descendants(ix))+ .map(|entries| entries.to_vec())+ .unwrap_or_default();}}++ // Using `unique_by` allows us to deduplicate entries by `RepoPath`+ // ensuring that if a file is partially staged, meaning it shows up on+ // both "Staged" and "Unstaged" sections, we still report it as a single+ // entry and not two different ones.self.marked_file_entries()+ .into_iter()+ .unique_by(|entry| entry.repo_path.clone())+ .collect()}fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context<Self>) {@@ -2523,163 +2641,36 @@ impl GitPanel {fn revert_selected(&mut self,- action: &git::RestoreFile,+ action: &RestoreFile,window: &mut Window,cx: &mut Context<Self>,) {- let marked = self.effective_status_entries();- if marked.len() > 1 {- self.revert_entries(marked, action.skip_prompt, window, cx);- return;- }- let path_style = self.project.read(cx).path_style(cx);- maybe!({- let list_entry = self.entries.get(self.selected_entry?)?.clone();- let entry = list_entry.status_entry()?.to_owned();- let skip_prompt = action.skip_prompt || entry.status.is_created();-- let prompt = if skip_prompt {- Task::ready(Ok(0))- } else {- let (message, confirm_text) = if entry.status.is_deleted() {- ("Are you sure you want to restore ", "Restore File")- } else {- (- "Are you sure you want to discard changes to ",- "Discard Changes",- )- };- let prompt = window.prompt(- PromptLevel::Warning,- &format!(- "{}{}?",- message,- MarkdownInlineCode(- entry- .repo_path- .file_name()- .unwrap_or(entry.repo_path.display(path_style).as_ref())- ),- ),- None,- &[confirm_text, "Cancel"],- cx,- );- cx.background_spawn(prompt)- };-- let this = cx.weak_entity();- window- .spawn(cx, async move |cx| {- if prompt.await? != 0 {- return anyhow::Ok(());- }-- this.update_in(cx, |this, window, cx| {- this.revert_entry(&entry, window, cx);- })?;-- Ok(())- })- .detach();- Some(())- });+ let entries = self.effective_status_entries();+ self.revert_entries(entries, action.skip_prompt, window, cx);}- fn revert_entries(- &mut self,- entries: Vec<GitStatusEntry>,- skip_prompt: bool,- window: &mut Window,- cx: &mut Context<Self>,- ) {- let workspace = self.workspace.clone();- let Some(active_repo) = self.active_repository.clone() else {- return;- };-- let prompt = if skip_prompt {- Task::ready(Ok(0))- } else {- let mut details = entries+ /// Returns the repo path and whether it represents a directory for the+ /// currently selected entry, provided the entry can be added to an ignore+ /// file.+ ///+ /// A file is eligible when its status reports it as newly created. A+ /// directory is eligible only when all of its descendants are newly created.+ fn selected_ignorable_path(&self) -> Option<(RepoPath, bool)> {+ let selected_index = self.selected_entry?;+ let list_entry = self.entries.get(selected_index)?;++ if let Some(directory) = list_entry.directory_entry() {+ self.directory_descendants(selected_index)?.iter()- .filter_map(|entry| entry.repo_path.as_ref().file_name())- .map(|filename| filename.to_string())- .take(5)- .join("\n");- if entries.len() > 5 {- details.push_str(&format!("\nand {} more…", entries.len() - 5));- }- let all_created = entries.iter().all(|entry| entry.status.is_created());- let (message, confirm_label) = if all_created {- ("Trash these files?", "Trash")- } else {- ("Discard changes to these files?", "Discard Changes")- };- let prompt = window.prompt(- PromptLevel::Warning,- message,- Some(&details),- &[confirm_label, "Cancel"],- cx,- );- cx.background_spawn(prompt)- };-- let this = cx.weak_entity();- window- .spawn(cx, async move |cx| {- if prompt.await? != 0 {- return anyhow::Ok(());- }-- let created = this.update_in(cx, |this, window, cx| {- let staged = entries- .iter()- .filter(|entry| entry.status.staging().has_staged())- .cloned()- .collect::<Vec<_>>();- if !staged.is_empty() {- this.change_file_stage(false, staged, cx);- }- let tracked = entries- .iter()- .filter(|entry| !entry.status.is_created())- .cloned()- .collect::<Vec<_>>();- if !tracked.is_empty() {- this.perform_checkout(tracked, window, cx);- }- entries- .into_iter()- .filter(|entry| entry.status.is_created())- .collect::<Vec<_>>()- })?;-- if created.is_empty() {- return Ok(());- }- let tasks = workspace.update(cx, |workspace, cx| {- created- .iter()- .filter_map(|entry| {- workspace.project().update(cx, |project, cx| {- let project_path = active_repo- .read(cx)- .repo_path_to_project_path(&entry.repo_path, cx)?;- project.delete_file(project_path, cx)- })- })- .collect::<Vec<_>>()- })?;- for task in tasks {- task.await?;- }- Ok(())- })- .detach_and_prompt_err("Failed to discard changes", window, cx, |e, _, _| {- Some(format!("{e}"))- });+ .all(|entry| entry.status.is_created())+ .then(|| (directory.key.path.clone(), true))+ } else {+ let entry = list_entry.status_entry()?;+ entry+ .status+ .is_created()+ .then(|| (entry.repo_path.clone(), false))+ }}fn add_to_gitignore(@@ -2688,35 +2679,29 @@ impl GitPanel {_window: &mut Window,cx: &mut Context<Self>,) {- maybe!({- let list_entry = self.entries.get(self.selected_entry?)?.clone();- let entry = list_entry.status_entry()?.to_owned();-- if !entry.status.is_created() {- return Some(());- }+ let Some((repo_path, is_dir)) = self.selected_ignorable_path() else {+ return;+ };- let active_repository = self.active_repository.clone()?;- let workspace = self.workspace.clone();- let repo_path = entry.repo_path;+ let Some(active_repository) = self.active_repository.clone() else {+ return;+ };- let receiver = active_repository- .update(cx, |repo, _| repo.add_path_to_gitignore(&repo_path, false));+ let workspace = self.workspace.clone();+ let receiver =+ active_repository.update(cx, |repo, _| repo.add_path_to_gitignore(&repo_path, is_dir));- cx.spawn(async move |_, cx| {- if let Err(e) = receiver.await? {- if let Some(workspace) = workspace.upgrade() {- cx.update(|cx| {- show_error_toast(workspace, "add to .gitignore", e, cx);- });- }+ cx.spawn(async move |_, cx| {+ if let Err(e) = receiver.await? {+ if let Some(workspace) = workspace.upgrade() {+ cx.update(|cx| {+ show_error_toast(workspace, "add to .gitignore", e, cx);+ });}- anyhow::Ok(())- })- .detach_and_log_err(cx);-- Some(())- });+ }+ anyhow::Ok(())+ })+ .detach_and_log_err(cx);}fn add_to_git_info_exclude(@@ -2725,82 +2710,165 @@ impl GitPanel {_window: &mut Window,cx: &mut Context<Self>,) {- maybe!({- let list_entry = self.entries.get(self.selected_entry?)?.clone();- let entry = list_entry.status_entry()?.to_owned();-- if !entry.status.is_created() {- return Some(());- }+ let Some((repo_path, is_dir)) = self.selected_ignorable_path() else {+ return;+ };- let active_repository = self.active_repository.clone()?;- let workspace = self.workspace.clone();- let repo_path = entry.repo_path;+ let Some(active_repository) = self.active_repository.clone() else {+ return;+ };- let receiver = active_repository.update(cx, |repo, _| {- repo.add_path_to_git_info_exclude(&repo_path, false)- });+ let workspace = self.workspace.clone();+ let receiver = active_repository.update(cx, |repo, _| {+ repo.add_path_to_git_info_exclude(&repo_path, is_dir)+ });- cx.spawn(async move |_, cx| {- if let Err(e) = receiver.await? {- if let Some(workspace) = workspace.upgrade() {- cx.update(|cx| {- show_error_toast(workspace, "add to .git/info/exclude", e, cx);- });- }+ cx.spawn(async move |_, cx| {+ if let Err(e) = receiver.await? {+ if let Some(workspace) = workspace.upgrade() {+ cx.update(|cx| {+ show_error_toast(workspace, "add to .git/info/exclude", e, cx);+ });}- anyhow::Ok(())- })- .detach_and_log_err(cx);-- Some(())- });+ }+ anyhow::Ok(())+ })+ .detach_and_log_err(cx);}- fn revert_entry(+ fn revert_entries(&mut self,- entry: &GitStatusEntry,+ entries: Vec<GitStatusEntry>,+ skip_prompt: bool,window: &mut Window,cx: &mut Context<Self>,) {+ if entries.is_empty() {+ return;+ }+maybe!({let active_repo = self.active_repository.clone()?;- let path = active_repo- .read(cx)- .repo_path_to_project_path(&entry.repo_path, cx)?;let workspace = self.workspace.clone();+ let path_style = self.project.read(cx).path_style(cx);- if entry.status.staging().has_staged() {- self.change_file_stage(false, vec![entry.clone()], cx);- }- let filename = path.path.file_name()?.to_string();+ let staged = entries+ .iter()+ .filter(|entry| entry.status.staging().has_staged())+ .cloned()+ .collect::<Vec<_>>();++ let (tracked, untracked): (Vec<_>, Vec<_>) = entries+ .into_iter()+ .partition(|entry| !entry.status.is_created());++ let prompt = if skip_prompt {+ None+ } else if tracked.len() + untracked.len() == 1 {+ let entry = tracked.first().or_else(|| untracked.first())?;- if !entry.status.is_created() {- self.perform_checkout(vec![entry.clone()], window, cx);+ let (message, confirm_text) = if entry.status.is_deleted() {+ ("Are you sure you want to restore ", "Restore File")+ } else if entry.status.is_created() {+ ("Trash ", "Trash")+ } else {+ (+ "Are you sure you want to discard changes to ",+ "Discard Changes",+ )+ };++ Some(window.prompt(+ PromptLevel::Warning,+ &format!(+ "{}{}?",+ message,+ MarkdownInlineCode(+ entry+ .repo_path+ .file_name()+ .unwrap_or(entry.repo_path.display(path_style).as_ref())+ )+ ),+ None,+ &[confirm_text, "Cancel"],+ cx,+ ))} else {- let prompt = prompt(&format!("Trash {}?", filename), None, window, cx);- cx.spawn_in(window, async move |_, cx| {- match prompt.await? {- TrashCancel::Trash => {}- TrashCancel::Cancel => return Ok(()),+ let (message, confirm_text) = match (tracked.len(), untracked.len()) {+ (0, 0) => return Some(()),+ (tracked_count, 0) => (+ format!("Discard changes to {tracked_count} files?"),+ "Discard",+ ),+ (0, untracked_count) => (format!("Trash {untracked_count} files?"), "Trash"),+ (tracked_count, untracked_count) => (+ format!(+ "Discard changes to {tracked_count} files and trash {untracked_count} files?"+ ),+ "Discard and Trash",+ ),+ };++ Some(window.prompt(+ PromptLevel::Warning,+ &message,+ None,+ &[confirm_text, "Cancel"],+ cx,+ ))+ };++ // Resolve paths NOW, before entering async context.+ let paths = untracked+ .iter()+ .filter_map(|entry| {+ active_repo+ .read(cx)+ .repo_path_to_project_path(&entry.repo_path, cx)+ })+ .collect::<Vec<_>>();++ cx.spawn_in(window, async move |this, cx| {+ if let Some(prompt) = prompt {+ if prompt.await? != 0 {+ return Ok(());}+ }++ if !staged.is_empty() || !tracked.is_empty() {+ this.update_in(cx, |this, window, cx| {+ if !staged.is_empty() {+ this.change_file_stage(false, staged, cx);+ }++ if !tracked.is_empty() {+ this.perform_checkout(tracked, window, cx);+ }+ })?;+ }++ for path in paths {let task = workspace.update(cx, |workspace, cx| {workspace.project().update(cx, |project, cx| project.trash_file(path, cx))})?;+if let Some(task) = task {task.await?;}- Ok(())- })- .detach_and_prompt_err(- "Failed to trash file",- window,- cx,- |e, _, _| Some(format!("{e}")),- );- }+ }++ Ok(())+ })+ .detach_and_prompt_err(+ "Failed to revert changes",+ window,+ cx,+ |e, _, _| Some(format!("{e}")),+ );+Some(())});}@@ -2893,7 +2961,9 @@ impl GitPanel {match entries.len() {0 => return,- 1 => return self.revert_entry(&entries[0], window, cx),+ 1 => {+ return self.revert_entries(entries, false, window, cx);+ }_ => {}}let mut details = entries@@ -2942,7 +3012,9 @@ impl GitPanel {match to_delete.len() {0 => return,- 1 => return self.revert_entry(&to_delete[0], window, cx),+ 1 => {+ return self.revert_entries(to_delete, false, window, cx);+ }_ => {}};@@ -3382,22 +3454,20 @@ impl GitPanel {window: &mut Window,cx: &mut Context<Self>,) {- let entries = self.effective_status_entries();- if entries.len() > 1 {- let Some(repo) = self.active_repository.as_ref() else {- return;- };- let repo = repo.read(cx);- let stage = entries- .iter()- .any(|entry| Self::stage_status_for_entry(entry, repo) != StageStatus::Staged);- self.change_file_stage(stage, entries, cx);+ let Some(target_kind) = self.selection_target_kind() else {return;+ };++ if target_kind == SelectionTargetKind::Multiple {+ let entries = self.effective_status_entries();+ let should_unstage = self.should_unstage(target_kind, &entries, cx);+ return self.change_file_stage(!should_unstage, entries, cx);}let Some(selected_index) = self.selected_entry else {return;};+let Some(selected_entry) = self.entries.get(selected_index).cloned() else {return;};@@ -8031,61 +8101,57 @@ impl GitPanel {})}- fn deploy_entry_context_menu(- &mut self,- position: Point<Pixels>,- ix: usize,+ fn build_context_menu(+ &self,+ will_unstage: bool,+ all_created: bool,+ all_deleted: bool,+ file_count: usize,+ target_kind: SelectionTargetKind,window: &mut Window,cx: &mut Context<Self>,- ) {- let Some(entry) = self.entries.get(ix).and_then(|e| e.status_entry()).cloned() else {- return;- };- if !self- .marked_file_entries()- .iter()- .any(|marked| marked.repo_path == entry.repo_path)- {- self.clear_marks();- }- self.selected_entry = Some(ix);- let bulk_entries = self.effective_status_entries();- let (stage_title, restore_title) = if bulk_entries.len() > 1 {- let count = bulk_entries.len();- let stage_title = if bulk_entries- .iter()- .all(|entry| entry.status.staging().is_fully_staged())- {- format!("Unstage {count} Files")- } else {- format!("Stage {count} Files")- };- let restore_title = if bulk_entries.iter().all(|entry| entry.status.is_created()) {- format!("Trash {count} Files")- } else {- format!("Discard Changes to {count} Files")- };- (stage_title, restore_title)- } else {- let stage_title = if entry.status.staging().is_fully_staged() {- "Unstage File".to_string()- } else {- "Stage File".to_string()- };- let restore_title = if entry.status.is_created() {- "Trash File".to_string()- } else {- "Discard Changes".to_string()- };- (stage_title, restore_title)+ ) -> Entity<ContextMenu> {+ // It is possible for the `target_kind` to be `Multiple` but+ // `file_count` to be 1, for example, in the case where a marked+ // directory and its only single descendant are marked. In that case,+ // even though there's two rows marked, there's a single file that is+ // being affected.+ // As such, we need to ensure we show the correct label, depending on+ // the actual `file_count`.+ let file_label = if file_count == 1 { "File" } else { "Files" };++ let stage_title = match (target_kind, will_unstage) {+ (SelectionTargetKind::Directory, true) => "Unstage Folder",+ (SelectionTargetKind::Directory, false) => "Stage Folder",+ (SelectionTargetKind::File, true) => "Unstage File",+ (SelectionTargetKind::File, false) => "Stage File",+ (SelectionTargetKind::Multiple, true) => &format!("Unstage {file_count} {file_label}"),+ (SelectionTargetKind::Multiple, false) => &format!("Stage {file_count} {file_label}"),+ };++ let restore_title = match (target_kind, all_created, all_deleted) {+ (SelectionTargetKind::Directory, true, _) => "Trash Folder",+ (SelectionTargetKind::Directory, false, _) => "Discard Changes",+ (SelectionTargetKind::File, true, _) => "Trash File",+ (SelectionTargetKind::File, _, true) => "Restore File",+ (SelectionTargetKind::File, _, _) => "Discard Changes",+ (SelectionTargetKind::Multiple, true, _) => &format!("Trash {file_count} {file_label}"),+ (SelectionTargetKind::Multiple, _, true) => {+ &format!("Restore {file_count} {file_label}")+ }+ (SelectionTargetKind::Multiple, _, _) => {+ &format!("Discard Changes to {file_count} {file_label}")+ }};- let is_bulk = bulk_entries.len() > 1;- let context_menu = ContextMenu::build(window, cx, |context_menu, _, _| {- let is_created = entry.status.is_created();++ let is_bulk = matches!(target_kind, SelectionTargetKind::Multiple);+ let is_file = matches!(target_kind, SelectionTargetKind::File);++ ContextMenu::build(window, cx, |context_menu, _, _| {context_menu.context(self.focus_handle.clone()).action(stage_title, ToggleStaged.boxed_clone())- .action(restore_title, git::RestoreFile::default().boxed_clone())+ .action(restore_title, RestoreFile::default().boxed_clone()).separator().action("Unstaged Changes", ViewUnstagedChanges.boxed_clone()).action("Staged Changes", ViewStagedChanges.boxed_clone())@@ -8094,26 +8160,72 @@ impl GitPanel {.action("Copy Relative Path", CopyRelativePath.boxed_clone()).separator().action_disabled_when(- !is_created || is_bulk,+ !all_created || is_bulk,"Add to .gitignore",- git::AddToGitignore.boxed_clone(),+ AddToGitignore.boxed_clone(),).action_disabled_when(- !is_created || is_bulk,+ !all_created || is_bulk,"Add to .git/info/exclude",- git::AddToGitInfoExclude.boxed_clone(),+ AddToGitInfoExclude.boxed_clone(),)- .separator()- .action("Open Diff", menu::Confirm.boxed_clone())- .action("Open File Diff", menu::SecondaryConfirm.boxed_clone())- .action("View File", ViewFile.boxed_clone())- .when(!is_created, |context_menu| {+ .when(is_file, |context_menu| {+ context_menu+ .separator()+ .action("Open Diff", menu::Confirm.boxed_clone())+ .action("Open File Diff", menu::SecondaryConfirm.boxed_clone())+ .action("View File", ViewFile.boxed_clone())+ })+ .when(is_file && !all_created, |context_menu| {context_menu.separator().action("View File History", Box::new(git::FileHistory))})- });- self.set_context_menu(context_menu, position, None, window, cx);+ })+ }++ fn deploy_entry_context_menu(+ &mut self,+ position: Point<Pixels>,+ ix: usize,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ if !self.row_is_marked(ix) {+ self.clear_marks();+ }++ self.selected_entry = Some(ix);++ let Some(target_kind) = self.selection_target_kind() else {+ return;+ };++ let entries = self.effective_status_entries();++ if entries.is_empty() {+ return;+ }++ let all_created = entries.iter().all(|entry| entry.status.is_created());+ let all_deleted = entries.iter().all(|entry| entry.status.is_deleted());+ let will_unstage = self.should_unstage(target_kind, &entries, cx);++ self.set_context_menu(+ self.build_context_menu(+ will_unstage,+ all_created,+ all_deleted,+ entries.len(),+ target_kind,+ window,+ cx,+ ),+ position,+ None,+ window,+ cx,+ );}fn deploy_panel_context_menu(@@ -8477,7 +8589,6 @@ impl GitPanel {let selected = self.selected_entry == Some(ix);let marked = self.marked_directories.contains(&entry.key);let label_color = Color::Muted;-let id: ElementId = ElementId::Name(format!("dir_{}_{}", entry.name, ix).into());let checkbox_id: ElementId =ElementId::Name(format!("dir_checkbox_{}_{}", entry.name, ix).into());@@ -8572,7 +8683,6 @@ impl GitPanel {indicators})).child(self.entry_label(entry.name.clone(), label_color).truncate());-h_flex().id(id).h(self.list_item_height())@@ -9819,6 +9929,14 @@ mod tests {})}+ fn directory_index_for_repo_path(panel: &GitPanel, repo_path: &RepoPath) -> Option<usize> {+ panel.entries.iter().position(|entry| {+ entry+ .directory_entry()+ .is_some_and(|entry| &entry.key.path == repo_path)+ })+ }+async fn await_git_panel_entries(panel: &Entity<GitPanel>, cx: &mut VisualTestContext) {let handle = cx.update_window_entity(panel, |panel, _, _| {std::mem::replace(&mut panel.update_visible_entries_task, Task::ready(()))@@ -10614,7 +10732,7 @@ mod tests {panel.update_in(cx, |panel, window, cx| {panel.selected_entry = Some(1);- panel.revert_selected(&git::RestoreFile::default(), window, cx);+ panel.revert_selected(&RestoreFile::default(), window, cx);});let (message, _detail) = cx@@ -11349,6 +11467,94 @@ mod tests {});}+ #[gpui::test]+ async fn test_bulk_toggle_staged_respects_staged_section_intent(cx: &mut TestAppContext) {+ init_test(cx);++ // Enable both the Git Panel's Tree View as well as grouping the entries+ // by staging status, so we end up with both "Staged" and "Unstaged"+ // sections.+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ let git_panel = settings.git_panel.get_or_insert_default();+ git_panel.group_by = Some(GitPanelGroupBy::Staging);+ git_panel.tree_view = Some(true);+ })+ });+ });++ let (fs, project, _workspace, panel, mut cx) = setup_git_panel_with_changes(+ cx,+ json!({+ ".git": {},+ "src": {+ "partial.rs": "partial content",+ "staged.rs": "staged content",+ },+ }),+ &[],+ )+ .await;++ // Set up `src/partial.rs` to be partially staged (shows up on both+ // "Staged" and "Unstaged" sections) while `src/staged.rs` to be+ // staged.+ fs.set_status_for_repo(+ path!("/project/.git").as_ref(),+ &[+ (+ "src/partial.rs",+ TrackedStatus {+ index_status: StatusCode::Modified,+ worktree_status: StatusCode::Modified,+ }+ .into(),+ ),+ ("src/staged.rs", FileStatus::index(StatusCode::Modified)),+ ],+ );+ settle_git_panel(&project, &panel, &mut cx).await;++ panel.read_with(&cx, |panel, _| {+ let partial_staging = staging_for(panel, &repo_path("src/partial.rs"));+ let staged_staging = staging_for(panel, &repo_path("src/staged.rs"));+ assert_eq!(partial_staging, StageStatus::PartiallyStaged);+ assert_eq!(staged_staging, StageStatus::Staged);+ });++ panel.update_in(&mut cx, |panel, window, cx| {+ // Mark both entries (`src/partial.rs` and `src/staged.rs`) while+ // setting `src/staged.rs` as the `selected_entry`, simulating the+ // context menu being deployed by right-clicking on `src/partial.rs`.+ //+ // Since the context menu will be deployed from the "Staged"+ // section, we expect the menu to offer the ability to unstage the+ // files.+ let partial_path = repo_path("src/partial.rs");+ let staged_path = repo_path("src/staged.rs");+ panel.marked_entries.insert(partial_path.clone());+ panel.marked_entries.insert(staged_path);+ panel.selected_entry = panel.entry_by_path_in_section(&partial_path, Section::Staged);++ let entries = panel.effective_status_entries();+ assert_eq!(entries.len(), 2);+ assert!(panel.should_unstage(SelectionTargetKind::Multiple, &entries, cx));++ // Toggle the stage status for the selected entries, so we can later+ // assert that both are now unstaged.+ panel.toggle_staged_for_selected(&git::ToggleStaged, window, cx);+ });+ settle_git_panel(&project, &panel, &mut cx).await;++ panel.read_with(&cx, |panel, _| {+ let partial_staging = staging_for(panel, &repo_path("src/partial.rs"));+ let staged_staging = staging_for(panel, &repo_path("src/staged.rs"));+ assert_eq!(partial_staging, StageStatus::Unstaged);+ assert_eq!(staged_staging, StageStatus::Unstaged);+ });+ }+#[gpui::test]async fn test_group_by_staging_open_diff_uses_section_diff(cx: &mut TestAppContext) {init_test(cx);@@ -14437,6 +14643,256 @@ mod tests {);}+ #[gpui::test]+ async fn test_add_to_gitignore(cx: &mut TestAppContext) {+ init_test(cx);++ // Enable tree view so directories are represented as selectable panel+ // entries.+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings.git_panel.get_or_insert_default().tree_view = Some(true);+ })+ });+ });++ let (fs, _project, _workspace, panel, mut cx) =+ setup_git_panel_with_changes(cx, json!({ ".git": {}, }), &[]).await;++ // Add a new untracked file under a directory so we can confirm that+ // selecting the directory still allows us to add its path to+ // `.gitignore`.+ fs.insert_tree(+ path!("/project/src"),+ json!({+ "untracked.rs": ""+ }),+ )+ .await;++ fs.set_status_for_repo(+ Path::new(path!("/project/.git")),+ &[("src/untracked.rs", FileStatus::Untracked)],+ );++ await_git_panel_entries(&panel, &mut cx).await;++ panel.update_in(&mut cx, |panel, window, cx| {+ let index = directory_index_for_repo_path(&panel, &repo_path("src"))+ .expect("`src` directory should be present in the Git panel");++ panel.selected_entry = Some(index);+ panel.add_to_gitignore(&AddToGitignore, window, cx);+ });++ cx.run_until_parked();++ assert_eq!(+ fs.load(Path::new(path!("/project/.gitignore")))+ .await+ .expect(".gitignore should be readable"),+ "src/\n"+ );++ // Create a new directory with a tracked and untracked file, so we can+ // later confirm that its path is not added to `.gitignore`.+ fs.insert_tree(+ path!("/project/docs"),+ json!({+ "tracked.txt": "",+ "untracked.txt": ""+ }),+ )+ .await;++ fs.set_status_for_repo(+ Path::new(path!("/project/.git")),+ &[+ ("docs/tracked.txt", StatusCode::Modified.worktree()),+ ("docs/untracked.txt", FileStatus::Untracked),+ ],+ );++ await_git_panel_entries(&panel, &mut cx).await;++ panel.update_in(&mut cx, |panel, window, cx| {+ let index = directory_index_for_repo_path(&panel, &repo_path("docs"))+ .expect("`docs` directory should be present in the Git panel");++ panel.selected_entry = Some(index);+ panel.add_to_gitignore(&AddToGitignore, window, cx);+ });++ cx.run_until_parked();++ assert_eq!(+ fs.load(Path::new(path!("/project/.gitignore")))+ .await+ .expect(".gitignore should be readable"),+ "src/\n"+ );+ }++ #[gpui::test]+ async fn test_add_to_git_info_exclude(cx: &mut TestAppContext) {+ init_test(cx);++ // Enable tree view so directories are represented as selectable panel+ // entries.+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings.git_panel.get_or_insert_default().tree_view = Some(true);+ })+ });+ });++ let (fs, _project, _workspace, panel, mut cx) =+ setup_git_panel_with_changes(cx, json!({ ".git": {}, }), &[]).await;++ // Add a new untracked file under a directory so we can confirm that+ // selecting the directory still allows us to add its path to+ // `.git/info/exclude`.+ fs.insert_tree(+ path!("/project/src"),+ json!({+ "untracked.rs": ""+ }),+ )+ .await;++ fs.set_status_for_repo(+ Path::new(path!("/project/.git")),+ &[("src/untracked.rs", FileStatus::Untracked)],+ );++ await_git_panel_entries(&panel, &mut cx).await;++ panel.update_in(&mut cx, |panel, window, cx| {+ let index = directory_index_for_repo_path(&panel, &repo_path("src"))+ .expect("`src` directory should be present in the Git panel");++ panel.selected_entry = Some(index);+ panel.add_to_git_info_exclude(&AddToGitInfoExclude, window, cx);+ });++ cx.run_until_parked();++ assert_eq!(+ fs.load(Path::new(path!("/project/.git/info/exclude")))+ .await+ .expect(".git/info/exclude should be readable"),+ "src/\n"+ );++ // Create a new directory with a tracked and untracked file, so we can+ // later confirm that its path is not added to `.git/info/exclude`.+ fs.insert_tree(+ path!("/project/docs"),+ json!({+ "tracked.txt": "",+ "untracked.txt": ""+ }),+ )+ .await;++ fs.set_status_for_repo(+ Path::new(path!("/project/.git")),+ &[+ ("docs/tracked.txt", StatusCode::Modified.worktree()),+ ("docs/untracked.txt", FileStatus::Untracked),+ ],+ );++ await_git_panel_entries(&panel, &mut cx).await;++ panel.update_in(&mut cx, |panel, window, cx| {+ let index = directory_index_for_repo_path(&panel, &repo_path("docs"))+ .expect("`docs` directory should be present in the Git panel");++ panel.selected_entry = Some(index);+ panel.add_to_git_info_exclude(&AddToGitInfoExclude, window, cx);+ });++ cx.run_until_parked();++ assert_eq!(+ fs.load(Path::new(path!("/project/.git/info/exclude")))+ .await+ .expect(".git/info/exclude should be readable"),+ "src/\n"+ );+ }++ #[gpui::test]+ async fn test_revert_directory_trashes_untracked_files(cx: &mut TestAppContext) {+ init_test(cx);++ // Enable tree view so directories are represented as selectable panel+ // entries.+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings.git_panel.get_or_insert_default().tree_view = Some(true);+ })+ });+ });++ let (fs, _project, _workspace, panel, mut cx) = setup_git_panel_with_changes(+ cx,+ json!({+ ".git": {},+ "changes": {+ "untracked.txt": "",+ "nested": {+ "untracked.txt": ""+ }+ },+ }),+ &[],+ )+ .await;++ fs.set_status_for_repo(+ Path::new(path!("/project/.git")),+ &[+ ("changes/untracked.txt", FileStatus::Untracked),+ ("changes/nested/untracked.txt", FileStatus::Untracked),+ ],+ );++ await_git_panel_entries(&panel, &mut cx).await;++ panel.update_in(&mut cx, |panel, window, cx| {+ let index = directory_index_for_repo_path(&panel, &repo_path("changes"))+ .expect("`changes` directory should be present in the Git panel");++ panel.selected_entry = Some(index);+ panel.revert_selected(&RestoreFile { skip_prompt: true }, window, cx);+ });++ cx.run_until_parked();+ await_git_panel_entries(&panel, &mut cx).await;++ panel.read_with(&cx, |panel, cx| {+ let repository = panel+ .active_repository+ .as_ref()+ .expect("Git panel should have an active repository")+ .read(cx);++ assert_eq!(+ repository.status_for_path(&repo_path("changes/untracked.txt")),+ None+ );+ assert_eq!(+ repository.status_for_path(&repo_path("changes/nested/untracked.txt")),+ None+ );+ })+ }+async fn setup_flat_marks_fixture(cx: &mut TestAppContext,) -> (