1use gpui::{
2 AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
3};
4use itertools::Itertools;
5use picker::{Picker, PickerDelegate};
6use project::{Project, git_store::Repository};
7use std::sync::Arc;
8use ui::{ListItem, ListItemSpacing, prelude::*};
9use workspace::{ModalView, Workspace};
10
11pub fn register(workspace: &mut Workspace) {
12 workspace.register_action(open);
13}
14
15pub fn open(
16 workspace: &mut Workspace,
17 _: &zed_actions::git::SelectRepo,
18 window: &mut Window,
19 cx: &mut Context<Workspace>,
20) {
21 let project = workspace.project().clone();
22 workspace.toggle_modal(window, cx, |window, cx| {
23 RepositorySelector::new(project, rems(34.), window, cx)
24 })
25}
26
27pub struct RepositorySelector {
28 width: Rems,
29 picker: Entity<Picker<RepositorySelectorDelegate>>,
30}
31
32impl RepositorySelector {
33 pub fn new(
34 project_handle: Entity<Project>,
35 width: Rems,
36 window: &mut Window,
37 cx: &mut Context<Self>,
38 ) -> Self {
39 let git_store = project_handle.read(cx).git_store().clone();
40 let repository_entries = git_store.update(cx, |git_store, _cx| {
41 git_store
42 .repositories()
43 .values()
44 .cloned()
45 .collect::<Vec<_>>()
46 });
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()
52 .len()
53 .cmp(&b.read(cx).display_name().len())
54 });
55
56 let delegate = RepositorySelectorDelegate {
57 repository_selector: cx.entity().downgrade(),
58 repository_entries,
59 filtered_repositories,
60 selected_index: 0,
61 };
62
63 let picker = cx.new(|cx| {
64 Picker::nonsearchable_uniform_list(delegate, window, cx)
65 .widest_item(widest_item_ix)
66 .max_height(Some(rems(20.).into()))
67 });
68
69 RepositorySelector { picker, width }
70 }
71}
72
73//pub(crate) fn filtered_repository_entries(
74// git_store: &GitStore,
75// cx: &App,
76//) -> Vec<Entity<Repository>> {
77// let repositories = git_store
78// .repositories()
79// .values()
80// .sorted_by_key(|repo| {
81// let repo = repo.read(cx);
82// (
83// repo.dot_git_abs_path.clone(),
84// repo.worktree_abs_path.clone(),
85// )
86// })
87// .collect::<Vec<&Entity<Repository>>>();
88//
89// repositories
90// .chunk_by(|a, b| a.read(cx).dot_git_abs_path == b.read(cx).dot_git_abs_path)
91// .flat_map(|chunk| {
92// let has_non_single_file_worktree = chunk
93// .iter()
94// .any(|repo| !repo.read(cx).is_from_single_file_worktree);
95// chunk.iter().filter(move |repo| {
96// // Remove any entry that comes from a single file worktree and represents a repository that is also represented by a non-single-file worktree.
97// !repo.read(cx).is_from_single_file_worktree || !has_non_single_file_worktree
98// })
99// })
100// .map(|&repo| repo.clone())
101// .collect()
102//}
103
104impl EventEmitter<DismissEvent> for RepositorySelector {}
105
106impl Focusable for RepositorySelector {
107 fn focus_handle(&self, cx: &App) -> FocusHandle {
108 self.picker.focus_handle(cx)
109 }
110}
111
112impl Render for RepositorySelector {
113 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
114 div().w(self.width).child(self.picker.clone())
115 }
116}
117
118impl ModalView for RepositorySelector {}
119
120pub struct RepositorySelectorDelegate {
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, async move |this, cx| {
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(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| {
199 selected_repo.set_as_active_repository(cx)
200 });
201 self.dismissed(window, cx);
202 }
203
204 fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
205 self.repository_selector
206 .update(cx, |_this, cx| cx.emit(DismissEvent))
207 .ok();
208 }
209
210 fn render_header(
211 &self,
212 _window: &mut Window,
213 _cx: &mut Context<Picker<Self>>,
214 ) -> Option<AnyElement> {
215 // TODO: Implement header rendering if needed
216 None
217 }
218
219 fn render_match(
220 &self,
221 ix: usize,
222 selected: bool,
223 _window: &mut Window,
224 cx: &mut Context<Picker<Self>>,
225 ) -> Option<Self::ListItem> {
226 let repo_info = self.filtered_repositories.get(ix)?;
227 let display_name = repo_info.read(cx).display_name();
228 Some(
229 ListItem::new(ix)
230 .inset(true)
231 .spacing(ListItemSpacing::Sparse)
232 .toggle_state(selected)
233 .child(Label::new(display_name)),
234 )
235 }
236}