Add recent project picker

crates/recent_projects/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "recent_projects"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/recent_projects.rs"
+doctest = false
+
+[dependencies]
+db = { path = "../db" }
+editor = { path = "../editor" }
+fuzzy = { path = "../fuzzy" }
+gpui = { path = "../gpui" }
+language = { path = "../language" }
+picker = { path = "../picker" }
+settings = { path = "../settings" }
+text = { path = "../text" }
+workspace = { path = "../workspace" }
+ordered-float = "2.1.1"
+postage = { version = "0.4", features = ["futures-traits"] }
+smol = "1.2"

crates/recent_projects/src/highlighted_workspace_location.rs

@@ -0,0 +1,129 @@
+use std::path::Path;
+
+use fuzzy::StringMatch;
+use gpui::{
+    elements::{Label, LabelStyle},
+    Element, ElementBox,
+};
+use workspace::WorkspaceLocation;
+
+pub struct HighlightedText {
+    pub text: String,
+    pub highlight_positions: Vec<usize>,
+    char_count: usize,
+}
+
+impl HighlightedText {
+    fn join(components: impl Iterator<Item = Self>, separator: &str) -> Self {
+        let mut char_count = 0;
+        let separator_char_count = separator.chars().count();
+        let mut text = String::new();
+        let mut highlight_positions = Vec::new();
+        for component in components {
+            if char_count != 0 {
+                text.push_str(separator);
+                char_count += separator_char_count;
+            }
+
+            highlight_positions.extend(
+                component
+                    .highlight_positions
+                    .iter()
+                    .map(|position| position + char_count),
+            );
+            text.push_str(&component.text);
+            char_count += component.text.chars().count();
+        }
+
+        Self {
+            text,
+            highlight_positions,
+            char_count,
+        }
+    }
+
+    pub fn render(self, style: impl Into<LabelStyle>) -> ElementBox {
+        Label::new(self.text, style)
+            .with_highlights(self.highlight_positions)
+            .boxed()
+    }
+}
+
+pub struct HighlightedWorkspaceLocation {
+    pub names: HighlightedText,
+    pub paths: Vec<HighlightedText>,
+}
+
+impl HighlightedWorkspaceLocation {
+    pub fn new(string_match: &StringMatch, location: &WorkspaceLocation) -> Self {
+        let mut path_start_offset = 0;
+        let (names, paths): (Vec<_>, Vec<_>) = location
+            .paths()
+            .iter()
+            .map(|path| {
+                let highlighted_text = Self::highlights_for_path(
+                    path.as_ref(),
+                    &string_match.positions,
+                    path_start_offset,
+                );
+
+                path_start_offset += highlighted_text.1.char_count;
+
+                highlighted_text
+            })
+            .unzip();
+
+        Self {
+            names: HighlightedText::join(names.into_iter().filter_map(|name| name), ", "),
+            paths,
+        }
+    }
+
+    // Compute the highlighted text for the name and path
+    fn highlights_for_path(
+        path: &Path,
+        match_positions: &Vec<usize>,
+        path_start_offset: usize,
+    ) -> (Option<HighlightedText>, HighlightedText) {
+        let path_string = path.to_string_lossy();
+        let path_char_count = path_string.chars().count();
+        // Get the subset of match highlight positions that line up with the given path.
+        // Also adjusts them to start at the path start
+        let path_positions = match_positions
+            .iter()
+            .copied()
+            .skip_while(|position| *position < path_start_offset)
+            .take_while(|position| *position < path_start_offset + path_char_count)
+            .map(|position| position - path_start_offset)
+            .collect::<Vec<_>>();
+
+        // Again subset the highlight positions to just those that line up with the file_name
+        // again adjusted to the start of the file_name
+        let file_name_text_and_positions = path.file_name().map(|file_name| {
+            let text = file_name.to_string_lossy();
+            let char_count = text.chars().count();
+            let file_name_start = path_char_count - char_count;
+            let highlight_positions = path_positions
+                .iter()
+                .copied()
+                .skip_while(|position| *position < file_name_start)
+                .take_while(|position| *position < file_name_start + char_count)
+                .map(|position| position - file_name_start)
+                .collect::<Vec<_>>();
+            HighlightedText {
+                text: text.to_string(),
+                highlight_positions,
+                char_count,
+            }
+        });
+
+        (
+            file_name_text_and_positions,
+            HighlightedText {
+                text: path_string.to_string(),
+                highlight_positions: path_positions,
+                char_count: path_char_count,
+            },
+        )
+    }
+}

crates/recent_projects/src/recent_projects.rs

@@ -0,0 +1,187 @@
+mod highlighted_workspace_location;
+
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    actions,
+    elements::{ChildView, Flex, ParentElement},
+    AnyViewHandle, Element, ElementBox, Entity, MutableAppContext, RenderContext, Task, View,
+    ViewContext, ViewHandle,
+};
+use highlighted_workspace_location::HighlightedWorkspaceLocation;
+use ordered_float::OrderedFloat;
+use picker::{Picker, PickerDelegate};
+use settings::Settings;
+use workspace::{OpenPaths, Workspace, WorkspaceLocation};
+
+const RECENT_LIMIT: usize = 100;
+
+actions!(recent_projects, [Toggle]);
+
+pub fn init(cx: &mut MutableAppContext) {
+    cx.add_action(RecentProjectsView::toggle);
+    Picker::<RecentProjectsView>::init(cx);
+}
+
+struct RecentProjectsView {
+    picker: ViewHandle<Picker<Self>>,
+    workspace_locations: Vec<WorkspaceLocation>,
+    selected_match_index: usize,
+    matches: Vec<StringMatch>,
+}
+
+impl RecentProjectsView {
+    fn new(cx: &mut ViewContext<Self>) -> Self {
+        let handle = cx.weak_handle();
+        let workspace_locations: Vec<WorkspaceLocation> = workspace::WORKSPACE_DB
+            .recent_workspaces(RECENT_LIMIT)
+            .unwrap_or_default()
+            .into_iter()
+            .map(|(_, location)| location)
+            .collect();
+        Self {
+            picker: cx.add_view(|cx| {
+                Picker::new("Recent Projects...", handle, cx).with_max_size(800., 1200.)
+            }),
+            workspace_locations,
+            selected_match_index: 0,
+            matches: Default::default(),
+        }
+    }
+
+    fn toggle(workspace: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
+        workspace.toggle_modal(cx, |_, cx| {
+            let view = cx.add_view(|cx| Self::new(cx));
+            cx.subscribe(&view, Self::on_event).detach();
+            view
+        });
+    }
+
+    fn on_event(
+        workspace: &mut Workspace,
+        _: ViewHandle<Self>,
+        event: &Event,
+        cx: &mut ViewContext<Workspace>,
+    ) {
+        match event {
+            Event::Dismissed => workspace.dismiss_modal(cx),
+        }
+    }
+}
+
+pub enum Event {
+    Dismissed,
+}
+
+impl Entity for RecentProjectsView {
+    type Event = Event;
+}
+
+impl View for RecentProjectsView {
+    fn ui_name() -> &'static str {
+        "RecentProjectsView"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        ChildView::new(self.picker.clone(), cx).boxed()
+    }
+
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+        if cx.is_self_focused() {
+            cx.focus(&self.picker);
+        }
+    }
+}
+
+impl PickerDelegate for RecentProjectsView {
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_match_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _cx: &mut ViewContext<Self>) {
+        self.selected_match_index = ix;
+    }
+
+    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Self>) -> gpui::Task<()> {
+        let query = query.trim_start();
+        let smart_case = query.chars().any(|c| c.is_uppercase());
+        let candidates = self
+            .workspace_locations
+            .iter()
+            .enumerate()
+            .map(|(id, location)| {
+                let combined_string = location
+                    .paths()
+                    .iter()
+                    .map(|path| path.to_string_lossy().to_owned())
+                    .collect::<Vec<_>>()
+                    .join("");
+                StringMatchCandidate::new(id, combined_string)
+            })
+            .collect::<Vec<_>>();
+        self.matches = smol::block_on(fuzzy::match_strings(
+            candidates.as_slice(),
+            query,
+            smart_case,
+            100,
+            &Default::default(),
+            cx.background().clone(),
+        ));
+        self.matches.sort_unstable_by_key(|m| m.candidate_id);
+
+        self.selected_match_index = self
+            .matches
+            .iter()
+            .enumerate()
+            .max_by_key(|(_, m)| OrderedFloat(m.score))
+            .map(|(ix, _)| ix)
+            .unwrap_or(0);
+        Task::ready(())
+    }
+
+    fn confirm(&mut self, cx: &mut ViewContext<Self>) {
+        let selected_match = &self.matches[self.selected_index()];
+        let workspace_location = &self.workspace_locations[selected_match.candidate_id];
+        cx.dispatch_global_action(OpenPaths {
+            paths: workspace_location.paths().as_ref().clone(),
+        });
+        cx.emit(Event::Dismissed);
+    }
+
+    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismissed);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        mouse_state: &mut gpui::MouseState,
+        selected: bool,
+        cx: &gpui::AppContext,
+    ) -> ElementBox {
+        let settings = cx.global::<Settings>();
+        let string_match = &self.matches[ix];
+        let style = settings.theme.picker.item.style_for(mouse_state, selected);
+
+        let highlighted_location = HighlightedWorkspaceLocation::new(
+            &string_match,
+            &self.workspace_locations[string_match.candidate_id],
+        );
+
+        Flex::column()
+            .with_child(highlighted_location.names.render(style.label.clone()))
+            .with_children(
+                highlighted_location
+                    .paths
+                    .into_iter()
+                    .map(|highlighted_path| highlighted_path.render(style.label.clone())),
+            )
+            .flex(1., false)
+            .contained()
+            .with_style(style.container)
+            .named("match")
+    }
+}