1use gpui::{
2 AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
3};
4use itertools::Itertools;
5use picker::{Picker, PickerDelegate};
6use project::{
7 git_store::{GitStore, Repository},
8 Project,
9};
10use std::sync::Arc;
11use ui::{prelude::*, ListItem, ListItemSpacing};
12use workspace::{ModalView, Workspace};
13
14pub fn register(workspace: &mut Workspace) {
15 workspace.register_action(open);
16}
17
18pub fn open(
19 workspace: &mut Workspace,
20 _: &zed_actions::git::SelectRepo,
21 window: &mut Window,
22 cx: &mut Context<Workspace>,
23) {
24 let project = workspace.project().clone();
25 workspace.toggle_modal(window, cx, |window, cx| {
26 RepositorySelector::new(project, rems(34.), window, cx)
27 })
28}
29
30pub struct RepositorySelector {
31 width: Rems,
32 picker: Entity<Picker<RepositorySelectorDelegate>>,
33}
34
35impl RepositorySelector {
36 pub fn new(
37 project_handle: Entity<Project>,
38 width: Rems,
39 window: &mut Window,
40 cx: &mut Context<Self>,
41 ) -> Self {
42 let git_store = project_handle.read(cx).git_store().clone();
43 let repository_entries = git_store.update(cx, |git_store, cx| {
44 filtered_repository_entries(git_store, cx)
45 });
46 let project = project_handle.read(cx);
47 let filtered_repositories = repository_entries.clone();
48
49 let widest_item_ix = repository_entries.iter().position_max_by(|a, b| {
50 a.read(cx)
51 .display_name(project, cx)
52 .len()
53 .cmp(&b.read(cx).display_name(project, cx).len())
54 });
55
56 let delegate = RepositorySelectorDelegate {
57 project: project_handle.downgrade(),
58 repository_selector: cx.entity().downgrade(),
59 repository_entries,
60 filtered_repositories,
61 selected_index: 0,
62 };
63
64 let picker = cx.new(|cx| {
65 Picker::nonsearchable_uniform_list(delegate, window, cx)
66 .widest_item(widest_item_ix)
67 .max_height(Some(rems(20.).into()))
68 });
69
70 RepositorySelector { picker, width }
71 }
72}
73
74pub(crate) fn filtered_repository_entries(
75 git_store: &GitStore,
76 cx: &App,
77) -> Vec<Entity<Repository>> {
78 let repositories = git_store
79 .repositories()
80 .values()
81 .sorted_by_key(|repo| {
82 let repo = repo.read(cx);
83 (
84 repo.dot_git_abs_path.clone(),
85 repo.worktree_abs_path.clone(),
86 )
87 })
88 .collect::<Vec<&Entity<Repository>>>();
89
90 repositories
91 .chunk_by(|a, b| a.read(cx).dot_git_abs_path == b.read(cx).dot_git_abs_path)
92 .flat_map(|chunk| {
93 let has_non_single_file_worktree = chunk
94 .iter()
95 .any(|repo| !repo.read(cx).is_from_single_file_worktree);
96 chunk.iter().filter(move |repo| {
97 // Remove any entry that comes from a single file worktree and represents a repository that is also represented by a non-single-file worktree.
98 !repo.read(cx).is_from_single_file_worktree || !has_non_single_file_worktree
99 })
100 })
101 .map(|&repo| repo.clone())
102 .collect()
103}
104
105impl EventEmitter<DismissEvent> for RepositorySelector {}
106
107impl Focusable for RepositorySelector {
108 fn focus_handle(&self, cx: &App) -> FocusHandle {
109 self.picker.focus_handle(cx)
110 }
111}
112
113impl Render for RepositorySelector {
114 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
115 div().w(self.width).child(self.picker.clone())
116 }
117}
118
119impl ModalView for RepositorySelector {}
120
121pub struct RepositorySelectorDelegate {
122 project: WeakEntity<Project>,
123 repository_selector: WeakEntity<RepositorySelector>,
124 repository_entries: Vec<Entity<Repository>>,
125 filtered_repositories: Vec<Entity<Repository>>,
126 selected_index: usize,
127}
128
129impl RepositorySelectorDelegate {
130 pub fn update_repository_entries(&mut self, all_repositories: Vec<Entity<Repository>>) {
131 self.repository_entries = all_repositories.clone();
132 self.filtered_repositories = all_repositories;
133 self.selected_index = 0;
134 }
135}
136
137impl PickerDelegate for RepositorySelectorDelegate {
138 type ListItem = ListItem;
139
140 fn match_count(&self) -> usize {
141 self.filtered_repositories.len()
142 }
143
144 fn selected_index(&self) -> usize {
145 self.selected_index
146 }
147
148 fn set_selected_index(
149 &mut self,
150 ix: usize,
151 _window: &mut Window,
152 cx: &mut Context<Picker<Self>>,
153 ) {
154 self.selected_index = ix.min(self.filtered_repositories.len().saturating_sub(1));
155 cx.notify();
156 }
157
158 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
159 "Select a repository...".into()
160 }
161
162 fn update_matches(
163 &mut self,
164 query: String,
165 window: &mut Window,
166 cx: &mut Context<Picker<Self>>,
167 ) -> Task<()> {
168 let all_repositories = self.repository_entries.clone();
169
170 cx.spawn_in(window, async move |this, cx| {
171 let filtered_repositories = cx
172 .background_spawn(async move {
173 if query.is_empty() {
174 all_repositories
175 } else {
176 all_repositories
177 .into_iter()
178 .filter(|_repo_info| {
179 // TODO: Implement repository filtering logic
180 true
181 })
182 .collect()
183 }
184 })
185 .await;
186
187 this.update_in(cx, |this, window, cx| {
188 this.delegate.filtered_repositories = filtered_repositories;
189 this.delegate.set_selected_index(0, window, cx);
190 cx.notify();
191 })
192 .ok();
193 })
194 }
195
196 fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
197 let Some(selected_repo) = self.filtered_repositories.get(self.selected_index) else {
198 return;
199 };
200 selected_repo.update(cx, |selected_repo, cx| {
201 selected_repo.set_as_active_repository(cx)
202 });
203 self.dismissed(window, cx);
204 }
205
206 fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
207 self.repository_selector
208 .update(cx, |_this, cx| cx.emit(DismissEvent))
209 .ok();
210 }
211
212 fn render_header(
213 &self,
214 _window: &mut Window,
215 _cx: &mut Context<Picker<Self>>,
216 ) -> Option<AnyElement> {
217 // TODO: Implement header rendering if needed
218 None
219 }
220
221 fn render_match(
222 &self,
223 ix: usize,
224 selected: bool,
225 _window: &mut Window,
226 cx: &mut Context<Picker<Self>>,
227 ) -> Option<Self::ListItem> {
228 let project = self.project.upgrade()?;
229 let repo_info = self.filtered_repositories.get(ix)?;
230 let display_name = repo_info.read(cx).display_name(project.read(cx), cx);
231 Some(
232 ListItem::new(ix)
233 .inset(true)
234 .spacing(ListItemSpacing::Sparse)
235 .toggle_state(selected)
236 .child(Label::new(display_name)),
237 )
238 }
239}