From d8567da83a37f4f9b5880b2f167ae07e733a543e Mon Sep 17 00:00:00 2001
From: Mike Dilger <mike@mikedilger.com>
Date: Fri, 23 Dec 2022 14:44:06 +1300
Subject: [PATCH] cleanup

---
 src/db/person.rs           |  6 +++++-
 src/globals.rs             | 27 ++++++++++++---------------
 src/overlord/minion/mod.rs |  2 +-
 src/overlord/mod.rs        | 26 +++++++++++++++++++-------
 4 files changed, 37 insertions(+), 24 deletions(-)

diff --git a/src/db/person.rs b/src/db/person.rs
index af3fdecb..e44535bb 100644
--- a/src/db/person.rs
+++ b/src/db/person.rs
@@ -135,7 +135,11 @@ impl DbPerson {
         Ok(())
     }
 
-    pub async fn update_metadata(pubkey: PublicKeyHex, metadata: Metadata, created_at: Unixtime) -> Result<(), Error> {
+    pub async fn update_metadata(
+        pubkey: PublicKeyHex,
+        metadata: Metadata,
+        created_at: Unixtime,
+    ) -> Result<(), Error> {
         let sql =
             "UPDATE person SET name=?, about=?, picture=?, dns_id=?, metadata_at=? WHERE pubkey=?";
 
diff --git a/src/globals.rs b/src/globals.rs
index 624accb7..2dd9bc01 100644
--- a/src/globals.rs
+++ b/src/globals.rs
@@ -134,19 +134,13 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
         let count = event
             .tags
             .iter()
-            .filter(|t| match t {
-                Tag::Event { .. } => true,
-                _ => false,
-            })
+            .filter(|t| matches!(t, Tag::Event { .. }))
             .count();
 
         for (n, tag) in event
             .tags
             .iter()
-            .filter(|t| match t {
-                Tag::Event { .. } => true,
-                _ => false,
-            })
+            .filter(|t| matches!(t, Tag::Event { .. }))
             .enumerate()
         {
             if let Tag::Event {
@@ -198,13 +192,13 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
             update_feed_event(event.id, |this_event| {
                 this_event.in_reply_to = Some(id);
             })
-                .await;
+            .await;
 
             // Mark the parent event as having us as a reply
             update_feed_event(id, |parent_event| {
                 parent_event.replies.push(event.id);
             })
-                .await;
+            .await;
 
             // Get our last_reply_at for propogating upwards
             let mut last_reply_at = event.created_at.0;
@@ -222,7 +216,7 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
                     }
                     in_reply_to = ancestor_event.in_reply_to; // next up the chain
                 })
-                    .await;
+                .await;
 
                 xid = match in_reply_to {
                     Some(ref id) => *id,
@@ -232,7 +226,9 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
         }
 
         // We ignore 'root' and 'refer'.
-        if let Some(id) = root { trace!("event root = {}", id.as_hex_string()); }
+        if let Some(id) = root {
+            trace!("event root = {}", id.as_hex_string());
+        }
     }
 
     // Some kinds seen in the wild:
@@ -361,11 +357,12 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
 async fn insert_event(event: &Event) {
     let mut feed_events = GLOBALS.feed_events.lock().await;
 
-    feed_events.entry(event.id)
+    feed_events
+        .entry(event.id)
         .and_modify(|feed_event| {
             // If the event already exists, update it's base data.
             // (sometimes it is created to add feed data, but doesn't have base data yet)
-            feed_event.feed_related = event.kind==EventKind::TextNote;
+            feed_event.feed_related = event.kind == EventKind::TextNote;
             if feed_event.last_reply_at.is_none() {
                 feed_event.last_reply_at = Some(event.created_at.0)
             }
@@ -373,7 +370,7 @@ async fn insert_event(event: &Event) {
                 feed_event.event = Some(event.to_owned());
             }
         })
-        .or_insert(event.into());
+        .or_insert_with(|| event.into());
 }
 
 async fn update_feed_event<F>(id: Id, mut f: F)
diff --git a/src/overlord/minion/mod.rs b/src/overlord/minion/mod.rs
index 3a93b93e..105f1057 100644
--- a/src/overlord/minion/mod.rs
+++ b/src/overlord/minion/mod.rs
@@ -8,7 +8,7 @@ use crate::error::Error;
 use crate::globals::GLOBALS;
 use crate::settings::Settings;
 use futures::{SinkExt, StreamExt};
-use futures_util::stream::{SplitStream, SplitSink};
+use futures_util::stream::{SplitSink, SplitStream};
 use http::Uri;
 use nostr_proto::{EventKind, Filters, PublicKeyHex, RelayInformationDocument, Unixtime, Url};
 use subscription::Subscriptions;
diff --git a/src/overlord/mod.rs b/src/overlord/mod.rs
index 77f9fc36..bb3dcfa1 100644
--- a/src/overlord/mod.rs
+++ b/src/overlord/mod.rs
@@ -113,20 +113,29 @@ impl Overlord {
                 let metadata: Metadata = match serde_json::from_str(&dbevent.content) {
                     Ok(e) => e,
                     Err(_) => {
-                        error!("Bad metadata: id={}, content={}", dbevent.id, dbevent.content);
+                        error!(
+                            "Bad metadata: id={}, content={}",
+                            dbevent.id, dbevent.content
+                        );
                         continue;
                     }
                 };
 
                 // Update in globals
                 crate::globals::update_person_from_event_metadata(
-                    e.pubkey, e.created_at, metadata.clone()
-                ).await;
+                    e.pubkey,
+                    e.created_at,
+                    metadata.clone(),
+                )
+                .await;
 
                 // Update in database
-                DbPerson::update_metadata(PublicKeyHex(e.pubkey.as_hex_string()),
-                                          metadata,
-                                          e.created_at).await?;
+                DbPerson::update_metadata(
+                    PublicKeyHex(e.pubkey.as_hex_string()),
+                    metadata,
+                    e.created_at,
+                )
+                .await?;
             }
         }
 
@@ -272,7 +281,10 @@ impl Overlord {
                         debug!("new feed event arrived: {}...", event.id.as_hex_string());
                     } else {
                         // Not Feed Related:  Metadata, RecommendRelay, ContactList
-                        debug!("new non-feed event arrived: {}...", event.id.as_hex_string());
+                        debug!(
+                            "new non-feed event arrived: {}...",
+                            event.id.as_hex_string()
+                        );
 
                         if event.kind == EventKind::Metadata {
                             let metadata: Metadata = serde_json::from_str(&event.content)?;