feat: modularize the event system and add helper macros for creating …

…messages

src/ipc/pipe/platform/unix/client.rs

@@ -4,7 +4,11 @@ use std::sync::mpsc::Sender;
 use std::thread::JoinHandle;
 
 use crate::ipc::pipe::PipeClientImpl;
-use crate::messages::message::{ClientMessage, Event, LocalMessage, Message};
+use crate::local_event;
+use crate::messages::events::client::ClientEvent;
+use crate::messages::events::event::Event;
+use crate::messages::events::local::{ClientDisconnectedEvent, ErrorEvent};
+use crate::messages::message::Message;
 
 pub struct PipeClient {
     id: u32,
@@ -45,26 +49,19 @@ impl PipeClientImpl for PipeClient {
                 loop {
                     match read_pipe.read(&mut buf) {
                         Ok(n) if n == 0 => {
-                            tx.send(Message::new(
-                                id,
-                                Event::Local(LocalMessage::ClientDisconnected),
-                            ))
-                            .ok();
+                            tx.send(local_event!(id, ClientDisconnected)).ok();
                             break;
                         }
                         Ok(n) => {
                             if let Ok(message) =
-                                ClientMessage::deserialize(&String::from_utf8_lossy(&buf[..n]))
+                                ClientEvent::deserialize(&String::from_utf8_lossy(&buf[..n]))
                             {
                                 tx.send(Message::new(id, Event::Client(message))).ok();
                             }
                         }
                         Err(e) => {
-                            tx.send(Message::new(
-                                id,
-                                Event::Local(LocalMessage::Error(Box::new(e))),
-                            ))
-                            .ok();
+                            tx.send(local_event!(id, Error, ErrorEvent::new(Box::new(e))))
+                                .ok();
                             break;
                         }
                     }

src/ipc/pipe/platform/unix/server.rs

@@ -8,7 +8,9 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 
 use crate::ipc::pipe::{PipeClientImpl, PipeServerImpl};
-use crate::messages::message::{Event, LocalMessage, Message};
+use crate::local_event;
+use crate::messages::events::local::ErrorEvent;
+use crate::messages::message::Message;
 
 use super::client::PipeClient;
 
@@ -64,11 +66,8 @@ impl PipeServerImpl for PipeServer {
                         clients.lock().unwrap().insert(client_id, client);
                     }
                     Err(e) => {
-                        tx.send(Message::new(
-                            0,
-                            Event::Local(LocalMessage::Error(Box::new(e))),
-                        ))
-                        .ok();
+                        tx.send(local_event!(0, Error, ErrorEvent::new(Box::new(e))))
+                            .ok();
                     }
                 }
             }

src/ipc/pipe/platform/windows/client.rs

@@ -5,7 +5,11 @@ use std::sync::Arc;
 use std::thread::JoinHandle;
 
 use crate::ipc::pipe::PipeClientImpl;
-use crate::messages::message::{ClientMessage, Event, LocalMessage, Message};
+use crate::local_event;
+use crate::messages::events::client::ClientEvent;
+use crate::messages::events::event::Event;
+use crate::messages::events::local::{ClientDisconnectedEvent, ErrorEvent};
+use crate::messages::message::Message;
 
 pub struct PipeClient {
     id: u32,
@@ -43,26 +47,19 @@ impl PipeClientImpl for PipeClient {
                 loop {
                     match pipe.read(&mut buf) {
                         Ok(n) if n == 0 => {
-                            tx.send(Message::new(
-                                id,
-                                Event::Local(LocalMessage::ClientDisconnected),
-                            ))
-                            .ok();
+                            tx.send(local_event!(id, ClientDisconnected)).ok();
                             break;
                         }
                         Ok(n) => {
                             if let Ok(message) =
-                                ClientMessage::deserialize(&String::from_utf8_lossy(&buf[..n]))
+                                ClientEvent::deserialize(&String::from_utf8_lossy(&buf[..n]))
                             {
                                 tx.send(Message::new(id, Event::Client(message))).ok();
                             }
                         }
                         Err(e) => {
-                            tx.send(Message::new(
-                                id,
-                                Event::Local(LocalMessage::Error(Box::new(e))),
-                            ))
-                            .ok();
+                            tx.send(local_event!(id, Error, ErrorEvent::new(Box::new(e))))
+                                .ok();
                             break;
                         }
                     }

src/ipc/pipe/platform/windows/server.rs

@@ -8,7 +8,9 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 
 use crate::ipc::pipe::{PipeClientImpl, PipeServerImpl};
-use crate::messages::message::{Event, LocalMessage, Message};
+use crate::local_event;
+use crate::messages::events::local::ErrorEvent;
+use crate::messages::message::Message;
 
 use super::client::PipeClient;
 
@@ -84,11 +86,12 @@ impl PipeServerImpl for PipeServer {
                                 let error = GetLastError();
                                 if error != ERROR_PIPE_CONNECTED {
                                     CloseHandle(handle);
-                                    tx.send(Message::new(
+                                    tx.send(local_event!(
                                         0,
-                                        Event::Local(LocalMessage::Error(Box::new(
-                                            io::Error::from_raw_os_error(error as _),
-                                        ))),
+                                        Error,
+                                        ErrorEvent::new(Box::new(io::Error::from_raw_os_error(
+                                            error as _
+                                        )))
                                     ))
                                     .ok();
                                     continue;

src/main.rs

@@ -4,7 +4,10 @@ use ipc::{
     discord::client::{Connection, RichClient},
     pipe::{platform::server::PipeServer, PipeServerImpl},
 };
-use messages::message::{Event, LocalMessage, Message};
+use messages::{
+    events::{event::Event, local::LocalEvent},
+    message::Message,
+};
 
 mod ipc;
 mod json;
@@ -22,15 +25,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     pipe.start()?;
 
     while let Ok(message) = rx.recv() {
-        match message.message {
+        match message.event {
             Event::Client(_client_message) => {}
             Event::Local(server_message) => match server_message {
-                LocalMessage::ClientDisconnected => {
+                LocalEvent::ClientDisconnected(_) => {
                     println!("Client {} disconnected", message.client_id);
                     break;
                 }
-                LocalMessage::Error(e) => {
-                    println!("Error: {}", e);
+                LocalEvent::Error(event) => {
+                    println!("Error: {}", event.error);
                     break;
                 }
             },

src/messages/events/client/clear_activity.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Default)]
+pub struct ClearActivityEvent;
+
+impl ClearActivityEvent {
+    pub fn on_clear_activity(self) {}
+}

src/messages/events/client/connect.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Default)]
+pub struct ConnectEvent;
+
+impl ConnectEvent {
+    pub fn on_connect(self) {}
+}

src/messages/events/client/disconnect.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Default)]
+pub struct DisconnectEvent;
+
+impl DisconnectEvent {
+    pub fn on_disconnect(self) {}
+}

src/messages/events/client/initialize.rs

@@ -0,0 +1,14 @@
+use crate::types::Config;
+
+#[derive(Debug)]
+pub struct InitializeEvent {
+    pub config: Config,
+}
+
+impl InitializeEvent {
+    pub fn new(config: Config) -> Self {
+        Self { config }
+    }
+
+    pub fn on_initialize(self) {}
+}

src/messages/events/client/mod.rs

@@ -0,0 +1,74 @@
+use crate::{
+    json::deserialize::{Deserializable, Json},
+    presence::activity::ActivityContext,
+    types::Config,
+};
+
+pub mod clear_activity;
+pub mod connect;
+pub mod disconnect;
+pub mod initialize;
+pub mod reset_timestamp;
+pub mod update_activity;
+pub mod update_workspace;
+
+pub use clear_activity::ClearActivityEvent;
+pub use connect::ConnectEvent;
+pub use disconnect::DisconnectEvent;
+pub use initialize::InitializeEvent;
+pub use reset_timestamp::ResetTimestampEvent;
+pub use update_activity::UpdateActivityEvent;
+pub use update_workspace::UpdateWorkspaceEvent;
+
+#[derive(Debug)]
+pub enum ClientEvent {
+    Connect(ConnectEvent),
+    Initialize(InitializeEvent),
+    UpdateActivity(UpdateActivityEvent),
+    ClearActivity(ClearActivityEvent),
+    UpdateWorkspace(UpdateWorkspaceEvent),
+    ResetTimestamp(ResetTimestampEvent),
+    Disconnect(DisconnectEvent),
+}
+
+macro_rules! data {
+    ($map:expr) => {
+        $map.get("data")
+            .and_then(|v| v.as_map())
+            .ok_or("Missing or invalid 'data' field")?
+    };
+    ($map:expr, $expr:expr) => {
+        $map.get("data")
+            .and_then($expr)
+            .ok_or("Missing or invalid 'data' field")?
+    };
+}
+
+impl ClientEvent {
+    // { type: string, data: any }
+    pub fn deserialize(json: &str) -> Result<Self, String> {
+        let map = Json::deserialize(json)?;
+
+        let ty = map
+            .get("type")
+            .and_then(|v| v.as_str())
+            .ok_or("Missing 'type' field")?;
+
+        Ok(match ty {
+            "connect" => Self::Connect(ConnectEvent),
+            "initialize" => {
+                Self::Initialize(InitializeEvent::new(Config::deserialize(data!(map))?))
+            }
+            "update_activity" => Self::UpdateActivity(UpdateActivityEvent::new(
+                ActivityContext::deserialize(data!(map))?,
+            )),
+            "clear_activity" => Self::ClearActivity(ClearActivityEvent),
+            "update_workspace" => {
+                Self::UpdateWorkspace(UpdateWorkspaceEvent::new(data!(map, |v| v.as_string())))
+            }
+            "reset_timestamp" => Self::ResetTimestamp(ResetTimestampEvent),
+            "disconnect" => Self::Disconnect(DisconnectEvent),
+            _ => return Err(format!("Unknown message type: {}", ty)),
+        })
+    }
+}

src/messages/events/client/reset_timestamp.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Default)]
+pub struct ResetTimestampEvent;
+
+impl ResetTimestampEvent {
+    pub fn on_timestamp_reset(self) {}
+}

src/messages/events/client/update_activity.rs

@@ -0,0 +1,14 @@
+use crate::presence::activity::ActivityContext;
+
+#[derive(Debug)]
+pub struct UpdateActivityEvent {
+    pub context: ActivityContext,
+}
+
+impl UpdateActivityEvent {
+    pub fn new(context: ActivityContext) -> Self {
+        Self { context }
+    }
+
+    pub fn on_update_activity(self) {}
+}

src/messages/events/client/update_workspace.rs

@@ -0,0 +1,12 @@
+#[derive(Debug)]
+pub struct UpdateWorkspaceEvent {
+    pub workspace: String,
+}
+
+impl UpdateWorkspaceEvent {
+    pub fn new(workspace: String) -> Self {
+        Self { workspace }
+    }
+
+    pub fn on_update_workspace(self) {}
+}

src/messages/events/event.rs

@@ -0,0 +1,7 @@
+use super::{client::ClientEvent, local::LocalEvent};
+
+#[derive(Debug)]
+pub enum Event {
+    Client(ClientEvent),
+    Local(LocalEvent),
+}

src/messages/events/local/client_disconnected.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, Default)]
+pub struct ClientDisconnectedEvent;
+
+impl ClientDisconnectedEvent {
+    pub fn on_client_disconnected(self) {}
+}

src/messages/events/local/error.rs

@@ -0,0 +1,14 @@
+type Error = Box<dyn std::error::Error + Send + Sync>;
+
+#[derive(Debug)]
+pub struct ErrorEvent {
+    pub error: Error,
+}
+
+impl ErrorEvent {
+    pub fn new(error: Error) -> Self {
+        Self { error }
+    }
+
+    pub fn on_error(self) {}
+}

src/messages/events/local/mod.rs

@@ -0,0 +1,11 @@
+pub mod client_disconnected;
+pub mod error;
+
+pub use client_disconnected::ClientDisconnectedEvent;
+pub use error::ErrorEvent;
+
+#[derive(Debug)]
+pub enum LocalEvent {
+    ClientDisconnected(ClientDisconnectedEvent),
+    Error(ErrorEvent),
+}

src/messages/events/mod.rs

@@ -0,0 +1,3 @@
+pub mod client;
+pub mod event;
+pub mod local;