Skip to content

armgit / zed

Public Imported from GitHub
0

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 multi-select to git panel for bulk stage, unstage, and discard (#60340)

justinschmitz97f8c278352fcc
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index ec50d9e606a..db670d26552 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -1036,6 +1036,8 @@
"right": "git_panel::ExpandSelectedEntry",
"up": "git_panel::PreviousEntry",
"down": "git_panel::NextEntry",
+ "shift-up": "menu::SelectPrevious",
+ "shift-down": "menu::SelectNext",
"enter": "menu::Confirm",
"alt-y": "git::StageFile",
"alt-shift-y": "git::UnstageFile",
@@ -1048,7 +1050,7 @@
"alt-ctrl-shift-c": "workspace::CopyRelativePath",
"tab": "git_panel::FocusEditor",
"shift-tab": "git_panel::FocusEditor",
- "escape": "git_panel::ToggleFocus",
+ "escape": "menu::Cancel",
"alt-enter": "menu::SecondaryConfirm",
"delete": ["git::RestoreFile", { "skip_prompt": false }],
"backspace": ["git::RestoreFile", { "skip_prompt": false }],
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index bfee85b03af..3324bce7da1 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -1093,6 +1093,8 @@
"bindings": {
"up": "git_panel::PreviousEntry",
"down": "git_panel::NextEntry",
+ "shift-up": "menu::SelectPrevious",
+ "shift-down": "menu::SelectNext",
"cmd-up": "git_panel::FirstEntry",
"cmd-down": "git_panel::LastEntry",
"left": "git_panel::CollapseSelectedEntry",
@@ -1108,7 +1110,7 @@
"alt-down": "git_panel::FocusEditor",
"tab": "git_panel::FocusEditor",
"shift-tab": "git_panel::FocusEditor",
- "escape": "git_panel::ToggleFocus",
+ "escape": "menu::Cancel",
"backspace": ["git::RestoreFile", { "skip_prompt": false }],
"delete": ["git::RestoreFile", { "skip_prompt": false }],
"cmd-backspace": ["git::RestoreFile", { "skip_prompt": true }],
diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json
index 82d8c93124f..1afd97082a9 100644
--- a/assets/keymaps/default-windows.json
+++ b/assets/keymaps/default-windows.json
@@ -1027,6 +1027,8 @@
"bindings": {
"up": "git_panel::PreviousEntry",
"down": "git_panel::NextEntry",
+ "shift-up": "menu::SelectPrevious",
+ "shift-down": "menu::SelectNext",
"left": "git_panel::CollapseSelectedEntry",
"right": "git_panel::ExpandSelectedEntry",
"enter": "menu::Confirm",
@@ -1038,7 +1040,7 @@
"ctrl-k ctrl-shift-c": "workspace::CopyRelativePath",
"tab": "git_panel::FocusEditor",
"shift-tab": "git_panel::FocusEditor",
- "escape": "git_panel::ToggleFocus",
+ "escape": "menu::Cancel",
"alt-enter": "menu::SecondaryConfirm",
"delete": ["git::RestoreFile", { "skip_prompt": false }],
"backspace": ["git::RestoreFile", { "skip_prompt": false }],
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 8a701f26a02..f4a15545a6e 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -752,6 +752,66 @@ impl GitListEntry {
}
}
+/// The identity a row contributes to the multi-selection: files select by
+/// repo path, directories select as a unit covering their descendants.
+enum RowMark {
+ File(RepoPath),
+ Directory(TreeKey),
+}
+
+/// 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.
+struct MarkRangeGesture {
+ anchor_ix: usize,
+ base_files: HashSet<RepoPath>,
+ base_directories: HashSet<TreeKey>,
+}
+
+/// Tracks, while walking `entries` in display order, whether the current row
+/// sits inside a directory that is part of the multi-selection.
+#[derive(Default)]
+struct MarkedDirectoryCoverage {
+ covering_depth: Option<usize>,
+}
+
+impl MarkedDirectoryCoverage {
+ /// Feeds the next row in display order; returns whether that row is
+ /// inside a marked directory.
+ fn observe(&mut self, entry: &GitListEntry, marked_directories: &HashSet<TreeKey>) -> bool {
+ let depth = match entry {
+ GitListEntry::Header(_) => {
+ self.covering_depth = None;
+ return false;
+ }
+ GitListEntry::Directory(directory) => {
+ if self.covers(directory.depth) {
+ return true;
+ }
+ self.covering_depth = marked_directories
+ .contains(&directory.key)
+ .then_some(directory.depth);
+ return false;
+ }
+ // Flat view has no directory rows.
+ GitListEntry::Status(_) => return false,
+ GitListEntry::TreeStatus(status) => status.depth,
+ GitListEntry::EmptySection(_) => return false,
+ };
+ if self.covers(depth) {
+ true
+ } else {
+ self.covering_depth = None;
+ false
+ }
+ }
+
+ fn covers(&self, depth: usize) -> bool {
+ self.covering_depth
+ .is_some_and(|covering_depth| depth > covering_depth)
+ }
+}
+
enum GitPanelViewMode {
Flat,
Tree(TreeViewState),
@@ -1076,7 +1136,9 @@ pub struct GitPanel {
scroll_handle: UniformListScrollHandle,
max_width_item_index: Option<usize>,
selected_entry: Option<usize>,
- marked_entries: Vec<usize>,
+ marked_entries: HashSet<RepoPath>,
+ marked_directories: HashSet<TreeKey>,
+ mark_range_gesture: Option<MarkRangeGesture>,
tracked_count: usize,
tracked_staged_count: usize,
update_visible_entries_task: Task<()>,
@@ -1378,7 +1440,9 @@ impl GitPanel {
scroll_handle,
max_width_item_index: None,
selected_entry: None,
- marked_entries: Vec::new(),
+ marked_entries: HashSet::default(),
+ marked_directories: HashSet::default(),
+ mark_range_gesture: None,
tracked_count: 0,
tracked_staged_count: 0,
update_visible_entries_task: Task::ready(()),
@@ -1427,6 +1491,169 @@ impl GitPanel {
.map(|entry| entry.index)
}
+ fn has_marks(&self) -> bool {
+ !self.marked_entries.is_empty() || !self.marked_directories.is_empty()
+ }
+
+ fn clear_marks(&mut self) {
+ self.marked_entries.clear();
+ self.marked_directories.clear();
+ self.mark_range_gesture = None;
+ }
+
+ fn clear_marks_and_select(&mut self, ix: usize, cx: &mut Context<Self>) {
+ self.clear_marks();
+ self.selected_entry = Some(ix);
+ cx.notify();
+ }
+
+ fn row_mark(&self, ix: usize) -> Option<RowMark> {
+ match self.entries.get(ix)? {
+ GitListEntry::Status(entry) => Some(RowMark::File(entry.repo_path.clone())),
+ GitListEntry::TreeStatus(entry) => Some(RowMark::File(entry.entry.repo_path.clone())),
+ GitListEntry::Directory(directory) => Some(RowMark::Directory(directory.key.clone())),
+ GitListEntry::Header(_) => None,
+ GitListEntry::EmptySection(_) => None,
+ }
+ }
+
+ fn mark_row(&mut self, ix: usize) {
+ match self.row_mark(ix) {
+ Some(RowMark::File(path)) => {
+ self.marked_entries.insert(path);
+ }
+ Some(RowMark::Directory(key)) => {
+ self.marked_directories.insert(key);
+ }
+ None => {}
+ }
+ }
+
+ fn toggle_mark(&mut self, ix: usize, cx: &mut Context<Self>) {
+ self.mark_range_gesture = None;
+ if let Some(mark) = self.row_mark(ix) {
+ if !self.has_marks()
+ && let Some(previous) = self.selected_entry.filter(|&previous| previous != ix)
+ {
+ self.mark_row(previous);
+ }
+ match mark {
+ RowMark::File(path) => {
+ if !self.marked_entries.remove(&path) {
+ self.marked_entries.insert(path);
+ }
+ }
+ RowMark::Directory(key) => {
+ if !self.marked_directories.remove(&key) {
+ self.marked_directories.insert(key);
+ }
+ }
+ }
+ }
+ self.selected_entry = Some(ix);
+ cx.notify();
+ }
+
+ fn mark_range(&mut self, anchor_ix: usize, target_ix: usize) {
+ let entry_indices: Vec<usize> = match &self.view_mode {
+ GitPanelViewMode::Flat => {
+ let (start, end) = if anchor_ix <= target_ix {
+ (anchor_ix, target_ix)
+ } else {
+ (target_ix, anchor_ix)
+ };
+ (start..=end).collect()
+ }
+ GitPanelViewMode::Tree(state) => {
+ let anchor_pos = state.logical_indices.iter().position(|&ix| ix == anchor_ix);
+ let target_pos = state.logical_indices.iter().position(|&ix| ix == target_ix);
+ match anchor_pos.zip(target_pos) {
+ Some((anchor_pos, target_pos)) => {
+ let (start, end) = if anchor_pos <= target_pos {
+ (anchor_pos, target_pos)
+ } else {
+ (target_pos, anchor_pos)
+ };
+ state.logical_indices[start..=end].to_vec()
+ }
+ None => vec![target_ix],
+ }
+ }
+ };
+ for ix in entry_indices {
+ self.mark_row(ix);
+ }
+ }
+
+ /// Every file in the multi-selection, in display order: files marked
+ /// directly plus the descendants of marked directories.
+ fn marked_file_entries(&self) -> Vec<GitStatusEntry> {
+ let mut coverage = MarkedDirectoryCoverage::default();
+ let mut marked = Vec::new();
+ for entry in &self.entries {
+ let covered = coverage.observe(entry, &self.marked_directories);
+ if let Some(status_entry) = entry.status_entry()
+ && (covered || self.marked_entries.contains(&status_entry.repo_path))
+ {
+ marked.push(status_entry.clone());
+ }
+ }
+ marked
+ }
+
+ /// 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()];
+ }
+ }
+ self.marked_file_entries()
+ }
+
+ fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context<Self>) {
+ if self.active_tab == GitPanelTab::Changes && self.has_marks() {
+ self.clear_marks();
+ cx.notify();
+ } else {
+ window.dispatch_action(Box::new(ToggleFocus), cx);
+ }
+ }
+
+ /// Extends or shrinks the live shift-range: marks become the gesture's
+ /// base set plus everything between the gesture's anchor and `target_ix`.
+ /// `origin_ix` anchors a new gesture when none is active.
+ fn apply_range_gesture(&mut self, origin_ix: usize, target_ix: usize) {
+ if self.mark_range_gesture.is_none() {
+ self.mark_range_gesture = Some(MarkRangeGesture {
+ anchor_ix: origin_ix,
+ base_files: self.marked_entries.clone(),
+ base_directories: self.marked_directories.clone(),
+ });
+ }
+ let Some(gesture) = &self.mark_range_gesture else {
+ return;
+ };
+ let anchor_ix = gesture.anchor_ix;
+ self.marked_entries = gesture.base_files.clone();
+ self.marked_directories = gesture.base_directories.clone();
+ self.mark_range(anchor_ix, target_ix);
+ }
+
pub fn select_entry_by_path(
&mut self,
path: ProjectPath,
@@ -1782,6 +2009,7 @@ impl GitPanel {
};
if let Some(first_entry) = first_entry {
+ self.mark_range_gesture = None;
self.selected_entry = Some(first_entry);
self.scroll_to_selected_entry(cx);
}
@@ -1790,7 +2018,7 @@ impl GitPanel {
fn select_previous(
&mut self,
_: &menu::SelectPrevious,
- _window: &mut Window,
+ window: &mut Window,
cx: &mut Context<Self>,
) {
if self.active_tab == GitPanelTab::History {
@@ -1857,6 +2085,12 @@ impl GitPanel {
}
};
+ if window.modifiers().shift {
+ let target_ix = candidate.unwrap_or(selected_entry);
+ self.apply_range_gesture(selected_entry, target_ix);
+ } else {
+ self.mark_range_gesture = None;
+ }
let Some(candidate) = candidate else {
return;
};
@@ -1865,7 +2099,7 @@ impl GitPanel {
self.scroll_to_selected_entry(cx);
}
- fn select_next(&mut self, _: &menu::SelectNext, _window: &mut Window, cx: &mut Context<Self>) {
+ fn select_next(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context<Self>) {
if self.active_tab == GitPanelTab::History {
self.select_next_history_entry(cx);
return;
@@ -1935,6 +2169,12 @@ impl GitPanel {
}
};
+ if window.modifiers().shift {
+ let target_ix = candidate.unwrap_or(selected_entry);
+ self.apply_range_gesture(selected_entry, target_ix);
+ } else {
+ self.mark_range_gesture = None;
+ }
let Some(candidate) = candidate else {
return;
};
@@ -1944,6 +2184,11 @@ impl GitPanel {
}
fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
+ if self.entries.last().is_some() {
+ self.mark_range_gesture = None;
+ self.selected_entry = Some(self.entries.len() - 1);
+ }
+
let last_entry = match &self.view_mode {
GitPanelViewMode::Flat => self.entries.iter().rposition(GitListEntry::is_selectable),
GitPanelViewMode::Tree(state) => {
@@ -2263,6 +2508,11 @@ impl GitPanel {
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();
@@ -2317,6 +2567,102 @@ impl GitPanel {
});
}
+ 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
+ .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}"))
+ });
+ }
+
fn add_to_gitignore(
&mut self,
_: &git::AddToGitignore,
@@ -3017,6 +3363,19 @@ 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);
+ return;
+ }
+
let Some(selected_index) = self.selected_entry else {
return;
};
@@ -3041,14 +3400,13 @@ impl GitPanel {
}
fn stage_selected(&mut self, _: &git::StageFile, _window: &mut Window, cx: &mut Context<Self>) {
- let Some(selected_entry) = self.get_selected_entry() else {
- return;
- };
- let Some(status_entry) = selected_entry.status_entry() else {
- return;
- };
- if status_entry.staging != StageStatus::Staged {
- self.change_file_stage(true, vec![status_entry.clone()], cx);
+ let to_stage = self
+ .effective_status_entries()
+ .into_iter()
+ .filter(|entry| entry.staging != StageStatus::Staged)
+ .collect::<Vec<_>>();
+ if !to_stage.is_empty() {
+ self.change_file_stage(true, to_stage, cx);
}
}
@@ -3058,14 +3416,13 @@ impl GitPanel {
_window: &mut Window,
cx: &mut Context<Self>,
) {
- let Some(selected_entry) = self.get_selected_entry() else {
- return;
- };
- let Some(status_entry) = selected_entry.status_entry() else {
- return;
- };
- if status_entry.staging != StageStatus::Unstaged {
- self.change_file_stage(false, vec![status_entry.clone()], cx);
+ let to_unstage = self
+ .effective_status_entries()
+ .into_iter()
+ .filter(|entry| entry.staging != StageStatus::Unstaged)
+ .collect::<Vec<_>>();
+ if !to_unstage.is_empty() {
+ self.change_file_stage(false, to_unstage, cx);
}
}
@@ -4707,6 +5064,7 @@ impl GitPanel {
let active_repository_changed = self.active_repository.as_ref().map(Entity::entity_id)
!= new_active_repository.as_ref().map(Entity::entity_id);
if active_repository_changed {
+ self.clear_marks();
self.set_skip_hooks_enabled(false, cx);
if self.amend_pending {
// Leaving a repository with a pending amend: undo it so the amend
@@ -4860,6 +5218,12 @@ impl GitPanel {
.as_ref()
.and_then(|op| self.entry_by_path(&op.anchor));
+ let active_repository = self.project.read(cx).active_repository(cx);
+ if active_repository != self.active_repository {
+ self.active_repository = active_repository;
+ self.git_access = None;
+ self.clear_marks();
+ }
self.entries.clear();
self.projected_entries_by_path.clear();
self.single_staged_entry.take();
@@ -5201,6 +5565,27 @@ impl GitPanel {
self.bulk_staging = bulk_staging;
}
+ match &self.view_mode {
+ GitPanelViewMode::Tree(state) => {
+ let directories = &state.directory_descendants;
+ self.marked_directories
+ .retain(|key| directories.contains_key(key));
+ }
+ GitPanelViewMode::Flat => self.marked_directories.clear(),
+ }
+ if !self.marked_entries.is_empty() {
+ let present_paths: HashSet<RepoPath> = self
+ .entries
+ .iter()
+ .filter_map(|entry| entry.status_entry())
+ .map(|entry| entry.repo_path.clone())
+ .collect();
+ self.marked_entries
+ .retain(|path| present_paths.contains(path));
+ }
+ // The rebuild may have reordered rows, invalidating the anchor index.
+ self.mark_range_gesture = None;
+
if let Some((path, section)) = selected_change {
self.selected_entry = section
.and_then(|section| self.entry_by_path_in_section(&path, section))
@@ -7632,34 +8017,48 @@ impl GitPanel {
window: &mut Window,
cx: &mut Context<Self>,
) {
- if matches!(self.entries.get(ix), Some(GitListEntry::Directory(_))) {
- self.selected_entry = Some(ix);
- self.deploy_panel_context_menu(position, Some(ix), true, window, cx);
- return;
- }
-
- let stage_intent = self.stage_intent_for_entry_index(ix);
- let Some(entry) = self.entries.get(ix).and_then(|e| e.status_entry()) else {
+ let Some(entry) = self.entries.get(ix).and_then(|e| e.status_entry()).cloned() else {
return;
};
- // Resolve against the pending-op-aware status (like the checkboxes do)
- // so the menu label can't lag behind a just-clicked checkbox.
- let repo = self.active_repository.as_ref().map(|repo| repo.read(cx));
- let stage_title = if stage_intent.resolve_with(|| match repo {
- Some(repo) => GitPanel::stage_status_for_entry(entry, repo),
- None => entry.status.staging(),
- }) {
- "Stage File"
- } else {
- "Unstage File"
- };
- let restore_title = if entry.status.is_created() {
- "Trash File"
- } else if entry.status.is_deleted() {
- "Restore File"
+ 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 {
- "Discard Changes"
+ 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)
};
+ let is_bulk = bulk_entries.len() > 1;
let context_menu = ContextMenu::build(window, cx, |context_menu, _, _| {
let is_created = entry.status.is_created();
context_menu
@@ -7674,12 +8073,12 @@ impl GitPanel {
.action("Copy Relative Path", CopyRelativePath.boxed_clone())
.separator()
.action_disabled_when(
- !is_created,
+ !is_created || is_bulk,
"Add to .gitignore",
git::AddToGitignore.boxed_clone(),
)
.action_disabled_when(
- !is_created,
+ !is_created || is_bulk,
"Add to .git/info/exclude",
git::AddToGitInfoExclude.boxed_clone(),
)
@@ -7693,7 +8092,6 @@ impl GitPanel {
.action("View File History", Box::new(git::FileHistory))
})
});
- self.selected_entry = Some(ix);
self.set_context_menu(context_menu, position, None, window, cx);
}
@@ -7789,7 +8187,7 @@ impl GitPanel {
let display_name = entry.display_name(path_style);
let selected = self.selected_entry == Some(ix);
- let marked = self.marked_entries.contains(&ix);
+ let marked = self.marked_entries.contains(&entry.repo_path);
let status_style = settings.status_style;
let status = entry.status;
let file_icon = if settings.file_icons {
@@ -8014,9 +8412,17 @@ impl GitPanel {
)
.on_click({
cx.listener(move |this, event: &ClickEvent, window, cx| {
- this.selected_entry = Some(ix);
- cx.notify();
- this.open_selected_entry_on_click(event.modifiers().secondary(), window, cx);
+ if event.modifiers().shift {
+ let anchor_ix = this.selected_entry.unwrap_or(ix);
+ this.apply_range_gesture(anchor_ix, ix);
+ this.selected_entry = Some(ix);
+ cx.notify();
+ } else if event.modifiers().secondary() {
+ this.toggle_mark(ix, cx);
+ } else {
+ this.clear_marks_and_select(ix, cx);
+ this.open_selected_entry_on_click(event.click_count() > 1, window, cx);
+ }
})
})
.on_mouse_down(
@@ -8047,8 +8453,8 @@ impl GitPanel {
window: &Window,
cx: &Context<Self>,
) -> AnyElement {
- // TODO: Have not yet plugged in self.marked_entries. Not sure when and why we need that
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());
@@ -8058,23 +8464,26 @@ impl GitPanel {
ElementId::Name(format!("dir_checkbox_wrapper_{}_{}", entry.name, ix).into());
let selected_bg_alpha = 0.08;
+ let marked_bg_alpha = 0.12;
let state_opacity_step = 0.04;
let info_color = cx.theme().status().info;
let colors = cx.theme().colors();
- let (base_bg, hover_bg, active_bg) = if selected {
+ let base_bg = match (selected, marked) {
+ (true, true) => info_color.alpha(selected_bg_alpha + marked_bg_alpha),
+ (true, false) => info_color.alpha(selected_bg_alpha),
+ (false, true) => info_color.alpha(marked_bg_alpha),
+ _ => colors.ghost_element_background,
+ };
+
+ let (hover_bg, active_bg) = if selected {
(
- info_color.alpha(selected_bg_alpha),
info_color.alpha(selected_bg_alpha + state_opacity_step),
info_color.alpha(selected_bg_alpha + state_opacity_step * 2.0),
)
} else {
- (
- colors.ghost_element_background,
- colors.ghost_element_hover,
- colors.ghost_element_active,
- )
+ (colors.ghost_element_hover, colors.ghost_element_active)
};
let settings = GitPanelSettings::get_global(cx);
@@ -8203,9 +8612,19 @@ impl GitPanel {
)
.on_click({
let key = entry.key.clone();
- cx.listener(move |this, _event: &ClickEvent, window, cx| {
- this.selected_entry = Some(ix);
- this.toggle_directory(&key, window, cx);
+ cx.listener(move |this, event: &ClickEvent, window, cx| {
+ if event.modifiers().shift {
+ let anchor_ix = this.selected_entry.unwrap_or(ix);
+ this.apply_range_gesture(anchor_ix, ix);
+ this.selected_entry = Some(ix);
+ cx.notify();
+ } else if event.modifiers().secondary() {
+ this.toggle_mark(ix, cx);
+ } else {
+ this.clear_marks();
+ this.selected_entry = Some(ix);
+ this.toggle_directory(&key, window, cx);
+ }
})
})
.on_mouse_down(
@@ -8549,6 +8968,7 @@ impl Render for GitPanel {
.on_action(cx.listener(Self::stash_staged))
.on_action(cx.listener(Self::stash_pop))
})
+ .on_action(cx.listener(Self::cancel))
.on_action(cx.listener(Self::collapse_selected_entry))
.on_action(cx.listener(Self::expand_selected_entry))
.on_action(cx.listener(Self::select_first))
@@ -9274,7 +9694,7 @@ mod tests {
repository::repo_path,
status::{StatusCode, TrackedStatus, UnmergedStatus, UnmergedStatusCode},
};
- use gpui::{TestAppContext, UpdateGlobal, VisualTestContext, px};
+ use gpui::{Modifiers, TestAppContext, UpdateGlobal, VisualTestContext, px};
use indoc::indoc;
use project::FakeFs;
use search::{BufferSearchBar, buffer_search::Deploy};
@@ -13668,4 +14088,846 @@ mod tests {
],
);
}
+
+ async fn setup_flat_marks_fixture(
+ cx: &mut TestAppContext,
+ ) -> (
+ Arc<FakeFs>,
+ Entity<Project>,
+ Entity<GitPanel>,
+ VisualTestContext,
+ ) {
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/project"),
+ json!({
+ ".git": {},
+ "a.txt": "a",
+ "b.txt": "b",
+ "c.txt": "c",
+ "new1.txt": "1",
+ "new2.txt": "2",
+ }),
+ )
+ .await;
+ fs.set_status_for_repo(
+ path!("/project/.git").as_ref(),
+ &[
+ ("a.txt", StatusCode::Modified.worktree()),
+ ("b.txt", StatusCode::Modified.worktree()),
+ ("c.txt", StatusCode::Modified.worktree()),
+ ("new1.txt", FileStatus::Untracked),
+ ("new2.txt", FileStatus::Untracked),
+ ],
+ );
+
+ let project = Project::test(fs.clone(), [Path::new(path!("/project"))], cx).await;
+ let window_handle =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = window_handle
+ .read_with(cx, |mw, _| mw.workspace().clone())
+ .unwrap();
+ let mut cx = VisualTestContext::from_window(window_handle.into(), cx);
+
+ cx.read(|cx| {
+ project
+ .read(cx)
+ .worktrees(cx)
+ .next()
+ .unwrap()
+ .read(cx)
+ .as_local()
+ .unwrap()
+ .scan_complete()
+ })
+ .await;
+ cx.executor().run_until_parked();
+
+ let panel = workspace.update_in(&mut cx, GitPanel::new);
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ (fs, project, panel, cx)
+ }
+
+ async fn settle_git_panel(
+ project: &Entity<Project>,
+ panel: &Entity<GitPanel>,
+ cx: &mut VisualTestContext,
+ ) {
+ cx.read(|cx| {
+ project
+ .read(cx)
+ .worktrees(cx)
+ .next()
+ .unwrap()
+ .read(cx)
+ .as_local()
+ .unwrap()
+ .scan_complete()
+ })
+ .await;
+ cx.executor().run_until_parked();
+ await_git_panel_entries(panel, cx).await;
+ }
+
+ fn staging_for(panel: &GitPanel, path: &RepoPath) -> StageStatus {
+ panel
+ .entries
+ .iter()
+ .filter_map(|entry| entry.status_entry())
+ .find(|entry| &entry.repo_path == path)
+ .expect("entry should exist")
+ .staging
+ }
+
+ #[gpui::test]
+ async fn test_mark_range_flat(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, _cx| {
+ let a_ix = entry_index_for_repo_path(panel, &repo_path("a.txt")).unwrap();
+ let new1_ix = entry_index_for_repo_path(panel, &repo_path("new1.txt")).unwrap();
+
+ panel.mark_range(a_ix, new1_ix);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("a.txt"),
+ repo_path("b.txt"),
+ repo_path("c.txt"),
+ repo_path("new1.txt"),
+ ]),
+ "range should mark all files between anchor and target, skipping the header",
+ );
+
+ panel.marked_entries.clear();
+ panel.mark_range(new1_ix, a_ix);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("a.txt"),
+ repo_path("b.txt"),
+ repo_path("c.txt"),
+ repo_path("new1.txt"),
+ ]),
+ "a reversed range should mark the same entries",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_mark_range_tree_marks_dirs_skips_headers(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_, _, _, panel, mut cx) = setup_git_panel_with_changes(
+ cx,
+ json!({
+ ".git": {},
+ "src": {
+ "a.rs": "a",
+ "b.rs": "b",
+ },
+ "top.txt": "top",
+ }),
+ &[
+ ("src/a.rs", StatusCode::Modified),
+ ("src/b.rs", StatusCode::Modified),
+ ("top.txt", StatusCode::Modified),
+ ],
+ )
+ .await;
+
+ cx.update(|_window, cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.git_panel.get_or_insert_default().tree_view = Some(true);
+ })
+ });
+ });
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ let dir_key = panel
+ .entries
+ .iter()
+ .find_map(|entry| entry.directory_entry().map(|dir| dir.key.clone()))
+ .expect("tree view should contain a directory row");
+
+ panel.mark_range(0, panel.entries.len() - 1);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("src/a.rs"),
+ repo_path("src/b.rs"),
+ repo_path("top.txt"),
+ ]),
+ "header rows should not be marked",
+ );
+ assert_eq!(
+ panel.marked_directories,
+ HashSet::from_iter([dir_key.clone()]),
+ "directory rows inside the range should be marked",
+ );
+
+ panel.clear_marks();
+ panel.toggle_directory(&dir_key, window, cx);
+
+ let src_ix = panel
+ .entries
+ .iter()
+ .position(|entry| entry.directory_entry().is_some())
+ .unwrap();
+ let top_ix = entry_index_for_repo_path(panel, &repo_path("top.txt")).unwrap();
+ panel.mark_range(src_ix, top_ix);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("top.txt")]),
+ "files hidden in the collapsed directory are not marked individually",
+ );
+ assert_eq!(
+ panel.marked_directories,
+ HashSet::from_iter([dir_key.clone()]),
+ "a collapsed directory inside the range is selected as a unit",
+ );
+ assert_eq!(
+ panel
+ .effective_status_entries()
+ .iter()
+ .map(|entry| entry.repo_path.clone())
+ .collect::<HashSet<_>>(),
+ HashSet::from_iter([
+ repo_path("src/a.rs"),
+ repo_path("src/b.rs"),
+ repo_path("top.txt"),
+ ]),
+ "operations expand the selected directory to its files",
+ );
+
+ panel.clear_marks();
+ let hidden_ix = entry_index_for_repo_path(panel, &repo_path("src/a.rs"))
+ .expect("collapsed entries should stay in the entry list");
+ panel.mark_range(hidden_ix, top_ix);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("top.txt")]),
+ "an anchor hidden in a collapsed directory should mark the target only",
+ );
+ assert_eq!(panel.marked_directories, HashSet::default());
+ });
+ }
+
+ #[gpui::test]
+ async fn test_shift_range_shrinks_when_reversed(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, _cx| {
+ // A mark from before the gesture must survive the whole gesture.
+ panel.marked_entries.insert(repo_path("new1.txt"));
+ let a_ix = entry_index_for_repo_path(panel, &repo_path("a.txt")).unwrap();
+ panel.selected_entry = Some(a_ix);
+ });
+
+ cx.simulate_modifiers_change(Modifiers {
+ shift: true,
+ ..Default::default()
+ });
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.select_next(&menu::SelectNext, window, cx);
+ panel.select_next(&menu::SelectNext, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("a.txt"),
+ repo_path("b.txt"),
+ repo_path("c.txt"),
+ repo_path("new1.txt"),
+ ]),
+ "shift+down twice should mark the anchor and two more rows",
+ );
+
+ panel.select_previous(&menu::SelectPrevious, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("a.txt"),
+ repo_path("b.txt"),
+ repo_path("new1.txt"),
+ ]),
+ "shift+up should shrink the range back toward the anchor",
+ );
+
+ panel.select_previous(&menu::SelectPrevious, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt"), repo_path("new1.txt")]),
+ "shrinking to the anchor leaves only the anchor and prior marks",
+ );
+ });
+
+ // Releasing shift and navigating ends the gesture; the next shift
+ // press starts a new range anchored at the current cursor.
+ cx.simulate_modifiers_change(Modifiers::default());
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.select_next(&menu::SelectNext, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt"), repo_path("new1.txt")]),
+ "plain navigation must not change the marks",
+ );
+ });
+ cx.simulate_modifiers_change(Modifiers {
+ shift: true,
+ ..Default::default()
+ });
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.select_next(&menu::SelectNext, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([
+ repo_path("a.txt"),
+ repo_path("b.txt"),
+ repo_path("c.txt"),
+ repo_path("new1.txt"),
+ ]),
+ "a new gesture anchors at the row plain navigation moved to",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_directory_selection_is_explicit(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_, _, _, panel, mut cx) = setup_git_panel_with_changes(
+ cx,
+ json!({
+ ".git": {},
+ "src": {
+ "a.rs": "a",
+ "nested": {
+ "c.rs": "c",
+ },
+ },
+ "top.txt": "top",
+ }),
+ &[
+ ("src/a.rs", StatusCode::Modified),
+ ("src/nested/c.rs", StatusCode::Modified),
+ ("top.txt", StatusCode::Modified),
+ ],
+ )
+ .await;
+
+ cx.update(|_window, cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.git_panel.get_or_insert_default().tree_view = Some(true);
+ })
+ });
+ });
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, cx| {
+ let directory = |panel: &GitPanel, name: &str| {
+ panel
+ .entries
+ .iter()
+ .filter_map(|entry| entry.directory_entry())
+ .find(|dir| dir.name.as_ref() == name)
+ .cloned()
+ .expect("tree view should contain the directory row")
+ };
+ let src = directory(panel, "src");
+ let src_ix = panel
+ .entries
+ .iter()
+ .position(|entry| {
+ entry
+ .directory_entry()
+ .is_some_and(|directory| directory.key == src.key)
+ })
+ .unwrap();
+
+ panel.marked_entries =
+ HashSet::from_iter([repo_path("src/a.rs"), repo_path("src/nested/c.rs")]);
+ assert_eq!(
+ panel.marked_directories,
+ HashSet::default(),
+ "marking every file must not implicitly select their directories",
+ );
+
+ panel.clear_marks();
+ panel.selected_entry = Some(src_ix);
+ panel.toggle_mark(src_ix, cx);
+ assert_eq!(
+ panel.marked_directories,
+ HashSet::from_iter([src.key]),
+ "toggling a directory selects the directory itself",
+ );
+ assert_eq!(
+ panel
+ .effective_status_entries()
+ .iter()
+ .map(|entry| entry.repo_path.clone())
+ .collect::<HashSet<_>>(),
+ HashSet::from_iter([repo_path("src/a.rs"), repo_path("src/nested/c.rs")]),
+ "operations expand a selected directory to its recursive descendants",
+ );
+
+ panel.marked_entries.insert(repo_path("top.txt"));
+ panel.toggle_mark(src_ix, cx);
+ assert_eq!(
+ panel.marked_directories,
+ HashSet::default(),
+ "toggling a selected directory again deselects it",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_toggle_mark_promotes_selection(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, cx| {
+ let a_ix = entry_index_for_repo_path(panel, &repo_path("a.txt")).unwrap();
+ let b_ix = entry_index_for_repo_path(panel, &repo_path("b.txt")).unwrap();
+
+ panel.selected_entry = Some(a_ix);
+ panel.toggle_mark(b_ix, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt"), repo_path("b.txt")]),
+ "the first toggle should also mark the previously selected entry",
+ );
+ assert_eq!(panel.selected_entry, Some(b_ix));
+
+ panel.toggle_mark(b_ix, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt")]),
+ "toggling a marked entry should unmark it",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_effective_status_entries_rule(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, _cx| {
+ let a_ix = entry_index_for_repo_path(panel, &repo_path("a.txt")).unwrap();
+ panel.selected_entry = Some(a_ix);
+
+ let paths = |panel: &GitPanel| {
+ panel
+ .effective_status_entries()
+ .iter()
+ .map(|entry| entry.repo_path.clone())
+ .collect::<Vec<_>>()
+ };
+
+ assert_eq!(
+ paths(panel),
+ vec![repo_path("a.txt")],
+ "no marks: the selection acts alone",
+ );
+
+ panel.marked_entries.insert(repo_path("b.txt"));
+ assert_eq!(
+ paths(panel),
+ vec![repo_path("a.txt")],
+ "a single mark elsewhere should not override the selection",
+ );
+
+ panel.marked_entries.insert(repo_path("c.txt"));
+ assert_eq!(
+ paths(panel),
+ vec![repo_path("b.txt"), repo_path("c.txt")],
+ "multiple marks win, in panel order",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_bulk_toggle_staged_mixed(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ let entries = panel.read_with(&cx, |panel, _| panel.entries.clone());
+ let a_entry = entries
+ .iter()
+ .find(|entry| {
+ entry
+ .status_entry()
+ .is_some_and(|entry| entry.repo_path == repo_path("a.txt"))
+ })
+ .unwrap()
+ .clone();
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.toggle_staged_for_entry(&a_entry, StageIntent::Toggle, window, cx);
+ });
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ assert_eq!(staging_for(panel, &repo_path("a.txt")), StageStatus::Staged);
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("b.txt"));
+ panel.selected_entry = entry_index_for_repo_path(panel, &repo_path("a.txt"));
+ panel.toggle_staged_for_selected(&git::ToggleStaged, window, cx);
+ });
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ assert_eq!(
+ staging_for(panel, &repo_path("a.txt")),
+ StageStatus::Staged,
+ "a mixed selection should be staged as a whole",
+ );
+ assert_eq!(staging_for(panel, &repo_path("b.txt")), StageStatus::Staged);
+
+ panel.toggle_staged_for_selected(&git::ToggleStaged, window, cx);
+ });
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.read_with(&cx, |panel, _| {
+ assert_eq!(
+ staging_for(panel, &repo_path("a.txt")),
+ StageStatus::Unstaged,
+ "a fully staged selection should be unstaged as a whole",
+ );
+ assert_eq!(
+ staging_for(panel, &repo_path("b.txt")),
+ StageStatus::Unstaged
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_marks_pruned_after_refresh(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (fs, project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, _cx| {
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("b.txt"));
+ });
+
+ fs.set_status_for_repo(
+ path!("/project/.git").as_ref(),
+ &[
+ ("b.txt", StatusCode::Modified.worktree()),
+ ("c.txt", StatusCode::Modified.worktree()),
+ ("new1.txt", FileStatus::Untracked),
+ ("new2.txt", FileStatus::Untracked),
+ ],
+ );
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.read_with(&cx, |panel, _| {
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("b.txt")]),
+ "marks for entries that left the list should be pruned",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_clear_marks_and_select(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, cx| {
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("b.txt"));
+
+ let c_ix = entry_index_for_repo_path(panel, &repo_path("c.txt")).unwrap();
+ panel.clear_marks_and_select(c_ix, cx);
+ assert!(panel.marked_entries.is_empty());
+ assert_eq!(panel.selected_entry, Some(c_ix));
+ });
+ }
+
+ #[gpui::test]
+ async fn test_shift_select_next_extends_marks(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ let (a_ix, b_ix) = panel.update_in(&mut cx, |panel, _window, _cx| {
+ let a_ix = entry_index_for_repo_path(panel, &repo_path("a.txt")).unwrap();
+ panel.selected_entry = Some(a_ix);
+ (
+ a_ix,
+ entry_index_for_repo_path(panel, &repo_path("b.txt")).unwrap(),
+ )
+ });
+
+ cx.simulate_modifiers_change(Modifiers {
+ shift: true,
+ ..Default::default()
+ });
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.select_next(&menu::SelectNext, window, cx);
+ });
+
+ panel.read_with(&cx, |panel, _| {
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt"), repo_path("b.txt")]),
+ "shift+down should mark the origin and the destination",
+ );
+ assert_eq!(panel.selected_entry, Some(b_ix));
+ assert_ne!(a_ix, b_ix);
+ });
+ }
+
+ #[gpui::test]
+ async fn test_bulk_revert_prompt_cancel_mixed(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("new1.txt"));
+ panel.selected_entry = entry_index_for_repo_path(panel, &repo_path("a.txt"));
+ panel.revert_selected(&git::RestoreFile::default(), window, cx);
+ });
+
+ assert!(cx.has_pending_prompt(), "bulk revert should prompt once");
+ cx.simulate_prompt_answer("Cancel");
+ cx.executor().run_until_parked();
+
+ assert!(fs.is_file(path!("/project/a.txt").as_ref()).await);
+ assert!(fs.is_file(path!("/project/new1.txt").as_ref()).await);
+ panel.read_with(&cx, |panel, _| {
+ assert_eq!(
+ staging_for(panel, &repo_path("a.txt")),
+ StageStatus::Unstaged
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_bulk_revert_trashes_created_files(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/project"),
+ json!({
+ ".git": {},
+ "new1.txt": "1",
+ "new2.txt": "2",
+ }),
+ )
+ .await;
+ fs.set_status_for_repo(
+ path!("/project/.git").as_ref(),
+ &[
+ ("new1.txt", FileStatus::Untracked),
+ ("new2.txt", StatusCode::Added.index()),
+ ],
+ );
+
+ let project = Project::test(fs.clone(), [Path::new(path!("/project"))], cx).await;
+ let window_handle =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = window_handle
+ .read_with(cx, |mw, _| mw.workspace().clone())
+ .unwrap();
+ let mut cx = VisualTestContext::from_window(window_handle.into(), cx);
+
+ cx.read(|cx| {
+ project
+ .read(cx)
+ .worktrees(cx)
+ .next()
+ .unwrap()
+ .read(cx)
+ .as_local()
+ .unwrap()
+ .scan_complete()
+ })
+ .await;
+ cx.executor().run_until_parked();
+
+ let panel = workspace.update_in(&mut cx, GitPanel::new);
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.marked_entries.insert(repo_path("new1.txt"));
+ panel.marked_entries.insert(repo_path("new2.txt"));
+ panel.selected_entry = entry_index_for_repo_path(panel, &repo_path("new1.txt"));
+ panel.revert_selected(&git::RestoreFile::default(), window, cx);
+ });
+
+ assert!(cx.has_pending_prompt());
+ cx.simulate_prompt_answer("Trash");
+ cx.executor().run_until_parked();
+
+ assert!(
+ !fs.is_file(path!("/project/new1.txt").as_ref()).await,
+ "created files should be trashed by bulk revert",
+ );
+ assert!(!fs.is_file(path!("/project/new2.txt").as_ref()).await);
+ }
+
+ #[gpui::test]
+ async fn test_stage_and_unstage_actions_apply_to_marks(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("b.txt"));
+ panel.selected_entry = entry_index_for_repo_path(panel, &repo_path("a.txt"));
+ panel.stage_selected(&git::StageFile, window, cx);
+ });
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ assert_eq!(staging_for(panel, &repo_path("a.txt")), StageStatus::Staged);
+ assert_eq!(staging_for(panel, &repo_path("b.txt")), StageStatus::Staged);
+ assert_eq!(
+ staging_for(panel, &repo_path("c.txt")),
+ StageStatus::Unstaged,
+ "unmarked entries should be untouched",
+ );
+
+ panel.unstage_selected(&git::UnstageFile, window, cx);
+ });
+ settle_git_panel(&project, &panel, &mut cx).await;
+
+ panel.read_with(&cx, |panel, _| {
+ assert_eq!(
+ staging_for(panel, &repo_path("a.txt")),
+ StageStatus::Unstaged
+ );
+ assert_eq!(
+ staging_for(panel, &repo_path("b.txt")),
+ StageStatus::Unstaged
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_cancel_clears_marks_only_on_changes_tab(cx: &mut TestAppContext) {
+ init_test(cx);
+ let (_fs, _project, panel, mut cx) = setup_flat_marks_fixture(cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.marked_entries.insert(repo_path("b.txt"));
+
+ panel.cancel(&menu::Cancel, window, cx);
+ assert!(
+ panel.marked_entries.is_empty(),
+ "cancel on the changes tab should clear the marks",
+ );
+
+ panel.active_tab = GitPanelTab::History;
+ panel.marked_entries.insert(repo_path("a.txt"));
+ panel.cancel(&menu::Cancel, window, cx);
+ assert_eq!(
+ panel.marked_entries,
+ HashSet::from_iter([repo_path("a.txt")]),
+ "cancel on the history tab should leave changes-tab marks alone",
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_marks_cleared_on_repo_switch(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "project-a": {
+ ".git": {},
+ "x.txt": "a",
+ },
+ "project-b": {
+ ".git": {},
+ "x.txt": "b",
+ },
+ }),
+ )
+ .await;
+ fs.set_status_for_repo(
+ path!("/root/project-a/.git").as_ref(),
+ &[("x.txt", StatusCode::Modified.worktree())],
+ );
+ fs.set_status_for_repo(
+ path!("/root/project-b/.git").as_ref(),
+ &[("x.txt", StatusCode::Modified.worktree())],
+ );
+
+ let project = Project::test(
+ fs.clone(),
+ [
+ Path::new(path!("/root/project-a")),
+ Path::new(path!("/root/project-b")),
+ ],
+ cx,
+ )
+ .await;
+ let (repository_a, repository_b) = project.read_with(cx, |project, cx| {
+ let git_store = project.git_store().clone();
+ let mut repository_a = None;
+ let mut repository_b = None;
+ for repository in git_store.read(cx).repositories().values() {
+ let work_directory_abs_path = &repository.read(cx).work_directory_abs_path;
+ if work_directory_abs_path.as_ref() == Path::new(path!("/root/project-a")) {
+ repository_a = Some(repository.clone());
+ } else if work_directory_abs_path.as_ref() == Path::new(path!("/root/project-b")) {
+ repository_b = Some(repository.clone());
+ }
+ }
+ (
+ repository_a.expect("should have repository for project-a"),
+ repository_b.expect("should have repository for project-b"),
+ )
+ });
+ repository_a.update(cx, |repository, cx| repository.set_as_active_repository(cx));
+
+ let window_handle =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = window_handle
+ .read_with(cx, |mw, _| mw.workspace().clone())
+ .unwrap();
+ let mut cx = VisualTestContext::from_window(window_handle.into(), cx);
+ cx.executor().run_until_parked();
+
+ let panel = workspace.update_in(&mut cx, GitPanel::new);
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ panel.update_in(&mut cx, |panel, _window, _cx| {
+ assert!(
+ entry_index_for_repo_path(panel, &repo_path("x.txt")).is_some(),
+ "repo A should list x.txt",
+ );
+ panel.marked_entries.insert(repo_path("x.txt"));
+ });
+
+ repository_b.update(&mut cx, |repository, cx| {
+ repository.set_as_active_repository(cx)
+ });
+ cx.executor().run_until_parked();
+ await_git_panel_entries(&panel, &mut cx).await;
+
+ panel.read_with(&cx, |panel, _| {
+ assert!(
+ entry_index_for_repo_path(panel, &repo_path("x.txt")).is_some(),
+ "repo B should list its own x.txt",
+ );
+ assert!(
+ panel.marked_entries.is_empty(),
+ "marks must not carry over to another repository",
+ );
+ });
+ }
}