feat: unregister client on nvim exist + drop workspace

Author: kkharji

Cargo.lock

@@ -32,7 +32,8 @@ wax = "0.4.0"
 regex = "1.5"
 lazy_static = "1.4.0"
 shell-words = "1.1.0"
-
+# TODO: make libxcodebase lightweight
+# Use features to exclude stuff likce tracing and async-trait as well tokio
 # WARN: api totally changed on later versions.
 # It would make sense to create custom function
 # Breaks
@@ -47,5 +48,4 @@ members = [
   "daemon",
   "lsp",
   "nvim",
-  "server"
 ]

Cargo.toml

@@ -6,11 +6,13 @@ mod build;
 mod register;
 mod rename_file;
 mod run;
+mod unregister;
 
 pub use build::Build;
 pub use register::Register;
 pub use rename_file::RenameFile;
 pub use run::Run;
+pub use unregister::UnRegister;
 
 #[async_trait]
 pub trait DaemonCommand {
@@ -24,6 +26,7 @@ pub enum Command {
     Run(Run),
     RenameFile(RenameFile),
     Register(Register),
+    UnRegister(UnRegister),
 }
 
 impl Command {
@@ -33,6 +36,7 @@ impl Command {
             Command::Run(c) => c.handle(state).await,
             Command::RenameFile(c) => c.handle(state).await,
             Command::Register(c) => c.handle(state).await,
+            Command::UnRegister(c) => c.handle(state).await,
         }
     }
 
@@ -44,6 +48,7 @@ impl Command {
             "run" => Ok(Self::Run(Run::new(args)?)),
             "rename_file" => Ok(Self::RenameFile(RenameFile::new(args)?)),
             "register" => Ok(Self::Register(Register::new(args)?)),
+            "unregister" => Ok(Self::UnRegister(UnRegister::new(args)?)),
             _ => bail!("Unknown command messsage: {cmd}"),
         }
     }

core/command.rs

@@ -0,0 +1,44 @@
+use crate::state::SharedState;
+use crate::{daemon, DaemonCommand};
+use anyhow::{bail, Result};
+use async_trait::async_trait;
+use tracing::trace;
+
+/// Register new client with workspace
+#[derive(Debug)]
+pub struct UnRegister {
+    pub pid: i32,
+    pub root: String,
+}
+
+impl UnRegister {
+    pub fn new(args: Vec<&str>) -> Result<Self> {
+        let pid = args.get(0);
+        let root = args.get(1);
+
+        if pid.is_none() || root.is_none() {
+            bail!("Missing arugments: [ pid: {:?}, root: {:?} ]", pid, root)
+        }
+
+        Ok(Self {
+            pid: pid.unwrap().parse::<i32>()?,
+            root: root.unwrap().to_string(),
+        })
+    }
+
+    pub fn request(pid: i32, root: String) -> Result<()> {
+        daemon::execute(&["unregister", pid.to_string().as_str(), root.as_str()])
+    }
+}
+
+#[async_trait]
+impl DaemonCommand for UnRegister {
+    async fn handle(&self, state: SharedState) -> Result<()> {
+        trace!("{:?}", self);
+        state
+            .lock()
+            .await
+            .remove_workspace(&self.root, self.pid)
+            .await
+    }
+}

core/command/unregister.rs

@@ -1,5 +1,5 @@
 use crate::workspace::Workspace;
-use anyhow::{Ok, Result};
+use anyhow::{bail, Ok, Result};
 use libproc::libproc::proc_pid;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -49,15 +49,34 @@ impl State {
         match self.workspaces.get_mut(root) {
             Some(workspace) => workspace.add_client(pid),
             None => {
-                self.workspaces.insert(
-                    root.to_string(),
-                    Workspace::new_with_client(&root, pid).await?,
-                );
+                let workspace = Workspace::new_with_client(&root, pid).await?;
+
+                tracing::info!("Managing [{}] {:?}", workspace.project.name(), root);
+
+                self.workspaces.insert(root.to_string(), workspace);
             }
         };
 
         // Print New state
         trace!("{:#?}", self);
         Ok(())
     }
+
+    // Remove remove client from workspace and the workspace if it's this client was the last one.
+    pub async fn remove_workspace(&mut self, root: &str, pid: i32) -> Result<()> {
+        let mut name = None;
+        if let Some(workspace) = self.workspaces.get_mut(root) {
+            let clients_len = workspace.remove_client(pid);
+            clients_len
+                .eq(&0)
+                .then(|| name = workspace.project.name().to_string().into());
+        } else {
+            bail!("workspace with '{root}' with given pid {pid} doesn't exist")
+        }
+        if let Some(name) = name {
+            tracing::info!("Dropping [{}] {:?}", name, root);
+            self.workspaces.remove(root);
+        }
+        Ok(())
+    }
 }

core/state.rs

@@ -34,8 +34,6 @@ impl Workspace {
             Project::new_from_project_yml(root.clone(), path).await?
         };
 
-        tracing::info!("Managing [{}] {:?}", project.name(), root);
-
         Ok(Self {
             root,
             project,
@@ -53,7 +51,7 @@ impl Workspace {
         let name = self.project.name();
         self.clients.retain(|&pid| {
             if proc_pid::name(pid).is_err() {
-                tracing::debug!("[{}]: Remove Client: {pid}", name);
+                tracing::info!("[{}]: Remove Client: {pid}", name);
                 false
             } else {
                 true
@@ -66,10 +64,17 @@ impl Workspace {
         // Remove no longer active clients
         self.update_clients();
         // NOTE: Implicitly assuming that pid is indeed a valid pid
-        tracing::debug!("[{}] Add Client: {pid}", self.name());
+        tracing::info!("[{}] Add Client: {pid}", self.name());
         self.clients.push(pid)
     }
 
+    /// Remove client from workspace
+    pub fn remove_client(&mut self, pid: i32) -> usize {
+        tracing::info!("[{}] Remove Client: {pid}", self.name());
+        self.clients.retain(|&p| p != pid);
+        self.clients.iter().count()
+    }
+
     /// Wrapper around Project.name:
     /// Returns project name
     pub fn name(&self) -> &str {