1use ::settings::Settings;
2use editor::{tasks::task_context, Editor};
3use gpui::{AppContext, Task as AsyncTask, ViewContext, WindowContext};
4use modal::{TaskOverrides, TasksModal};
5use project::{Location, WorktreeId};
6use task::{RevealTarget, TaskId};
7use workspace::tasks::schedule_task;
8use workspace::{tasks::schedule_resolved_task, Workspace};
9
10mod modal;
11mod settings;
12
13pub use modal::{Rerun, Spawn};
14
15pub fn init(cx: &mut AppContext) {
16 settings::TaskSettings::register(cx);
17 cx.observe_new_views(
18 |workspace: &mut Workspace, _: &mut ViewContext<Workspace>| {
19 workspace
20 .register_action(spawn_task_or_modal)
21 .register_action(move |workspace, action: &modal::Rerun, cx| {
22 if let Some((task_source_kind, mut last_scheduled_task)) = workspace
23 .project()
24 .read(cx)
25 .task_store()
26 .read(cx)
27 .task_inventory()
28 .and_then(|inventory| {
29 inventory.read(cx).last_scheduled_task(
30 action
31 .task_id
32 .as_ref()
33 .map(|id| TaskId(id.clone()))
34 .as_ref(),
35 )
36 })
37 {
38 if action.reevaluate_context {
39 let mut original_task = last_scheduled_task.original_task().clone();
40 if let Some(allow_concurrent_runs) = action.allow_concurrent_runs {
41 original_task.allow_concurrent_runs = allow_concurrent_runs;
42 }
43 if let Some(use_new_terminal) = action.use_new_terminal {
44 original_task.use_new_terminal = use_new_terminal;
45 }
46 let context_task = task_context(workspace, cx);
47 cx.spawn(|workspace, mut cx| async move {
48 let task_context = context_task.await;
49 workspace
50 .update(&mut cx, |workspace, cx| {
51 schedule_task(
52 workspace,
53 task_source_kind,
54 &original_task,
55 &task_context,
56 false,
57 cx,
58 )
59 })
60 .ok()
61 })
62 .detach()
63 } else {
64 if let Some(resolved) = last_scheduled_task.resolved.as_mut() {
65 if let Some(allow_concurrent_runs) = action.allow_concurrent_runs {
66 resolved.allow_concurrent_runs = allow_concurrent_runs;
67 }
68 if let Some(use_new_terminal) = action.use_new_terminal {
69 resolved.use_new_terminal = use_new_terminal;
70 }
71 }
72
73 schedule_resolved_task(
74 workspace,
75 task_source_kind,
76 last_scheduled_task,
77 false,
78 cx,
79 );
80 }
81 } else {
82 toggle_modal(workspace, None, cx).detach();
83 };
84 });
85 },
86 )
87 .detach();
88}
89
90fn spawn_task_or_modal(workspace: &mut Workspace, action: &Spawn, cx: &mut ViewContext<Workspace>) {
91 match action {
92 Spawn::ByName {
93 task_name,
94 reveal_target,
95 } => {
96 let overrides = reveal_target.map(|reveal_target| TaskOverrides {
97 reveal_target: Some(reveal_target),
98 });
99 spawn_task_with_name(task_name.clone(), overrides, cx).detach_and_log_err(cx)
100 }
101 Spawn::ViaModal { reveal_target } => toggle_modal(workspace, *reveal_target, cx).detach(),
102 }
103}
104
105fn toggle_modal(
106 workspace: &mut Workspace,
107 reveal_target: Option<RevealTarget>,
108 cx: &mut ViewContext<Workspace>,
109) -> AsyncTask<()> {
110 let task_store = workspace.project().read(cx).task_store().clone();
111 let workspace_handle = workspace.weak_handle();
112 let can_open_modal = workspace.project().update(cx, |project, cx| {
113 project.is_local() || project.ssh_connection_string(cx).is_some() || project.is_via_ssh()
114 });
115 if can_open_modal {
116 let context_task = task_context(workspace, cx);
117 cx.spawn(|workspace, mut cx| async move {
118 let task_context = context_task.await;
119 workspace
120 .update(&mut cx, |workspace, cx| {
121 workspace.toggle_modal(cx, |cx| {
122 TasksModal::new(
123 task_store.clone(),
124 task_context,
125 reveal_target.map(|target| TaskOverrides {
126 reveal_target: Some(target),
127 }),
128 workspace_handle,
129 cx,
130 )
131 })
132 })
133 .ok();
134 })
135 } else {
136 AsyncTask::ready(())
137 }
138}
139
140fn spawn_task_with_name(
141 name: String,
142 overrides: Option<TaskOverrides>,
143 cx: &mut ViewContext<Workspace>,
144) -> AsyncTask<anyhow::Result<()>> {
145 cx.spawn(|workspace, mut cx| async move {
146 let context_task =
147 workspace.update(&mut cx, |workspace, cx| task_context(workspace, cx))?;
148 let task_context = context_task.await;
149 let tasks = workspace.update(&mut cx, |workspace, cx| {
150 let Some(task_inventory) = workspace
151 .project()
152 .read(cx)
153 .task_store()
154 .read(cx)
155 .task_inventory()
156 .cloned()
157 else {
158 return Vec::new();
159 };
160 let (worktree, location) = active_item_selection_properties(workspace, cx);
161 let (file, language) = location
162 .map(|location| {
163 let buffer = location.buffer.read(cx);
164 (
165 buffer.file().cloned(),
166 buffer.language_at(location.range.start),
167 )
168 })
169 .unwrap_or_default();
170 task_inventory
171 .read(cx)
172 .list_tasks(file, language, worktree, cx)
173 })?;
174
175 let did_spawn = workspace
176 .update(&mut cx, |workspace, cx| {
177 let (task_source_kind, mut target_task) =
178 tasks.into_iter().find(|(_, task)| task.label == name)?;
179 if let Some(overrides) = &overrides {
180 if let Some(target_override) = overrides.reveal_target {
181 target_task.reveal_target = target_override;
182 }
183 }
184 schedule_task(
185 workspace,
186 task_source_kind,
187 &target_task,
188 &task_context,
189 false,
190 cx,
191 );
192 Some(())
193 })?
194 .is_some();
195 if !did_spawn {
196 workspace
197 .update(&mut cx, |workspace, cx| {
198 spawn_task_or_modal(
199 workspace,
200 &Spawn::ViaModal {
201 reveal_target: overrides.and_then(|overrides| overrides.reveal_target),
202 },
203 cx,
204 );
205 })
206 .ok();
207 }
208
209 Ok(())
210 })
211}
212
213fn active_item_selection_properties(
214 workspace: &Workspace,
215 cx: &mut WindowContext,
216) -> (Option<WorktreeId>, Option<Location>) {
217 let active_item = workspace.active_item(cx);
218 let worktree_id = active_item
219 .as_ref()
220 .and_then(|item| item.project_path(cx))
221 .map(|path| path.worktree_id);
222 let location = active_item
223 .and_then(|active_item| active_item.act_as::<Editor>(cx))
224 .and_then(|editor| {
225 editor.update(cx, |editor, cx| {
226 let selection = editor.selections.newest_anchor();
227 let multi_buffer = editor.buffer().clone();
228 let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
229 let (buffer_snapshot, buffer_offset) =
230 multi_buffer_snapshot.point_to_buffer_offset(selection.head())?;
231 let buffer_anchor = buffer_snapshot.anchor_before(buffer_offset);
232 let buffer = multi_buffer.read(cx).buffer(buffer_snapshot.remote_id())?;
233 Some(Location {
234 buffer,
235 range: buffer_anchor..buffer_anchor,
236 })
237 })
238 });
239 (worktree_id, location)
240}
241
242#[cfg(test)]
243mod tests {
244 use std::{collections::HashMap, sync::Arc};
245
246 use editor::Editor;
247 use gpui::{Entity, TestAppContext};
248 use language::{Language, LanguageConfig};
249 use project::{task_store::TaskStore, BasicContextProvider, FakeFs, Project};
250 use serde_json::json;
251 use task::{TaskContext, TaskVariables, VariableName};
252 use ui::VisualContext;
253 use workspace::{AppState, Workspace};
254
255 use crate::task_context;
256
257 #[gpui::test]
258 async fn test_default_language_context(cx: &mut TestAppContext) {
259 init_test(cx);
260 let fs = FakeFs::new(cx.executor());
261 fs.insert_tree(
262 "/dir",
263 json!({
264 ".zed": {
265 "tasks.json": r#"[
266 {
267 "label": "example task",
268 "command": "echo",
269 "args": ["4"]
270 },
271 {
272 "label": "another one",
273 "command": "echo",
274 "args": ["55"]
275 },
276 ]"#,
277 },
278 "a.ts": "function this_is_a_test() { }",
279 "rust": {
280 "b.rs": "use std; fn this_is_a_rust_file() { }",
281 }
282
283 }),
284 )
285 .await;
286 let project = Project::test(fs, ["/dir".as_ref()], cx).await;
287 let worktree_store = project.update(cx, |project, _| project.worktree_store().clone());
288 let rust_language = Arc::new(
289 Language::new(
290 LanguageConfig::default(),
291 Some(tree_sitter_rust::LANGUAGE.into()),
292 )
293 .with_outline_query(
294 r#"(function_item
295 "fn" @context
296 name: (_) @name) @item"#,
297 )
298 .unwrap()
299 .with_context_provider(Some(Arc::new(BasicContextProvider::new(
300 worktree_store.clone(),
301 )))),
302 );
303
304 let typescript_language = Arc::new(
305 Language::new(
306 LanguageConfig::default(),
307 Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
308 )
309 .with_outline_query(
310 r#"(function_declaration
311 "async"? @context
312 "function" @context
313 name: (_) @name
314 parameters: (formal_parameters
315 "(" @context
316 ")" @context)) @item"#,
317 )
318 .unwrap()
319 .with_context_provider(Some(Arc::new(BasicContextProvider::new(
320 worktree_store.clone(),
321 )))),
322 );
323
324 let worktree_id = project.update(cx, |project, cx| {
325 project.worktrees(cx).next().unwrap().read(cx).id()
326 });
327 let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
328
329 let buffer1 = workspace
330 .update(cx, |this, cx| {
331 this.project()
332 .update(cx, |this, cx| this.open_buffer((worktree_id, "a.ts"), cx))
333 })
334 .await
335 .unwrap();
336 buffer1.update(cx, |this, cx| {
337 this.set_language(Some(typescript_language), cx)
338 });
339 let editor1 = cx.new_view(|cx| Editor::for_buffer(buffer1, Some(project.clone()), cx));
340 let buffer2 = workspace
341 .update(cx, |this, cx| {
342 this.project().update(cx, |this, cx| {
343 this.open_buffer((worktree_id, "rust/b.rs"), cx)
344 })
345 })
346 .await
347 .unwrap();
348 buffer2.update(cx, |this, cx| this.set_language(Some(rust_language), cx));
349 let editor2 = cx.new_view(|cx| Editor::for_buffer(buffer2, Some(project), cx));
350
351 let first_context = workspace
352 .update(cx, |workspace, cx| {
353 workspace.add_item_to_center(Box::new(editor1.clone()), cx);
354 workspace.add_item_to_center(Box::new(editor2.clone()), cx);
355 assert_eq!(
356 workspace.active_item(cx).unwrap().item_id(),
357 editor2.entity_id()
358 );
359 task_context(workspace, cx)
360 })
361 .await;
362 assert_eq!(
363 first_context,
364 TaskContext {
365 cwd: Some("/dir".into()),
366 task_variables: TaskVariables::from_iter([
367 (VariableName::File, "/dir/rust/b.rs".into()),
368 (VariableName::Filename, "b.rs".into()),
369 (VariableName::RelativeFile, "rust/b.rs".into()),
370 (VariableName::Dirname, "/dir/rust".into()),
371 (VariableName::Stem, "b".into()),
372 (VariableName::WorktreeRoot, "/dir".into()),
373 (VariableName::Row, "1".into()),
374 (VariableName::Column, "1".into()),
375 ]),
376 project_env: HashMap::default(),
377 }
378 );
379
380 // And now, let's select an identifier.
381 editor2.update(cx, |editor, cx| {
382 editor.change_selections(None, cx, |selections| selections.select_ranges([14..18]))
383 });
384
385 assert_eq!(
386 workspace
387 .update(cx, |workspace, cx| { task_context(workspace, cx) })
388 .await,
389 TaskContext {
390 cwd: Some("/dir".into()),
391 task_variables: TaskVariables::from_iter([
392 (VariableName::File, "/dir/rust/b.rs".into()),
393 (VariableName::Filename, "b.rs".into()),
394 (VariableName::RelativeFile, "rust/b.rs".into()),
395 (VariableName::Dirname, "/dir/rust".into()),
396 (VariableName::Stem, "b".into()),
397 (VariableName::WorktreeRoot, "/dir".into()),
398 (VariableName::Row, "1".into()),
399 (VariableName::Column, "15".into()),
400 (VariableName::SelectedText, "is_i".into()),
401 (VariableName::Symbol, "this_is_a_rust_file".into()),
402 ]),
403 project_env: HashMap::default(),
404 }
405 );
406
407 assert_eq!(
408 workspace
409 .update(cx, |workspace, cx| {
410 // Now, let's switch the active item to .ts file.
411 workspace.activate_item(&editor1, true, true, cx);
412 task_context(workspace, cx)
413 })
414 .await,
415 TaskContext {
416 cwd: Some("/dir".into()),
417 task_variables: TaskVariables::from_iter([
418 (VariableName::File, "/dir/a.ts".into()),
419 (VariableName::Filename, "a.ts".into()),
420 (VariableName::RelativeFile, "a.ts".into()),
421 (VariableName::Dirname, "/dir".into()),
422 (VariableName::Stem, "a".into()),
423 (VariableName::WorktreeRoot, "/dir".into()),
424 (VariableName::Row, "1".into()),
425 (VariableName::Column, "1".into()),
426 (VariableName::Symbol, "this_is_a_test".into()),
427 ]),
428 project_env: HashMap::default(),
429 }
430 );
431 }
432
433 pub(crate) fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
434 cx.update(|cx| {
435 let state = AppState::test(cx);
436 file_icons::init((), cx);
437 language::init(cx);
438 crate::init(cx);
439 editor::init(cx);
440 workspace::init_settings(cx);
441 Project::init_settings(cx);
442 TaskStore::init(None);
443 state
444 })
445 }
446}