Rename runnables into tasks (#8119)

Release Notes:

- N/A

crates/tasks_ui/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "tasks_ui"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[dependencies]
+anyhow.workspace = true
+db.workspace = true
+editor.workspace = true
+fs.workspace = true
+futures.workspace = true
+fuzzy.workspace = true
+gpui.workspace = true
+log.workspace = true
+menu.workspace = true
+picker.workspace = true
+project.workspace = true
+task.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true

crates/tasks_ui/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/tasks_ui/src/lib.rs

@@ -0,0 +1,86 @@
+use std::path::PathBuf;
+
+use gpui::{AppContext, ViewContext, WindowContext};
+use modal::TasksModal;
+pub use oneshot_source::OneshotSource;
+use task::Task;
+use util::ResultExt;
+use workspace::Workspace;
+
+mod modal;
+mod oneshot_source;
+
+pub fn init(cx: &mut AppContext) {
+    cx.observe_new_views(
+        |workspace: &mut Workspace, _: &mut ViewContext<Workspace>| {
+            workspace
+                .register_action(|workspace, _: &modal::Spawn, cx| {
+                    let inventory = workspace.project().read(cx).task_inventory().clone();
+                    let workspace_handle = workspace.weak_handle();
+                    workspace
+                        .toggle_modal(cx, |cx| TasksModal::new(inventory, workspace_handle, cx))
+                })
+                .register_action(move |workspace, _: &modal::Rerun, cx| {
+                    if let Some(task) = workspace.project().update(cx, |project, cx| {
+                        project
+                            .task_inventory()
+                            .update(cx, |inventory, cx| inventory.last_scheduled_task(cx))
+                    }) {
+                        schedule_task(workspace, task.as_ref(), cx)
+                    };
+                });
+        },
+    )
+    .detach();
+}
+
+fn schedule_task(workspace: &Workspace, task: &dyn Task, cx: &mut ViewContext<'_, Workspace>) {
+    let cwd = match task.cwd() {
+        Some(cwd) => Some(cwd.to_path_buf()),
+        None => task_cwd(workspace, cx).log_err().flatten(),
+    };
+    let spawn_in_terminal = task.exec(cwd);
+    if let Some(spawn_in_terminal) = spawn_in_terminal {
+        workspace.project().update(cx, |project, cx| {
+            project.task_inventory().update(cx, |inventory, _| {
+                inventory.last_scheduled_task = Some(task.id().clone());
+            })
+        });
+        cx.emit(workspace::Event::SpawnTask(spawn_in_terminal));
+    }
+}
+
+fn task_cwd(workspace: &Workspace, cx: &mut WindowContext) -> anyhow::Result<Option<PathBuf>> {
+    let project = workspace.project().read(cx);
+    let available_worktrees = project
+        .worktrees()
+        .filter(|worktree| {
+            let worktree = worktree.read(cx);
+            worktree.is_visible()
+                && worktree.is_local()
+                && worktree.root_entry().map_or(false, |e| e.is_dir())
+        })
+        .collect::<Vec<_>>();
+    let cwd = match available_worktrees.len() {
+        0 => None,
+        1 => Some(available_worktrees[0].read(cx).abs_path()),
+        _ => {
+            let cwd_for_active_entry = project.active_entry().and_then(|entry_id| {
+                available_worktrees.into_iter().find_map(|worktree| {
+                    let worktree = worktree.read(cx);
+                    if worktree.contains_entry(entry_id) {
+                        Some(worktree.abs_path())
+                    } else {
+                        None
+                    }
+                })
+            });
+            anyhow::ensure!(
+                cwd_for_active_entry.is_some(),
+                "Cannot determine task cwd for multiple worktrees"
+            );
+            cwd_for_active_entry
+        }
+    };
+    Ok(cwd.map(|path| path.to_path_buf()))
+}

crates/tasks_ui/src/modal.rs

@@ -0,0 +1,224 @@
+use std::sync::Arc;
+
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    actions, rems, AppContext, DismissEvent, EventEmitter, FocusableView, InteractiveElement,
+    Model, ParentElement, Render, SharedString, Styled, Subscription, View, ViewContext,
+    VisualContext, WeakView,
+};
+use picker::{Picker, PickerDelegate};
+use project::Inventory;
+use task::Task;
+use ui::{v_flex, HighlightedLabel, ListItem, ListItemSpacing, Selectable};
+use util::ResultExt;
+use workspace::{ModalView, Workspace};
+
+use crate::{schedule_task, OneshotSource};
+
+actions!(task, [Spawn, Rerun]);
+
+/// A modal used to spawn new tasks.
+pub(crate) struct TasksModalDelegate {
+    inventory: Model<Inventory>,
+    candidates: Vec<Arc<dyn Task>>,
+    matches: Vec<StringMatch>,
+    selected_index: usize,
+    placeholder_text: Arc<str>,
+    workspace: WeakView<Workspace>,
+    last_prompt: String,
+}
+
+impl TasksModalDelegate {
+    fn new(inventory: Model<Inventory>, workspace: WeakView<Workspace>) -> Self {
+        Self {
+            inventory,
+            workspace,
+            candidates: Vec::new(),
+            matches: Vec::new(),
+            selected_index: 0,
+            placeholder_text: Arc::from("Select task..."),
+            last_prompt: String::default(),
+        }
+    }
+
+    fn spawn_oneshot(&mut self, cx: &mut AppContext) -> Option<Arc<dyn Task>> {
+        let oneshot_source = self
+            .inventory
+            .update(cx, |this, _| this.source::<OneshotSource>())?;
+        oneshot_source.update(cx, |this, _| {
+            let Some(this) = this.as_any().downcast_mut::<OneshotSource>() else {
+                return None;
+            };
+            Some(this.spawn(self.last_prompt.clone()))
+        })
+    }
+}
+
+pub(crate) struct TasksModal {
+    picker: View<Picker<TasksModalDelegate>>,
+    _subscription: Subscription,
+}
+
+impl TasksModal {
+    pub(crate) fn new(
+        inventory: Model<Inventory>,
+        workspace: WeakView<Workspace>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let picker = cx
+            .new_view(|cx| Picker::uniform_list(TasksModalDelegate::new(inventory, workspace), cx));
+        let _subscription = cx.subscribe(&picker, |_, _, _, cx| {
+            cx.emit(DismissEvent);
+        });
+        Self {
+            picker,
+            _subscription,
+        }
+    }
+}
+
+impl Render for TasksModal {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl gpui::prelude::IntoElement {
+        v_flex()
+            .w(rems(34.))
+            .child(self.picker.clone())
+            .on_mouse_down_out(cx.listener(|modal, _, cx| {
+                modal.picker.update(cx, |picker, cx| {
+                    picker.cancel(&Default::default(), cx);
+                })
+            }))
+    }
+}
+
+impl EventEmitter<DismissEvent> for TasksModal {}
+
+impl FocusableView for TasksModal {
+    fn focus_handle(&self, cx: &gpui::AppContext) -> gpui::FocusHandle {
+        self.picker.read(cx).focus_handle(cx)
+    }
+}
+
+impl ModalView for TasksModal {}
+
+impl PickerDelegate for TasksModalDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _cx: &mut ViewContext<picker::Picker<Self>>) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self) -> Arc<str> {
+        self.placeholder_text.clone()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        cx: &mut ViewContext<picker::Picker<Self>>,
+    ) -> gpui::Task<()> {
+        cx.spawn(move |picker, mut cx| async move {
+            let Some(candidates) = picker
+                .update(&mut cx, |picker, cx| {
+                    picker.delegate.candidates = picker
+                        .delegate
+                        .inventory
+                        .update(cx, |inventory, cx| inventory.list_tasks(None, cx));
+                    picker
+                        .delegate
+                        .candidates
+                        .sort_by(|a, b| a.name().cmp(&b.name()));
+
+                    picker
+                        .delegate
+                        .candidates
+                        .iter()
+                        .enumerate()
+                        .map(|(index, candidate)| StringMatchCandidate {
+                            id: index,
+                            char_bag: candidate.name().chars().collect(),
+                            string: candidate.name().into(),
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .ok()
+            else {
+                return;
+            };
+            let matches = fuzzy::match_strings(
+                &candidates,
+                &query,
+                true,
+                1000,
+                &Default::default(),
+                cx.background_executor().clone(),
+            )
+            .await;
+            picker
+                .update(&mut cx, |picker, _| {
+                    let delegate = &mut picker.delegate;
+                    delegate.matches = matches;
+                    delegate.last_prompt = query;
+
+                    if delegate.matches.is_empty() {
+                        delegate.selected_index = 0;
+                    } else {
+                        delegate.selected_index =
+                            delegate.selected_index.min(delegate.matches.len() - 1);
+                    }
+                })
+                .log_err();
+        })
+    }
+
+    fn confirm(&mut self, secondary: bool, cx: &mut ViewContext<picker::Picker<Self>>) {
+        let current_match_index = self.selected_index();
+        let Some(task) = secondary
+            .then(|| self.spawn_oneshot(cx))
+            .flatten()
+            .or_else(|| {
+                self.matches.get(current_match_index).map(|current_match| {
+                    let ix = current_match.candidate_id;
+                    self.candidates[ix].clone()
+                })
+            })
+        else {
+            return;
+        };
+
+        self.workspace
+            .update(cx, |workspace, cx| {
+                schedule_task(workspace, task.as_ref(), cx);
+            })
+            .ok();
+        cx.emit(DismissEvent);
+    }
+
+    fn dismissed(&mut self, cx: &mut ViewContext<picker::Picker<Self>>) {
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _cx: &mut ViewContext<picker::Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let hit = &self.matches[ix];
+        let highlights: Vec<_> = hit.positions.iter().copied().collect();
+        Some(
+            ListItem::new(SharedString::from(format!("tasks-modal-{ix}")))
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .selected(selected)
+                .start_slot(HighlightedLabel::new(hit.string.clone(), highlights)),
+        )
+    }
+}

crates/tasks_ui/src/oneshot_source.rs

@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use gpui::{AppContext, Model};
+use task::{Source, SpawnInTerminal, Task, TaskId};
+use ui::Context;
+
+pub struct OneshotSource {
+    tasks: Vec<Arc<dyn Task>>,
+}
+
+#[derive(Clone)]
+struct OneshotTask {
+    id: TaskId,
+}
+
+impl OneshotTask {
+    fn new(prompt: String) -> Self {
+        Self { id: TaskId(prompt) }
+    }
+}
+
+impl Task for OneshotTask {
+    fn id(&self) -> &TaskId {
+        &self.id
+    }
+
+    fn name(&self) -> &str {
+        &self.id.0
+    }
+
+    fn cwd(&self) -> Option<&std::path::Path> {
+        None
+    }
+
+    fn exec(&self, cwd: Option<std::path::PathBuf>) -> Option<SpawnInTerminal> {
+        if self.id().0.is_empty() {
+            return None;
+        }
+        Some(SpawnInTerminal {
+            id: self.id().clone(),
+            label: self.name().to_owned(),
+            command: self.id().0.clone(),
+            args: vec![],
+            cwd,
+            env: Default::default(),
+            use_new_terminal: Default::default(),
+            allow_concurrent_runs: Default::default(),
+            separate_shell: true,
+        })
+    }
+}
+
+impl OneshotSource {
+    pub fn new(cx: &mut AppContext) -> Model<Box<dyn Source>> {
+        cx.new_model(|_| Box::new(Self { tasks: Vec::new() }) as Box<dyn Source>)
+    }
+
+    pub fn spawn(&mut self, prompt: String) -> Arc<dyn Task> {
+        let ret = Arc::new(OneshotTask::new(prompt));
+        self.tasks.push(ret.clone());
+        ret
+    }
+}
+
+impl Source for OneshotSource {
+    fn as_any(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+
+    fn tasks_for_path(
+        &mut self,
+        _path: Option<&std::path::Path>,
+        _cx: &mut gpui::ModelContext<Box<dyn Source>>,
+    ) -> Vec<Arc<dyn Task>> {
+        self.tasks.clone()
+    }
+}