Rename RemoteProject -> DevServerProject (#11301)

Co-Authored-By: Mikayla <mikayla@zed.dev>

In a fit of ill-advisedness I called these things remote projects;
forgetting that remote project is also what we call collaboratively
shared projects.

Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Bennet <bennetbo@gmx.de>

crates/dev_server_projects/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "dev_server_projects"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/dev_server_projects.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+gpui.workspace = true
+serde.workspace = true
+client.workspace = true
+rpc.workspace = true
+
+[dev-dependencies]
+serde_json.workspace = true

crates/dev_server_projects/src/dev_server_projects.rs

@@ -0,0 +1,191 @@
+use anyhow::Result;
+use gpui::{AppContext, AsyncAppContext, Context, Global, Model, ModelContext, SharedString, Task};
+use rpc::{
+    proto::{self, DevServerStatus},
+    TypedEnvelope,
+};
+use std::{collections::HashMap, sync::Arc};
+
+use client::{Client, ProjectId};
+pub use client::{DevServerId, DevServerProjectId};
+
+pub struct Store {
+    dev_server_projects: HashMap<DevServerProjectId, DevServerProject>,
+    dev_servers: HashMap<DevServerId, DevServer>,
+    _subscriptions: Vec<client::Subscription>,
+    client: Arc<Client>,
+}
+
+#[derive(Debug, Clone)]
+pub struct DevServerProject {
+    pub id: DevServerProjectId,
+    pub project_id: Option<ProjectId>,
+    pub path: SharedString,
+    pub dev_server_id: DevServerId,
+}
+
+impl From<proto::DevServerProject> for DevServerProject {
+    fn from(project: proto::DevServerProject) -> Self {
+        Self {
+            id: DevServerProjectId(project.id),
+            project_id: project.project_id.map(|id| ProjectId(id)),
+            path: project.path.into(),
+            dev_server_id: DevServerId(project.dev_server_id),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DevServer {
+    pub id: DevServerId,
+    pub name: SharedString,
+    pub status: DevServerStatus,
+}
+
+impl From<proto::DevServer> for DevServer {
+    fn from(dev_server: proto::DevServer) -> Self {
+        Self {
+            id: DevServerId(dev_server.dev_server_id),
+            status: dev_server.status(),
+            name: dev_server.name.into(),
+        }
+    }
+}
+
+struct GlobalStore(Model<Store>);
+
+impl Global for GlobalStore {}
+
+pub fn init(client: Arc<Client>, cx: &mut AppContext) {
+    let store = cx.new_model(|cx| Store::new(client, cx));
+    cx.set_global(GlobalStore(store));
+}
+
+impl Store {
+    pub fn global(cx: &AppContext) -> Model<Store> {
+        cx.global::<GlobalStore>().0.clone()
+    }
+
+    pub fn new(client: Arc<Client>, cx: &ModelContext<Self>) -> Self {
+        Self {
+            dev_server_projects: Default::default(),
+            dev_servers: Default::default(),
+            _subscriptions: vec![client
+                .add_message_handler(cx.weak_model(), Self::handle_dev_server_projects_update)],
+            client,
+        }
+    }
+
+    pub fn projects_for_server(&self, id: DevServerId) -> Vec<DevServerProject> {
+        let mut projects: Vec<DevServerProject> = self
+            .dev_server_projects
+            .values()
+            .filter(|project| project.dev_server_id == id)
+            .cloned()
+            .collect();
+        projects.sort_by_key(|p| (p.path.clone(), p.id));
+        projects
+    }
+
+    pub fn dev_servers(&self) -> Vec<DevServer> {
+        let mut dev_servers: Vec<DevServer> = self.dev_servers.values().cloned().collect();
+        dev_servers.sort_by_key(|d| (d.status == DevServerStatus::Offline, d.name.clone(), d.id));
+        dev_servers
+    }
+
+    pub fn dev_server(&self, id: DevServerId) -> Option<&DevServer> {
+        self.dev_servers.get(&id)
+    }
+
+    pub fn dev_server_status(&self, id: DevServerId) -> DevServerStatus {
+        self.dev_server(id)
+            .map(|server| server.status)
+            .unwrap_or(DevServerStatus::Offline)
+    }
+
+    pub fn dev_server_projects(&self) -> Vec<DevServerProject> {
+        let mut projects: Vec<DevServerProject> =
+            self.dev_server_projects.values().cloned().collect();
+        projects.sort_by_key(|p| (p.path.clone(), p.id));
+        projects
+    }
+
+    pub fn dev_server_project(&self, id: DevServerProjectId) -> Option<&DevServerProject> {
+        self.dev_server_projects.get(&id)
+    }
+
+    pub fn dev_server_for_project(&self, id: DevServerProjectId) -> Option<&DevServer> {
+        self.dev_server_project(id)
+            .and_then(|project| self.dev_server(project.dev_server_id))
+    }
+
+    async fn handle_dev_server_projects_update(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::DevServerProjectsUpdate>,
+        _: Arc<Client>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            this.dev_servers = envelope
+                .payload
+                .dev_servers
+                .into_iter()
+                .map(|dev_server| (DevServerId(dev_server.dev_server_id), dev_server.into()))
+                .collect();
+            this.dev_server_projects = envelope
+                .payload
+                .dev_server_projects
+                .into_iter()
+                .map(|project| (DevServerProjectId(project.id), project.into()))
+                .collect();
+
+            cx.notify();
+        })?;
+        Ok(())
+    }
+
+    pub fn create_dev_server_project(
+        &mut self,
+        dev_server_id: DevServerId,
+        path: String,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<proto::CreateDevServerProjectResponse>> {
+        let client = self.client.clone();
+        cx.background_executor().spawn(async move {
+            client
+                .request(proto::CreateDevServerProject {
+                    dev_server_id: dev_server_id.0,
+                    path,
+                })
+                .await
+        })
+    }
+
+    pub fn create_dev_server(
+        &mut self,
+        name: String,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<proto::CreateDevServerResponse>> {
+        let client = self.client.clone();
+        cx.background_executor().spawn(async move {
+            let result = client.request(proto::CreateDevServer { name }).await?;
+            Ok(result)
+        })
+    }
+
+    pub fn delete_dev_server(
+        &mut self,
+        id: DevServerId,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let client = self.client.clone();
+        cx.background_executor().spawn(async move {
+            client
+                .request(proto::DeleteDevServer {
+                    dev_server_id: id.0,
+                })
+                .await?;
+            Ok(())
+        })
+    }
+}