git: Implement a basic repository selector (#23419)

This PR adds a rough-and-ready picker for selecting which of the
project's repositories the git panel should display.

Release Notes:

- N/A

---------

Co-authored-by: Nate Butler <iamnbutler@gmail.com>
Co-authored-by: Nate <nate@zed.dev>

crates/git_ui/src/repository_selector.rs

@@ -0,0 +1,232 @@
+use gpui::{
+    AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, Model,
+    Subscription, Task, View, WeakModel, WeakView,
+};
+use picker::{Picker, PickerDelegate};
+use project::{
+    git::{GitState, RepositoryHandle},
+    Project,
+};
+use std::sync::Arc;
+use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverMenuHandle, PopoverTrigger};
+
+pub struct RepositorySelector {
+    picker: View<Picker<RepositorySelectorDelegate>>,
+    /// The task used to update the picker's matches when there is a change to
+    /// the repository list.
+    update_matches_task: Option<Task<()>>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl RepositorySelector {
+    pub fn new(project: Model<Project>, cx: &mut ViewContext<Self>) -> Self {
+        let git_state = project.read(cx).git_state().cloned();
+        let all_repositories = git_state
+            .as_ref()
+            .map_or(vec![], |git_state| git_state.read(cx).all_repositories());
+        let filtered_repositories = all_repositories.clone();
+        let delegate = RepositorySelectorDelegate {
+            project: project.downgrade(),
+            repository_selector: cx.view().downgrade(),
+            repository_entries: all_repositories,
+            filtered_repositories,
+            selected_index: 0,
+        };
+
+        let picker =
+            cx.new_view(|cx| Picker::uniform_list(delegate, cx).max_height(Some(rems(20.).into())));
+
+        let _subscriptions = if let Some(git_state) = git_state {
+            vec![cx.subscribe(&git_state, Self::handle_project_git_event)]
+        } else {
+            Vec::new()
+        };
+
+        RepositorySelector {
+            picker,
+            update_matches_task: None,
+            _subscriptions,
+        }
+    }
+
+    fn handle_project_git_event(
+        &mut self,
+        git_state: Model<GitState>,
+        _event: &project::git::Event,
+        cx: &mut ViewContext<Self>,
+    ) {
+        // TODO handle events individually
+        let task = self.picker.update(cx, |this, cx| {
+            let query = this.query(cx);
+            this.delegate.repository_entries = git_state.read(cx).all_repositories();
+            this.delegate.update_matches(query, cx)
+        });
+        self.update_matches_task = Some(task);
+    }
+}
+
+impl EventEmitter<DismissEvent> for RepositorySelector {}
+
+impl FocusableView for RepositorySelector {
+    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for RepositorySelector {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        self.picker.clone()
+    }
+}
+
+#[derive(IntoElement)]
+pub struct RepositorySelectorPopoverMenu<T>
+where
+    T: PopoverTrigger,
+{
+    repository_selector: View<RepositorySelector>,
+    trigger: T,
+    handle: Option<PopoverMenuHandle<RepositorySelector>>,
+}
+
+impl<T: PopoverTrigger> RepositorySelectorPopoverMenu<T> {
+    pub fn new(repository_selector: View<RepositorySelector>, trigger: T) -> Self {
+        Self {
+            repository_selector,
+            trigger,
+            handle: None,
+        }
+    }
+
+    pub fn with_handle(mut self, handle: PopoverMenuHandle<RepositorySelector>) -> Self {
+        self.handle = Some(handle);
+        self
+    }
+}
+
+impl<T: PopoverTrigger> RenderOnce for RepositorySelectorPopoverMenu<T> {
+    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+        let repository_selector = self.repository_selector.clone();
+
+        PopoverMenu::new("repository-switcher")
+            .menu(move |_cx| Some(repository_selector.clone()))
+            .trigger(self.trigger)
+            .attach(gpui::Corner::BottomLeft)
+            .when_some(self.handle.clone(), |menu, handle| menu.with_handle(handle))
+    }
+}
+
+pub struct RepositorySelectorDelegate {
+    project: WeakModel<Project>,
+    repository_selector: WeakView<RepositorySelector>,
+    repository_entries: Vec<RepositoryHandle>,
+    filtered_repositories: Vec<RepositoryHandle>,
+    selected_index: usize,
+}
+
+impl RepositorySelectorDelegate {
+    pub fn update_repository_entries(&mut self, all_repositories: Vec<RepositoryHandle>) {
+        self.repository_entries = all_repositories.clone();
+        self.filtered_repositories = all_repositories;
+        self.selected_index = 0;
+    }
+}
+
+impl PickerDelegate for RepositorySelectorDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.filtered_repositories.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
+        self.selected_index = ix.min(self.filtered_repositories.len().saturating_sub(1));
+        cx.notify();
+    }
+
+    fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
+        "Select a repository...".into()
+    }
+
+    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+        let all_repositories = self.repository_entries.clone();
+
+        cx.spawn(|this, mut cx| async move {
+            let filtered_repositories = cx
+                .background_executor()
+                .spawn(async move {
+                    if query.is_empty() {
+                        all_repositories
+                    } else {
+                        all_repositories
+                            .into_iter()
+                            .filter(|_repo_info| {
+                                // TODO: Implement repository filtering logic
+                                true
+                            })
+                            .collect()
+                    }
+                })
+                .await;
+
+            this.update(&mut cx, |this, cx| {
+                this.delegate.filtered_repositories = filtered_repositories;
+                this.delegate.set_selected_index(0, cx);
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
+        let Some(selected_repo) = self.filtered_repositories.get(self.selected_index) else {
+            return;
+        };
+        selected_repo.activate(cx);
+        self.dismissed(cx);
+    }
+
+    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+        self.repository_selector
+            .update(cx, |_this, cx| cx.emit(DismissEvent))
+            .ok();
+    }
+
+    fn render_header(&self, _cx: &mut ViewContext<Picker<Self>>) -> Option<AnyElement> {
+        // TODO: Implement header rendering if needed
+        None
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        cx: &mut ViewContext<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let project = self.project.upgrade()?;
+        let repo_info = self.filtered_repositories.get(ix)?;
+        let display_name = repo_info.display_name(project.read(cx), cx);
+        // TODO: Implement repository item rendering
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(Label::new(display_name)),
+        )
+    }
+
+    fn render_footer(&self, cx: &mut ViewContext<Picker<Self>>) -> Option<gpui::AnyElement> {
+        // TODO: Implement footer rendering if needed
+        Some(
+            div()
+                .text_ui_sm(cx)
+                .child("Temporary location for repo selector")
+                .into_any_element(),
+        )
+    }
+}