feat: implement OnEvent trait for all events

src/cord.rs

@@ -1,7 +1,7 @@
 use std::{
     io,
     sync::{
-        mpsc::{self, Sender},
+        mpsc::{self, Receiver, Sender},
         Arc,
     },
 };
@@ -12,44 +12,58 @@ use crate::{
         pipe::{platform::server::PipeServer, PipeServerImpl},
     },
     local_event,
-    messages::{events::local::ErrorEvent, handler::MessageHandler, message::Message},
+    messages::{
+        events::{
+            event::{EventContext, OnEvent},
+            local::ErrorEvent,
+        },
+        message::Message,
+    },
     server_event,
     types::Config,
 };
 
 pub struct Cord {
     pub config: Option<Config>,
-    pub message_handler: MessageHandler,
     pub rich_client: Arc<RichClient>,
-    pub server: PipeServer,
+    pub pipe: PipeServer,
     pub tx: Sender<Message>,
+    pub rx: Receiver<Message>,
 }
 
 impl Cord {
-    pub fn new(pipe_name: &str, client_id: u64) -> io::Result<Self> {
+    pub fn new(pipe_name: &str, client_id: u64) -> crate::Result<Self> {
         let (tx, rx) = mpsc::channel::<Message>();
-        let message_handler = MessageHandler::new(rx);
         let rich_client = Arc::new(RichClient::connect(client_id)?);
         let server = PipeServer::new(pipe_name, tx.clone());
 
         Ok(Self {
             config: None,
-            message_handler,
             rich_client,
-            server,
+            pipe: server,
             tx,
+            rx,
         })
     }
 
-    pub fn run(&mut self) -> io::Result<()> {
+    pub fn run(&mut self) -> crate::Result<()> {
         self.start_rpc()?;
-        self.server.start()?;
-        self.message_handler.run(&self.server);
+        self.pipe.start()?;
+        self.start_event_loop();
 
         Ok(())
     }
 
-    fn start_rpc(&self) -> io::Result<()> {
+    fn start_event_loop(&mut self) {
+        for msg in self.rx.iter() {
+            msg.event.on_event(&EventContext {
+                pipe: &self.pipe,
+                rich_client: self.rich_client.clone(),
+            });
+        }
+    }
+
+    fn start_rpc(&self) -> crate::Result<()> {
         self.rich_client.handshake()?;
         let rich_client = self.rich_client.clone();
         let tx = self.tx.clone();

src/json/serialize.rs

@@ -12,14 +12,11 @@ pub enum SValue<'a> {
     Object(&'a dyn Serialize),
 }
 
-pub type SerializeFn<'a> = fn(&'a str, SValue<'a>, &mut SerializeState) -> Result<(), String>;
+pub type SerializeFn<'a> = fn(&'a str, SValue<'a>, &mut SerializeState) -> crate::Result<()>;
 
 pub trait Serialize {
-    fn serialize<'a>(
-        &'a self,
-        f: SerializeFn<'a>,
-        state: &mut SerializeState,
-    ) -> Result<(), String>;
+    fn serialize<'a>(&'a self, f: SerializeFn<'a>, state: &mut SerializeState)
+        -> crate::Result<()>;
 }
 
 pub trait SerializeObj: Serialize + std::fmt::Debug {}
@@ -65,12 +62,12 @@ impl<'a> std::fmt::Debug for SValue<'a> {
 }
 
 impl Json {
-    pub fn serialize(value: &dyn Serialize) -> Result<String, String> {
+    pub fn serialize(value: &dyn Serialize) -> crate::Result<String> {
         let mut state = SerializeState::new();
         state.buf.push('{');
         state.push_scope();
 
-        fn write_kv(key: &str, value: &SValue, state: &mut SerializeState) -> Result<(), String> {
+        fn write_kv(key: &str, value: &SValue, state: &mut SerializeState) -> crate::Result<()> {
             if state.needs_comma() {
                 state.buf.push(',');
             }
@@ -84,7 +81,7 @@ impl Json {
             key: &str,
             value: SValue,
             state: &mut SerializeState,
-        ) -> Result<(), String> {
+        ) -> crate::Result<()> {
             write_kv(key, &value, state)
         }
 
@@ -94,7 +91,7 @@ impl Json {
     }
 }
 
-fn write_value(value: &SValue, state: &mut SerializeState) -> Result<(), String> {
+fn write_value(value: &SValue, state: &mut SerializeState) -> crate::Result<()> {
     match value {
         SValue::String(s) => {
             state.buf.push('"');
@@ -104,7 +101,8 @@ fn write_value(value: &SValue, state: &mut SerializeState) -> Result<(), String>
         }
         SValue::Number(n) => {
             use std::fmt::Write;
-            write!(state.buf, "{}", n).map_err(|e| e.to_string())
+            write!(state.buf, "{}", n).map_err(|e| e.to_string())?;
+            Ok(())
         }
         SValue::Boolean(b) => {
             state.buf.push_str(if *b { "true" } else { "false" });

src/main.rs

@@ -3,6 +3,7 @@ use std::env::args;
 use cord::Cord;
 
 mod cord;
+mod error;
 mod ipc;
 mod json;
 mod mappings;
@@ -11,7 +12,9 @@ mod presence;
 mod types;
 mod util;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+use error::Result;
+
+fn main() -> Result<()> {
     let client_id = args().nth(1).ok_or("Missing client ID")?.parse::<u64>()?;
 
     Cord::new("cord-ipc", client_id)?.run().map_err(Into::into)

src/messages/events/client/clear_activity.rs

@@ -1,6 +1,12 @@
 #[derive(Debug, Default)]
 pub struct ClearActivityEvent;
 
+use crate::messages::events::event::{EventContext, OnEvent};
+
 impl ClearActivityEvent {
     pub fn on_clear_activity(self) {}
 }
+
+impl OnEvent for ClearActivityEvent {
+    fn on_event(self, _ctx: &EventContext) {}
+}

src/messages/events/client/connect.rs

@@ -1,6 +1,12 @@
 #[derive(Debug, Default)]
 pub struct ConnectEvent;
 
+use crate::messages::events::event::{EventContext, OnEvent};
+
 impl ConnectEvent {
     pub fn on_connect(self) {}
 }
+
+impl OnEvent for ConnectEvent {
+    fn on_event(self, _ctx: &EventContext) {}
+}

src/messages/events/client/disconnect.rs

@@ -1,6 +1,12 @@
 #[derive(Debug, Default)]
 pub struct DisconnectEvent;
 
+use crate::messages::events::event::{EventContext, OnEvent};
+
 impl DisconnectEvent {
     pub fn on_disconnect(self) {}
 }
+
+impl OnEvent for DisconnectEvent {
+    fn on_event(self, _ctx: &EventContext) {}
+}

src/messages/events/client/initialize.rs

@@ -1,10 +1,15 @@
+use crate::messages::events::event::{EventContext, OnEvent};
 use crate::types::Config;
 
 #[derive(Debug)]
 pub struct InitializeEvent {
     pub config: Config,
 }
 
+impl OnEvent for InitializeEvent {
+    fn on_event(self, _ctx: &EventContext) {}
+}
+
 impl InitializeEvent {
     pub fn new(config: Config) -> Self {
         Self { config }

src/messages/events/client/mod.rs

@@ -1,5 +1,6 @@
 use crate::{
     json::{deserialize::Deserialize, Json},
+    messages::events::event::{EventContext, OnEvent},
     presence::activity::ActivityContext,
     types::Config,
 };
@@ -71,16 +72,18 @@ impl ClientEvent {
             _ => return Err(format!("Unknown message type: {}", ty)),
         })
     }
+}
 
-    pub fn on_event(self) {
+impl OnEvent for ClientEvent {
+    fn on_event(self, ctx: &EventContext) {
         match self {
-            ClientEvent::Connect(event) => event.on_connect(),
-            ClientEvent::Initialize(event) => event.on_initialize(),
-            ClientEvent::UpdateActivity(event) => event.on_update_activity(),
-            ClientEvent::ClearActivity(event) => event.on_clear_activity(),
-            ClientEvent::UpdateWorkspace(event) => event.on_update_workspace(),
-            ClientEvent::ResetTimestamp(event) => event.on_reset_timestamp(),
-            ClientEvent::Disconnect(event) => event.on_disconnect(),
+            Self::Initialize(e) => e.on_event(ctx),
+            Self::Connect(e) => e.on_event(ctx),
+            Self::Disconnect(e) => e.on_event(ctx),
+            Self::UpdateActivity(e) => e.on_event(ctx),
+            Self::ClearActivity(e) => e.on_event(ctx),
+            Self::ResetTimestamp(e) => e.on_event(ctx),
+            Self::UpdateWorkspace(e) => e.on_event(ctx),
         }
     }
 }

src/messages/events/client/reset_timestamp.rs

@@ -1,6 +1,8 @@
+use crate::messages::events::event::{EventContext, OnEvent};
+
 #[derive(Debug, Default)]
 pub struct ResetTimestampEvent;
 
-impl ResetTimestampEvent {
-    pub fn on_reset_timestamp(self) {}
+impl OnEvent for ResetTimestampEvent {
+    fn on_event(self, _ctx: &EventContext) {}
 }

src/messages/events/client/update_activity.rs

@@ -1,3 +1,4 @@
+use crate::messages::events::event::{EventContext, OnEvent};
 use crate::presence::activity::ActivityContext;
 
 #[derive(Debug)]
@@ -9,6 +10,8 @@ impl UpdateActivityEvent {
     pub fn new(context: ActivityContext) -> Self {
         Self { context }
     }
+}
 
-    pub fn on_update_activity(self) {}
+impl OnEvent for UpdateActivityEvent {
+    fn on_event(self, _ctx: &EventContext) {}
 }

src/messages/events/client/update_workspace.rs

@@ -1,3 +1,5 @@
+use crate::messages::events::event::{EventContext, OnEvent};
+
 #[derive(Debug)]
 pub struct UpdateWorkspaceEvent {
     pub workspace: String,
@@ -7,6 +9,8 @@ impl UpdateWorkspaceEvent {
     pub fn new(workspace: String) -> Self {
         Self { workspace }
     }
+}
 
-    pub fn on_update_workspace(self) {}
+impl OnEvent for UpdateWorkspaceEvent {
+    fn on_event(self, _ctx: &EventContext) {}
 }

src/messages/events/event.rs

@@ -1,4 +1,6 @@
-use crate::ipc::pipe::PipeServerImpl;
+use std::sync::Arc;
+
+use crate::ipc::{discord::client::RichClient, pipe::platform::server::PipeServer};
 
 use super::{client::ClientEvent, local::LocalEvent, server::ServerEvent};
 
@@ -9,12 +11,21 @@ pub enum Event {
     Server(ServerEvent),
 }
 
-impl Event {
-    pub fn on_event<T: PipeServerImpl>(self, pipe: &T) {
+pub struct EventContext<'a> {
+    pub pipe: &'a PipeServer,
+    pub rich_client: Arc<RichClient>,
+}
+
+pub trait OnEvent {
+    fn on_event(self, ctx: &EventContext);
+}
+
+impl OnEvent for Event {
+    fn on_event(self, ctx: &EventContext) {
         match self {
-            Event::Client(client_event) => client_event.on_event(),
-            Event::Local(local_event) => local_event.on_event(),
-            Event::Server(server_event) => server_event.on_event(pipe),
+            Event::Client(e) => e.on_event(ctx),
+            Event::Local(e) => e.on_event(ctx),
+            Event::Server(e) => e.on_event(ctx),
         }
     }
 }

src/messages/events/local/client_disconnected.rs

@@ -1,6 +1,8 @@
+use crate::messages::events::event::{EventContext, OnEvent};
+
 #[derive(Debug, Default)]
 pub struct ClientDisconnectedEvent;
 
-impl ClientDisconnectedEvent {
-    pub fn on_client_disconnected(self) {}
+impl OnEvent for ClientDisconnectedEvent {
+    fn on_event(self, _ctx: &EventContext) {}
 }

src/messages/events/local/error.rs

@@ -1,3 +1,5 @@
+use crate::messages::events::event::{EventContext, OnEvent};
+
 type Error = Box<dyn std::error::Error + Send + Sync>;
 
 #[derive(Debug)]
@@ -9,6 +11,8 @@ impl ErrorEvent {
     pub fn new(error: Error) -> Self {
         Self { error }
     }
+}
 
-    pub fn on_error(self) {}
+impl OnEvent for ErrorEvent {
+    fn on_event(self, _ctx: &EventContext) {}
 }

src/messages/events/local/mod.rs

@@ -4,17 +4,19 @@ pub mod error;
 pub use client_disconnected::ClientDisconnectedEvent;
 pub use error::ErrorEvent;
 
+use super::event::{EventContext, OnEvent};
+
 #[derive(Debug)]
 pub enum LocalEvent {
     ClientDisconnected(ClientDisconnectedEvent),
     Error(ErrorEvent),
 }
 
-impl LocalEvent {
-    pub fn on_event(self) {
+impl OnEvent for LocalEvent {
+    fn on_event(self, ctx: &EventContext) {
         match self {
-            LocalEvent::ClientDisconnected(event) => event.on_client_disconnected(),
-            LocalEvent::Error(event) => event.on_error(),
+            Self::ClientDisconnected(e) => e.on_event(ctx),
+            Self::Error(e) => e.on_event(ctx),
         }
     }
 }

src/messages/events/server/log.rs

@@ -3,12 +3,16 @@ pub struct LogEvent {
     pub message: String,
 }
 
+use crate::messages::events::event::{EventContext, OnEvent};
+
+impl OnEvent for LogEvent {
+    fn on_event(self, _ctx: &EventContext) {
+        println!("{}", self.message);
+    }
+}
+
 impl LogEvent {
     pub fn new(message: String) -> Self {
         Self { message }
     }
-
-    pub fn on_log(self) -> Option<(u32, String)> {
-        Some((0, self.message))
-    }
 }