1use anyhow::{Context as _, Result};
2use channel::{ChannelChat, ChannelStore, MessageParams};
3use client::{UserId, UserStore};
4use collections::HashSet;
5use editor::{AnchorRangeExt, CompletionProvider, Editor, EditorElement, EditorStyle, ExcerptId};
6use fuzzy::{StringMatch, StringMatchCandidate};
7use gpui::{
8 AsyncApp, AsyncWindowContext, Context, Entity, Focusable, FontStyle, FontWeight,
9 HighlightStyle, IntoElement, Render, Task, TextStyle, WeakEntity, Window,
10};
11use language::{
12 Anchor, Buffer, BufferSnapshot, CodeLabel, LanguageRegistry, ToOffset,
13 language_settings::SoftWrap,
14};
15use project::{Completion, CompletionResponse, CompletionSource, search::SearchQuery};
16use settings::Settings;
17use std::{
18 ops::Range,
19 rc::Rc,
20 sync::{Arc, LazyLock},
21 time::Duration,
22};
23use theme::ThemeSettings;
24use ui::{TextSize, prelude::*};
25
26use crate::panel_settings::MessageEditorSettings;
27
28const MENTIONS_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(50);
29
30static MENTIONS_SEARCH: LazyLock<SearchQuery> = LazyLock::new(|| {
31 SearchQuery::regex(
32 "@[-_\\w]+",
33 false,
34 false,
35 false,
36 false,
37 Default::default(),
38 Default::default(),
39 false,
40 None,
41 )
42 .unwrap()
43});
44
45pub struct MessageEditor {
46 pub editor: Entity<Editor>,
47 user_store: Entity<UserStore>,
48 channel_chat: Option<Entity<ChannelChat>>,
49 mentions: Vec<UserId>,
50 mentions_task: Option<Task<()>>,
51 reply_to_message_id: Option<u64>,
52 edit_message_id: Option<u64>,
53}
54
55struct MessageEditorCompletionProvider(WeakEntity<MessageEditor>);
56
57impl CompletionProvider for MessageEditorCompletionProvider {
58 fn completions(
59 &self,
60 _excerpt_id: ExcerptId,
61 buffer: &Entity<Buffer>,
62 buffer_position: language::Anchor,
63 _: editor::CompletionContext,
64 _window: &mut Window,
65 cx: &mut Context<Editor>,
66 ) -> Task<Result<Vec<CompletionResponse>>> {
67 let Some(handle) = self.0.upgrade() else {
68 return Task::ready(Ok(Vec::new()));
69 };
70 handle.update(cx, |message_editor, cx| {
71 message_editor.completions(buffer, buffer_position, cx)
72 })
73 }
74
75 fn is_completion_trigger(
76 &self,
77 _buffer: &Entity<Buffer>,
78 _position: language::Anchor,
79 text: &str,
80 _trigger_in_words: bool,
81 _menu_is_open: bool,
82 _cx: &mut Context<Editor>,
83 ) -> bool {
84 text == "@"
85 }
86}
87
88impl MessageEditor {
89 pub fn new(
90 language_registry: Arc<LanguageRegistry>,
91 user_store: Entity<UserStore>,
92 channel_chat: Option<Entity<ChannelChat>>,
93 editor: Entity<Editor>,
94 window: &mut Window,
95 cx: &mut Context<Self>,
96 ) -> Self {
97 let this = cx.entity().downgrade();
98 editor.update(cx, |editor, cx| {
99 editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
100 editor.set_offset_content(false, cx);
101 editor.set_use_autoclose(false);
102 editor.set_show_gutter(false, cx);
103 editor.set_show_wrap_guides(false, cx);
104 editor.set_show_indent_guides(false, cx);
105 editor.set_completion_provider(Some(Rc::new(MessageEditorCompletionProvider(this))));
106 editor.set_auto_replace_emoji_shortcode(
107 MessageEditorSettings::get_global(cx)
108 .auto_replace_emoji_shortcode
109 .unwrap_or_default(),
110 );
111 });
112
113 let buffer = editor
114 .read(cx)
115 .buffer()
116 .read(cx)
117 .as_singleton()
118 .expect("message editor must be singleton");
119
120 cx.subscribe_in(&buffer, window, Self::on_buffer_event)
121 .detach();
122 cx.observe_global::<settings::SettingsStore>(|this, cx| {
123 this.editor.update(cx, |editor, cx| {
124 editor.set_auto_replace_emoji_shortcode(
125 MessageEditorSettings::get_global(cx)
126 .auto_replace_emoji_shortcode
127 .unwrap_or_default(),
128 )
129 })
130 })
131 .detach();
132
133 let markdown = language_registry.language_for_name("Markdown");
134 cx.spawn_in(window, async move |_, cx| {
135 let markdown = markdown.await.context("failed to load Markdown language")?;
136 buffer.update(cx, |buffer, cx| buffer.set_language(Some(markdown), cx))
137 })
138 .detach_and_log_err(cx);
139
140 Self {
141 editor,
142 user_store,
143 channel_chat,
144 mentions: Vec::new(),
145 mentions_task: None,
146 reply_to_message_id: None,
147 edit_message_id: None,
148 }
149 }
150
151 pub fn reply_to_message_id(&self) -> Option<u64> {
152 self.reply_to_message_id
153 }
154
155 pub fn set_reply_to_message_id(&mut self, reply_to_message_id: u64) {
156 self.reply_to_message_id = Some(reply_to_message_id);
157 }
158
159 pub fn clear_reply_to_message_id(&mut self) {
160 self.reply_to_message_id = None;
161 }
162
163 pub fn edit_message_id(&self) -> Option<u64> {
164 self.edit_message_id
165 }
166
167 pub fn set_edit_message_id(&mut self, edit_message_id: u64) {
168 self.edit_message_id = Some(edit_message_id);
169 }
170
171 pub fn clear_edit_message_id(&mut self) {
172 self.edit_message_id = None;
173 }
174
175 pub fn set_channel_chat(&mut self, chat: Entity<ChannelChat>, cx: &mut Context<Self>) {
176 let channel_id = chat.read(cx).channel_id;
177 self.channel_chat = Some(chat);
178 let channel_name = ChannelStore::global(cx)
179 .read(cx)
180 .channel_for_id(channel_id)
181 .map(|channel| channel.name.clone());
182 self.editor.update(cx, |editor, cx| {
183 if let Some(channel_name) = channel_name {
184 editor.set_placeholder_text(format!("Message #{channel_name}"), cx);
185 } else {
186 editor.set_placeholder_text("Message Channel", cx);
187 }
188 });
189 }
190
191 pub fn take_message(&mut self, window: &mut Window, cx: &mut Context<Self>) -> MessageParams {
192 self.editor.update(cx, |editor, cx| {
193 let highlights = editor.text_highlights::<Self>(cx);
194 let text = editor.text(cx);
195 let snapshot = editor.buffer().read(cx).snapshot(cx);
196 let mentions = if let Some((_, ranges)) = highlights {
197 ranges
198 .iter()
199 .map(|range| range.to_offset(&snapshot))
200 .zip(self.mentions.iter().copied())
201 .collect()
202 } else {
203 Vec::new()
204 };
205
206 editor.clear(window, cx);
207 self.mentions.clear();
208 let reply_to_message_id = std::mem::take(&mut self.reply_to_message_id);
209
210 MessageParams {
211 text,
212 mentions,
213 reply_to_message_id,
214 }
215 })
216 }
217
218 fn on_buffer_event(
219 &mut self,
220 buffer: &Entity<Buffer>,
221 event: &language::BufferEvent,
222 window: &mut Window,
223 cx: &mut Context<Self>,
224 ) {
225 if let language::BufferEvent::Reparsed | language::BufferEvent::Edited = event {
226 let buffer = buffer.read(cx).snapshot();
227 self.mentions_task = Some(cx.spawn_in(window, async move |this, cx| {
228 cx.background_executor()
229 .timer(MENTIONS_DEBOUNCE_INTERVAL)
230 .await;
231 Self::find_mentions(this, buffer, cx).await;
232 }));
233 }
234 }
235
236 fn completions(
237 &mut self,
238 buffer: &Entity<Buffer>,
239 end_anchor: Anchor,
240 cx: &mut Context<Self>,
241 ) -> Task<Result<Vec<CompletionResponse>>> {
242 if let Some((start_anchor, query, candidates)) =
243 self.collect_mention_candidates(buffer, end_anchor, cx)
244 && !candidates.is_empty()
245 {
246 return cx.spawn(async move |_, cx| {
247 let completion_response = Self::completions_for_candidates(
248 cx,
249 query.as_str(),
250 &candidates,
251 start_anchor..end_anchor,
252 Self::completion_for_mention,
253 )
254 .await;
255 Ok(vec![completion_response])
256 });
257 }
258
259 if let Some((start_anchor, query, candidates)) =
260 self.collect_emoji_candidates(buffer, end_anchor, cx)
261 && !candidates.is_empty()
262 {
263 return cx.spawn(async move |_, cx| {
264 let completion_response = Self::completions_for_candidates(
265 cx,
266 query.as_str(),
267 candidates,
268 start_anchor..end_anchor,
269 Self::completion_for_emoji,
270 )
271 .await;
272 Ok(vec![completion_response])
273 });
274 }
275
276 Task::ready(Ok(vec![CompletionResponse {
277 completions: Vec::new(),
278 is_incomplete: false,
279 }]))
280 }
281
282 async fn completions_for_candidates(
283 cx: &AsyncApp,
284 query: &str,
285 candidates: &[StringMatchCandidate],
286 range: Range<Anchor>,
287 completion_fn: impl Fn(&StringMatch) -> (String, CodeLabel),
288 ) -> CompletionResponse {
289 const LIMIT: usize = 10;
290 let matches = fuzzy::match_strings(
291 candidates,
292 query,
293 true,
294 true,
295 LIMIT,
296 &Default::default(),
297 cx.background_executor().clone(),
298 )
299 .await;
300
301 let completions = matches
302 .into_iter()
303 .map(|mat| {
304 let (new_text, label) = completion_fn(&mat);
305 Completion {
306 replace_range: range.clone(),
307 new_text,
308 label,
309 icon_path: None,
310 confirm: None,
311 documentation: None,
312 insert_text_mode: None,
313 source: CompletionSource::Custom,
314 }
315 })
316 .collect::<Vec<_>>();
317
318 CompletionResponse {
319 is_incomplete: completions.len() >= LIMIT,
320 completions,
321 }
322 }
323
324 fn completion_for_mention(mat: &StringMatch) -> (String, CodeLabel) {
325 let label = CodeLabel {
326 filter_range: 1..mat.string.len() + 1,
327 text: format!("@{}", mat.string),
328 runs: Vec::new(),
329 };
330 (mat.string.clone(), label)
331 }
332
333 fn completion_for_emoji(mat: &StringMatch) -> (String, CodeLabel) {
334 let emoji = emojis::get_by_shortcode(&mat.string).unwrap();
335 let label = CodeLabel {
336 filter_range: 1..mat.string.len() + 1,
337 text: format!(":{}: {}", mat.string, emoji),
338 runs: Vec::new(),
339 };
340 (emoji.to_string(), label)
341 }
342
343 fn collect_mention_candidates(
344 &mut self,
345 buffer: &Entity<Buffer>,
346 end_anchor: Anchor,
347 cx: &mut Context<Self>,
348 ) -> Option<(Anchor, String, Vec<StringMatchCandidate>)> {
349 let end_offset = end_anchor.to_offset(buffer.read(cx));
350
351 let query = buffer.read_with(cx, |buffer, _| {
352 let mut query = String::new();
353 for ch in buffer.reversed_chars_at(end_offset).take(100) {
354 if ch == '@' {
355 return Some(query.chars().rev().collect::<String>());
356 }
357 if ch.is_whitespace() || !ch.is_ascii() {
358 break;
359 }
360 query.push(ch);
361 }
362 None
363 })?;
364
365 let start_offset = end_offset - query.len();
366 let start_anchor = buffer.read(cx).anchor_before(start_offset);
367
368 let mut names = HashSet::default();
369 if let Some(chat) = self.channel_chat.as_ref() {
370 let chat = chat.read(cx);
371 for participant in ChannelStore::global(cx)
372 .read(cx)
373 .channel_participants(chat.channel_id)
374 {
375 names.insert(participant.github_login.clone());
376 }
377 for message in chat
378 .messages_in_range(chat.message_count().saturating_sub(100)..chat.message_count())
379 {
380 names.insert(message.sender.github_login.clone());
381 }
382 }
383
384 let candidates = names
385 .into_iter()
386 .map(|user| StringMatchCandidate::new(0, &user))
387 .collect::<Vec<_>>();
388
389 Some((start_anchor, query, candidates))
390 }
391
392 fn collect_emoji_candidates(
393 &mut self,
394 buffer: &Entity<Buffer>,
395 end_anchor: Anchor,
396 cx: &mut Context<Self>,
397 ) -> Option<(Anchor, String, &'static [StringMatchCandidate])> {
398 static EMOJI_FUZZY_MATCH_CANDIDATES: LazyLock<Vec<StringMatchCandidate>> =
399 LazyLock::new(|| {
400 emojis::iter()
401 .flat_map(|s| s.shortcodes())
402 .map(|emoji| StringMatchCandidate::new(0, emoji))
403 .collect::<Vec<_>>()
404 });
405
406 let end_offset = end_anchor.to_offset(buffer.read(cx));
407
408 let query = buffer.read_with(cx, |buffer, _| {
409 let mut query = String::new();
410 for ch in buffer.reversed_chars_at(end_offset).take(100) {
411 if ch == ':' {
412 let next_char = buffer
413 .reversed_chars_at(end_offset - query.len() - 1)
414 .next();
415 // Ensure we are at the start of the message or that the previous character is a whitespace
416 if next_char.is_none() || next_char.unwrap().is_whitespace() {
417 return Some(query.chars().rev().collect::<String>());
418 }
419
420 // If the previous character is not a whitespace, we are in the middle of a word
421 // and we only want to complete the shortcode if the word is made up of other emojis
422 let mut containing_word = String::new();
423 for ch in buffer
424 .reversed_chars_at(end_offset - query.len() - 1)
425 .take(100)
426 {
427 if ch.is_whitespace() {
428 break;
429 }
430 containing_word.push(ch);
431 }
432 let containing_word = containing_word.chars().rev().collect::<String>();
433 if util::word_consists_of_emojis(containing_word.as_str()) {
434 return Some(query.chars().rev().collect::<String>());
435 }
436 break;
437 }
438 if ch.is_whitespace() || !ch.is_ascii() {
439 break;
440 }
441 query.push(ch);
442 }
443 None
444 })?;
445
446 let start_offset = end_offset - query.len() - 1;
447 let start_anchor = buffer.read(cx).anchor_before(start_offset);
448
449 Some((start_anchor, query, &EMOJI_FUZZY_MATCH_CANDIDATES))
450 }
451
452 async fn find_mentions(
453 this: WeakEntity<MessageEditor>,
454 buffer: BufferSnapshot,
455 cx: &mut AsyncWindowContext,
456 ) {
457 let (buffer, ranges) = cx
458 .background_spawn(async move {
459 let ranges = MENTIONS_SEARCH.search(&buffer, None).await;
460 (buffer, ranges)
461 })
462 .await;
463
464 this.update(cx, |this, cx| {
465 let mut anchor_ranges = Vec::new();
466 let mut mentioned_user_ids = Vec::new();
467 let mut text = String::new();
468
469 this.editor.update(cx, |editor, cx| {
470 let multi_buffer = editor.buffer().read(cx).snapshot(cx);
471 for range in ranges {
472 text.clear();
473 text.extend(buffer.text_for_range(range.clone()));
474 if let Some(username) = text.strip_prefix('@')
475 && let Some(user) = this
476 .user_store
477 .read(cx)
478 .cached_user_by_github_login(username)
479 {
480 let start = multi_buffer.anchor_after(range.start);
481 let end = multi_buffer.anchor_after(range.end);
482
483 mentioned_user_ids.push(user.id);
484 anchor_ranges.push(start..end);
485 }
486 }
487
488 editor.clear_highlights::<Self>(cx);
489 editor.highlight_text::<Self>(
490 anchor_ranges,
491 HighlightStyle {
492 font_weight: Some(FontWeight::BOLD),
493 ..Default::default()
494 },
495 cx,
496 )
497 });
498
499 this.mentions = mentioned_user_ids;
500 this.mentions_task.take();
501 })
502 .ok();
503 }
504
505 pub(crate) fn focus_handle(&self, cx: &gpui::App) -> gpui::FocusHandle {
506 self.editor.read(cx).focus_handle(cx)
507 }
508}
509
510impl Render for MessageEditor {
511 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
512 let settings = ThemeSettings::get_global(cx);
513 let text_style = TextStyle {
514 color: if self.editor.read(cx).read_only(cx) {
515 cx.theme().colors().text_disabled
516 } else {
517 cx.theme().colors().text
518 },
519 font_family: settings.ui_font.family.clone(),
520 font_features: settings.ui_font.features.clone(),
521 font_fallbacks: settings.ui_font.fallbacks.clone(),
522 font_size: TextSize::Small.rems(cx).into(),
523 font_weight: settings.ui_font.weight,
524 font_style: FontStyle::Normal,
525 line_height: relative(1.3),
526 ..Default::default()
527 };
528
529 div()
530 .w_full()
531 .px_2()
532 .py_1()
533 .bg(cx.theme().colors().editor_background)
534 .rounded_sm()
535 .child(EditorElement::new(
536 &self.editor,
537 EditorStyle {
538 local_player: cx.theme().players().local(),
539 text: text_style,
540 ..Default::default()
541 },
542 ))
543 }
544}