1use gpui::{
2 AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
3};
4use itertools::Itertools;
5use picker::{Picker, PickerDelegate};
6use project::{
7 git::{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 mut repository_entries = git_store.all_repositories();
79 repository_entries.sort_by_key(|repo| {
80 let repo = repo.read(cx);
81 (
82 repo.dot_git_abs_path.clone(),
83 repo.worktree_abs_path.clone(),
84 )
85 });
86 // Remove any entry that comes from a single file worktree and represents a repository that is also represented by a non-single-file worktree.
87 repository_entries
88 .chunk_by(|a, b| a.read(cx).dot_git_abs_path == b.read(cx).dot_git_abs_path)
89 .flat_map(|chunk| {
90 let has_non_single_file_worktree = chunk
91 .iter()
92 .any(|repo| !repo.read(cx).is_from_single_file_worktree);
93 chunk
94 .iter()
95 .filter(move |repo| {
96 !repo.read(cx).is_from_single_file_worktree || !has_non_single_file_worktree
97 })
98 .cloned()
99 })
100 .collect()
101}
102
103impl EventEmitter<DismissEvent> for RepositorySelector {}
104
105impl Focusable for RepositorySelector {
106 fn focus_handle(&self, cx: &App) -> FocusHandle {
107 self.picker.focus_handle(cx)
108 }
109}
110
111impl Render for RepositorySelector {
112 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
113 div().w(self.width).child(self.picker.clone())
114 }
115}
116
117impl ModalView for RepositorySelector {}
118
119pub struct RepositorySelectorDelegate {
120 project: WeakEntity<Project>,
121 repository_selector: WeakEntity<RepositorySelector>,
122 repository_entries: Vec<Entity<Repository>>,
123 filtered_repositories: Vec<Entity<Repository>>,
124 selected_index: usize,
125}
126
127impl RepositorySelectorDelegate {
128 pub fn update_repository_entries(&mut self, all_repositories: Vec<Entity<Repository>>) {
129 self.repository_entries = all_repositories.clone();
130 self.filtered_repositories = all_repositories;
131 self.selected_index = 0;
132 }
133}
134
135impl PickerDelegate for RepositorySelectorDelegate {
136 type ListItem = ListItem;
137
138 fn match_count(&self) -> usize {
139 self.filtered_repositories.len()
140 }
141
142 fn selected_index(&self) -> usize {
143 self.selected_index
144 }
145
146 fn set_selected_index(
147 &mut self,
148 ix: usize,
149 _window: &mut Window,
150 cx: &mut Context<Picker<Self>>,
151 ) {
152 self.selected_index = ix.min(self.filtered_repositories.len().saturating_sub(1));
153 cx.notify();
154 }
155
156 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
157 "Select a repository...".into()
158 }
159
160 fn update_matches(
161 &mut self,
162 query: String,
163 window: &mut Window,
164 cx: &mut Context<Picker<Self>>,
165 ) -> Task<()> {
166 let all_repositories = self.repository_entries.clone();
167
168 cx.spawn_in(window, |this, mut cx| async move {
169 let filtered_repositories = cx
170 .background_spawn(async move {
171 if query.is_empty() {
172 all_repositories
173 } else {
174 all_repositories
175 .into_iter()
176 .filter(|_repo_info| {
177 // TODO: Implement repository filtering logic
178 true
179 })
180 .collect()
181 }
182 })
183 .await;
184
185 this.update_in(&mut cx, |this, window, cx| {
186 this.delegate.filtered_repositories = filtered_repositories;
187 this.delegate.set_selected_index(0, window, cx);
188 cx.notify();
189 })
190 .ok();
191 })
192 }
193
194 fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
195 let Some(selected_repo) = self.filtered_repositories.get(self.selected_index) else {
196 return;
197 };
198 selected_repo.update(cx, |selected_repo, cx| selected_repo.activate(cx));
199 self.dismissed(window, cx);
200 }
201
202 fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
203 self.repository_selector
204 .update(cx, |_this, cx| cx.emit(DismissEvent))
205 .ok();
206 }
207
208 fn render_header(
209 &self,
210 _window: &mut Window,
211 _cx: &mut Context<Picker<Self>>,
212 ) -> Option<AnyElement> {
213 // TODO: Implement header rendering if needed
214 None
215 }
216
217 fn render_match(
218 &self,
219 ix: usize,
220 selected: bool,
221 _window: &mut Window,
222 cx: &mut Context<Picker<Self>>,
223 ) -> Option<Self::ListItem> {
224 let project = self.project.upgrade()?;
225 let repo_info = self.filtered_repositories.get(ix)?;
226 let display_name = repo_info.read(cx).display_name(project.read(cx), cx);
227 Some(
228 ListItem::new(ix)
229 .inset(true)
230 .spacing(ListItemSpacing::Sparse)
231 .toggle_state(selected)
232 .child(Label::new(display_name)),
233 )
234 }
235}