added topics to prove registry groups

test/chat/pubsub.gleam

@@ -5,10 +5,9 @@ import gleam/otp/actor
 import gleam/otp/supervisor
 
 pub type PubSub =
-  process.Subject(group.Message(Nil, event.Event))
+  process.Subject(group.Message(Channel, event.Event))
 
-// TODO: Maybe do channels for a more complex use case
-type Channel {
+pub type Channel {
   General
   Coffee
   Pets
@@ -23,12 +22,16 @@ pub fn childspec() {
   |> supervisor.returning(fn(_param, pubsub) { pubsub })
 }
 
-pub fn subscribe(pubsub: PubSub, subject: process.Subject(event.Event)) -> Nil {
-  group.register(pubsub, subject, Nil)
+pub fn subscribe(
+  pubsub: PubSub,
+  channel: Channel,
+  subject: process.Subject(event.Event),
+) -> Nil {
+  group.register(pubsub, subject, channel)
 }
 
-pub fn publish(pubsub: PubSub, message: event.Event) -> Nil {
-  group.dispatch(pubsub, Nil, fn(subscriber) {
+pub fn publish(pubsub: PubSub, channel: Channel, message: event.Event) -> Nil {
+  group.dispatch(pubsub, channel, fn(subscriber) {
     process.send(subscriber, message)
   })
 }

test/chat/server.gleam

@@ -22,17 +22,26 @@ pub fn childspec(caller: process.Subject(Server)) {
   })
 }
 
-pub fn connect(server: Server, client: process.Subject(event.Event)) -> Nil {
-  actor.send(server, Connect(client))
+pub fn connect(
+  server: Server,
+  client: process.Subject(event.Event),
+  channel: pubsub.Channel,
+) -> Nil {
+  actor.send(server, Connect(client, channel))
 }
 
-pub fn send(server: Server, user: String, message: String) -> Nil {
-  actor.send(server, Send(user, message))
+pub fn send(
+  server: Server,
+  channel: pubsub.Channel,
+  user: String,
+  message: String,
+) -> Nil {
+  actor.send(server, Send(channel, user, message))
 }
 
 pub opaque type Message {
-  Connect(client: process.Subject(event.Event))
-  Send(user: String, message: String)
+  Connect(client: process.Subject(event.Event), channel: pubsub.Channel)
+  Send(channel: pubsub.Channel, user: String, message: String)
 }
 
 type State {
@@ -46,16 +55,16 @@ fn init(pubsub: pubsub.PubSub) {
 
 fn loop(message: Message, state: State) {
   case message {
-    Connect(client) -> {
-      pubsub.subscribe(state.pubsub, client)
+    Connect(client, channel) -> {
+      pubsub.subscribe(state.pubsub, channel, client)
       actor.Continue(state, option.None)
     }
 
-    Send(user, message) -> {
+    Send(channel, user, message) -> {
       let event = event.next(state.chat, user, message)
       let chat = [event, ..state.chat]
 
-      pubsub.publish(state.pubsub, event)
+      pubsub.publish(state.pubsub, channel, event)
       let state = State(..state, chat: chat)
       actor.Continue(state, option.None)
     }

test/chip/chat_test.gleam

@@ -1,4 +1,5 @@
 import chat/event
+import chat/pubsub
 import chat/server
 import chat/supervisor as chat_supervisor
 import gleam/erlang/process
@@ -12,24 +13,43 @@ pub fn chat_test() {
   let assert Ok(server) = process.receive(caller, 100)
 
   // For this scenario, out of simplicity, the client is the current process.
-  let client: Client = process.new_subject()
+  let client_a: Client = process.new_subject()
+  let client_b: Client = process.new_subject()
 
   // Connect the client so it can receive new messages from the server.
-  server.connect(server, client)
+  server.connect(server, client_a, pubsub.General)
+  server.connect(server, client_b, pubsub.Coffee)
+  server.connect(server, client_b, pubsub.Pets)
 
   task.async(fn() {
     // Send messages from another Subject.
-    server.send(server, "luis", "Hola Juan.")
-    server.send(server, "juan", "Hola Luis, como vas?")
-    server.send(server, "luis", "Bien! Recibiendo mensajes.")
+    server.send(server, pubsub.Coffee, "roberto", "Hey!")
+    server.send(server, pubsub.General, "luis", "Hola Juan.")
+    server.send(server, pubsub.Coffee, "roberto", "Busco recetas para café.")
+    server.send(server, pubsub.General, "juan", "Hola Luis, como vas?")
+    server.send(server, pubsub.Coffee, "francisco", "¿Qué método?")
+    server.send(server, pubsub.Pets, "roberto", "Mi gato 🐈 ♡")
+    server.send(server, pubsub.General, "luis", "Bien! Recibiendo mensajes.")
+    server.send(server, pubsub.Pets, "anonymous", "owwww! ♡ ♡ ♡")
+    server.send(server, pubsub.Coffee, "roberto", "Para dripper.")
   })
 
   // Client should have received the messages
   let assert [
     "luis: Hola Juan.",
     "juan: Hola Luis, como vas?",
     "luis: Bien! Recibiendo mensajes.",
-  ] = wait_for_messages(client, [])
+  ] = wait_for_messages(client_a, [])
+
+  // Client should have received the messages
+  let assert [
+    "roberto: Hey!",
+    "roberto: Busco recetas para café.",
+    "francisco: ¿Qué método?",
+    "roberto: Mi gato 🐈 ♡",
+    "anonymous: owwww! ♡ ♡ ♡",
+    "roberto: Para dripper.",
+  ] = wait_for_messages(client_b, [])
 }
 
 // Client helpers