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