Update testbot example

Packet handling is now extracted into a separate function and the bot
uses euphoxide's joined.since for its !uptime command.

examples/testbot.rs

@@ -1,8 +1,13 @@
-use std::error::Error;
+//! A small bot that doesn't use the `bot` submodule. Meant to show how the main
-use std::time::{Duration, Instant};
+//! parts of the API fit together.
 
+use std::error::Error;
+use std::time::Duration;
+
+use euphoxide::api::packet::ParsedPacket;
 use euphoxide::api::{Data, Nick, Send};
-use euphoxide::conn::Conn;
+use euphoxide::conn::{Conn, ConnTx, State};
+use time::OffsetDateTime;
 
 const TIMEOUT: Duration = Duration::from_secs(10);
 const DOMAIN: &str = "euphoria.io";
@@ -10,12 +15,12 @@ const ROOM: &str = "test";
 const NICK: &str = "TestBot";
 const HELP: &str = "I'm an example bot for https://github.com/Garmelon/euphoxide";
 
-fn format_delta(delta: Duration) -> String {
+fn format_delta(delta: time::Duration) -> String {
     const MINUTE: u64 = 60;
     const HOUR: u64 = MINUTE * 60;
     const DAY: u64 = HOUR * 24;
 
-    let mut seconds = delta.as_secs();
+    let mut seconds: u64 = delta.whole_seconds().try_into().unwrap();
     let mut parts = vec![];
 
     let days = seconds / DAY;
@@ -43,20 +48,15 @@ fn format_delta(delta: Duration) -> String {
     parts.join(" ")
 }
 
-#[tokio::main]
+async fn on_packet(packet: ParsedPacket, conn_tx: &ConnTx, state: &State) -> Result<(), ()> {
-async fn main() -> Result<(), Box<dyn Error>> {
-    let start = Instant::now();
-
-    let (mut conn, _) = Conn::connect(DOMAIN, ROOM, false, None, TIMEOUT).await?;
-
-    while let Ok(packet) = conn.recv().await {
     let data = match packet.content {
         Ok(data) => data,
         Err(err) => {
             println!("Error for {}: {err}", packet.r#type);
-                continue;
+            return Err(());
         }
     };
+
     match data {
         Data::HelloEvent(event) => println!("Connected with id {}", event.session.id),
         Data::SnapshotEvent(event) => {
@@ -71,11 +71,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
             // We only need to do this because we want to log the result of
             // the nick command. Otherwise, we could've just called
             // tx.send() synchronously and ignored the returned Future.
-                let tx = conn.tx().clone();
+            let conn_tx_clone = conn_tx.clone();
             tokio::spawn(async move {
                 // Awaiting the future returned by the send command lets you
                 // (type-safely) access the server's reply.
-                    let reply = tx
+                let reply = conn_tx_clone
                     .send(Nick {
                         name: NICK.to_string(),
                     })
@@ -88,11 +88,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
         Data::BounceEvent(_) => {
             println!("Received bounce event, stopping");
-                break;
+            return Err(());
         }
         Data::DisconnectEvent(_) => {
             println!("Received disconnect event, stopping");
-                break;
+            return Err(());
         }
         Data::JoinEvent(event) => println!("{:?} ({}) joined", event.0.name, event.0.id),
         Data::PartEvent(event) => println!("{:?} ({}) left", event.0.name, event.0.id),
@@ -111,8 +111,10 @@ async fn main() -> Result<(), Box<dyn Error>> {
             } else if content == format!("!help @{NICK}") {
                 reply = Some(HELP.to_string());
             } else if content == format!("!uptime @{NICK}") {
-                    let delta = Instant::now().duration_since(start);
+                if let Some(joined) = state.joined() {
+                    let delta = OffsetDateTime::now_utc() - joined.since;
                     reply = Some(format!("/me has been up for {}", format_delta(delta)));
+                }
             } else if content == "!test" {
                 reply = Some("Test successful!".to_string());
             } else if content == format!("!kill @{NICK}") {
@@ -125,21 +127,20 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 // would be a race between sending the message and closing
                 // the connection as the send function can return before the
                 // message has actually been sent.
-                    let _ = conn
+                let _ = conn_tx
-                        .tx()
                     .send(Send {
                         content: "/me dies".to_string(),
                         parent: Some(event.0.id),
                     })
                     .await;
-                    break;
+                return Err(());
             }
 
             if let Some(reply) = reply {
                 // If you are not interested in the result, you can just
                 // throw away the future returned by the send function.
                 println!("Sending reply...");
-                    let _ = conn.tx().send(Send {
+                let _ = conn_tx.send(Send {
                     content: reply,
                     parent: Some(event.0.id),
                 });
@@ -148,6 +149,18 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
         _ => {}
     }
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let (mut conn, _) = Conn::connect(DOMAIN, ROOM, false, None, TIMEOUT).await?;
+
+    while let Ok(packet) = conn.recv().await {
+        if on_packet(packet, conn.tx(), conn.state()).await.is_err() {
+            break;
+        }
     }
     Ok(())
 }