Add mention insertion methods

bindings/wysiwyg-ffi/src/ffi_composer_model.rs

@@ -258,10 +258,9 @@ impl ComposerModel {
         ))
     }
 
-    /// This function creates a link with the first argument being the href, the second being the
-    /// display text, the third being the (rust model) suggestion that is being replaced and the
-    /// final argument being a list of attributes that will be added to the Link.
-    pub fn set_link_suggestion(
+    /// This function creates a mention node and inserts it into the composer, replacing the
+    /// text content defined by the suggestion
+    pub fn insert_mention_at_suggestion(
         self: &Arc<Self>,
         url: String,
         text: String,
@@ -284,7 +283,7 @@ impl ComposerModel {
             self.inner
                 .lock()
                 .unwrap()
-                .set_link_suggestion(url, text, suggestion, attrs),
+                .insert_mention_at_suggestion(url, text, suggestion, attrs),
         ))
     }
 

bindings/wysiwyg-ffi/src/ffi_composer_update.rs

@@ -121,35 +121,120 @@ mod test {
     }
 
     #[test]
-    fn test_set_link_suggestion_ffi() {
-        let model = Arc::new(ComposerModel::new());
+    fn test_replace_whole_suggestion_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
         let update = model.replace_text("@alic".into());
 
-        let MenuAction::Suggestion { suggestion_pattern } =
-            update.menu_action() else
-        {
-            panic!("No suggestion found");
-        };
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "<a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a>\u{a0}",
+        )
+    }
+
+    #[test]
+    fn test_replace_end_of_text_node_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+        model.replace_text("hello ".into());
+
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "hello <a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a>\u{a0}",
+        )
+    }
+
+    #[test]
+    fn test_replace_start_of_text_node_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+        model.replace_text(" says hello".into());
+        model.select(0, 0);
+
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "<a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a> says hello",
+        )
+    }
+
+    #[test]
+    fn test_replace_text_in_middle_of_node_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+        model.replace_text("Like  said".into());
+        model.select(5, 5); // "Like | said"
+
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "Like <a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a> said",
+        )
+    }
 
-        model.set_link_suggestion(
+    #[test]
+    fn test_replace_text_in_second_paragraph_node_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+        model.replace_text("hello".into());
+        model.enter();
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "<p>hello</p><p><a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a>\u{a0}</p>",
+        )
+    }
+
+    #[test]
+    fn test_replace_text_in_second_list_item_start_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+
+        model.ordered_list();
+        model.replace_text("hello".into());
+        model.enter();
+
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "<ol><li>hello</li><li><a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a>\u{a0}</li></ol>",
+        )
+    }
+
+    #[test]
+    fn test_replace_text_in_second_list_item_end_with_mention_ffi() {
+        let mut model = Arc::new(ComposerModel::new());
+        model.ordered_list();
+        model.replace_text("hello".into());
+        model.enter();
+        model.replace_text("there ".into());
+
+        insert_mention_at_cursor(&mut model);
+
+        assert_eq!(
+            model.get_content_as_html(),
+            "<ol><li>hello</li><li>there <a data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\" contenteditable=\"false\">Alice</a>\u{a0}</li></ol>",
+        )
+    }
+
+    // TODO remove attributes when Rust model can parse url directly
+    // https://github.com/matrix-org/matrix-rich-text-editor/issues/709
+    fn insert_mention_at_cursor(model: &mut Arc<ComposerModel>) {
+        let update = model.replace_text("@alic".into());
+        let MenuAction::Suggestion{suggestion_pattern} = update.menu_action() else {
+        panic!("No suggestion pattern found")
+    };
+        model.insert_mention_at_suggestion(
             "https://matrix.to/#/@alice:matrix.org".into(),
             "Alice".into(),
             suggestion_pattern,
-            vec![
-                Attribute {
-                    key: "contenteditable".into(),
-                    value: "false".into(),
-                },
-                Attribute {
-                    key: "data-mention-type".into(),
-                    value: "user".into(),
-                },
-            ],
+            vec![Attribute {
+                key: "data-mention-type".into(),
+                value: "user".into(),
+            }],
         );
-        assert_eq!(
-            model.get_content_as_html(),
-            "<a contenteditable=\"false\" data-mention-type=\"user\" href=\"https://matrix.to/#/@alice:matrix.org\">Alice</a>\u{a0}",
-        )
     }
 
     fn redo_indent_unindent_disabled() -> HashMap<ComposerAction, ActionState> {

bindings/wysiwyg-ffi/src/wysiwyg_composer.udl

@@ -47,7 +47,7 @@ interface ComposerModel {
     ComposerUpdate unindent();
     ComposerUpdate set_link(string url, sequence<Attribute> attributes);
     ComposerUpdate set_link_with_text(string url, string text, sequence<Attribute> attributes);
-    ComposerUpdate set_link_suggestion(string url, string text, SuggestionPattern suggestion, sequence<Attribute> attributes);
+    ComposerUpdate insert_mention_at_suggestion(string url, string text, SuggestionPattern suggestion, sequence<Attribute> attributes);
     ComposerUpdate remove_links();
     ComposerUpdate code_block();
     ComposerUpdate quote();

bindings/wysiwyg-wasm/src/lib.rs

@@ -312,17 +312,16 @@ impl ComposerModel {
         ))
     }
 
-    /// This function creates a link with the first argument being the href, the second being the
-    /// display text, the third being the (rust model) suggestion that is being replaced and the
-    /// final argument being a map of html attributes that will be added to the Link.
-    pub fn set_link_suggestion(
+    /// This function creates a mention node and inserts it into the composer, replacing the
+    /// text content defined by the suggestion
+    pub fn insert_mention_at_suggestion(
         &mut self,
         url: &str,
         text: &str,
         suggestion: &SuggestionPattern,
         attributes: js_sys::Map,
     ) -> ComposerUpdate {
-        ComposerUpdate::from(self.inner.set_link_suggestion(
+        ComposerUpdate::from(self.inner.insert_mention_at_suggestion(
             Utf16String::from_str(url),
             Utf16String::from_str(text),
             wysiwyg::SuggestionPattern::from(suggestion.clone()),

crates/wysiwyg/src/composer_model.rs

@@ -20,6 +20,7 @@ pub mod format;
 mod format_inline_code;
 pub mod hyperlinks;
 pub mod lists;
+pub mod mentions;
 pub mod menu_action;
 pub mod menu_state;
 pub mod new_lines;

crates/wysiwyg/src/composer_model/example_format.rs

@@ -350,18 +350,18 @@ impl SelectionWriter {
     /// after a mention node
     ///
     /// * `buf` - the output buffer up to and including the given node
-    /// * `pos` - the buffer position immediately after the node
+    /// * `start_pos` - the buffer position immediately before the node
     pub fn write_selection_mention_node<S: UnicodeString>(
         &mut self,
         buf: &mut S,
-        pos: usize,
+        start_pos: usize,
         node: &MentionNode<S>,
     ) {
         if let Some(loc) = self.locations.get(&node.handle()) {
             let strings_to_add = self.state.advance(loc, 1);
             for (str, i) in strings_to_add.into_iter().rev() {
-                let i = if i == 0 { 0 } else { buf.len() };
-                buf.insert(pos + i, &S::from(str));
+                let insert_pos = if i == 0 { start_pos } else { buf.len() };
+                buf.insert(insert_pos, &S::from(str));
             }
         }
     }

crates/wysiwyg/src/composer_model/hyperlinks.rs

@@ -21,8 +21,7 @@ use crate::dom::nodes::DomNode;
 use crate::dom::unicode_string::UnicodeStrExt;
 use crate::dom::Range;
 use crate::{
-    ComposerModel, ComposerUpdate, DomHandle, LinkAction, Location,
-    SuggestionPattern, UnicodeString,
+    ComposerModel, ComposerUpdate, DomHandle, LinkAction, UnicodeString,
 };
 use email_address::*;
 use url::{ParseError, Url};
@@ -63,24 +62,6 @@ where
         }
     }
 
-    pub fn set_link_suggestion(
-        &mut self,
-        url: S,
-        text: S,
-        suggestion: SuggestionPattern,
-        attributes: Vec<(S, S)>,
-    ) -> ComposerUpdate<S> {
-        // TODO - this function allows us to accept a Vec of attributes to add to the Link we create,
-        // but these attributes will be present in the html of the message we output. We may need to
-        // add a step in the future that strips these attributes from the html before it is sent.
-
-        self.do_replace_text_in(S::default(), suggestion.start, suggestion.end);
-        self.state.start = Location::from(suggestion.start);
-        self.state.end = self.state.start;
-        self.set_link_with_text(url, text, attributes);
-        self.do_replace_text(" ".into())
-    }
-
     fn is_blank_selection(&self, range: Range) -> bool {
         for leaf in range.leaves() {
             match leaf.kind {

crates/wysiwyg/src/composer_model/mentions.rs

@@ -0,0 +1,96 @@
+// Copyright 2023 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::{
+    dom::DomLocation, ComposerModel, ComposerUpdate, DomNode, Location,
+    SuggestionPattern, UnicodeString,
+};
+
+impl<S> ComposerModel<S>
+where
+    S: UnicodeString,
+{
+    /// Remove the suggestion text and then add a mention to the composer
+    pub fn insert_mention_at_suggestion(
+        &mut self,
+        url: S,
+        text: S,
+        suggestion: SuggestionPattern,
+        attributes: Vec<(S, S)>,
+    ) -> ComposerUpdate<S> {
+        // This function removes the text between the suggestion start and end points, updates the
+        // cursor position and then calls insert_mention (equivalent to link insertion steps)
+        self.do_replace_text_in(S::default(), suggestion.start, suggestion.end);
+        self.state.start = Location::from(suggestion.start);
+        self.state.end = self.state.start;
+
+        self.insert_mention(url, text, attributes)
+    }
+
+    /// Inserts a mention into the composer. It uses the following rules:
+    /// - If the selection or cursor contains/is inside a link, do nothing (see
+    /// https://github.com/matrix-org/matrix-rich-text-editor/issues/702)
+    /// - If the composer contains a selection, remove the contents of the selection
+    /// prior to inserting a mention at the cursor.
+    /// - If the composer contains a cursor, insert a mention at the cursor
+    pub fn insert_mention(
+        &mut self,
+        url: S,
+        text: S,
+        attributes: Vec<(S, S)>,
+    ) -> ComposerUpdate<S> {
+        let (start, end) = self.safe_selection();
+        let range = self.state.dom.find_range(start, end);
+
+        if range.locations.iter().any(|l: &DomLocation| {
+            l.kind.is_link_kind() || l.kind.is_code_kind()
+        }) {
+            return ComposerUpdate::keep();
+        }
+
+        if range.is_selection() {
+            self.replace_text(S::default());
+        }
+
+        self.do_insert_mention(url, text, attributes)
+    }
+
+    fn do_insert_mention(
+        &mut self,
+        url: S,
+        text: S,
+        attributes: Vec<(S, S)>,
+    ) -> ComposerUpdate<S> {
+        let (start, end) = self.safe_selection();
+        let range = self.state.dom.find_range(start, end);
+
+        let new_node = DomNode::new_mention(url, text, attributes);
+        let new_cursor_index = start + new_node.text_len();
+
+        self.push_state_to_history();
+
+        let handle = self.state.dom.insert_node_at_cursor(&range, new_node);
+
+        // manually move the cursor to the end of the mention
+        self.state.start = Location::from(new_cursor_index);
+        self.state.end = self.state.start;
+
+        // add a trailing space in cases when we do not have a next sibling
+        if self.state.dom.is_last_in_parent(&handle) {
+            self.do_replace_text(" ".into())
+        } else {
+            self.create_update_replace_all()
+        }
+    }
+}

crates/wysiwyg/src/composer_model/menu_action.rs

@@ -28,7 +28,12 @@ where
     pub(crate) fn compute_menu_action(&self) -> MenuAction {
         let (s, e) = self.safe_selection();
         let range = self.state.dom.find_range(s, e);
-        if range.locations.iter().any(|l| l.kind.is_code_kind()) {
+
+        if range
+            .locations
+            .iter()
+            .any(|l| l.kind.is_code_kind() || l.kind.is_link_kind())
+        {
             return MenuAction::None;
         }
         let (raw_text, start, end) = self.extended_text(range);

crates/wysiwyg/src/dom.rs

@@ -23,6 +23,7 @@ pub mod dom_struct;
 pub mod find_extended_range;
 pub mod find_range;
 pub mod find_result;
+pub mod insert_node_at_cursor;
 pub mod insert_parent;
 pub mod iter;
 pub mod join_nodes;