show display name and pronouns in buffer

Author: casperstorm

data/src/client.rs

@@ -174,7 +174,6 @@ pub struct Client {
     mode_requests: Vec<ModeRequest>,
     channel_discovery_manager: channel_discovery::Manager,
     http_client: Option<Arc<reqwest::Client>>, // Only Some if config.proxy.is_some()
-    preview_proxy_client: Option<Arc<reqwest::Client>>,
     registry: metadata::ServerRegistry,
 }
 

data/src/config/display.rs

@@ -1,9 +1,21 @@
 use serde::Deserialize;
 
-#[derive(Debug, Clone, Deserialize, Default)]
+pub mod nickname;
+
+#[derive(Debug, Clone, Deserialize)]
 #[serde(default)]
 pub struct Display {
     pub direction_arrows: DirectionArrows,
+    pub nickname: Vec<nickname::Metadata>,
+}
+
+impl Default for Display {
+    fn default() -> Self {
+        Self {
+            direction_arrows: DirectionArrows::default(),
+            nickname: vec![nickname::Metadata::DisplayName],
+        }
+    }
 }
 
 #[derive(Debug, Clone, Deserialize)]

data/src/config/display/nickname.rs

@@ -0,0 +1,85 @@
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Metadata {
+    DisplayName,
+    Pronouns,
+}
+
+pub fn format(
+    nickname: &str,
+    enabled: &[Metadata],
+    display_name: Option<&str>,
+    pronouns: Option<&str>,
+) -> String {
+    let display_name = enabled
+        .contains(&Metadata::DisplayName)
+        .then_some(display_name)
+        .flatten()
+        .filter(|s| !s.is_empty());
+    let pronouns = enabled
+        .contains(&Metadata::Pronouns)
+        .then_some(pronouns)
+        .flatten()
+        .filter(|s| !s.is_empty());
+
+    match (display_name, pronouns) {
+        (Some(display_name), Some(pronouns)) => {
+            format!("{display_name} ({nickname}, {pronouns})")
+        }
+        (Some(display_name), None) => format!("{display_name} ({nickname})"),
+        (None, Some(pronouns)) => format!("{nickname} ({pronouns})"),
+        (None, None) => nickname.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Metadata, format};
+
+    #[test]
+    fn keeps_plain_nickname_when_no_metadata_enabled() {
+        assert_eq!(
+            format("storm", &[], Some("Casper"), Some("he/him")),
+            "storm"
+        );
+    }
+
+    #[test]
+    fn formats_display_name_when_present() {
+        assert_eq!(
+            format("storm", &[Metadata::DisplayName], Some("Casper"), None),
+            "Casper (storm)"
+        );
+    }
+
+    #[test]
+    fn skips_missing_display_name() {
+        assert_eq!(
+            format("storm", &[Metadata::DisplayName], None, None),
+            "storm"
+        );
+    }
+
+    #[test]
+    fn formats_pronouns_when_present() {
+        assert_eq!(
+            format("storm", &[Metadata::Pronouns], None, Some("he/him")),
+            "storm (he/him)"
+        );
+    }
+
+    #[test]
+    fn combines_display_name_and_pronouns() {
+        assert_eq!(
+            format(
+                "storm",
+                &[Metadata::Pronouns, Metadata::DisplayName],
+                Some("Casper"),
+                Some("he/him"),
+            ),
+            "Casper (storm, he/him)"
+        );
+    }
+}

data/src/history.rs

@@ -1284,7 +1284,6 @@ pub struct View<'a> {
     pub has_more_newer_messages: bool,
     pub old_messages: Vec<&'a Message>,
     pub new_messages: Vec<&'a Message>,
-    pub max_nick_chars: Option<usize>,
     pub max_prefix_chars: Option<usize>,
     pub range_end_timestamp_chars: Option<usize>,
     pub cleared: bool,

data/src/history/manager.rs

@@ -1383,38 +1383,6 @@ impl Data {
             .collect::<Vec<_>>();
 
         let total = processed.len();
-        let with_access_levels = buffer_config.nickname.show_access_levels;
-        let truncate = buffer_config.nickname.truncate;
-
-        let max_nick_chars =
-            buffer_config.nickname.alignment.is_right().then(|| {
-                processed
-                    .iter()
-                    .filter_map(|message| {
-                        if let message::Source::User(user) =
-                            message.target.source()
-                        {
-                            Some(
-                                buffer_config
-                                    .nickname
-                                    .brackets
-                                    .format(
-                                        user.display(
-                                            with_access_levels,
-                                            truncate,
-                                        ),
-                                    )
-                                    .chars()
-                                    .count(),
-                            )
-                        } else {
-                            None
-                        }
-                    })
-                    .max()
-                    .unwrap_or_default()
-            });
-
         let max_prefix_chars =
             buffer_config.nickname.alignment.is_right().then(|| {
                 if matches!(kind, history::Kind::Channel(..)) {
@@ -1507,7 +1475,6 @@ impl Data {
             has_more_newer_messages,
             old_messages: old.to_vec(),
             new_messages: new.to_vec(),
-            max_nick_chars,
             max_prefix_chars,
             range_end_timestamp_chars,
             cleared: *cleared,

data/src/user.rs

@@ -207,6 +207,14 @@ impl User {
         self.display_with_truncated(with_access_levels, truncate).0
     }
 
+    pub fn display_truncated(
+        &self,
+        with_access_levels: AccessLevelFormat,
+        truncate: Option<u16>,
+    ) -> bool {
+        self.display_with_truncated(with_access_levels, truncate).1
+    }
+
     pub fn display_with_truncated(
         &self,
         with_access_levels: AccessLevelFormat,

docs/configuration/display.md

@@ -31,3 +31,28 @@ Arrow shown for right-facing events.
 [display]
 direction_arrows = { right = ">" }
 ```
+
+## `nickname`
+
+Metadata to include when rendering user nicknames in message buffers.
+
+```toml
+# Type: array of strings
+# Values: "display-name", "pronouns"
+# Default: ["display-name"]
+
+[display]
+nickname = ["display-name"]
+```
+
+Examples:
+
+```toml
+[display]
+nickname = ["display-name", "pronouns"]
+```
+
+This renders as:
+- `["display-name"]` -> `Casper (casperstorm)` when display name (`Casper`) is set, otherwise `casperstorm`
+- `["pronouns"]` -> `casperstorm (he/him)` when pronouns are set, otherwise `storm`
+- `["display-name", "pronouns"]` -> `Casper (casperstorm, he/him)`, omitting missing metadata

src/buffer/highlights.rs

@@ -9,6 +9,7 @@ use iced::widget::{container, row, span};
 use iced::{Color, Length, Size, Task};
 
 use super::context_menu::{self, Context};
+use super::message_view::formatted_buffer_nickname;
 use super::scroll_view;
 use crate::widget::{
     Element, message_content, selectable_rich_text, selectable_text, tooltip,
@@ -109,11 +110,14 @@ pub fn view<'a>(
                             ShownStatus::Historical => false,
                         };
 
-                    let (user_display, show_nickname_tooltip) = user
-                        .display_with_truncated(with_access_levels, truncate);
+                    let show_nickname_tooltip =
+                        user.display_truncated(with_access_levels, truncate);
 
-                    let nick_text =
-                        config.buffer.nickname.brackets.format(user_display);
+                    let nick_text = formatted_buffer_nickname(
+                        user,
+                        config,
+                        clients.get_registry(server),
+                    );
 
                     let text = selectable_text(nick_text)
                         .font_maybe(

src/buffer/message_view.rs

@@ -21,6 +21,27 @@ use crate::widget::{
 };
 use crate::{Theme, font, icon, theme};
 
+pub(crate) fn formatted_buffer_nickname(
+    user: &User,
+    config: &Config,
+    registry: &dyn metadata::Registry,
+) -> String {
+    let with_access_levels = config.buffer.nickname.show_access_levels;
+    let truncate = config.buffer.nickname.truncate;
+    let nickname = config
+        .buffer
+        .nickname
+        .brackets
+        .format(user.display(with_access_levels, truncate));
+
+    data::config::display::nickname::format(
+        &nickname,
+        &config.display.nickname,
+        registry.display_name(TargetRef::Query(&Query::from(user))),
+        registry.pronouns(&Query::from(user)),
+    )
+}
+
 #[derive(Clone, Copy)]
 pub enum TargetInfo<'a> {
     Channel {
@@ -403,10 +424,9 @@ impl<'a> ChannelQueryLayout<'a> {
             dimmed_background_tuple,
         );
 
-        let (user_display, show_nickname_tooltip) =
-            user.display_with_truncated(with_access_levels, truncate);
-        let mut nick_text =
-            self.config.buffer.nickname.brackets.format(user_display);
+        let show_nickname_tooltip =
+            user.display_truncated(with_access_levels, truncate);
+        let nick_text = formatted_buffer_nickname(user, self.config, registry);
 
         let nick_element: Element<_> = if hide_nickname {
             let width = match self.config.buffer.nickname.alignment {
@@ -421,11 +441,6 @@ impl<'a> ChannelQueryLayout<'a> {
             };
             Space::new().width(width).into()
         } else {
-            if let Some(display_name) =
-                registry.display_name(TargetRef::Query(&Query::from(user)))
-            {
-                nick_text = format!("{display_name} ({nick_text})");
-            }
             let mut nick_text = selectable_text(nick_text)
                 .style(move |_| nickname_style)
                 .font_maybe(