1use crate::{
2 editor::{buffer_view, BufferView},
3 settings::Settings,
4 util, watch,
5 workspace::{Workspace, WorkspaceView},
6 worktree::{match_paths, PathMatch, Worktree},
7};
8use gpui::{
9 color::{ColorF, ColorU},
10 elements::*,
11 fonts::{Properties, Weight},
12 geometry::vector::vec2f,
13 keymap::{self, Binding},
14 AppContext, Axis, Border, Entity, ModelHandle, MutableAppContext, View, ViewContext,
15 ViewHandle, WeakViewHandle,
16};
17use std::{
18 cmp,
19 path::Path,
20 sync::{
21 atomic::{self, AtomicBool},
22 Arc,
23 },
24};
25
26pub struct FileFinder {
27 handle: WeakViewHandle<Self>,
28 settings: watch::Receiver<Settings>,
29 workspace: ModelHandle<Workspace>,
30 query_buffer: ViewHandle<BufferView>,
31 search_count: usize,
32 latest_search_id: usize,
33 matches: Vec<PathMatch>,
34 include_root_name: bool,
35 selected: Option<Arc<Path>>,
36 cancel_flag: Arc<AtomicBool>,
37 list_state: UniformListState,
38}
39
40pub fn init(app: &mut MutableAppContext) {
41 app.add_action("file_finder:toggle", FileFinder::toggle);
42 app.add_action("file_finder:confirm", FileFinder::confirm);
43 app.add_action("file_finder:select", FileFinder::select);
44 app.add_action("menu:select_prev", FileFinder::select_prev);
45 app.add_action("menu:select_next", FileFinder::select_next);
46 app.add_action("uniform_list:scroll", FileFinder::scroll);
47
48 app.add_bindings(vec![
49 Binding::new("cmd-p", "file_finder:toggle", None),
50 Binding::new("escape", "file_finder:toggle", Some("FileFinder")),
51 Binding::new("enter", "file_finder:confirm", Some("FileFinder")),
52 ]);
53}
54
55pub enum Event {
56 Selected(usize, Arc<Path>),
57 Dismissed,
58}
59
60impl Entity for FileFinder {
61 type Event = Event;
62}
63
64impl View for FileFinder {
65 fn ui_name() -> &'static str {
66 "FileFinder"
67 }
68
69 fn render(&self, _: &AppContext) -> ElementBox {
70 Align::new(
71 ConstrainedBox::new(
72 Container::new(
73 Flex::new(Axis::Vertical)
74 .with_child(ChildView::new(self.query_buffer.id()).boxed())
75 .with_child(Expanded::new(1.0, self.render_matches()).boxed())
76 .boxed(),
77 )
78 .with_margin_top(12.0)
79 .with_uniform_padding(6.0)
80 .with_corner_radius(6.0)
81 .with_background_color(ColorU::from_u32(0xf2f2f2ff))
82 .with_shadow(vec2f(0., 4.), 12., ColorF::new(0.0, 0.0, 0.0, 0.25).to_u8())
83 .boxed(),
84 )
85 .with_max_width(600.0)
86 .with_max_height(400.0)
87 .boxed(),
88 )
89 .top()
90 .named("file finder")
91 }
92
93 fn on_focus(&mut self, ctx: &mut ViewContext<Self>) {
94 ctx.focus(&self.query_buffer);
95 }
96
97 fn keymap_context(&self, _: &AppContext) -> keymap::Context {
98 let mut ctx = Self::default_keymap_context();
99 ctx.set.insert("menu".into());
100 ctx
101 }
102}
103
104impl FileFinder {
105 fn render_matches(&self) -> ElementBox {
106 if self.matches.is_empty() {
107 let settings = smol::block_on(self.settings.read());
108 return Container::new(
109 Label::new(
110 "No matches".into(),
111 settings.ui_font_family,
112 settings.ui_font_size,
113 )
114 .boxed(),
115 )
116 .with_margin_top(6.0)
117 .named("empty matches");
118 }
119
120 let handle = self.handle.clone();
121 let list = UniformList::new(
122 self.list_state.clone(),
123 self.matches.len(),
124 move |mut range, items, app| {
125 let finder = handle.upgrade(app).unwrap();
126 let finder = finder.read(app);
127 let start = range.start;
128 range.end = cmp::min(range.end, finder.matches.len());
129 items.extend(finder.matches[range].iter().enumerate().filter_map(
130 move |(i, path_match)| finder.render_match(path_match, start + i, app),
131 ));
132 },
133 );
134
135 Container::new(list.boxed())
136 .with_background_color(ColorU::from_u32(0xf7f7f7ff))
137 .with_border(Border::all(1.0, ColorU::from_u32(0xdbdbdcff)))
138 .with_margin_top(6.0)
139 .named("matches")
140 }
141
142 fn render_match(
143 &self,
144 path_match: &PathMatch,
145 index: usize,
146 app: &AppContext,
147 ) -> Option<ElementBox> {
148 let tree_id = path_match.tree_id;
149
150 self.worktree(tree_id, app).map(|tree| {
151 let prefix = if self.include_root_name {
152 tree.root_name()
153 } else {
154 ""
155 };
156 let path = path_match.path.clone();
157 let path_string = path_match.path.to_string_lossy();
158 let file_name = path_match
159 .path
160 .file_name()
161 .unwrap_or_default()
162 .to_string_lossy();
163
164 let path_positions = path_match.positions.clone();
165 let file_name_start =
166 prefix.len() + path_string.chars().count() - file_name.chars().count();
167 let mut file_name_positions = Vec::new();
168 file_name_positions.extend(path_positions.iter().filter_map(|pos| {
169 if pos >= &file_name_start {
170 Some(pos - file_name_start)
171 } else {
172 None
173 }
174 }));
175
176 let settings = smol::block_on(self.settings.read());
177 let highlight_color = ColorU::from_u32(0x304ee2ff);
178 let bold = *Properties::new().weight(Weight::BOLD);
179
180 let mut full_path = prefix.to_string();
181 full_path.push_str(&path_string);
182
183 let mut container = Container::new(
184 Flex::row()
185 .with_child(
186 Container::new(
187 LineBox::new(
188 settings.ui_font_family,
189 settings.ui_font_size,
190 Svg::new("icons/file-16.svg").boxed(),
191 )
192 .boxed(),
193 )
194 .with_padding_right(6.0)
195 .boxed(),
196 )
197 .with_child(
198 Expanded::new(
199 1.0,
200 Flex::column()
201 .with_child(
202 Label::new(
203 file_name.to_string(),
204 settings.ui_font_family,
205 settings.ui_font_size,
206 )
207 .with_highlights(highlight_color, bold, file_name_positions)
208 .boxed(),
209 )
210 .with_child(
211 Label::new(
212 full_path,
213 settings.ui_font_family,
214 settings.ui_font_size,
215 )
216 .with_highlights(highlight_color, bold, path_positions)
217 .boxed(),
218 )
219 .boxed(),
220 )
221 .boxed(),
222 )
223 .boxed(),
224 )
225 .with_uniform_padding(6.0);
226
227 let selected_index = self.selected_index();
228 if index == selected_index || index < self.matches.len() - 1 {
229 container =
230 container.with_border(Border::bottom(1.0, ColorU::from_u32(0xdbdbdcff)));
231 }
232
233 if index == selected_index {
234 container = container.with_background_color(ColorU::from_u32(0xdbdbdcff));
235 }
236
237 EventHandler::new(container.boxed())
238 .on_mouse_down(move |ctx| {
239 ctx.dispatch_action("file_finder:select", (tree_id, path.clone()));
240 true
241 })
242 .named("match")
243 })
244 }
245
246 fn toggle(workspace_view: &mut WorkspaceView, _: &(), ctx: &mut ViewContext<WorkspaceView>) {
247 workspace_view.toggle_modal(ctx, |ctx, workspace_view| {
248 let handle = ctx.add_view(|ctx| {
249 Self::new(
250 workspace_view.settings.clone(),
251 workspace_view.workspace.clone(),
252 ctx,
253 )
254 });
255 ctx.subscribe_to_view(&handle, Self::on_event);
256 handle
257 });
258 }
259
260 fn on_event(
261 workspace_view: &mut WorkspaceView,
262 _: ViewHandle<FileFinder>,
263 event: &Event,
264 ctx: &mut ViewContext<WorkspaceView>,
265 ) {
266 match event {
267 Event::Selected(tree_id, path) => {
268 workspace_view.open_entry((*tree_id, path.clone()), ctx);
269 workspace_view.dismiss_modal(ctx);
270 }
271 Event::Dismissed => {
272 workspace_view.dismiss_modal(ctx);
273 }
274 }
275 }
276
277 pub fn new(
278 settings: watch::Receiver<Settings>,
279 workspace: ModelHandle<Workspace>,
280 ctx: &mut ViewContext<Self>,
281 ) -> Self {
282 ctx.observe(&workspace, Self::workspace_updated);
283
284 let query_buffer = ctx.add_view(|ctx| BufferView::single_line(settings.clone(), ctx));
285 ctx.subscribe_to_view(&query_buffer, Self::on_query_buffer_event);
286
287 settings.notify_view_on_change(ctx);
288
289 Self {
290 handle: ctx.handle().downgrade(),
291 settings,
292 workspace,
293 query_buffer,
294 search_count: 0,
295 latest_search_id: 0,
296 matches: Vec::new(),
297 include_root_name: false,
298 selected: None,
299 cancel_flag: Arc::new(AtomicBool::new(false)),
300 list_state: UniformListState::new(),
301 }
302 }
303
304 fn workspace_updated(&mut self, _: ModelHandle<Workspace>, ctx: &mut ViewContext<Self>) {
305 self.spawn_search(self.query_buffer.read(ctx).text(ctx.as_ref()), ctx);
306 }
307
308 fn on_query_buffer_event(
309 &mut self,
310 _: ViewHandle<BufferView>,
311 event: &buffer_view::Event,
312 ctx: &mut ViewContext<Self>,
313 ) {
314 use buffer_view::Event::*;
315 match event {
316 Edited => {
317 let query = self.query_buffer.read(ctx).text(ctx.as_ref());
318 if query.is_empty() {
319 self.latest_search_id = util::post_inc(&mut self.search_count);
320 self.matches.clear();
321 ctx.notify();
322 } else {
323 self.spawn_search(query, ctx);
324 }
325 }
326 Blurred => ctx.emit(Event::Dismissed),
327 _ => {}
328 }
329 }
330
331 fn selected_index(&self) -> usize {
332 if let Some(selected) = self.selected.as_ref() {
333 for (ix, path_match) in self.matches.iter().enumerate() {
334 if path_match.path.as_ref() == selected.as_ref() {
335 return ix;
336 }
337 }
338 }
339 0
340 }
341
342 fn select_prev(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
343 let mut selected_index = self.selected_index();
344 if selected_index > 0 {
345 selected_index -= 1;
346 self.selected = Some(self.matches[selected_index].path.clone());
347 }
348 self.list_state.scroll_to(selected_index);
349 ctx.notify();
350 }
351
352 fn select_next(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
353 let mut selected_index = self.selected_index();
354 if selected_index + 1 < self.matches.len() {
355 selected_index += 1;
356 self.selected = Some(self.matches[selected_index].path.clone());
357 }
358 self.list_state.scroll_to(selected_index);
359 ctx.notify();
360 }
361
362 fn scroll(&mut self, _: &f32, ctx: &mut ViewContext<Self>) {
363 ctx.notify();
364 }
365
366 fn confirm(&mut self, _: &(), ctx: &mut ViewContext<Self>) {
367 if let Some(m) = self.matches.get(self.selected_index()) {
368 ctx.emit(Event::Selected(m.tree_id, m.path.clone()));
369 }
370 }
371
372 fn select(&mut self, (tree_id, path): &(usize, Arc<Path>), ctx: &mut ViewContext<Self>) {
373 ctx.emit(Event::Selected(*tree_id, path.clone()));
374 }
375
376 fn spawn_search(&mut self, query: String, ctx: &mut ViewContext<Self>) {
377 let snapshots = self
378 .workspace
379 .read(ctx)
380 .worktrees()
381 .iter()
382 .map(|tree| tree.read(ctx).snapshot())
383 .collect::<Vec<_>>();
384 let search_id = util::post_inc(&mut self.search_count);
385 let pool = ctx.as_ref().thread_pool().clone();
386 self.cancel_flag.store(true, atomic::Ordering::Relaxed);
387 self.cancel_flag = Arc::new(AtomicBool::new(false));
388 let cancel_flag = self.cancel_flag.clone();
389 let task = ctx.background_executor().spawn(async move {
390 let include_root_name = snapshots.len() > 1;
391 let matches = match_paths(
392 snapshots.iter(),
393 &query,
394 include_root_name,
395 false,
396 false,
397 100,
398 cancel_flag,
399 pool,
400 );
401 (search_id, include_root_name, matches)
402 });
403
404 ctx.spawn(task, Self::update_matches).detach();
405 }
406
407 fn update_matches(
408 &mut self,
409 (search_id, include_root_name, matches): (usize, bool, Vec<PathMatch>),
410 ctx: &mut ViewContext<Self>,
411 ) {
412 if search_id >= self.latest_search_id {
413 self.latest_search_id = search_id;
414 self.matches = matches;
415 self.include_root_name = include_root_name;
416 self.list_state.scroll_to(self.selected_index());
417 ctx.notify();
418 }
419 }
420
421 fn worktree<'a>(&'a self, tree_id: usize, app: &'a AppContext) -> Option<&'a Worktree> {
422 self.workspace
423 .read(app)
424 .worktrees()
425 .get(&tree_id)
426 .map(|worktree| worktree.read(app))
427 }
428}
429
430#[cfg(test)]
431mod tests {
432 use super::*;
433 use crate::{
434 editor, settings,
435 workspace::{Workspace, WorkspaceView},
436 };
437 use gpui::App;
438 use smol::fs;
439 use tempdir::TempDir;
440
441 #[test]
442 fn test_matching_paths() {
443 App::test_async((), |mut app| async move {
444 let tmp_dir = TempDir::new("example").unwrap();
445 fs::create_dir(tmp_dir.path().join("a")).await.unwrap();
446 fs::write(tmp_dir.path().join("a/banana"), "banana")
447 .await
448 .unwrap();
449 fs::write(tmp_dir.path().join("a/bandana"), "bandana")
450 .await
451 .unwrap();
452 app.update(|ctx| {
453 super::init(ctx);
454 editor::init(ctx);
455 });
456
457 let settings = settings::channel(&app.font_cache()).unwrap().1;
458 let workspace = app.add_model(|ctx| Workspace::new(vec![tmp_dir.path().into()], ctx));
459 let (window_id, workspace_view) =
460 app.add_window(|ctx| WorkspaceView::new(workspace.clone(), settings, ctx));
461 app.read(|ctx| workspace.read(ctx).worktree_scans_complete(ctx))
462 .await;
463 app.dispatch_action(
464 window_id,
465 vec![workspace_view.id()],
466 "file_finder:toggle".into(),
467 (),
468 );
469
470 let finder = app.read(|ctx| {
471 workspace_view
472 .read(ctx)
473 .modal()
474 .cloned()
475 .unwrap()
476 .downcast::<FileFinder>()
477 .unwrap()
478 });
479 let query_buffer = app.read(|ctx| finder.read(ctx).query_buffer.clone());
480
481 let chain = vec![finder.id(), query_buffer.id()];
482 app.dispatch_action(window_id, chain.clone(), "buffer:insert", "b".to_string());
483 app.dispatch_action(window_id, chain.clone(), "buffer:insert", "n".to_string());
484 app.dispatch_action(window_id, chain.clone(), "buffer:insert", "a".to_string());
485 finder
486 .condition(&app, |finder, _| finder.matches.len() == 2)
487 .await;
488
489 let active_pane = app.read(|ctx| workspace_view.read(ctx).active_pane().clone());
490 app.dispatch_action(
491 window_id,
492 vec![workspace_view.id(), finder.id()],
493 "menu:select_next",
494 (),
495 );
496 app.dispatch_action(
497 window_id,
498 vec![workspace_view.id(), finder.id()],
499 "file_finder:confirm",
500 (),
501 );
502 active_pane
503 .condition(&app, |pane, _| pane.active_item().is_some())
504 .await;
505 app.read(|ctx| {
506 let active_item = active_pane.read(ctx).active_item().unwrap();
507 assert_eq!(active_item.title(ctx), "bandana");
508 });
509 });
510 }
511}