Integrate mention parsing

bindings/wysiwyg-ffi/src/ffi_composer_model.rs

@@ -260,7 +260,7 @@ impl ComposerModel {
 
     /// Creates an at-room mention node and inserts it into the composer at the current selection
     pub fn insert_at_room_mention(
-        &mut self,
+        self: &Arc<Self>,
         attributes: Vec<Attribute>,
     ) -> Arc<ComposerUpdate> {
         let attrs = attributes
@@ -303,7 +303,7 @@ impl ComposerModel {
     /// Creates an at-room mention node and inserts it into the composer, replacing the
     /// text content defined by the suggestion
     pub fn insert_at_room_mention_at_suggestion(
-        &mut self,
+        self: &Arc<Self>,
         suggestion: SuggestionPattern,
         attributes: Vec<Attribute>,
     ) -> Arc<ComposerUpdate> {

bindings/wysiwyg-ffi/src/wysiwyg_composer.udl

@@ -48,7 +48,9 @@ interface ComposerModel {
     ComposerUpdate set_link(string url, sequence<Attribute> attributes);
     ComposerUpdate set_link_with_text(string url, string text, sequence<Attribute> attributes);
     ComposerUpdate remove_links();
+    ComposerUpdate insert_at_room_mention(sequence<Attribute> attributes);
     ComposerUpdate insert_mention(string url, string text, sequence<Attribute> attributes);
+    ComposerUpdate insert_at_room_mention_at_suggestion(SuggestionPattern suggestion, sequence<Attribute> attributes);
     ComposerUpdate insert_mention_at_suggestion(string url, string text, SuggestionPattern suggestion, sequence<Attribute> attributes);
     ComposerUpdate code_block();
     ComposerUpdate quote();

crates/matrix_mentions/Cargo.toml

@@ -9,6 +9,10 @@ name = "matrix_mentions"
 version = "0.1.0"
 edition = "2021"
 
-[dependencies]
+[features]
+default = ["custom-matrix-urls"]
+custom-matrix-urls = []
 
+[dependencies]
+cfg-if = "1.0.0"
 ruma-common = "0.11.3"

crates/matrix_mentions/src/lib.rs

@@ -14,6 +14,4 @@
 
 mod mention;
 
-pub use crate::mention::{
-    get_at_room_display_text, Mention, MentionKind, AT_ROOM,
-};
+pub use crate::mention::{Mention, MentionKind};

crates/matrix_mentions/src/mention.rs

@@ -15,12 +15,6 @@
 use ruma_common::{matrix_uri::MatrixId, IdParseError, MatrixToUri, MatrixUri};
 
 const MATRIX_TO_BASE_URL: &str = "https://matrix.to/#/";
-pub const AT_ROOM: &str = "@room";
-
-/// Util function to get the display text for an at-room mention
-pub fn get_at_room_display_text() -> &'static str {
-    AT_ROOM
-}
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Mention {
@@ -164,20 +158,28 @@ impl Mention {
 /// If any of the above succeed, return Some<MatrixIdI. Else return None.
 fn parse_matrix_id(uri: &str) -> Option<MatrixId> {
     if let Ok(matrix_uri) = MatrixUri::parse(uri) {
-        Some(matrix_uri.id().to_owned())
+        return Some(matrix_uri.id().to_owned());
     } else if let Ok(matrix_to_uri) = MatrixToUri::parse(uri) {
-        Some(matrix_to_uri.id().to_owned())
-    } else if let Ok(matrix_to_uri) = parse_external_id(uri) {
-        Some(matrix_to_uri.id().to_owned())
-    } else {
-        None
+        return Some(matrix_to_uri.id().to_owned());
+    }
+
+    cfg_if::cfg_if! {
+        if #[cfg(any(test, feature = "custom-matrix-urls"))] {
+             if let Ok(matrix_to_uri) = parse_external_id(uri) {
+            return Some(matrix_to_uri.id().to_owned());
+        }
+        }
     }
+
+    None
 }
 
 /// Attempts to split an external id on `/#/`, rebuild as a matrix to style permalink then parse
 /// using ruma.
 ///
 /// Returns the result of calling `parse` in ruma.
+
+#[cfg(any(test, feature = "custom-matrix-urls"))]
 fn parse_external_id(uri: &str) -> Result<MatrixToUri, IdParseError> {
     // first split the string into the parts we need
     let parts: Vec<&str> = uri.split("/#/").collect();

crates/wysiwyg/src/composer_model/mentions.rs

@@ -11,102 +11,95 @@
 // 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 matrix_mentions::Mention;
 
 use crate::{
-    dom::DomLocation, ComposerModel, ComposerUpdate, DomNode, Location,
-    SuggestionPattern, UnicodeString,
+    dom::{nodes::MentionNode, DomLocation},
+    ComposerModel, ComposerUpdate, DomNode, Location, SuggestionPattern,
+    UnicodeString,
 };
 
 impl<S> ComposerModel<S>
 where
     S: UnicodeString,
 {
-    /// Remove the suggestion text and then insert a mention into the composer, using the following rules
-    /// - Do not do anthing if the uri is invalid
-    /// - Do not do anthing if the range includes link or code leaves
-    /// - 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
+    /// Checks to see if the mention should be inserted and also if the mention can be created.
+    /// If both of these checks are passed it will remove the suggestion and then insert a mention.
     pub fn insert_mention_at_suggestion(
         &mut self,
         url: S,
         text: S,
         suggestion: SuggestionPattern,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_mention(&url) {
+        if self.range_contains_link_or_code_leaves() {
             return ComposerUpdate::keep();
         }
 
-        self.push_state_to_history();
-        self.do_replace_text_in(S::default(), suggestion.start, suggestion.end);
-        self.state.start = Location::from(suggestion.start);
-        self.state.end = self.state.start;
-
         if let Ok(mention_node) = DomNode::new_mention(url, text, attributes) {
+            self.push_state_to_history();
+            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.do_insert_mention(mention_node)
         } else {
             ComposerUpdate::keep()
         }
     }
 
-    /// Remove the suggestion text and then insert an at-room mention into the composer, using the following rules
-    /// - Do not do anthing if the range includes link or code leaves
-    /// - 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_at_room_mention_at_suggestion(
+    /// Checks to see if the mention should be inserted and also if the mention can be created.
+    /// If both of these checks are passed it will remove any selection if present and then insert a mention.
+    pub fn insert_mention(
         &mut self,
-        suggestion: SuggestionPattern,
+        url: S,
+        text: S,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_at_room_mention() {
+        if self.range_contains_link_or_code_leaves() {
             return ComposerUpdate::keep();
         }
 
-        self.push_state_to_history();
-        self.do_replace_text_in(S::default(), suggestion.start, suggestion.end);
-        self.state.start = Location::from(suggestion.start);
-        self.state.end = self.state.start;
-
-        let mention_node = DomNode::new_at_room_mention(attributes);
-        self.do_insert_mention(mention_node)
+        if let Ok(mention_node) = DomNode::new_mention(url, text, attributes) {
+            self.push_state_to_history();
+            if self.has_selection() {
+                self.do_replace_text(S::default());
+            }
+            self.do_insert_mention(mention_node)
+        } else {
+            ComposerUpdate::keep()
+        }
     }
 
-    /// Inserts a mention into the composer. It uses the following rules:
-    /// - Do not insert a mention if the uri is invalid
-    /// - Do not insert a mention if the range includes link or code leaves
-    /// - 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(
+    /// Checks to see if the at-room mention should be inserted.
+    /// If so it will remove the suggestion and then insert an at-room mention.
+    pub fn insert_at_room_mention_at_suggestion(
         &mut self,
-        url: S,
-        text: S,
+        suggestion: SuggestionPattern,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_mention(&url) {
+        if self.range_contains_link_or_code_leaves() {
             return ComposerUpdate::keep();
         }
 
         self.push_state_to_history();
-        if self.has_selection() {
-            self.do_replace_text(S::default());
-        }
+        self.do_replace_text_in(S::default(), suggestion.start, suggestion.end);
+        self.state.start = Location::from(suggestion.start);
+        self.state.end = self.state.start;
 
-        if let Ok(mention_node) = DomNode::new_mention(url, text, attributes) {
-            self.do_insert_mention(mention_node)
-        } else {
-            ComposerUpdate::keep()
-        }
+        let mention_node = DomNode::new_at_room_mention(attributes);
+        self.do_insert_mention(mention_node)
     }
 
+    /// Checks to see if the at-room mention should be inserted.
+    /// If so it will remove any selection if present and then insert an at-room mention.
     pub fn insert_at_room_mention(
         &mut self,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_at_room_mention() {
+        if self.range_contains_link_or_code_leaves() {
             return ComposerUpdate::keep();
         }
 
@@ -119,23 +112,21 @@ where
         self.do_insert_mention(mention_node)
     }
 
-    /// Creates a new mention node then inserts the node at the cursor position. If creation fails due to
-    /// an invalid uri, it will return `ComposerUpdate::keep()`.
-    /// It adds a trailing space when the inserted mention is the last node in it's parent.
+    /// Inserts the node at the cursor position. It adds a trailing space when the inserted
+    /// mention is the last node in it's parent.
     fn do_insert_mention(
         &mut self,
-        mention_node: DomNode<S>,
+        mention_node: MentionNode<S>, // TODO can we type this as a mention node somehow
     ) -> ComposerUpdate<S> {
-        if !mention_node.is_mention_node() {
-            return ComposerUpdate::keep();
-        }
-
         let (start, end) = self.safe_selection();
         let range = self.state.dom.find_range(start, end);
 
         let new_cursor_index = start + mention_node.text_len();
 
-        let handle = self.state.dom.insert_node_at_cursor(&range, mention_node);
+        let handle = self
+            .state
+            .dom
+            .insert_node_at_cursor(&range, DomNode::Mention(mention_node));
 
         // manually move the cursor to the end of the mention
         self.state.start = Location::from(new_cursor_index);
@@ -149,23 +140,8 @@ where
         }
     }
 
-    /// Utility functions for the insert_mention* methods. It returns false if:
-    /// - the range includes any link or code type leaves
-    /// - the url is not a valid matrix uri
-    ///
-    /// Related issue is here:
-    /// https://github.com/matrix-org/matrix-rich-text-editor/issues/702
-    /// We do not allow mentions to be inserted into links, the planned behaviour is
-    /// detailed in the above issue.
-    fn should_not_insert_mention(&self, url: &S) -> bool {
-        !Mention::is_valid_uri(url.to_string().as_str())
-            || self.range_contains_link_or_code_leaves()
-    }
-
-    fn should_not_insert_at_room_mention(&self) -> bool {
-        self.range_contains_link_or_code_leaves()
-    }
-
+    /// We should not insert a mention if the uri is invalid or the range contains link
+    /// or code leaves. See issue https://github.com/matrix-org/matrix-rich-text-editor/issues/702.
     fn range_contains_link_or_code_leaves(&self) -> bool {
         let (start, end) = self.safe_selection();
         let range = self.state.dom.find_range(start, end);

crates/wysiwyg/src/dom/nodes/dom_node.rs

@@ -11,6 +11,7 @@
 // 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::composer_model::example_format::SelectionWriter;
 use crate::dom::dom_handle::DomHandle;
 use crate::dom::nodes::{
@@ -138,26 +139,24 @@ where
         DomNode::Container(ContainerNode::new_link(url, children, attributes))
     }
 
-    /// Create a new mention node. This function will perform a single check of the display
-    /// text and return an at-room mention if that text exactly matches `@room`
-    ///
-    /// Returns a result as creating a mention node can fail with an invalid uri
+    /// Attempts to create a new mention node. Returns a result as creating a
+    /// mention node can fail if attempted with an invalid uri.
     pub fn new_mention(
         url: S,
         display_text: S,
         attributes: Vec<(S, S)>,
-    ) -> Result<DomNode<S>, UriParseError> {
+    ) -> Result<MentionNode<S>, UriParseError> {
         if let Ok(mention_node) =
             MentionNode::new(url, display_text, attributes)
         {
-            Ok(DomNode::Mention(mention_node))
+            Ok(mention_node)
         } else {
             Err(UriParseError)
         }
     }
 
-    pub fn new_at_room_mention(attributes: Vec<(S, S)>) -> DomNode<S> {
-        DomNode::Mention(MentionNode::new_at_room(attributes))
+    pub fn new_at_room_mention(attributes: Vec<(S, S)>) -> MentionNode<S> {
+        MentionNode::new_at_room(attributes)
     }
 
     pub fn is_container_node(&self) -> bool {