refactor: standardise error messages

src/bar.rs

@@ -4,7 +4,7 @@ use crate::dynamic_string::DynamicString;
 use crate::modules::{Module, ModuleInfo, ModuleLocation, ModuleUpdateEvent, WidgetContext};
 use crate::popup::Popup;
 use crate::script::{OutputStream, Script};
-use crate::{await_sync, Config};
+use crate::{await_sync, error as err, Config};
 use color_eyre::Result;
 use gtk::gdk::Monitor;
 use gtk::prelude::*;
@@ -253,7 +253,7 @@ where
 fn register_popup_content(popup: &Arc<RwLock<Popup>>, id: usize, popup_content: gtk::Box) {
     popup
         .write()
-        .expect("Failed to get write lock on popup")
+        .expect(err::ERR_WRITE_LOCK)
         .register_content(id, popup_content);
 }
 
@@ -277,15 +277,14 @@ fn setup_receiver<TSend>(
         match ev {
             ModuleUpdateEvent::Update(update) => {
                 if has_popup {
-                    p_tx.send(update.clone())
+                    p_tx.send(update.clone()).expect(err::ERR_CHANNEL_SEND);
-                        .expect("Failed to send update to popup");
                 }
 
-                w_tx.send(update).expect("Failed to send update to widget");
+                w_tx.send(update).expect(err::ERR_CHANNEL_SEND);
             }
             ModuleUpdateEvent::TogglePopup(geometry) => {
                 debug!("Toggling popup for {} [#{}]", name, id);
-                let popup = popup.read().expect("Failed to get read lock on popup");
+                let popup = popup.read().expect(err::ERR_READ_LOCK);
                 if popup.is_visible() {
                     popup.hide();
                 } else {
@@ -296,7 +295,7 @@ fn setup_receiver<TSend>(
             ModuleUpdateEvent::OpenPopup(geometry) => {
                 debug!("Opening popup for {} [#{}]", name, id);
 
-                let popup = popup.read().expect("Failed to get read lock on popup");
+                let popup = popup.read().expect(err::ERR_READ_LOCK);
                 popup.hide();
                 popup.show_content(id);
                 popup.show(geometry);
@@ -304,7 +303,7 @@ fn setup_receiver<TSend>(
             ModuleUpdateEvent::ClosePopup => {
                 debug!("Closing popup for {} [#{}]", name, id);
 
-                let popup = popup.read().expect("Failed to get read lock on popup");
+                let popup = popup.read().expect(err::ERR_READ_LOCK);
                 popup.hide();
             }
         }
@@ -334,8 +333,7 @@ fn setup_module_common_options(container: EventBox, common: CommonConfig) {
             spawn(async move {
                 script
                     .run(|(_, success)| {
-                        tx.send(success)
+                        tx.send(success).expect(err::ERR_CHANNEL_SEND);
-                            .expect("Failed to send widget visibility toggle message");
                     })
                     .await;
             });

src/bridge_channel.rs

@@ -1,3 +1,4 @@
+use crate::error;
 use tokio::spawn;
 use tokio::sync::mpsc;
 
@@ -21,7 +22,7 @@ impl<T: Send + 'static> BridgeChannel<T> {
 
         spawn(async move {
             while let Some(val) = async_rx.recv().await {
-                sync_tx.send(val).expect("Failed to send message");
+                sync_tx.send(val).expect(error::ERR_CHANNEL_SEND);
             }
         });
 

src/clients/wayland/client.rs

@@ -18,6 +18,7 @@ use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
     zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
     zwlr_foreign_toplevel_manager_v1::ZwlrForeignToplevelManagerV1,
 };
+use crate::error as err;
 
 pub struct WaylandClient {
     pub outputs: Vec<OutputInfo>,
@@ -48,7 +49,7 @@ impl WaylandClient {
             let outputs = Self::get_outputs(&env);
             output_tx
                 .send(outputs)
-                .expect("Failed to send outputs out of task");
+                .expect(err::ERR_CHANNEL_SEND);
 
             let seats = env.get_all_seats();
             seat_tx
@@ -58,7 +59,7 @@ impl WaylandClient {
                         .map(|seat| seat.detach())
                         .collect::<Vec<WlSeat>>(),
                 )
-                .expect("Failed to send seats out of task");
+                .expect(err::ERR_CHANNEL_SEND);
 
             let _toplevel_manager = env.require_global::<ZwlrForeignToplevelManagerV1>();
 
@@ -68,18 +69,18 @@ impl WaylandClient {
                 if event.change == ToplevelChange::Close {
                     toplevels2
                         .write()
-                        .expect("Failed to get write lock on toplevels")
+                        .expect(err::ERR_WRITE_LOCK)
                         .remove(&event.toplevel.id);
                 } else {
                     toplevels2
                         .write()
-                        .expect("Failed to get write lock on toplevels")
+                        .expect(err::ERR_WRITE_LOCK)
                         .insert(event.toplevel.id, (event.toplevel.clone(), handle));
                 }
 
                 toplevel_tx2
                     .send(event)
-                    .expect("Failed to send toplevel event");
+                    .expect(err::ERR_CHANNEL_SEND);
             });
 
             let mut event_loop =
@@ -101,9 +102,9 @@ impl WaylandClient {
 
         let outputs = output_rx
             .await
-            .expect("Failed to receive outputs from task");
+            .expect(err::ERR_CHANNEL_RECV);
 
-        let seats = seat_rx.await.expect("Failed to receive seats from task");
+        let seats = seat_rx.await.expect(err::ERR_CHANNEL_RECV);
 
         Self {
             outputs,

src/clients/wayland/toplevel.rs

@@ -4,6 +4,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use tracing::trace;
 use wayland_client::{DispatchData, Main};
 use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::zwlr_foreign_toplevel_handle_v1::{Event, ZwlrForeignToplevelHandleV1};
+use crate::error;
 
 const STATE_ACTIVE: u32 = 2;
 const STATE_FULLSCREEN: u32 = 3;
@@ -144,7 +145,7 @@ impl Toplevel {
         handle.quick_assign(move |_handle, event, ddata| {
             let mut inner = inner
                 .write()
-                .expect("Failed to get write lock on toplevel inner state");
+                .expect(error::ERR_WRITE_LOCK);
             toplevel_implem(event, &mut inner, &mut callback, ddata);
         });
 

src/config.rs

@@ -63,6 +63,8 @@ impl Default for BarPosition {
 }
 
 impl BarPosition {
+    /// Gets the orientation the bar and widgets should use
+    /// based on this position.
     pub fn get_orientation(self) -> Orientation {
         if self == Self::Top || self == Self::Bottom {
             Orientation::Horizontal
@@ -71,6 +73,8 @@ impl BarPosition {
         }
     }
 
+    /// Gets the angle that label text should be displayed at
+    /// based on this position.
     pub const fn get_angle(self) -> f64 {
         match self {
             Self::Top | Self::Bottom => 0.0,

src/dynamic_string.rs

@@ -1,3 +1,4 @@
+use crate::error;
 use crate::script::{OutputStream, Script};
 use gtk::prelude::*;
 use indexmap::IndexMap;
@@ -10,9 +11,7 @@ enum DynamicStringSegment {
     Dynamic(Script),
 }
 
-pub struct DynamicString {
+pub struct DynamicString;
-    // pub label: gtk::Label,
-}
 
 impl DynamicString {
     pub fn new<F>(input: &str, f: F) -> Self
@@ -69,7 +68,7 @@ impl DynamicString {
                 DynamicStringSegment::Static(str) => {
                     label_parts
                         .lock()
-                        .expect("Failed to get lock on label parts")
+                        .expect(error::ERR_MUTEX_LOCK)
                         .insert(i, str);
                 }
                 DynamicStringSegment::Dynamic(script) => {
@@ -80,9 +79,8 @@ impl DynamicString {
                         script
                             .run(|(out, _)| {
                                 if let OutputStream::Stdout(out) = out {
-                                    let mut label_parts = label_parts
+                                    let mut label_parts =
-                                        .lock()
+                                        label_parts.lock().expect(error::ERR_MUTEX_LOCK);
-                                        .expect("Failed to get lock on label parts");
 
                                     label_parts
                                         // .lock()
@@ -94,7 +92,7 @@ impl DynamicString {
                                         .map(|(_, part)| part.as_str())
                                         .collect::<String>();
 
-                                    tx.send(string).expect("Failed to send update");
+                                    tx.send(string).expect(error::ERR_CHANNEL_SEND);
                                 }
                             })
                             .await;
@@ -107,18 +105,17 @@ impl DynamicString {
         {
             let label_parts = label_parts
                 .lock()
-                .expect("Failed to get lock on label parts")
+                .expect(error::ERR_MUTEX_LOCK)
                 .iter()
                 .map(|(_, part)| part.as_str())
                 .collect::<String>();
 
-            tx.send(label_parts).expect("Failed to send update");
+            tx.send(label_parts).expect(error::ERR_CHANNEL_SEND);
         }
 
         rx.attach(None, f);
 
-        // Self { label }
+        Self
-        Self {}
     }
 }
 

src/error.rs

@@ -0,0 +1,13 @@
+#[repr(i32)]
+pub enum ExitCode {
+    GtkDisplay = 1,
+    CreateBars = 2,
+    Config = 3,
+}
+
+pub const ERR_OUTPUTS: &str = "GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen";
+pub const ERR_MUTEX_LOCK: &str = "Failed to get lock on Mutex";
+pub const ERR_READ_LOCK: &str = "Failed to get read lock";
+pub const ERR_WRITE_LOCK: &str = "Failed to get write lock";
+pub const ERR_CHANNEL_SEND: &str = "Failed to send message to channel";
+pub const ERR_CHANNEL_RECV: &str = "Failed to receive message from channel";

src/main.rs

@@ -3,6 +3,7 @@ mod bridge_channel;
 mod clients;
 mod config;
 mod dynamic_string;
+mod error;
 mod icon;
 mod logging;
 mod modules;
@@ -30,6 +31,7 @@ use crate::error::ExitCode;
 use clients::wayland::{self, WaylandClient};
 use tracing::{debug, error, info};
 
+const GTK_APP_ID: &str = "dev.jstanger.ironbar";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 #[tokio::main]
@@ -41,9 +43,7 @@ async fn main() -> Result<()> {
 
     let wayland_client = wayland::get_client().await;
 
-    let app = Application::builder()
+    let app = Application::builder().application_id(GTK_APP_ID).build();
-        .application_id("dev.jstanger.ironbar")
-        .build();
 
     app.connect_activate(move |app| {
         let display = Display::default().map_or_else(
@@ -112,8 +112,12 @@ fn create_bars(
     let num_monitors = display.n_monitors();
 
     for i in 0..num_monitors {
-        let monitor = display.monitor(i).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?;
+        let monitor = display
-        let output = outputs.get(i as usize).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?;
+            .monitor(i)
+            .ok_or_else(|| Report::msg(error::ERR_OUTPUTS))?;
+        let output = outputs
+            .get(i as usize)
+            .ok_or_else(|| Report::msg(error::ERR_OUTPUTS))?;
         let monitor_name = &output.name;
 
         // TODO: Could we use an Arc<Config> or `Cow<Config>` here to avoid cloning?

src/modules/clock.rs

@@ -1,4 +1,5 @@
 use crate::config::CommonConfig;
+use crate::error;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::popup::Popup;
 use chrono::{DateTime, Local};
@@ -48,7 +49,7 @@ impl Module<Button> for ClockModule {
                 let date = Local::now();
                 tx.send(ModuleUpdateEvent::Update(date))
                     .await
-                    .expect("Failed to send date");
+                    .expect(error::ERR_CHANNEL_SEND);
                 sleep(tokio::time::Duration::from_millis(500)).await;
             }
         });
@@ -74,7 +75,7 @@ impl Module<Button> for ClockModule {
                     button,
                     orientation,
                 )))
-                .expect("Failed to toggle popup");
+                .expect(error::ERR_CHANNEL_SEND);
         });
 
         let format = self.format.clone();

src/modules/custom.rs

@@ -1,5 +1,6 @@
 use crate::config::CommonConfig;
 use crate::dynamic_string::DynamicString;
+use crate::error as err;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::popup::{ButtonGeometry, Popup};
 use crate::script::Script;
@@ -119,8 +120,6 @@ impl Widget {
         }
 
         label
-
-        // DynamicString::new(label, &text)
     }
 
     /// Creates a `gtk::Button` from this widget
@@ -150,7 +149,7 @@ impl Widget {
                     cmd: exec.clone(),
                     geometry: Popup::button_pos(button, bar_orientation),
                 })
-                .expect("Failed to send exec message");
+                .expect(err::ERR_CHANNEL_SEND);
             });
         }
 
@@ -191,15 +190,15 @@ impl Module<gtk::Box> for CustomModule {
                 } else if event.cmd == "popup:toggle" {
                     tx.send(ModuleUpdateEvent::TogglePopup(event.geometry))
                         .await
-                        .expect("Failed to send open popup event");
+                        .expect(err::ERR_CHANNEL_SEND);
                 } else if event.cmd == "popup:open" {
                     tx.send(ModuleUpdateEvent::OpenPopup(event.geometry))
                         .await
-                        .expect("Failed to send open popup event");
+                        .expect(err::ERR_CHANNEL_SEND);
                 } else if event.cmd == "popup:close" {
                     tx.send(ModuleUpdateEvent::ClosePopup)
                         .await
-                        .expect("Failed to send open popup event");
+                        .expect(err::ERR_CHANNEL_SEND);
                 } else {
                     error!("Received invalid command: '{}'", event.cmd);
                 }

src/modules/focused.rs

@@ -1,7 +1,7 @@
 use crate::clients::wayland::{self, ToplevelChange};
 use crate::config::CommonConfig;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::{await_sync, icon};
+use crate::{await_sync, error, icon};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;
@@ -49,11 +49,7 @@ impl Module<gtk::Box> for FocusedModule {
     ) -> Result<()> {
         let focused = await_sync(async {
             let wl = wayland::get_client().await;
-            let toplevels = wl
+            let toplevels = wl.toplevels.read().expect(error::ERR_READ_LOCK).clone();
-                .toplevels
-                .read()
-                .expect("Failed to get read lock on toplevels")
-                .clone();
 
             toplevels.into_iter().find(|(_, (top, _))| top.active)
         });
@@ -81,7 +77,7 @@ impl Module<gtk::Box> for FocusedModule {
                         event.toplevel.app_id,
                     )))
                     .await
-                    .expect("Failed to send focus update");
+                    .expect(error::ERR_CHANNEL_SEND);
                 }
             }
         });

src/modules/launcher/item.rs

@@ -1,5 +1,6 @@
 use super::open_state::OpenState;
 use crate::clients::wayland::ToplevelInfo;
+use crate::error;
 use crate::icon::get_icon;
 use crate::modules::launcher::{ItemEvent, LauncherUpdate};
 use crate::modules::ModuleUpdateEvent;
@@ -181,10 +182,10 @@ impl ItemButton {
                 let style_context = button.style_context();
                 if style_context.has_class("open") {
                     tx.try_send(ItemEvent::FocusItem(app_id.clone()))
-                        .expect("Failed to send item focus event");
+                        .expect(error::ERR_CHANNEL_SEND);
                 } else {
                     tx.try_send(ItemEvent::OpenItem(app_id.clone()))
-                        .expect("Failed to send item open event");
+                        .expect(error::ERR_CHANNEL_SEND);
                 }
             });
         }
@@ -199,24 +200,22 @@ impl ItemButton {
             let menu_state = menu_state.clone();
 
             button.connect_enter_notify_event(move |button, _| {
-                let menu_state = menu_state
+                let menu_state = menu_state.read().expect(error::ERR_READ_LOCK);
-                    .read()
-                    .expect("Failed to get read lock on item menu state");
 
                 if menu_state.num_windows > 1 {
                     tx.try_send(ModuleUpdateEvent::Update(LauncherUpdate::Hover(
                         app_id.clone(),
                     )))
-                    .expect("Failed to send item open popup event");
+                    .expect(error::ERR_CHANNEL_SEND);
 
                     tx.try_send(ModuleUpdateEvent::OpenPopup(Popup::button_pos(
                         button,
                         orientation,
                     )))
-                    .expect("Failed to send item open popup event");
+                    .expect(error::ERR_CHANNEL_SEND);
                 } else {
                     tx.try_send(ModuleUpdateEvent::ClosePopup)
-                        .expect("Failed to send item close popup event");
+                        .expect(error::ERR_CHANNEL_SEND);
                 }
 
                 Inhibit(false)

src/modules/launcher/mod.rs

@@ -5,6 +5,7 @@ use self::item::{Item, ItemButton, Window};
 use self::open_state::OpenState;
 use crate::clients::wayland::{self, ToplevelChange};
 use crate::config::CommonConfig;
+use crate::error as err;
 use crate::icon::find_desktop_file;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::{Help, Report};
@@ -110,12 +111,9 @@ impl Module<gtk::Box> for LauncherModule {
             let tx = tx.clone();
             spawn(async move {
                 let wl = wayland::get_client().await;
-                let open_windows = wl
+                let open_windows = wl.toplevels.read().expect(err::ERR_READ_LOCK);
-                    .toplevels
-                    .read()
-                    .expect("Failed to get read lock on toplevels");
 
-                let mut items = items.lock().expect("Failed to get lock on items");
+                let mut items = items.lock().expect(err::ERR_MUTEX_LOCK);
 
                 for (_, (window, _)) in open_windows.clone() {
                     let item = items.get_mut(&window.app_id);
@@ -157,7 +155,7 @@ impl Module<gtk::Box> for LauncherModule {
                 let window = event.toplevel;
                 let app_id = window.app_id.clone();
 
-                let items = || items.lock().expect("Failed to get lock on items");
+                let items = || items.lock().expect(err::ERR_MUTEX_LOCK);
 
                 match event.change {
                     ToplevelChange::New => {
@@ -218,6 +216,7 @@ impl Module<gtk::Box> for LauncherModule {
                         };
                     }
                     ToplevelChange::Focus(focused) => {
+                        // TODO: Flatten this
                         let update_title = if focused {
                             if let Some(item) = items().get_mut(&app_id) {
                                 item.set_window_focused(window.id, true);
@@ -269,6 +268,7 @@ impl Module<gtk::Box> for LauncherModule {
                             if let Err(err) = Command::new("gtk-launch")
                                 .arg(
                                     file.file_name()
+                                        // TODO: Don't panic for this
                                         .expect("File segment missing from path to desktop file"),
                                 )
                                 .stdout(Stdio::null())
@@ -286,7 +286,7 @@ impl Module<gtk::Box> for LauncherModule {
                     );
                 } else {
                     let wl = wayland::get_client().await;
-                    let items = items.lock().expect("Failed to get lock on items");
+                    let items = items.lock().expect(err::ERR_MUTEX_LOCK);
 
                     let id = match event {
                         ItemEvent::FocusItem(app_id) => items
@@ -297,10 +297,7 @@ impl Module<gtk::Box> for LauncherModule {
                     };
 
                     if let Some(id) = id {
-                        let toplevels = wl
+                        let toplevels = wl.toplevels.read().expect(err::ERR_READ_LOCK);
-                            .toplevels
-                            .read()
-                            .expect("Failed to get read lock on toplevels");
                         let seat = wl.seats.first().expect("Failed to get Wayland seat");
                         if let Some((_top, handle)) = toplevels.get(&id) {
                             handle.activate(seat);
@@ -363,10 +360,8 @@ impl Module<gtk::Box> for LauncherModule {
                         if let Some(button) = buttons.get(&app_id) {
                             button.set_open(true);
 
-                            let mut menu_state = button
+                            let mut menu_state =
-                                .menu_state
+                                button.menu_state.write().expect(err::ERR_WRITE_LOCK);
-                                .write()
-                                .expect("Failed to get write lock on item menu state");
                             menu_state.num_windows += 1;
                         }
                     }
@@ -387,10 +382,8 @@ impl Module<gtk::Box> for LauncherModule {
                     }
                     LauncherUpdate::RemoveWindow(app_id, _) => {
                         if let Some(button) = buttons.get(&app_id) {
-                            let mut menu_state = button
+                            let mut menu_state =
-                                .menu_state
+                                button.menu_state.write().expect(err::ERR_WRITE_LOCK);
-                                .write()
-                                .expect("Failed to get write lock on item menu state");
                             menu_state.num_windows -= 1;
                         }
                     }
@@ -464,7 +457,7 @@ impl Module<gtk::Box> for LauncherModule {
                                     let tx = controller_tx.clone();
                                     button.connect_clicked(move |button| {
                                         tx.try_send(ItemEvent::FocusWindow(win.id))
-                                            .expect("Failed to send window click event");
+                                            .expect(err::ERR_CHANNEL_SEND);
 
                                         if let Some(win) = button.window() {
                                             win.hide();
@@ -494,7 +487,7 @@ impl Module<gtk::Box> for LauncherModule {
                                 let tx = controller_tx.clone();
                                 button.connect_clicked(move |button| {
                                     tx.try_send(ItemEvent::FocusWindow(win.id))
-                                        .expect("Failed to send window click event");
+                                        .expect(err::ERR_CHANNEL_SEND);
 
                                     if let Some(win) = button.window() {
                                         win.hide();

src/modules/mpd.rs

@@ -1,5 +1,6 @@
 use crate::clients::mpd::{get_client, get_duration, get_elapsed, MpdConnectionError};
 use crate::config::CommonConfig;
+use crate::error as err;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::popup::Popup;
 use color_eyre::Result;
@@ -229,7 +230,7 @@ impl Module<Button> for MpdModule {
                     button,
                     orientation,
                 )))
-                .expect("Failed to send MPD popup open event");
+                .expect(err::ERR_CHANNEL_SEND);
             });
         }
 
@@ -244,7 +245,7 @@ impl Module<Button> for MpdModule {
                 } else {
                     button.hide();
                     tx.try_send(ModuleUpdateEvent::ClosePopup)
-                        .expect("Failed to send close popup message");
+                        .expect(err::ERR_CHANNEL_SEND);
                 }
 
                 Continue(true)
@@ -324,28 +325,28 @@ impl Module<Button> for MpdModule {
         btn_prev.connect_clicked(move |_| {
             tx_prev
                 .try_send(PlayerCommand::Previous)
-                .expect("Failed to send prev track message");
+                .expect(err::ERR_CHANNEL_SEND);
         });
 
         let tx_toggle = tx.clone();
         btn_play_pause.connect_clicked(move |_| {
             tx_toggle
                 .try_send(PlayerCommand::Toggle)
-                .expect("Failed to send play/pause track message");
+                .expect(err::ERR_CHANNEL_SEND);
         });
 
         let tx_next = tx.clone();
         btn_next.connect_clicked(move |_| {
             tx_next
                 .try_send(PlayerCommand::Next)
-                .expect("Failed to send next track message");
+                .expect(err::ERR_CHANNEL_SEND);
         });
 
         let tx_vol = tx;
         volume_slider.connect_change_value(move |_, _, val| {
             tx_vol
                 .try_send(PlayerCommand::Volume(val as u8))
-                .expect("Failed to send volume message");
+                .expect(err::ERR_CHANNEL_SEND);
 
             Inhibit(false)
         });

src/modules/sysinfo.rs

@@ -1,4 +1,5 @@
 use crate::config::CommonConfig;
+use crate::error;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::Result;
 use gtk::prelude::*;
@@ -146,7 +147,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::Memory)
                         .await
-                        .expect("Failed to send memory refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.memory())).await;
                 }
             });
@@ -159,7 +160,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::Cpu)
                         .await
-                        .expect("Failed to send cpu refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.cpu())).await;
                 }
             });
@@ -172,7 +173,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::Temps)
                         .await
-                        .expect("Failed to send temperature refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.temps())).await;
                 }
             });
@@ -185,7 +186,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::Disks)
                         .await
-                        .expect("Failed to send disk refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.disks())).await;
                 }
             });
@@ -198,7 +199,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::Network)
                         .await
-                        .expect("Failed to send network refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.networks())).await;
                 }
             });
@@ -211,7 +212,7 @@ impl Module<gtk::Box> for SysInfoModule {
                 loop {
                     tx.send(RefreshType::System)
                         .await
-                        .expect("Failed to send system refresh");
+                        .expect(error::ERR_CHANNEL_SEND);
                     sleep(Duration::from_secs(interval.system())).await;
                 }
             });
@@ -234,7 +235,7 @@ impl Module<gtk::Box> for SysInfoModule {
 
                 tx.send(ModuleUpdateEvent::Update(format_info.clone()))
                     .await
-                    .expect("Failed to send system info map");
+                    .expect(error::ERR_CHANNEL_SEND);
             }
         });
 

src/modules/tray.rs

@@ -1,7 +1,7 @@
-use crate::await_sync;
 use crate::clients::system_tray::get_tray_event_client;
 use crate::config::CommonConfig;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::{await_sync, error};
 use color_eyre::Result;
 use gtk::prelude::*;
 use gtk::{IconLookupFlags, IconTheme, Image, Menu, MenuBar, MenuItem, SeparatorMenuItem};
@@ -75,7 +75,7 @@ fn get_menu_items(
                                 menu_path: path.clone(),
                                 notifier_address: id.clone(),
                             })
-                            .expect("Failed to send menu item clicked event");
+                            .expect(error::ERR_CHANNEL_SEND);
                         });
                     }
 

src/modules/workspaces.rs

@@ -1,7 +1,7 @@
-use crate::await_sync;
 use crate::clients::sway::{get_client, get_sub_client};
 use crate::config::CommonConfig;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::{await_sync, error};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::Button;
@@ -53,8 +53,7 @@ fn create_button(
         let tx = tx.clone();
         let name = name.to_string();
         button.connect_clicked(move |_item| {
-            tx.try_send(name.clone())
+            tx.try_send(name.clone()).expect(error::ERR_CHANNEL_SEND);
-                .expect("Failed to send workspace click event");
         });
     }
 
@@ -95,7 +94,7 @@ impl Module<gtk::Box> for WorkspacesModule {
         };
 
         tx.try_send(ModuleUpdateEvent::Update(WorkspaceUpdate::Init(workspaces)))
-            .expect("Failed to send initial workspace list");
+            .expect(error::ERR_CHANNEL_SEND);
 
         // Subscribe & send events
         spawn(async move {
@@ -109,7 +108,7 @@ impl Module<gtk::Box> for WorkspacesModule {
             while let Ok(payload) = srx.recv().await {
                 tx.send(ModuleUpdateEvent::Update(WorkspaceUpdate::Update(payload)))
                     .await
-                    .expect("Failed to send workspace update");
+                    .expect(error::ERR_CHANNEL_SEND);
             }
         });
 

src/script.rs

@@ -1,3 +1,4 @@
+use crate::error as err;
 use color_eyre::eyre::WrapErr;
 use color_eyre::{Report, Result};
 use serde::Deserialize;
@@ -129,12 +130,10 @@ impl From<&str> for Script {
                         .iter()
                         .take_while(|c| c.is_ascii_digit())
                         .collect::<String>();
-                    (
+
-                        ScriptInputToken::Interval(
+                    // TODO: Handle this better than panicking
-                            interval_str.parse::<u64>().expect("Invalid interval"),
+                    let interval = interval_str.parse::<u64>().expect("Invalid interval");
-                        ),
+                    (ScriptInputToken::Interval(interval), interval_str.len())
-                        interval_str.len(),
-                    )
                 }
                 // watching or polling
                 'w' | 'p' => {
@@ -262,10 +261,10 @@ impl Script {
                 select! {
                     _ = handle.wait() => break,
                     Ok(Some(line)) = stdout_lines.next_line() => {
-                        tx.send(OutputStream::Stdout(line)).await.expect("Failed to send stdout");
+                        tx.send(OutputStream::Stdout(line)).await.expect(err::ERR_CHANNEL_SEND);
                     }
                     Ok(Some(line)) = stderr_lines.next_line() => {
-                        tx.send(OutputStream::Stderr(line)).await.expect("Failed to send stderr");
+                        tx.send(OutputStream::Stderr(line)).await.expect(err::ERR_CHANNEL_SEND);
                     }
                 }
             }

src/style.rs

@@ -1,3 +1,4 @@
+use crate::error as err;
 use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::CssProviderExt;
@@ -37,8 +38,7 @@ pub fn load_css(style_path: PathBuf) {
             Ok(event) if event.kind == EventKind::Modify(ModifyKind::Data(DataChange::Any)) => {
                 debug!("{event:?}");
                 if let Some(path) = event.paths.first() {
-                    tx.send(path.clone())
+                    tx.send(path.clone()).expect(err::ERR_CHANNEL_SEND);
-                        .expect("Failed to send style changed message");
                 }
             }
             Err(e) => error!("Error occurred when watching stylesheet: {:?}", e),