Merge pull request #1259 from squidowl/renormalized-load

Renormalize Messages in `history::load`

Author: andymandias

data/src/client.rs

@@ -30,7 +30,7 @@ use crate::time::Posix;
 use crate::user::{ChannelUsers, Nick, NickRef};
 use crate::{
     Server, User, buffer, compression, config, ctcp, dcc, environment,
-    file_transfer, isupport, message, mode, server,
+    file_transfer, history, isupport, message, mode, server,
 };
 
 pub mod on_connect;
@@ -3750,6 +3750,29 @@ impl Map {
             .is_some_and(|client| client.supports_detach)
     }
 
+    pub fn get_seed(&self, kind: &history::Kind) -> Option<history::Seed> {
+        match kind {
+            history::Kind::Highlights => {
+                let casemappings: HashMap<Server, isupport::CaseMap> = self
+                    .servers()
+                    .filter_map(|server| {
+                        self.client(server)
+                            .map(Client::casemapping)
+                            .map(|casemapping| (server.clone(), casemapping))
+                    })
+                    .collect();
+
+                (!casemappings.is_empty())
+                    .then_some(history::Seed::Multiple(casemappings))
+            }
+            _ => kind.server().and_then(|server| {
+                self.client(server)
+                    .map(Client::casemapping)
+                    .map(history::Seed::Single)
+            }),
+        }
+    }
+
     pub fn get_server_handle(
         &self,
         server: &Server,

data/src/history.rs

@@ -168,15 +168,47 @@ pub struct Loaded {
     pub metadata: Metadata,
 }
 
-pub async fn load(kind: Kind) -> Result<Loaded, Error> {
+pub enum Seed {
+    Single(isupport::CaseMap),
+    Multiple(HashMap<Server, isupport::CaseMap>),
+}
+
+pub async fn load(kind: Kind, seed: Option<Seed>) -> Result<Loaded, Error> {
     let path = path(&kind).await?;
 
-    let messages = read_all(&path).await.unwrap_or_default();
+    let mut messages = read_all(&path).await.unwrap_or_default();
+
+    if let Some(seed) = seed {
+        // TODO: Utilize DeserializeSeed (or equivalent) so proper normalization
+        // happens inside read_all, rather than having to renormalize afterward
+        renormalize_messages(&mut messages, seed);
+    }
+
     let metadata = metadata::load(kind).await.unwrap_or_default();
 
     Ok(Loaded { messages, metadata })
 }
 
+pub fn renormalize_messages(messages: &mut [Message], seed: Seed) {
+    match seed {
+        Seed::Multiple(casemappings) => {
+            messages.iter_mut().for_each(|message| {
+                if let message::Target::Highlights { server, .. } =
+                    &message.target
+                    && let Some(casemapping) = casemappings.get(server)
+                {
+                    message.renormalize(*casemapping);
+                }
+            });
+        }
+        Seed::Single(casemapping) => {
+            messages
+                .iter_mut()
+                .for_each(|message| message.renormalize(casemapping));
+        }
+    }
+}
+
 pub async fn overwrite(
     kind: &Kind,
     messages: &[Message],
@@ -200,10 +232,11 @@ pub async fn overwrite(
 
 pub async fn append(
     kind: &Kind,
+    seed: Option<Seed>,
     messages: Vec<Message>,
     read_marker: Option<ReadMarker>,
 ) -> Result<(), Error> {
-    let loaded = load(kind.clone()).await?;
+    let loaded = load(kind.clone(), seed).await?;
 
     let mut all_messages = loaded.messages;
     messages.into_iter().for_each(|message| {
@@ -406,6 +439,7 @@ impl History {
     fn flush(
         &mut self,
         now: Option<Instant>,
+        seed: Option<Seed>,
     ) -> Option<BoxFuture<'static, Result<(), Error>>> {
         match self {
             History::Partial {
@@ -428,11 +462,11 @@ impl History {
                     *last_updated_at = None;
 
                     return Some(
-                            async move {
-                                append(&kind, messages, read_marker).await
-                            }
-                            .boxed(),
-                        );
+                        async move {
+                            append(&kind, seed, messages, read_marker).await
+                        }
+                        .boxed(),
+                    );
                 }
 
                 None
@@ -517,14 +551,14 @@ impl History {
         }
     }
 
-    async fn close(self) -> Result<(), Error> {
+    async fn close(self, seed: Option<Seed>) -> Result<(), Error> {
         match self {
             History::Partial {
                 kind,
                 messages,
                 read_marker,
                 ..
-            } => append(&kind, messages, read_marker).await,
+            } => append(&kind, seed, messages, read_marker).await,
             History::Full {
                 kind,
                 messages,

data/src/history/manager.rs

@@ -68,9 +68,10 @@ impl Manager {
     pub fn clear_messages(
         &mut self,
         kind: history::Kind,
+        clients: &client::Map,
     ) -> Option<BoxFuture<'static, Message>> {
         if let Some(history) = self.data.map.get_mut(&kind) {
-            let task = history.flush(None);
+            let task = history.flush(None, clients.get_seed(&kind));
 
             match history {
                 History::Full {
@@ -98,13 +99,17 @@ impl Manager {
     pub fn track(
         &mut self,
         new_resources: HashSet<Resource>,
+        clients: Option<&client::Map>,
     ) -> Vec<BoxFuture<'static, Message>> {
         let added = new_resources.difference(&self.resources).cloned();
         let removed = self.resources.difference(&new_resources).cloned();
 
         let added = added.into_iter().map(|resource| {
+            let seed =
+                clients.and_then(|clients| clients.get_seed(&resource.kind));
+
             async move {
-                history::load(resource.kind.clone())
+                history::load(resource.kind.clone(), seed)
                     .map(move |result| Message::LoadFull(resource.kind, result))
                     .await
             }
@@ -137,8 +142,6 @@ impl Manager {
                 self.data.load_full(kind.clone(), loaded);
                 log::debug!("loaded history for {kind}: {len} messages");
 
-                self.renormalize_messages(kind.clone(), clients);
-
                 self.process_messages(kind.clone(), clients, buffer_config);
 
                 return Some(Event::Loaded(kind));
@@ -212,25 +215,40 @@ impl Manager {
         &mut self.filters
     }
 
-    pub fn tick(&mut self, now: Instant) -> Vec<BoxFuture<'static, Message>> {
-        self.data.flush_all(now)
+    pub fn tick(
+        &mut self,
+        now: Instant,
+        clients: &client::Map,
+    ) -> Vec<BoxFuture<'static, Message>> {
+        self.data.flush_all(now, clients)
     }
 
     pub fn close(
         &mut self,
         kind: history::Kind,
+        clients: &client::Map,
     ) -> Option<impl Future<Output = Message> + use<>> {
         let history = self.data.map.remove(&kind)?;
 
-        Some(history.close().map(|result| Message::Closed(kind, result)))
+        Some(
+            history
+                .close(clients.get_seed(&kind))
+                .map(|result| Message::Closed(kind, result)),
+        )
     }
 
-    pub fn exit(&mut self) -> impl Future<Output = Message> + use<> {
+    pub fn exit(
+        &mut self,
+        clients: &client::Map,
+    ) -> impl Future<Output = Message> + use<> {
         let map = std::mem::take(&mut self.data).map;
+        let seeds: Vec<Option<history::Seed>> =
+            map.keys().map(|kind| clients.get_seed(kind)).collect();
+        let seeded_map = map.into_iter().zip(seeds);
 
         async move {
-            let tasks = map.into_iter().map(|(kind, state)| {
-                state.close().map(move |result| (kind, result))
+            let tasks = seeded_map.into_iter().map(|((kind, state), seed)| {
+                state.close(seed).map(move |result| (kind, result))
             });
 
             Message::Exited(future::join_all(tasks).await)
@@ -866,37 +884,18 @@ impl Manager {
 
     pub fn renormalize_messages(
         &mut self,
-        kind: history::Kind,
+        kind: &history::Kind,
         clients: &client::Map,
     ) {
-        if let Some(history) = self.data.map.get_mut(&kind) {
+        if let Some(history) = self.data.map.get_mut(kind)
+            && let Some(seed) = clients.get_seed(kind)
+        {
             let messages = match history {
                 History::Full { messages, .. } => messages,
                 History::Partial { messages, .. } => messages,
             };
 
-            match kind {
-                history::Kind::Highlights => {
-                    messages.iter_mut().for_each(|message| {
-                        if let message::Target::Highlights { server, .. } =
-                            &message.target
-                        {
-                            let casemapping = clients
-                                .get_casemapping_or_default(Some(server));
-
-                            message.renormalize(casemapping);
-                        }
-                    });
-                }
-                _ => {
-                    let casemapping =
-                        clients.get_casemapping_or_default(kind.server());
-
-                    messages
-                        .iter_mut()
-                        .for_each(|message| message.renormalize(casemapping));
-                }
-            }
+            history::renormalize_messages(messages, seed);
         }
     }
 }
@@ -1329,16 +1328,22 @@ impl Data {
         self.map.get_mut(kind).and_then(History::make_partial)
     }
 
-    fn flush_all(&mut self, now: Instant) -> Vec<BoxFuture<'static, Message>> {
+    fn flush_all(
+        &mut self,
+        now: Instant,
+        clients: &client::Map,
+    ) -> Vec<BoxFuture<'static, Message>> {
         self.map
             .iter_mut()
             .filter_map(|(kind, state)| {
                 let kind = kind.clone();
 
-                state.flush(Some(now)).map(move |task| {
-                    task.map(move |result| Message::Flushed(kind, result))
-                        .boxed()
-                })
+                state.flush(Some(now), clients.get_seed(&kind)).map(
+                    move |task| {
+                        task.map(move |result| Message::Flushed(kind, result))
+                            .boxed()
+                    },
+                )
             })
             .collect()
     }

src/buffer/input_view.rs

@@ -603,7 +603,7 @@ impl State {
                                     );
 
                                     let event = history
-                                        .clear_messages(kind)
+                                        .clear_messages(kind, clients)
                                         .map(|history_task| Event::Cleared {
                                             history_task: Task::future(
                                                 history_task,

src/main.rs

@@ -401,7 +401,7 @@ impl Halloy {
                 );
 
                 // Retrack after dashboard state changes
-                let track = dashboard.track();
+                let track = dashboard.track(Some(&self.clients));
 
                 let event_task = match event {
                     Some(dashboard::Event::ConfigReloaded(config)) => {
@@ -1214,7 +1214,7 @@ impl Halloy {
                 }
 
                 if let Screen::Dashboard(dashboard) = &mut self.screen {
-                    dashboard.tick(now).map(Message::Dashboard)
+                    dashboard.tick(now, &self.clients).map(Message::Dashboard)
                 } else {
                     Task::none()
                 }