feat: common module options (show_if, on_click, tooltip)

The first three of many options that are common to all modules.

Resolves #36. Resolves partially #34.

src/modules/script.rs

@@ -1,39 +1,32 @@
+use crate::config::CommonConfig;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::script::exec_command;
+use crate::script::{OutputStream, Script, ScriptMode};
 use color_eyre::{Help, Report, Result};
 use gtk::prelude::*;
 use gtk::Label;
 use serde::Deserialize;
-use std::process::Stdio;
-use tokio::io::{AsyncBufReadExt, BufReader};
-use tokio::process::Command;
+use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
-use tokio::time::sleep;
-use tokio::{select, spawn};
 use tracing::error;
 
-#[derive(Debug, Deserialize, Clone, Copy)]
-#[serde(rename_all = "kebab-case")]
-enum Mode {
-    Poll,
-    Watch,
-}
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct ScriptModule {
     /// Path to script to execute.
     path: String,
     /// Script execution mode
     #[serde(default = "default_mode")]
-    mode: Mode,
+    mode: ScriptMode,
     /// Time in milliseconds between executions.
     #[serde(default = "default_interval")]
     interval: u64,
+
+    #[serde(flatten)]
+    pub common: CommonConfig,
 }
 
 /// `Mode::Poll`
-const fn default_mode() -> Mode {
-    Mode::Poll
+const fn default_mode() -> ScriptMode {
+    ScriptMode::Poll
 }
 
 /// 5000ms
@@ -41,6 +34,16 @@ const fn default_interval() -> u64 {
     5000
 }
 
+impl From<&ScriptModule> for Script {
+    fn from(module: &ScriptModule) -> Self {
+        Self {
+            mode: module.mode,
+            cmd: module.path.clone(),
+            interval: module.interval,
+        }
+    }
+}
+
 impl Module<Label> for ScriptModule {
     type SendMessage = String;
     type ReceiveMessage = ();
@@ -51,78 +54,22 @@ impl Module<Label> for ScriptModule {
         tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
         _rx: Receiver<Self::ReceiveMessage>,
     ) -> Result<()> {
-        let interval = self.interval;
-        let path = self.path.clone();
+        let script: Script = self.into();
 
-        match self.mode {
-            Mode::Poll => spawn(async move {
-                loop {
-                    match exec_command(&path) {
-                        Ok(stdout) => tx
-                            .send(ModuleUpdateEvent::Update(stdout))
-                            .await
-                            .expect("Failed to send stdout"),
-                        Err(err) => error!("{:?}", err),
-                    }
-
-                    sleep(tokio::time::Duration::from_millis(interval)).await;
-                }
-            }),
-            Mode::Watch => spawn(async move {
-                loop {
-                    let mut handle = Command::new("sh")
-                        .args(["-c", &path])
-                        .stdout(Stdio::piped())
-                        .stderr(Stdio::piped())
-                        .stdin(Stdio::null())
-                        .spawn()
-                        .expect("Failed to spawn process");
-
-                    let mut stdout_lines = BufReader::new(
-                        handle
-                            .stdout
-                            .take()
-                            .expect("Failed to take script handle stdout"),
-                    )
-                    .lines();
-
-                    let mut stderr_lines = BufReader::new(
-                        handle
-                            .stderr
-                            .take()
-                            .expect("Failed to take script handle stderr"),
-                    )
-                    .lines();
-
-                    loop {
-                        select! {
-                            _ = handle.wait() => break,
-                            Ok(Some(line)) = stdout_lines.next_line() => {
-                                tx.send(ModuleUpdateEvent::Update(line.to_string()))
-                            .await
-                            .expect("Failed to send stdout");
-                            }
-                            Ok(Some(line)) = stderr_lines.next_line() => {
-                                error!("{:?}", Report::msg(line)
+        spawn(async move {
+            script.run(move |(out, _)| match out {
+               OutputStream::Stdout(stdout) => {
+                   tx.try_send(ModuleUpdateEvent::Update(stdout))
+                       .expect("Failed to send stdout"); }
+               OutputStream::Stderr(stderr) => {
+                   error!("{:?}", Report::msg(stderr)
                                     .wrap_err("Watched script error:")
                                     .suggestion("Check the path to your script")
                                     .suggestion("Check the script for errors")
-                                    .suggestion("If you expect the script to write to stderr, consider redirecting its output to /dev/null to suppress these messages")
-                                )
-                            }
-                        }
-                    }
-
-                    while let Ok(Some(line)) = stdout_lines.next_line().await {
-                        tx.send(ModuleUpdateEvent::Update(line.to_string()))
-                            .await
-                            .expect("Failed to send stdout");
-                    }
-
-                    sleep(tokio::time::Duration::from_millis(interval)).await;
-                }
-            }),
-        };
+                                    .suggestion("If you expect the script to write to stderr, consider redirecting its output to /dev/null to suppress these messages"));
+               }
+           }).await;
+        });
 
         Ok(())
     }