update

crates/signed_state/src/profile.rs

@@ -10,7 +10,7 @@ use utils::shorten_pubkey;
 
 use crate::backend::{Backend, BackendEvent, sync_bootstrap_only};
 
-/// A user profile (kind `0` metadata), as plain data for the UI.
+/// A user profile as plain data for the UI, from the kind-0 metadata.
 #[derive(Debug, Clone)]
 pub struct Profile {
     public_key: PublicKey,
@@ -62,18 +62,20 @@ impl Profile {
 
 /// Message from the fetch task to the main thread.
 enum Dispatch {
-    /// A batched sync finished; re-read seen profiles from the database.
+    /// A batched sync finished.
+    /// Re-read seen profiles from the database.
     Synced,
 }
 
 /// How long to wait for more requests before firing a batched sync.
 const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
 
-/// Global profile cache. Profiles are fetched in batches and kept as plain
-/// data; the whole store notifies on change.
+/// Global profile cache.
+/// Profiles are fetched in batches and kept as plain data.
+/// The whole store notifies on change.
 pub struct ProfileStore {
     profiles: HashMap<PublicKey, Profile>,
-    /// Public keys we've already requested this session (main thread only).
+    /// Public keys requested this session, main thread only.
     seen: RefCell<HashSet<PublicKey>>,
     /// Sender for queuing fetch requests, batched by a background task.
     sender: Sender<PublicKey>,
@@ -111,8 +113,8 @@ impl ProfileStore {
             _ => {}
         });
 
-        // Fetch requests are queued on a channel and synced in batches by a
-        // background task.
+        // Fetch requests are queued on a channel.
+        // A background task syncs them in batches.
         let client = backend.read(cx).client();
         let (sender, receiver) = flume::unbounded::<PublicKey>();
         let (dispatch_tx, dispatch_rx) = flume::unbounded::<Dispatch>();
@@ -143,8 +145,9 @@ impl ProfileStore {
         store
     }
 
-    /// Get a profile. Returns a placeholder (default metadata) and queues a
-    /// fetch if the profile isn't cached yet.
+    /// Get a profile.
+    /// Returns a placeholder with default metadata.
+    /// Queues a fetch when the profile is not cached yet.
     pub fn get(&self, public_key: &PublicKey) -> Profile {
         if let Some(profile) = self.profiles.get(public_key) {
             return profile.clone();
@@ -170,7 +173,8 @@ impl ProfileStore {
             let filter = Filter::new().kind(Kind::Metadata).limit(200);
             let events = client.database().query(filter).await?;
 
-            // Parse off the main thread; only plain profiles cross back.
+            // Parse off the main thread.
+            // Only plain profiles cross back.
             let profiles: Vec<Profile> = events
                 .into_iter()
                 .map(|event| {
@@ -205,7 +209,8 @@ impl ProfileStore {
             let filter = Filter::new().kind(Kind::Metadata).author(public_key);
             let events = client.database().query(filter).await?;
 
-            // Parse off the main thread; only the profile crosses back.
+            // Parse off the main thread.
+            // Only the profile crosses back.
             let profile = events
                 .into_iter()
                 .max_by_key(|e| e.created_at)
@@ -231,8 +236,8 @@ impl ProfileStore {
         }));
     }
 
-    /// Re-read the latest metadata of every requested author from the local
-    /// database (used after a sync, which produces no NostrUpdate events).
+    /// Re-read the latest metadata of every requested author from the local database.
+    /// Used after a sync, which produces no NostrUpdate events.
     fn apply_seen(&mut self, cx: &mut Context<Self>) {
         let authors: Vec<PublicKey> = self.seen.borrow().iter().copied().collect();
 
@@ -286,9 +291,9 @@ impl ProfileStore {
         }));
     }
 
-    /// Sync metadata for requested authors in batches, debounced to collect
-    /// requests. Runs on a background thread; results are dispatched to the
-    /// main thread, which re-reads the database.
+    /// Sync metadata for requested authors in batches, debounced to collect requests.
+    /// Runs on a background thread.
+    /// Results are dispatched to the main thread, which re-reads the database.
     async fn handle_requests(
         client: &Client,
         dispatch: &Sender<Dispatch>,
@@ -316,9 +321,9 @@ impl ProfileStore {
                 .kind(Kind::Metadata)
                 .authors(batch.drain().collect::<Vec<PublicKey>>());
 
-            // Negentropy-sync with the bootstrap relays. Synced events are
-            // written to the database directly (no NostrUpdate), so re-apply
-            // from the database afterwards.
+            // Negentropy-sync with the bootstrap relays.
+            // Synced events are written to the database directly, no NostrUpdate.
+            // Re-apply from the database afterwards.
             match sync_bootstrap_only(client, filter, SyncOptions::default()).await {
                 Ok(_) => {
                     if dispatch.send(Dispatch::Synced).is_err() {