feat(tmux): concurrent async comm with tmux

Cargo.toml

@@ -8,6 +8,5 @@ edition = "2018"
 
 [dependencies]
 regex = "1.4"
-duct = "0.13"
 futures = "0.3"
 tokio = { version = "1.4", features = ["fs", "macros", "process", "rt-multi-thread"] }

src/main.rs

@@ -10,24 +10,31 @@ use tokio::fs;
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
 async fn app() -> Result<()> {
-    println!("Hello, world!");
+    let mut handles = Vec::new();
 
-    println!("---- sessions ----");
-    let sessions = tmux::session::available_sessions()?;
-    for session in sessions {
-        println!("{:?}", session);
-    }
-
-    println!("---- windows ----");
-    let windows = tmux::window::available_windows()?;
-    for window in windows {
-        println!("{:?}", window);
-    }
+    let handle = tokio::spawn(async move {
+        println!("---- sessions ----");
+        let sessions = tmux::session::available_sessions().await.unwrap();
+        for session in sessions {
+            println!("{:?}", session);
+        }
+        Ok(())
+    });
+    handles.push(handle);
+
+    let handle = tokio::spawn(async move {
+        println!("---- windows ----");
+        let windows = tmux::window::available_windows().await.unwrap();
+        for window in windows {
+            println!("{:?}", window);
+        }
+        Ok(())
+    });
+    handles.push(handle);
 
     println!("---- panes ----");
-    let panes = tmux::pane::available_panes()?;
+    let panes = tmux::pane::available_panes().await?;
 
-    let mut handles = Vec::new();
     for pane in panes {
         let handle = tokio::spawn(async move {
             let output = pane.capture().await.unwrap();
@@ -48,7 +55,7 @@ fn main() {
     let rt = tokio::runtime::Runtime::new().unwrap();
 
     match rt.block_on(app()) {
-        Ok(_) => println!("Done"),
+        Ok(_) => println!("✅ sessions persisted."),
         Err(e) => println!("An error ocurred: {}", e),
     };
 }

src/tmux/pane.rs

@@ -6,8 +6,6 @@
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use tokio::process;
-
 use super::pane_id::PaneId;
 use crate::error;
 
@@ -144,14 +142,17 @@ impl Pane {
             "-",
         ];
 
-        let output = process::Command::new("tmux").args(&args).output().await?;
-        // let text = String::from_utf8(output.stdout)?;
+        let output = tokio::process::Command::new("tmux")
+            .args(&args)
+            .output()
+            .await?;
+
         Ok(output.stdout)
     }
 }
 
 /// Returns a list of all `Pane` from all sessions.
-pub fn available_panes() -> Result<Vec<Pane>, error::ParseError> {
+pub async fn available_panes() -> Result<Vec<Pane>, error::ParseError> {
     let args = vec![
         "list-panes",
         "-a",
@@ -166,11 +167,15 @@ pub fn available_panes() -> Result<Vec<Pane>, error::ParseError> {
         :#{pane_current_command}",
     ];
 
-    let output = duct::cmd("tmux", &args).read()?;
+    let output = tokio::process::Command::new("tmux")
+        .args(&args)
+        .output()
+        .await?;
+    let buffer = String::from_utf8(output.stdout)?;
 
     // Each call to `Pane::parse` returns a `Result<Pane, _>`. All results
     // are collected into a Result<Vec<Pane>, _>, thanks to `collect()`.
-    let result: Result<Vec<Pane>, error::ParseError> = output
+    let result: Result<Vec<Pane>, error::ParseError> = buffer
         .trim_end() // trim last '\n' as it would create an empty line
         .split('\n')
         .map(|line| Pane::from_str(line))

src/tmux/session.rs

@@ -58,14 +58,18 @@ impl FromStr for Session {
 }
 
 /// Returns a list of all `Session` from the current tmux session.
-pub fn available_sessions() -> Result<Vec<Session>, ParseError> {
+pub async fn available_sessions() -> Result<Vec<Session>, ParseError> {
     let args = vec!["list-sessions", "-F", "#{session_id}:#{session_name}"];
 
-    let output = duct::cmd("tmux", &args).read()?;
+    let output = tokio::process::Command::new("tmux")
+        .args(&args)
+        .output()
+        .await?;
+    let buffer = String::from_utf8(output.stdout)?;
 
     // Each call to `Session::parse` returns a `Result<Session, _>`. All results
     // are collected into a Result<Vec<Session>, _>, thanks to `collect()`.
-    let result: Result<Vec<Session>, ParseError> = output
+    let result: Result<Vec<Session>, ParseError> = buffer
         .trim_end() // trim last '\n' as it would create an empty line
         .split('\n')
         .map(|line| Session::from_str(line))

src/tmux/window.rs

@@ -89,7 +89,7 @@ impl FromStr for Window {
 }
 
 /// Returns a list of all `Window` from all sessions.
-pub fn available_windows() -> Result<Vec<Window>, ParseError> {
+pub async fn available_windows() -> Result<Vec<Window>, ParseError> {
     let args = vec![
         "list-windows",
         "-a",
@@ -102,11 +102,15 @@ pub fn available_windows() -> Result<Vec<Window>, ParseError> {
         :#{window_linked_sessions_list}",
     ];
 
-    let output = duct::cmd("tmux", &args).read()?;
+    let output = tokio::process::Command::new("tmux")
+        .args(&args)
+        .output()
+        .await?;
+    let buffer = String::from_utf8(output.stdout)?;
 
     // Each call to `Window::parse` returns a `Result<Window, _>`. All results
     // are collected into a Result<Vec<Window>, _>, thanks to `collect()`.
-    let result: Result<Vec<Window>, ParseError> = output
+    let result: Result<Vec<Window>, ParseError> = buffer
         .trim_end() // trim last '\n' as it would create an empty line
         .split('\n')
         .map(|line| Window::from_str(line))