Rename runnables into tasks (#8119)

Release Notes:

- N/A

crates/task/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "task"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[dependencies]
+anyhow.workspace = true
+collections.workspace = true
+futures.workspace = true
+gpui.workspace = true
+parking_lot.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_json_lenient.workspace = true
+settings.workspace = true
+smol.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+gpui = { workspace = true, features = ["test-support"] }

crates/task/LICENSE-GPL

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

crates/task/src/lib.rs

@@ -0,0 +1,70 @@
+//! Baseline interface of Tasks in Zed: all tasks in Zed are intended to use those for implementing their own logic.
+#![deny(missing_docs)]
+
+pub mod static_source;
+mod static_task;
+
+pub use static_task::StaticTask;
+
+use collections::HashMap;
+use gpui::ModelContext;
+use std::any::Any;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+/// Task identifier, unique within the application.
+/// Based on it, task reruns and terminal tabs are managed.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TaskId(pub String);
+
+/// Contains all information needed by Zed to spawn a new terminal tab for the given task.
+#[derive(Debug, Clone)]
+pub struct SpawnInTerminal {
+    /// Id of the task to use when determining task tab affinity.
+    pub id: TaskId,
+    /// Human readable name of the terminal tab.
+    pub label: String,
+    /// Executable command to spawn.
+    pub command: String,
+    /// Arguments to the command.
+    pub args: Vec<String>,
+    /// Current working directory to spawn the command into.
+    pub cwd: Option<PathBuf>,
+    /// Env overrides for the command, will be appended to the terminal's environment from the settings.
+    pub env: HashMap<String, String>,
+    /// Whether to use a new terminal tab or reuse the existing one to spawn the process.
+    pub use_new_terminal: bool,
+    /// Whether to allow multiple instances of the same task to be run, or rather wait for the existing ones to finish.
+    pub allow_concurrent_runs: bool,
+    /// Whether the command should be spawned in a separate shell instance.
+    pub separate_shell: bool,
+}
+
+/// Represents a short lived recipe of a task, whose main purpose
+/// is to get spawned.
+pub trait Task {
+    /// Unique identifier of the task to spawn.
+    fn id(&self) -> &TaskId;
+    /// Human readable name of the task to display in the UI.
+    fn name(&self) -> &str;
+    /// Task's current working directory. If `None`, current project's root will be used.
+    fn cwd(&self) -> Option<&Path>;
+    /// Sets up everything needed to spawn the task in the given directory (`cwd`).
+    /// If a task is intended to be spawned in the terminal, it should return the corresponding struct filled with the data necessary.
+    fn exec(&self, cwd: Option<PathBuf>) -> Option<SpawnInTerminal>;
+}
+
+/// [`Source`] produces tasks that can be scheduled.
+///
+/// Implementations of this trait could be e.g. [`StaticSource`] that parses tasks from a .json files and provides process templates to be spawned;
+/// another one could be a language server providing lenses with tests or build server listing all targets for a given project.
+pub trait Source: Any {
+    /// A way to erase the type of the source, processing and storing them generically.
+    fn as_any(&mut self) -> &mut dyn Any;
+    /// Collects all tasks available for scheduling, for the path given.
+    fn tasks_for_path(
+        &mut self,
+        path: Option<&Path>,
+        cx: &mut ModelContext<Box<dyn Source>>,
+    ) -> Vec<Arc<dyn Task>>;
+}

crates/task/src/static_source.rs

@@ -0,0 +1,159 @@
+//! A source of tasks, based on a static configuration, deserialized from the tasks config file, and related infrastructure for tracking changes to the file.
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use collections::HashMap;
+use futures::StreamExt;
+use gpui::{AppContext, Context, Model, ModelContext, Subscription};
+use schemars::{gen::SchemaSettings, JsonSchema};
+use serde::{Deserialize, Serialize};
+use util::ResultExt;
+
+use crate::{Source, StaticTask, Task};
+use futures::channel::mpsc::UnboundedReceiver;
+
+/// The source of tasks defined in a tasks config file.
+pub struct StaticSource {
+    tasks: Vec<StaticTask>,
+    _definitions: Model<TrackedFile<DefinitionProvider>>,
+    _subscription: Subscription,
+}
+
+/// Static task definition from the tasks config file.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub(crate) struct Definition {
+    /// Human readable name of the task to display in the UI.
+    pub label: String,
+    /// Executable command to spawn.
+    pub command: String,
+    /// Arguments to the command.
+    #[serde(default)]
+    pub args: Vec<String>,
+    /// Env overrides for the command, will be appended to the terminal's environment from the settings.
+    #[serde(default)]
+    pub env: HashMap<String, String>,
+    /// Current working directory to spawn the command into, defaults to current project root.
+    #[serde(default)]
+    pub cwd: Option<PathBuf>,
+    /// Whether to use a new terminal tab or reuse the existing one to spawn the process.
+    #[serde(default)]
+    pub use_new_terminal: bool,
+    /// Whether to allow multiple instances of the same task to be run, or rather wait for the existing ones to finish.
+    #[serde(default)]
+    pub allow_concurrent_runs: bool,
+}
+
+/// A group of Tasks defined in a JSON file.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub struct DefinitionProvider {
+    version: String,
+    tasks: Vec<Definition>,
+}
+
+impl DefinitionProvider {
+    /// Generates JSON schema of Tasks JSON definition format.
+    pub fn generate_json_schema() -> serde_json_lenient::Value {
+        let schema = SchemaSettings::draft07()
+            .with(|settings| settings.option_add_null_type = false)
+            .into_generator()
+            .into_root_schema_for::<Self>();
+
+        serde_json_lenient::to_value(schema).unwrap()
+    }
+}
+/// A Wrapper around deserializable T that keeps track of it's contents
+/// via a provided channel. Once T value changes, the observers of [`TrackedFile`] are
+/// notified.
+struct TrackedFile<T> {
+    parsed_contents: T,
+}
+
+impl<T: for<'a> Deserialize<'a> + PartialEq + 'static> TrackedFile<T> {
+    fn new(
+        parsed_contents: T,
+        mut tracker: UnboundedReceiver<String>,
+        cx: &mut AppContext,
+    ) -> Model<Self> {
+        cx.new_model(move |cx| {
+            cx.spawn(|tracked_file, mut cx| async move {
+                while let Some(new_contents) = tracker.next().await {
+                    if !new_contents.trim().is_empty() {
+                        let Some(new_contents) =
+                            serde_json_lenient::from_str(&new_contents).log_err()
+                        else {
+                            continue;
+                        };
+                        tracked_file.update(&mut cx, |tracked_file: &mut TrackedFile<T>, cx| {
+                            if tracked_file.parsed_contents != new_contents {
+                                tracked_file.parsed_contents = new_contents;
+                                cx.notify();
+                            };
+                        })?;
+                    }
+                }
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+            Self { parsed_contents }
+        })
+    }
+
+    fn get(&self) -> &T {
+        &self.parsed_contents
+    }
+}
+
+impl StaticSource {
+    /// Initializes the static source, reacting on tasks config changes.
+    pub fn new(
+        tasks_file_tracker: UnboundedReceiver<String>,
+        cx: &mut AppContext,
+    ) -> Model<Box<dyn Source>> {
+        let definitions = TrackedFile::new(DefinitionProvider::default(), tasks_file_tracker, cx);
+        cx.new_model(|cx| {
+            let _subscription = cx.observe(
+                &definitions,
+                |source: &mut Box<(dyn Source + 'static)>, new_definitions, cx| {
+                    if let Some(static_source) = source.as_any().downcast_mut::<Self>() {
+                        static_source.tasks = new_definitions
+                            .read(cx)
+                            .get()
+                            .tasks
+                            .clone()
+                            .into_iter()
+                            .enumerate()
+                            .map(|(id, definition)| StaticTask::new(id, definition))
+                            .collect();
+                        cx.notify();
+                    }
+                },
+            );
+            Box::new(Self {
+                tasks: Vec::new(),
+                _definitions: definitions,
+                _subscription,
+            })
+        })
+    }
+}
+
+impl Source for StaticSource {
+    fn tasks_for_path(
+        &mut self,
+        _: Option<&Path>,
+        _: &mut ModelContext<Box<dyn Source>>,
+    ) -> Vec<Arc<dyn Task>> {
+        self.tasks
+            .clone()
+            .into_iter()
+            .map(|task| Arc::new(task) as Arc<dyn Task>)
+            .collect()
+    }
+
+    fn as_any(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}

crates/task/src/static_task.rs

@@ -0,0 +1,49 @@
+//! Definitions of tasks with a static file config definition, not dependent on the application state.
+
+use std::path::{Path, PathBuf};
+
+use crate::{static_source::Definition, SpawnInTerminal, Task, TaskId};
+
+/// A single config file entry with the deserialized task definition.
+#[derive(Clone, Debug, PartialEq)]
+pub struct StaticTask {
+    id: TaskId,
+    definition: Definition,
+}
+
+impl StaticTask {
+    pub(super) fn new(id: usize, task_definition: Definition) -> Self {
+        Self {
+            id: TaskId(format!("static_{}_{}", task_definition.label, id)),
+            definition: task_definition,
+        }
+    }
+}
+
+impl Task for StaticTask {
+    fn exec(&self, cwd: Option<PathBuf>) -> Option<SpawnInTerminal> {
+        Some(SpawnInTerminal {
+            id: self.id.clone(),
+            cwd,
+            use_new_terminal: self.definition.use_new_terminal,
+            allow_concurrent_runs: self.definition.allow_concurrent_runs,
+            label: self.definition.label.clone(),
+            command: self.definition.command.clone(),
+            args: self.definition.args.clone(),
+            env: self.definition.env.clone(),
+            separate_shell: false,
+        })
+    }
+
+    fn name(&self) -> &str {
+        &self.definition.label
+    }
+
+    fn id(&self) -> &TaskId {
+        &self.id
+    }
+
+    fn cwd(&self) -> Option<&Path> {
+        self.definition.cwd.as_deref()
+    }
+}