melib/imap/untagged: update all mailboxes

When receiving an envelope event (deleted, or changed flags), update all
mailboxes that contain that envelope hash; not just the currently
selected mailbox.

Signed-off-by: Manos Pitsidianakis <manos@pitsidianak.is>

melib/src/imap/untagged.rs

@@ -120,35 +120,46 @@ impl ImapConnection {
                         .lock()
                         .unwrap()
                         .iter()
-                        .filter(|((mailbox_hash_, u), _)| {
+                        .filter(|((_, u), _)| !results.contains(u))
-                            *mailbox_hash_ == mailbox_hash && !results.contains(u)
-                        })
                         .map(|((_, uid), hash)| (*uid, *hash))
                         .collect::<Vec<(UID, crate::email::EnvelopeHash)>>();
+                    let mut mboxes_to_update = vec![];
                     for (deleted_uid, deleted_hash) in deleteds {
-                        mailbox.exists.lock().unwrap().remove(deleted_hash);
+                        for (mailbox_hash, mbx) in self.uid_store.mailboxes.lock().await.iter_mut()
-                        mailbox.unseen.lock().unwrap().remove(deleted_hash);
+                        {
-                        self.uid_store
+                            mbx.exists.lock().unwrap().remove(deleted_hash);
-                            .uid_index
+                            mbx.unseen.lock().unwrap().remove(deleted_hash);
-                            .lock()
+                            let mut existed = self
-                            .unwrap()
+                                .uid_store
-                            .remove(&(mailbox_hash, deleted_uid));
+                                .uid_index
-                        self.uid_store
+                                .lock()
-                            .hash_index
+                                .unwrap()
-                            .lock()
+                                .remove(&(*mailbox_hash, deleted_uid))
-                            .unwrap()
+                                .is_some();
-                            .remove(&deleted_hash);
+                            existed |= self
-                        events.push((
+                                .uid_store
-                            deleted_uid,
+                                .hash_index
-                            RefreshEvent {
+                                .lock()
-                                account_hash: self.uid_store.account_hash,
+                                .unwrap()
-                                mailbox_hash,
+                                .remove(&deleted_hash)
-                                kind: Remove(deleted_hash),
+                                .is_some();
-                            },
+                            if existed {
-                        ));
+                                mboxes_to_update.push(*mailbox_hash);
+                                events.push((
+                                    deleted_uid,
+                                    RefreshEvent {
+                                        account_hash: self.uid_store.account_hash,
+                                        mailbox_hash: *mailbox_hash,
+                                        kind: Remove(deleted_hash),
+                                    },
+                                ));
+                            }
+                        }
                     }
                     if *self.uid_store.keep_offline_cache.lock().unwrap() {
-                        cache_handle.update(mailbox_hash, &events)?;
+                        for mailbox_hash in mboxes_to_update {
+                            cache_handle.update(mailbox_hash, &events)?;
+                        }
                     }
                     for (_, event) in events {
                         self.add_refresh_event(event);
@@ -175,32 +186,41 @@ impl ImapConnection {
                     Some(v) => v,
                     None => return Ok(true),
                 };
-                mailbox.exists.lock().unwrap().remove(deleted_hash);
+                let mut mboxes_to_update = vec![];
-                mailbox.unseen.lock().unwrap().remove(deleted_hash);
+                for (mailbox_hash, mbx) in self.uid_store.mailboxes.lock().await.iter_mut() {
+                    if mbx.exists.lock().unwrap().remove(deleted_hash) {
+                        mboxes_to_update.push(*mailbox_hash);
+                    }
+                    mbx.unseen.lock().unwrap().remove(deleted_hash);
+                }
                 self.uid_store
                     .hash_index
                     .lock()
                     .unwrap()
                     .remove(&deleted_hash);
-                let mut event: [(UID, RefreshEvent); 1] = [(
+                let events = mboxes_to_update
-                    deleted_uid,
+                    .into_iter()
-                    RefreshEvent {
+                    .map(|mailbox_hash| {
-                        account_hash: self.uid_store.account_hash,
+                        (
-                        mailbox_hash,
+                            mailbox_hash,
-                        kind: Remove(deleted_hash),
+                            [(
-                    },
+                                deleted_uid,
-                )];
+                                RefreshEvent {
-                if *self.uid_store.keep_offline_cache.lock().unwrap() {
+                                    account_hash: self.uid_store.account_hash,
-                    cache_handle.update(mailbox_hash, &event)?;
+                                    mailbox_hash,
+                                    kind: Remove(deleted_hash),
+                                },
+                            )],
+                        )
+                    })
+                    .collect::<Vec<(_, [(UID, RefreshEvent); 1])>>();
+                for (mailbox_hash, pair) in events {
+                    if *self.uid_store.keep_offline_cache.lock().unwrap() {
+                        cache_handle.update(mailbox_hash, &pair)?;
+                    }
+                    let [(_, event)] = pair;
+                    self.add_refresh_event(event);
                 }
-                self.add_refresh_event(std::mem::replace(
-                    &mut event[0].1,
-                    RefreshEvent {
-                        account_hash: self.uid_store.account_hash,
-                        mailbox_hash,
-                        kind: Rescan,
-                    },
-                ));
             }
             UntaggedResponse::Exists(n) => {
                 debug!("exists {}", n);
@@ -505,9 +525,15 @@ impl ImapConnection {
                         temp
                     } {
                         if !flags.0.intersects(crate::email::Flag::SEEN) {
-                            mailbox.unseen.lock().unwrap().insert_new(env_hash);
+                            for mbx in self.uid_store.mailboxes.lock().await.values_mut() {
+                                if mbx.exists.lock().unwrap().contains(&env_hash) {
+                                    mbx.unseen.lock().unwrap().insert_new(env_hash);
+                                }
+                            }
                         } else {
-                            mailbox.unseen.lock().unwrap().remove(env_hash);
+                            for mbx in self.uid_store.mailboxes.lock().await.values_mut() {
+                                mbx.unseen.lock().unwrap().remove(env_hash);
+                            }
                         }
                         mailbox.exists.lock().unwrap().insert_new(env_hash);
                         if let Some(modseq) = modseq {