Integrate mention parsing

crates/matrix_mentions/src/lib.rs

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

crates/matrix_mentions/src/mention.rs

@@ -59,6 +59,11 @@ impl Mention {
         &self.kind
     }
 
+    /// Determine if a uri is a valid matrix uri
+    pub fn is_valid_uri(uri: &str) -> bool {
+        parse_matrix_id(uri).is_some()
+    }
+
     /// Create a mention from a URI
     ///
     /// If the URI is a valid room or user, it creates a mention using the

crates/wysiwyg/src/composer_model/mentions.rs

@@ -11,17 +11,20 @@
 // 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 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.
@@ -33,7 +36,7 @@ where
         suggestion: SuggestionPattern,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_mention() {
+        if self.should_not_insert_mention(&url, &text) {
             return ComposerUpdate::keep();
         }
 
@@ -45,6 +48,7 @@ where
     }
 
     /// 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.
@@ -55,7 +59,7 @@ where
         text: S,
         attributes: Vec<(S, S)>,
     ) -> ComposerUpdate<S> {
-        if self.should_not_insert_mention() {
+        if self.should_not_insert_mention(&url, &text) {
             return ComposerUpdate::keep();
         }
 
@@ -66,8 +70,9 @@ where
         self.do_insert_mention(url, text, attributes)
     }
 
-    /// Creates a new mention node then inserts the node at the cursor position. It adds a trailing space when the inserted
-    /// mention is the last node in it's parent.
+    /// 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.
     fn do_insert_mention(
         &mut self,
         url: S,
@@ -77,45 +82,51 @@ where
         let (start, end) = self.safe_selection();
         let range = self.state.dom.find_range(start, end);
 
-        // use the display text decide the mention type
-        // TODO extract this into a util function if it is reused when parsing the html prior to editing a message
-        // TODO decide if this do* function should be separated to handle mention vs at-room mention
-        // TODO handle invalid mention urls after permalink parsing methods have been created
-        let new_node = if text == "@room".into() {
-            DomNode::new_at_room_mention(attributes)
-        } else {
-            DomNode::new_mention(url, text, attributes)
-        };
-
-        let new_cursor_index = start + new_node.text_len();
+        if let Ok(new_node) = DomNode::new_mention(url, text, attributes) {
+            let new_cursor_index = start + new_node.text_len();
 
-        let handle = self.state.dom.insert_node_at_cursor(&range, new_node);
+            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;
+            // 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())
+            // 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()
+            }
         } else {
-            self.create_update_replace_all()
+            ComposerUpdate::keep()
         }
     }
 
-    /// Utility function for the insert_mention* methods. It returns false if the range
-    /// includes any link or code type leaves.
+    /// Utility function 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 (with special case for at-room)
     ///
     /// 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) -> bool {
+    fn should_not_insert_mention(&self, url: &S, text: &S) -> bool {
         let (start, end) = self.safe_selection();
         let range = self.state.dom.find_range(start, end);
 
-        range.locations.iter().any(|l: &DomLocation| {
-            l.kind.is_link_kind() || l.kind.is_code_kind()
-        })
+        let invalid_uri = !Mention::is_valid_uri(url.to_string().as_str());
+
+        let range_contains_link_or_code_leaves =
+            range.locations.iter().any(|l: &DomLocation| {
+                l.kind.is_link_kind() || l.kind.is_code_kind()
+            });
+
+        // when we have an at-room mention, it doesn't matter about the url as we do not use
+        // it, rendering the mention as raw text in the html output
+        if MentionNode::is_at_room_display_text(text) {
+            range_contains_link_or_code_leaves
+        } else {
+            invalid_uri || range_contains_link_or_code_leaves
+        }
     }
 }

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

@@ -11,7 +11,6 @@
 // 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::{
@@ -26,6 +25,7 @@ use crate::dom::unicode_string::UnicodeStrExt;
 use crate::dom::{self, UnicodeString};
 use crate::{InlineFormatType, ListType};
 
+use super::mention_node::UriParseError;
 use super::MentionNode;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -138,12 +138,25 @@ 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
     pub fn new_mention(
         url: S,
         display_text: S,
         attributes: Vec<(S, S)>,
-    ) -> DomNode<S> {
-        DomNode::Mention(MentionNode::new(url, display_text, attributes))
+    ) -> Result<DomNode<S>, UriParseError> {
+        // special case for at-room
+        if MentionNode::is_at_room_display_text(&display_text) {
+            Ok(DomNode::Mention(MentionNode::new_at_room(attributes)))
+        } else if let Ok(mention_node) =
+            MentionNode::new(url, display_text, attributes)
+        {
+            Ok(DomNode::Mention(mention_node))
+        } else {
+            Err(UriParseError)
+        }
     }
 
     pub fn new_at_room_mention(attributes: Vec<(S, S)>) -> DomNode<S> {