ref(daemon): improve nvim.logger interface

Author: kkharji

src/daemon/requests/build.rs

@@ -3,7 +3,7 @@ use crate::{nvim::BufferDirection, types::BuildConfiguration};
 use std::fmt::Debug;
 
 #[cfg(feature = "daemon")]
-use crate::{constants::DAEMON_STATE, xcode::stream_build};
+use crate::constants::DAEMON_STATE;
 
 /// Build a project.
 #[derive(Debug, Serialize, Deserialize)]
@@ -20,7 +20,7 @@ impl Handler for Build {
         let Self { client, config, .. } = &self;
         let Client { pid, root } = client;
 
-        tracing::debug!("Handling build request {:#?}", self.config);
+        tracing::debug!("Handling build request {:#?}", config);
 
         let state = DAEMON_STATE.clone().lock_owned().await;
         let nvim = state
@@ -30,10 +30,16 @@ impl Handler for Build {
 
         let direction = self.direction.clone();
 
-        nvim.new_logger("build", config, &direction)
-            .log_stream(stream_build(&root, &config).await?, true, true)
+        let (success, _) = nvim
+            .new_logger("build", &config.target, &direction)
+            .log_build_stream(&root, &config.as_args(), true, true)
             .await?;
 
+        if !success {
+            nvim.echo_err(&format!("Failed: {} ", config.to_string()))
+                .await?;
+        };
+
         Ok(())
     }
 }

src/nvim.rs

@@ -17,6 +17,8 @@ use anyhow::Result;
 
 #[cfg(feature = "daemon")]
 type NvimConnection = Compat<tokio::io::WriteHalf<parity_tokio_ipc::Connection>>;
+#[cfg(feature = "daemon")]
+pub type NvimWindow = nvim_rs::Window<NvimConnection>;
 
 #[derive(Deserialize, Serialize)]
 pub struct NvimClient {
@@ -40,13 +42,14 @@ impl NvimClient {
         let (nvim, _) = connect(address, Dummy::new()).await?;
         let buf = nvim.create_buf(false, true).await?;
         let log_bufnr = buf.get_number().await?;
+        let script = format!("let g:xbase_log_bufnr={log_bufnr}");
 
-        buf.set_name("[xbase Logs]").await?;
-        buf.set_option("filetype", "xcodebuildlog".into()).await?;
-
-        // NOTE: store log bufnr somewhere in vim state
-        nvim.exec(&format!("let g:xbase_log_bufnr={log_bufnr}"), false)
-            .await?;
+        let (a, b, c) = tokio::join!(
+            buf.set_name("[xbase Logs]"),
+            buf.set_option("filetype", "xcodebuildlog".into()),
+            nvim.exec(&script, false)
+        );
+        _ = (a?, b?, c?);
 
         Ok(NvimClient {
             pid: *pid,
@@ -63,11 +66,16 @@ impl NvimClient {
 
     pub fn new_logger<'a>(
         &'a self,
-        title: &'a str,
-        config: &'a crate::types::BuildConfiguration,
+        ops: &str,
+        target: &str,
         direction: &'a Option<BufferDirection>,
     ) -> Logger<'a> {
-        Logger::new(self, title, &config, direction.clone())
+        use crate::util::string_as_section;
+        Logger::new(
+            self,
+            string_as_section(format!("[{ops}: {target}]")),
+            direction.clone(),
+        )
     }
 }
 
@@ -84,11 +92,9 @@ impl NvimClient {
 
         Ok(())
     }
-
     fn inner(&self) -> &nvim_rs::Neovim<NvimConnection> {
         self.conn.as_ref().unwrap()
     }
-
     pub async fn log_info(&self, scope: &str, msg: impl ToString) -> Result<()> {
         self.log("info", scope, msg).await
     }
@@ -108,9 +114,8 @@ impl NvimClient {
         self.exec(msg, false).await?;
         Ok(())
     }
-
     pub async fn echo_err(&self, msg: &str) -> Result<()> {
-        Ok(self.err_write(msg).await?)
+        Ok(self.err_writeln(msg).await?)
     }
 }
 

src/nvim/logger.rs

@@ -1,63 +1,92 @@
-use super::{NvimClient, NvimConnection};
+use std::path::Path;
+
+use super::{NvimClient, NvimConnection, NvimWindow};
 use crate::nvim::BufferDirection;
-use crate::types::BuildConfiguration;
 use anyhow::Result;
 use nvim_rs::{Buffer, Window};
-use tokio_stream::{Stream, StreamExt};
+use tokio_stream::StreamExt;
 
 pub struct Logger<'a> {
     pub nvim: &'a NvimClient,
-    pub title: &'a str,
-    pub request: &'a BuildConfiguration,
+    pub title: String,
     pub buf: Buffer<NvimConnection>,
     open_cmd: Option<String>,
     current_line_count: Option<i64>,
 }
 
 impl<'a> Logger<'a> {
-    pub fn new(
-        nvim: &'a NvimClient,
-        title: &'a str,
-        request: &'a BuildConfiguration,
-        direction: Option<BufferDirection>,
-    ) -> Self {
+    pub fn new(nvim: &'a NvimClient, title: String, direction: Option<BufferDirection>) -> Self {
         let buf = Buffer::new(nvim.log_bufnr.into(), nvim.inner().clone());
         let open_cmd = direction.map(|v| v.to_nvim_command(nvim.log_bufnr));
 
         Self {
             nvim,
             title,
-            request,
             buf,
             open_cmd,
             current_line_count: None,
         }
     }
 
-    pub async fn log(&mut self, msg: String) -> Result<()> {
-        let c = self.line_count().await?;
+    async fn clear(&self) -> Result<()> {
+        self.buf.set_lines(0, -1, false, vec![]).await?;
+        Ok(())
+    }
 
-        self.buf.set_lines(c, c + 1, false, vec![msg]).await?;
-        self.current_line_count = Some(c + 1);
+    async fn get_line_count(&'a self) -> Result<i64> {
+        Ok(if let Some(count) = self.current_line_count {
+            count
+        } else {
+            match self.buf.line_count().await? {
+                1 => 0,
+                count => count,
+            }
+        })
+    }
 
-        Ok(())
+    async fn get_open_cmd(&self, direction: Option<BufferDirection>) -> String {
+        let direction =
+            BufferDirection::get_window_direction(self.nvim, direction, self.nvim.log_bufnr);
+
+        match direction.await {
+            Ok(open_command) => open_command,
+            Err(e) => {
+                tracing::error!("Unable to convert value to string {e}");
+                BufferDirection::Horizontal.to_nvim_command(self.nvim.log_bufnr)
+            }
+        }
     }
 
-    async fn clear(&self) -> Result<()> {
-        self.buf.set_lines(0, -1, false, vec![]).await?;
+    pub async fn log(&mut self, msg: String, win: &Option<NvimWindow>) -> Result<()> {
+        let mut c = self.get_line_count().await?;
+        let lines = msg
+            .split("\n")
+            .map(ToString::to_string)
+            .collect::<Vec<String>>();
+        let lines_len = lines.len() as i64;
+
+        self.buf
+            .set_lines(c, c + lines_len as i64, false, lines)
+            .await?;
+        c += lines_len;
+
+        self.current_line_count = Some(c);
+
+        if let Some(win) = win {
+            win.set_cursor((c, 0)).await?;
+        }
+
         Ok(())
     }
 
-    pub async fn log_stream<S>(&mut self, mut stream: S, clear: bool, open: bool) -> Result<()>
-    where
-        S: Stream<Item = String> + Unpin,
-    {
-        self.set_running().await?;
-
-        let title = format!(
-            "[{}] ------------------------------------------------------",
-            self.title
-        );
+    pub async fn log_build_stream<P: AsRef<Path>>(
+        &mut self,
+        root: P,
+        args: &Vec<String>,
+        clear: bool,
+        open: bool,
+    ) -> Result<(bool, Option<Window<NvimConnection>>)> {
+        let mut stream = crate::xcode::stream_build(root, args).await?;
 
         // TODO(nvim): close log buffer if it is open for new direction
         //
@@ -74,22 +103,50 @@ impl<'a> Logger<'a> {
             None
         };
 
-        self.log(title).await?;
-
         let mut success = false;
+
+        self.set_running().await?;
+
         while let Some(line) = stream.next().await {
             line.contains("Succeed").then(|| success = true);
-            self.log(line).await?;
-            if open {
-                win.as_ref()
-                    .unwrap()
-                    .set_cursor((self.line_count().await?, 0))
-                    .await?;
-            }
+
+            self.log(line, &win).await?;
         }
 
         self.set_status_end(success, open).await?;
 
+        Ok((success, win))
+    }
+
+    async fn log_title(&mut self) -> Result<()> {
+        self.log(self.title.clone(), &None).await?;
+        Ok(())
+    }
+
+    async fn open_cmd(&self) -> String {
+        let open_cmd = match self.open_cmd.as_ref() {
+            Some(s) => s.clone(),
+            None => self.get_open_cmd(None).await,
+        };
+        open_cmd
+    }
+
+    pub async fn open_win(&self) -> Result<Window<NvimConnection>> {
+        let open_cmd = self.open_cmd().await;
+
+        self.nvim.exec(&open_cmd, false).await?;
+        let win = self.nvim.get_current_win().await?;
+        self.nvim.exec("setl nu nornu so=9", false).await?;
+        self.nvim.exec("wincmd w", false).await?;
+
+        Ok(win)
+    }
+
+    pub async fn set_running(&mut self) -> Result<()> {
+        self.log_title().await?;
+        self.nvim
+            .exec("let g:xbase_watch_build_status='running'", false)
+            .await?;
         Ok(())
     }
 
@@ -107,61 +164,11 @@ impl<'a> Logger<'a> {
                 self.nvim
                     .get_current_win()
                     .await?
-                    .set_cursor((self.line_count().await?, 0))
+                    .set_cursor((self.get_line_count().await?, 0))
                     .await?;
                 self.nvim.exec("call feedkeys('zt')", false).await?;
             }
         }
         Ok(())
     }
-
-    pub async fn set_running(&mut self) -> Result<()> {
-        self.nvim
-            .exec("let g:xbase_watch_build_status='running'", false)
-            .await?;
-        Ok(())
-    }
-
-    pub async fn line_count(&'a self) -> Result<i64> {
-        Ok(if let Some(count) = self.current_line_count {
-            count
-        } else {
-            match self.buf.line_count().await? {
-                1 => 0,
-                count => count,
-            }
-        })
-    }
-
-    async fn get_open_cmd(&self, direction: Option<BufferDirection>) -> String {
-        let direction =
-            BufferDirection::get_window_direction(self.nvim, direction, self.nvim.log_bufnr);
-
-        match direction.await {
-            Ok(open_command) => open_command,
-            Err(e) => {
-                tracing::error!("Unable to convert value to string {e}");
-                BufferDirection::Horizontal.to_nvim_command(self.nvim.log_bufnr)
-            }
-        }
-    }
-
-    pub async fn open_win(&self) -> Result<Window<NvimConnection>> {
-        let open_cmd = self.open_cmd().await;
-
-        self.nvim.exec(&open_cmd, false).await?;
-        let win = self.nvim.get_current_win().await?;
-        self.nvim.exec("setl nu nornu so=9", false).await?;
-        self.nvim.exec("wincmd w", false).await?;
-
-        Ok(win)
-    }
-
-    async fn open_cmd(&self) -> String {
-        let open_cmd = match self.open_cmd.as_ref() {
-            Some(s) => s.clone(),
-            None => self.get_open_cmd(None).await,
-        };
-        open_cmd
-    }
 }

src/store/clients.rs

@@ -57,7 +57,7 @@ impl ClientStore {
     pub async fn echo_err(&self, root: &PathBuf, scope: &str, msg: &str) {
         let msg = format!("{scope}: {msg}");
         for client in self.get_clients_by_root(&root).await {
-            client.echo_msg(&msg).await.ok();
+            client.echo_err(&msg).await.ok();
         }
     }