feat: move core to tui and begin grpc work

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/hyperlog-tui/src/events.rs

@@ -0,0 +1,126 @@
+use std::sync::{Arc, Mutex};
+
+use bus::{Bus, BusReader};
+
+use crate::commander::Command;
+
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub enum Event {
+    CommandEvent { command: Command },
+}
+
+#[derive(Clone)]
+pub struct Events {
+    bus: Arc<Mutex<Bus<Event>>>,
+}
+
+impl Default for Events {
+    fn default() -> Self {
+        let bus = Bus::new(10);
+
+        Self {
+            bus: Arc::new(Mutex::new(bus)),
+        }
+    }
+}
+
+impl Events {
+    pub fn enque_command(&self, cmd: Command) -> anyhow::Result<()> {
+        self.bus
+            .lock()
+            .unwrap()
+            .broadcast(Event::CommandEvent { command: cmd });
+
+        Ok(())
+    }
+
+    pub fn subscribe(&self) -> anyhow::Result<BusReader<Event>> {
+        let rx = self.bus.lock().unwrap().add_rx();
+
+        Ok(rx)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use similar_asserts::assert_eq;
+
+    use crate::{commander::Command, events::Event};
+
+    use super::Events;
+
+    #[test]
+    fn can_enque_command() -> anyhow::Result<()> {
+        let events = Events::default();
+
+        events.enque_command(Command::CreateRoot {
+            root: "some-root".into(),
+        })?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn can_deque_command() -> anyhow::Result<()> {
+        let events = Events::default();
+        let mut rx = events.subscribe()?;
+
+        std::thread::spawn(move || {
+            events
+                .enque_command(Command::CreateRoot {
+                    root: "some-root".into(),
+                })
+                .unwrap();
+        });
+
+        let event = rx.recv()?;
+
+        assert_eq!(
+            Event::CommandEvent {
+                command: Command::CreateRoot {
+                    root: "some-root".into()
+                },
+            },
+            event
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn is_broadcast() -> anyhow::Result<()> {
+        let events = Events::default();
+        let mut rx1 = events.subscribe()?;
+        let mut rx2 = events.subscribe()?;
+
+        std::thread::spawn(move || {
+            events
+                .enque_command(Command::CreateRoot {
+                    root: "some-root".into(),
+                })
+                .unwrap();
+
+            events
+                .enque_command(Command::CreateRoot {
+                    root: "another-event".into(),
+                })
+                .unwrap();
+        });
+
+        let event = rx1.recv()?;
+        let same_event = rx2.recv()?;
+
+        assert_eq!(event, same_event);
+
+        assert_eq!(
+            Event::CommandEvent {
+                command: Command::CreateRoot {
+                    root: "some-root".into()
+                },
+            },
+            event
+        );
+
+        Ok(())
+    }
+}