482 lines
15 KiB
Rust
482 lines
15 KiB
Rust
use collections::{CommandPaletteFilter, HashMap};
|
|
use fuzzy::{StringMatch, StringMatchCandidate};
|
|
use gpui::{
|
|
actions, div, Action, AppContext, Component, Div, EventEmitter, FocusHandle, Keystroke,
|
|
ParentElement, Render, StatelessInteractive, Styled, View, ViewContext, VisualContext,
|
|
WeakView, WindowContext,
|
|
};
|
|
use picker::{Picker, PickerDelegate};
|
|
use std::{
|
|
cmp::{self, Reverse},
|
|
sync::Arc,
|
|
};
|
|
use theme::ActiveTheme;
|
|
use ui::{h_stack, v_stack, HighlightedLabel, KeyBinding, StyledExt};
|
|
use util::{
|
|
channel::{parse_zed_link, ReleaseChannel, RELEASE_CHANNEL},
|
|
ResultExt,
|
|
};
|
|
use workspace::{Modal, ModalEvent, Workspace};
|
|
use zed_actions::OpenZedURL;
|
|
|
|
actions!(Toggle);
|
|
|
|
pub fn init(cx: &mut AppContext) {
|
|
cx.set_global(HitCounts::default());
|
|
cx.observe_new_views(CommandPalette::register).detach();
|
|
}
|
|
|
|
pub struct CommandPalette {
|
|
picker: View<Picker<CommandPaletteDelegate>>,
|
|
}
|
|
|
|
impl CommandPalette {
|
|
fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
|
|
workspace.register_action(|workspace, _: &Toggle, cx| {
|
|
let Some(previous_focus_handle) = cx.focused() else {
|
|
return;
|
|
};
|
|
workspace.toggle_modal(cx, move |cx| CommandPalette::new(previous_focus_handle, cx));
|
|
});
|
|
}
|
|
|
|
fn new(previous_focus_handle: FocusHandle, cx: &mut ViewContext<Self>) -> Self {
|
|
let filter = cx.try_global::<CommandPaletteFilter>();
|
|
|
|
let commands = cx
|
|
.available_actions()
|
|
.into_iter()
|
|
.filter_map(|action| {
|
|
let name = action.name();
|
|
let namespace = name.split("::").next().unwrap_or("malformed action name");
|
|
if filter.is_some_and(|f| f.filtered_namespaces.contains(namespace)) {
|
|
return None;
|
|
}
|
|
|
|
Some(Command {
|
|
name: humanize_action_name(&name),
|
|
action,
|
|
keystrokes: vec![], // todo!()
|
|
})
|
|
})
|
|
.collect();
|
|
|
|
let delegate =
|
|
CommandPaletteDelegate::new(cx.view().downgrade(), commands, previous_focus_handle);
|
|
|
|
let picker = cx.build_view(|cx| Picker::new(delegate, cx));
|
|
Self { picker }
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<ModalEvent> for CommandPalette {}
|
|
impl Modal for CommandPalette {
|
|
fn focus(&self, cx: &mut WindowContext) {
|
|
self.picker.update(cx, |picker, cx| picker.focus(cx));
|
|
}
|
|
}
|
|
|
|
impl Render for CommandPalette {
|
|
type Element = Div<Self>;
|
|
|
|
fn render(&mut self, _cx: &mut ViewContext<Self>) -> Self::Element {
|
|
v_stack().w_96().child(self.picker.clone())
|
|
}
|
|
}
|
|
|
|
pub type CommandPaletteInterceptor =
|
|
Box<dyn Fn(&str, &AppContext) -> Option<CommandInterceptResult>>;
|
|
|
|
pub struct CommandInterceptResult {
|
|
pub action: Box<dyn Action>,
|
|
pub string: String,
|
|
pub positions: Vec<usize>,
|
|
}
|
|
|
|
pub struct CommandPaletteDelegate {
|
|
command_palette: WeakView<CommandPalette>,
|
|
commands: Vec<Command>,
|
|
matches: Vec<StringMatch>,
|
|
selected_ix: usize,
|
|
previous_focus_handle: FocusHandle,
|
|
}
|
|
|
|
struct Command {
|
|
name: String,
|
|
action: Box<dyn Action>,
|
|
keystrokes: Vec<Keystroke>,
|
|
}
|
|
|
|
impl Clone for Command {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
name: self.name.clone(),
|
|
action: self.action.boxed_clone(),
|
|
keystrokes: self.keystrokes.clone(),
|
|
}
|
|
}
|
|
}
|
|
/// Hit count for each command in the palette.
|
|
/// We only account for commands triggered directly via command palette and not by e.g. keystrokes because
|
|
/// if an user already knows a keystroke for a command, they are unlikely to use a command palette to look for it.
|
|
#[derive(Default)]
|
|
struct HitCounts(HashMap<String, usize>);
|
|
|
|
impl CommandPaletteDelegate {
|
|
fn new(
|
|
command_palette: WeakView<CommandPalette>,
|
|
commands: Vec<Command>,
|
|
previous_focus_handle: FocusHandle,
|
|
) -> Self {
|
|
Self {
|
|
command_palette,
|
|
matches: vec![],
|
|
commands,
|
|
selected_ix: 0,
|
|
previous_focus_handle,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PickerDelegate for CommandPaletteDelegate {
|
|
type ListItem = Div<Picker<Self>>;
|
|
|
|
fn placeholder_text(&self) -> Arc<str> {
|
|
"Execute a command...".into()
|
|
}
|
|
|
|
fn match_count(&self) -> usize {
|
|
self.matches.len()
|
|
}
|
|
|
|
fn selected_index(&self) -> usize {
|
|
self.selected_ix
|
|
}
|
|
|
|
fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Picker<Self>>) {
|
|
self.selected_ix = ix;
|
|
}
|
|
|
|
fn update_matches(
|
|
&mut self,
|
|
query: String,
|
|
cx: &mut ViewContext<Picker<Self>>,
|
|
) -> gpui::Task<()> {
|
|
let mut commands = self.commands.clone();
|
|
|
|
cx.spawn(move |picker, mut cx| async move {
|
|
cx.read_global::<HitCounts, _>(|hit_counts, _| {
|
|
commands.sort_by_key(|action| {
|
|
(
|
|
Reverse(hit_counts.0.get(&action.name).cloned()),
|
|
action.name.clone(),
|
|
)
|
|
});
|
|
})
|
|
.ok();
|
|
|
|
let candidates = commands
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(ix, command)| StringMatchCandidate {
|
|
id: ix,
|
|
string: command.name.to_string(),
|
|
char_bag: command.name.chars().collect(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let mut matches = if query.is_empty() {
|
|
candidates
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(index, candidate)| StringMatch {
|
|
candidate_id: index,
|
|
string: candidate.string,
|
|
positions: Vec::new(),
|
|
score: 0.0,
|
|
})
|
|
.collect()
|
|
} else {
|
|
fuzzy::match_strings(
|
|
&candidates,
|
|
&query,
|
|
true,
|
|
10000,
|
|
&Default::default(),
|
|
cx.background_executor().clone(),
|
|
)
|
|
.await
|
|
};
|
|
|
|
let mut intercept_result = cx
|
|
.try_read_global(|interceptor: &CommandPaletteInterceptor, cx| {
|
|
(interceptor)(&query, cx)
|
|
})
|
|
.flatten();
|
|
|
|
if *RELEASE_CHANNEL == ReleaseChannel::Dev {
|
|
if parse_zed_link(&query).is_some() {
|
|
intercept_result = Some(CommandInterceptResult {
|
|
action: OpenZedURL { url: query.clone() }.boxed_clone(),
|
|
string: query.clone(),
|
|
positions: vec![],
|
|
})
|
|
}
|
|
}
|
|
if let Some(CommandInterceptResult {
|
|
action,
|
|
string,
|
|
positions,
|
|
}) = intercept_result
|
|
{
|
|
if let Some(idx) = matches
|
|
.iter()
|
|
.position(|m| commands[m.candidate_id].action.type_id() == action.type_id())
|
|
{
|
|
matches.remove(idx);
|
|
}
|
|
commands.push(Command {
|
|
name: string.clone(),
|
|
action,
|
|
keystrokes: vec![],
|
|
});
|
|
matches.insert(
|
|
0,
|
|
StringMatch {
|
|
candidate_id: commands.len() - 1,
|
|
string,
|
|
positions,
|
|
score: 0.0,
|
|
},
|
|
)
|
|
}
|
|
picker
|
|
.update(&mut cx, |picker, _| {
|
|
let delegate = &mut picker.delegate;
|
|
delegate.commands = commands;
|
|
delegate.matches = matches;
|
|
if delegate.matches.is_empty() {
|
|
delegate.selected_ix = 0;
|
|
} else {
|
|
delegate.selected_ix =
|
|
cmp::min(delegate.selected_ix, delegate.matches.len() - 1);
|
|
}
|
|
})
|
|
.log_err();
|
|
})
|
|
}
|
|
|
|
fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
|
|
self.command_palette
|
|
.update(cx, |_, cx| cx.emit(ModalEvent::Dismissed))
|
|
.log_err();
|
|
}
|
|
|
|
fn confirm(&mut self, _: bool, cx: &mut ViewContext<Picker<Self>>) {
|
|
if self.matches.is_empty() {
|
|
self.dismissed(cx);
|
|
return;
|
|
}
|
|
let action_ix = self.matches[self.selected_ix].candidate_id;
|
|
let command = self.commands.swap_remove(action_ix);
|
|
cx.update_global(|hit_counts: &mut HitCounts, _| {
|
|
*hit_counts.0.entry(command.name).or_default() += 1;
|
|
});
|
|
let action = command.action;
|
|
cx.focus(&self.previous_focus_handle);
|
|
cx.dispatch_action(action);
|
|
self.dismissed(cx);
|
|
}
|
|
|
|
fn render_match(
|
|
&self,
|
|
ix: usize,
|
|
selected: bool,
|
|
cx: &mut ViewContext<Picker<Self>>,
|
|
) -> Self::ListItem {
|
|
let colors = cx.theme().colors();
|
|
let Some(r#match) = self.matches.get(ix) else {
|
|
return div();
|
|
};
|
|
let Some(command) = self.commands.get(r#match.candidate_id) else {
|
|
return div();
|
|
};
|
|
|
|
div()
|
|
.px_1()
|
|
.text_color(colors.text)
|
|
.text_ui()
|
|
.bg(colors.ghost_element_background)
|
|
.rounded_md()
|
|
.when(selected, |this| this.bg(colors.ghost_element_selected))
|
|
.hover(|this| this.bg(colors.ghost_element_hover))
|
|
.child(
|
|
h_stack()
|
|
.justify_between()
|
|
.child(HighlightedLabel::new(
|
|
command.name.clone(),
|
|
r#match.positions.clone(),
|
|
))
|
|
.children(KeyBinding::for_action(&*command.action, cx)),
|
|
)
|
|
}
|
|
}
|
|
|
|
fn humanize_action_name(name: &str) -> String {
|
|
let capacity = name.len() + name.chars().filter(|c| c.is_uppercase()).count();
|
|
let mut result = String::with_capacity(capacity);
|
|
for char in name.chars() {
|
|
if char == ':' {
|
|
if result.ends_with(':') {
|
|
result.push(' ');
|
|
} else {
|
|
result.push(':');
|
|
}
|
|
} else if char == '_' {
|
|
result.push(' ');
|
|
} else if char.is_uppercase() {
|
|
if !result.ends_with(' ') {
|
|
result.push(' ');
|
|
}
|
|
result.extend(char.to_lowercase());
|
|
} else {
|
|
result.push(char);
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
impl std::fmt::Debug for Command {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("Command")
|
|
.field("name", &self.name)
|
|
.field("keystrokes", &self.keystrokes)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
// #[cfg(test)]
|
|
// mod tests {
|
|
// use std::sync::Arc;
|
|
|
|
// use super::*;
|
|
// use editor::Editor;
|
|
// use gpui::{executor::Deterministic, TestAppContext};
|
|
// use project::Project;
|
|
// use workspace::{AppState, Workspace};
|
|
|
|
// #[test]
|
|
// fn test_humanize_action_name() {
|
|
// assert_eq!(
|
|
// humanize_action_name("editor::GoToDefinition"),
|
|
// "editor: go to definition"
|
|
// );
|
|
// assert_eq!(
|
|
// humanize_action_name("editor::Backspace"),
|
|
// "editor: backspace"
|
|
// );
|
|
// assert_eq!(
|
|
// humanize_action_name("go_to_line::Deploy"),
|
|
// "go to line: deploy"
|
|
// );
|
|
// }
|
|
|
|
// #[gpui::test]
|
|
// async fn test_command_palette(deterministic: Arc<Deterministic>, cx: &mut TestAppContext) {
|
|
// let app_state = init_test(cx);
|
|
|
|
// let project = Project::test(app_state.fs.clone(), [], cx).await;
|
|
// let window = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
|
|
// let workspace = window.root(cx);
|
|
// let editor = window.add_view(cx, |cx| {
|
|
// let mut editor = Editor::single_line(None, cx);
|
|
// editor.set_text("abc", cx);
|
|
// editor
|
|
// });
|
|
|
|
// workspace.update(cx, |workspace, cx| {
|
|
// cx.focus(&editor);
|
|
// workspace.add_item(Box::new(editor.clone()), cx)
|
|
// });
|
|
|
|
// workspace.update(cx, |workspace, cx| {
|
|
// toggle_command_palette(workspace, &Toggle, cx);
|
|
// });
|
|
|
|
// let palette = workspace.read_with(cx, |workspace, _| {
|
|
// workspace.modal::<CommandPalette>().unwrap()
|
|
// });
|
|
|
|
// palette
|
|
// .update(cx, |palette, cx| {
|
|
// // Fill up palette's command list by running an empty query;
|
|
// // we only need it to subsequently assert that the palette is initially
|
|
// // sorted by command's name.
|
|
// palette.delegate_mut().update_matches("".to_string(), cx)
|
|
// })
|
|
// .await;
|
|
|
|
// palette.update(cx, |palette, _| {
|
|
// let is_sorted =
|
|
// |actions: &[Command]| actions.windows(2).all(|pair| pair[0].name <= pair[1].name);
|
|
// assert!(is_sorted(&palette.delegate().actions));
|
|
// });
|
|
|
|
// palette
|
|
// .update(cx, |palette, cx| {
|
|
// palette
|
|
// .delegate_mut()
|
|
// .update_matches("bcksp".to_string(), cx)
|
|
// })
|
|
// .await;
|
|
|
|
// palette.update(cx, |palette, cx| {
|
|
// assert_eq!(palette.delegate().matches[0].string, "editor: backspace");
|
|
// palette.confirm(&Default::default(), cx);
|
|
// });
|
|
// deterministic.run_until_parked();
|
|
// editor.read_with(cx, |editor, cx| {
|
|
// assert_eq!(editor.text(cx), "ab");
|
|
// });
|
|
|
|
// // Add namespace filter, and redeploy the palette
|
|
// cx.update(|cx| {
|
|
// cx.update_default_global::<CommandPaletteFilter, _, _>(|filter, _| {
|
|
// filter.filtered_namespaces.insert("editor");
|
|
// })
|
|
// });
|
|
|
|
// workspace.update(cx, |workspace, cx| {
|
|
// toggle_command_palette(workspace, &Toggle, cx);
|
|
// });
|
|
|
|
// // Assert editor command not present
|
|
// let palette = workspace.read_with(cx, |workspace, _| {
|
|
// workspace.modal::<CommandPalette>().unwrap()
|
|
// });
|
|
|
|
// palette
|
|
// .update(cx, |palette, cx| {
|
|
// palette
|
|
// .delegate_mut()
|
|
// .update_matches("bcksp".to_string(), cx)
|
|
// })
|
|
// .await;
|
|
|
|
// palette.update(cx, |palette, _| {
|
|
// assert!(palette.delegate().matches.is_empty())
|
|
// });
|
|
// }
|
|
|
|
// fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
|
|
// cx.update(|cx| {
|
|
// let app_state = AppState::test(cx);
|
|
// theme::init(cx);
|
|
// language::init(cx);
|
|
// editor::init(cx);
|
|
// workspace::init(app_state.clone(), cx);
|
|
// init(cx);
|
|
// Project::init_settings(cx);
|
|
// app_state
|
|
// })
|
|
// }
|
|
// }
|