1use file_finder::file_finder_settings::FileFinderSettings;
2use file_icons::FileIcons;
3use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
4use gpui::{
5 App, Context, DismissEvent, Entity, EventEmitter, Focusable, ParentElement, Render, Styled,
6 WeakEntity, Window, actions,
7};
8use language::{LanguageMatcher, LanguageName, LanguageRegistry};
9use paths::snippets_dir;
10use picker::{Picker, PickerDelegate};
11use settings::Settings;
12use std::{
13 borrow::{Borrow, Cow},
14 collections::HashSet,
15 fs,
16 path::Path,
17 sync::Arc,
18};
19use ui::{HighlightedLabel, ListItem, ListItemSpacing, prelude::*};
20use util::ResultExt;
21use workspace::{ModalView, OpenOptions, OpenVisible, Workspace, notifications::NotifyResultExt};
22
23#[derive(Eq, Hash, PartialEq)]
24struct ScopeName(Cow<'static, str>);
25
26struct ScopeFileName(Cow<'static, str>);
27
28impl ScopeFileName {
29 fn with_extension(self) -> String {
30 format!("{}.json", self.0)
31 }
32}
33
34const GLOBAL_SCOPE_NAME: &str = "global";
35const GLOBAL_SCOPE_FILE_NAME: &str = "snippets";
36
37impl From<ScopeName> for ScopeFileName {
38 fn from(value: ScopeName) -> Self {
39 if value.0 == GLOBAL_SCOPE_NAME {
40 ScopeFileName(Cow::Borrowed(GLOBAL_SCOPE_FILE_NAME))
41 } else {
42 ScopeFileName(value.0)
43 }
44 }
45}
46
47impl From<ScopeFileName> for ScopeName {
48 fn from(value: ScopeFileName) -> Self {
49 if value.0 == GLOBAL_SCOPE_FILE_NAME {
50 ScopeName(Cow::Borrowed(GLOBAL_SCOPE_NAME))
51 } else {
52 ScopeName(value.0)
53 }
54 }
55}
56
57actions!(
58 snippets,
59 [
60 /// Opens the snippets configuration file.
61 ConfigureSnippets,
62 /// Opens the snippets folder in the file manager.
63 OpenFolder
64 ]
65);
66
67pub fn init(cx: &mut App) {
68 cx.observe_new(register).detach();
69}
70
71fn register(workspace: &mut Workspace, _window: Option<&mut Window>, _: &mut Context<Workspace>) {
72 workspace.register_action(configure_snippets);
73 workspace.register_action(open_folder);
74}
75
76fn configure_snippets(
77 workspace: &mut Workspace,
78 _: &ConfigureSnippets,
79 window: &mut Window,
80 cx: &mut Context<Workspace>,
81) {
82 let language_registry = workspace.app_state().languages.clone();
83 let workspace_handle = workspace.weak_handle();
84
85 workspace.toggle_modal(window, cx, move |window, cx| {
86 ScopeSelector::new(language_registry, workspace_handle, window, cx)
87 });
88}
89
90fn open_folder(
91 workspace: &mut Workspace,
92 _: &OpenFolder,
93 _: &mut Window,
94 cx: &mut Context<Workspace>,
95) {
96 fs::create_dir_all(snippets_dir()).notify_err(workspace, cx);
97 cx.open_with_system(snippets_dir().borrow());
98}
99
100pub struct ScopeSelector {
101 picker: Entity<Picker<ScopeSelectorDelegate>>,
102}
103
104impl ScopeSelector {
105 fn new(
106 language_registry: Arc<LanguageRegistry>,
107 workspace: WeakEntity<Workspace>,
108 window: &mut Window,
109 cx: &mut Context<Self>,
110 ) -> Self {
111 let delegate =
112 ScopeSelectorDelegate::new(workspace, cx.entity().downgrade(), language_registry);
113
114 let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
115
116 Self { picker }
117 }
118}
119
120impl ModalView for ScopeSelector {}
121
122impl EventEmitter<DismissEvent> for ScopeSelector {}
123
124impl Focusable for ScopeSelector {
125 fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
126 self.picker.focus_handle(cx)
127 }
128}
129
130impl Render for ScopeSelector {
131 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
132 v_flex().w(rems(34.)).child(self.picker.clone())
133 }
134}
135
136pub struct ScopeSelectorDelegate {
137 workspace: WeakEntity<Workspace>,
138 scope_selector: WeakEntity<ScopeSelector>,
139 language_registry: Arc<LanguageRegistry>,
140 candidates: Vec<StringMatchCandidate>,
141 matches: Vec<StringMatch>,
142 selected_index: usize,
143 existing_scopes: HashSet<ScopeName>,
144}
145
146impl ScopeSelectorDelegate {
147 fn new(
148 workspace: WeakEntity<Workspace>,
149 scope_selector: WeakEntity<ScopeSelector>,
150 language_registry: Arc<LanguageRegistry>,
151 ) -> Self {
152 let languages = language_registry.language_names().into_iter();
153
154 let candidates = std::iter::once(LanguageName::new(GLOBAL_SCOPE_NAME))
155 .chain(languages)
156 .enumerate()
157 .map(|(candidate_id, name)| StringMatchCandidate::new(candidate_id, name.as_ref()))
158 .collect::<Vec<_>>();
159
160 let mut existing_scopes = HashSet::new();
161
162 if let Some(read_dir) = fs::read_dir(snippets_dir()).log_err() {
163 for entry in read_dir {
164 if let Some(entry) = entry.log_err() {
165 let path = entry.path();
166 if let (Some(stem), Some(extension)) = (path.file_stem(), path.extension())
167 && extension.to_os_string().to_str() == Some("json")
168 && let Ok(file_name) = stem.to_os_string().into_string()
169 {
170 existing_scopes
171 .insert(ScopeName::from(ScopeFileName(Cow::Owned(file_name))));
172 }
173 }
174 }
175 }
176
177 Self {
178 workspace,
179 scope_selector,
180 language_registry,
181 candidates,
182 matches: Vec::new(),
183 selected_index: 0,
184 existing_scopes,
185 }
186 }
187
188 fn scope_icon(&self, matcher: &LanguageMatcher, cx: &App) -> Option<Icon> {
189 matcher
190 .path_suffixes
191 .iter()
192 .find_map(|extension| FileIcons::get_icon(Path::new(extension), cx))
193 .or(FileIcons::get(cx).get_icon_for_type("default", cx))
194 .map(Icon::from_path)
195 .map(|icon| icon.color(Color::Muted))
196 }
197}
198
199impl PickerDelegate for ScopeSelectorDelegate {
200 type ListItem = ListItem;
201
202 fn placeholder_text(&self, _window: &mut Window, _: &mut App) -> Arc<str> {
203 "Select snippet scope...".into()
204 }
205
206 fn match_count(&self) -> usize {
207 self.matches.len()
208 }
209
210 fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
211 if let Some(mat) = self.matches.get(self.selected_index) {
212 let scope_name = self.candidates[mat.candidate_id].string.clone();
213 let language = self.language_registry.language_for_name(&scope_name);
214
215 if let Some(workspace) = self.workspace.upgrade() {
216 cx.spawn_in(window, async move |_, cx| {
217 let scope_file_name = ScopeFileName(match scope_name.to_lowercase().as_str() {
218 GLOBAL_SCOPE_NAME => Cow::Borrowed(GLOBAL_SCOPE_FILE_NAME),
219 _ => Cow::Owned(language.await?.lsp_id()),
220 });
221
222 workspace.update_in(cx, |workspace, window, cx| {
223 workspace
224 .with_local_workspace(window, cx, |workspace, window, cx| {
225 workspace
226 .open_abs_path(
227 snippets_dir().join(scope_file_name.with_extension()),
228 OpenOptions {
229 visible: Some(OpenVisible::None),
230 ..Default::default()
231 },
232 window,
233 cx,
234 )
235 .detach();
236 })
237 .detach();
238 })
239 })
240 .detach_and_log_err(cx);
241 };
242 }
243 self.dismissed(window, cx);
244 }
245
246 fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
247 self.scope_selector
248 .update(cx, |_, cx| cx.emit(DismissEvent))
249 .log_err();
250 }
251
252 fn selected_index(&self) -> usize {
253 self.selected_index
254 }
255
256 fn set_selected_index(
257 &mut self,
258 ix: usize,
259 _window: &mut Window,
260 _: &mut Context<Picker<Self>>,
261 ) {
262 self.selected_index = ix;
263 }
264
265 fn update_matches(
266 &mut self,
267 query: String,
268 window: &mut Window,
269 cx: &mut Context<Picker<Self>>,
270 ) -> gpui::Task<()> {
271 let background = cx.background_executor().clone();
272 let candidates = self.candidates.clone();
273 cx.spawn_in(window, async move |this, cx| {
274 let matches = if query.is_empty() {
275 candidates
276 .into_iter()
277 .enumerate()
278 .map(|(index, candidate)| StringMatch {
279 candidate_id: index,
280 string: candidate.string,
281 positions: Vec::new(),
282 score: 0.0,
283 })
284 .collect()
285 } else {
286 match_strings(
287 &candidates,
288 &query,
289 false,
290 true,
291 100,
292 &Default::default(),
293 background,
294 )
295 .await
296 };
297
298 this.update(cx, |this, cx| {
299 let delegate = &mut this.delegate;
300 delegate.matches = matches;
301 delegate.selected_index = delegate
302 .selected_index
303 .min(delegate.matches.len().saturating_sub(1));
304 cx.notify();
305 })
306 .log_err();
307 })
308 }
309
310 fn render_match(
311 &self,
312 ix: usize,
313 selected: bool,
314 _window: &mut Window,
315 cx: &mut Context<Picker<Self>>,
316 ) -> Option<Self::ListItem> {
317 let mat = &self.matches.get(ix)?;
318 let name_label = mat.string.clone();
319
320 let scope_name = ScopeName(Cow::Owned(
321 LanguageName::new(&self.candidates[mat.candidate_id].string).lsp_id(),
322 ));
323 let file_label = if self.existing_scopes.contains(&scope_name) {
324 Some(ScopeFileName::from(scope_name).with_extension())
325 } else {
326 None
327 };
328
329 let language_icon = if FileFinderSettings::get_global(cx).file_icons {
330 let language_name = LanguageName::new(mat.string.as_str());
331 self.language_registry
332 .available_language_for_name(language_name.as_ref())
333 .and_then(|available_language| self.scope_icon(available_language.matcher(), cx))
334 .or_else(|| {
335 Some(
336 Icon::from_path(IconName::ToolWeb.path())
337 .map(|icon| icon.color(Color::Muted)),
338 )
339 })
340 } else {
341 None
342 };
343
344 Some(
345 ListItem::new(ix)
346 .inset(true)
347 .spacing(ListItemSpacing::Sparse)
348 .toggle_state(selected)
349 .start_slot::<Icon>(language_icon)
350 .child(
351 h_flex()
352 .gap_x_2()
353 .child(HighlightedLabel::new(name_label, mat.positions.clone()))
354 .when_some(file_label, |item, path_label| {
355 item.child(
356 Label::new(path_label)
357 .color(Color::Muted)
358 .size(LabelSize::Small),
359 )
360 }),
361 ),
362 )
363 }
364}