feat: add TokenDelimiters struct and impl

unimarkup · Jul 17, 2022 · 4f81c70 · 4f81c70
1 parent be9f540
commit 4f81c70
Show file tree

Hide file tree

Showing 2 changed files with 86 additions and 32 deletions.
diff --git a/inline/src/inlines/mod.rs b/inline/src/inlines/mod.rs
@@ -1,6 +1,6 @@
 use std::collections::VecDeque;
 
-use crate::{Span, TokenKind};
+use crate::{Span, TokenDelimiters, TokenKind};
 
 mod content;
 
@@ -185,19 +185,30 @@ impl Inline {
     /// [`Inline`]: self::Inline
     pub fn as_string(&self) -> String {
         let token_kind = TokenKind::from(self);
-        let (begin_delim, end_delim) = token_kind.delimiters();
+        let delimiters = token_kind.delimiters();
 
-        let delim_len = begin_delim.len() + end_delim.len();
+        let (begin_delim, end_delim) = delimiters.as_str();
+
+        let delim_len = begin_delim.len() + end_delim.map(str::len).unwrap_or(0);
 
         let mut res = String::with_capacity(self.content_len() + delim_len);
 
         res.push_str(begin_delim);
         res.push_str(&self.as_ref().as_string());
-        res.push_str(end_delim);
+        res.push_str(end_delim.unwrap_or(""));
 
         res
     }
 
+    /// Returns the opening and, if available, closing [`TokenKind`] for the given [`Inline`].
+    ///
+    /// [`Inline`]: self::Inline
+    /// [`TokenKind`]: crate::TokenKind
+    pub fn delimiters(&self) -> TokenDelimiters {
+        let kind = TokenKind::from(self);
+        TokenDelimiters::from(&kind)
+    }
+
     /// Returns the length of content of this [`Inline`].
     ///
     /// [`Inline`]: self::Inline

diff --git a/inline/src/lexer/token.rs b/inline/src/lexer/token.rs
@@ -495,34 +495,8 @@ impl TokenKind {
     /// Returns the pair of delimiters for this kind as [`&str`].
     ///
     /// [`&str`]: &str
-    pub fn delimiters(&self) -> (&str, &str) {
-        match self {
-            TokenKind::Bold
-            | TokenKind::Italic
-            | TokenKind::ItalicBold
-            | TokenKind::Underline
-            | TokenKind::Subscript
-            | TokenKind::UnderlineSubscript
-            | TokenKind::Superscript
-            | TokenKind::Overline
-            | TokenKind::Strikethrough
-            | TokenKind::Highlight
-            | TokenKind::Verbatim
-            | TokenKind::Quote
-            | TokenKind::Math => (self.as_str(), self.as_str()),
-
-            TokenKind::Newline | TokenKind::Whitespace | TokenKind::Plain => ("", ""),
-
-            TokenKind::OpenParens | TokenKind::CloseParens => {
-                (Self::OpenParens.as_str(), Self::CloseParens.as_str())
-            }
-            TokenKind::OpenBracket | TokenKind::CloseBracket => {
-                (Self::OpenBracket.as_str(), Self::CloseBracket.as_str())
-            }
-            TokenKind::OpenBrace | TokenKind::CloseBrace => {
-                (Self::OpenBrace.as_str(), Self::CloseBrace.as_str())
-            }
-        }
+    pub fn delimiters(&self) -> TokenDelimiters {
+        TokenDelimiters::from(self)
     }
 
     /// Checks whether the content of this token is significant - should be stored.
@@ -616,6 +590,75 @@ impl From<(Symbol<'_>, usize)> for TokenKind {
     }
 }
 
+impl From<TokenDelimiters> for (TokenKind, Option<TokenKind>) {
+    fn from(delimiters: TokenDelimiters) -> Self {
+        (delimiters.open, delimiters.close)
+    }
+}
+
+/// Delimiters
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TokenDelimiters {
+    open: TokenKind,
+    close: Option<TokenKind>,
+}
+
+impl From<&TokenKind> for TokenDelimiters {
+    fn from(kind: &TokenKind) -> Self {
+        match kind {
+            TokenKind::Bold
+            | TokenKind::Italic
+            | TokenKind::ItalicBold
+            | TokenKind::Underline
+            | TokenKind::Subscript
+            | TokenKind::UnderlineSubscript
+            | TokenKind::Superscript
+            | TokenKind::Overline
+            | TokenKind::Strikethrough
+            | TokenKind::Highlight
+            | TokenKind::Verbatim
+            | TokenKind::Quote
+            | TokenKind::Math => Self {
+                open: *kind,
+                close: Some(*kind),
+            },
+
+            TokenKind::OpenParens | TokenKind::CloseParens => Self {
+                open: TokenKind::OpenParens,
+                close: Some(TokenKind::CloseParens),
+            },
+            TokenKind::OpenBracket | TokenKind::CloseBracket => Self {
+                open: TokenKind::OpenBracket,
+                close: Some(TokenKind::CloseBracket),
+            },
+            TokenKind::OpenBrace | TokenKind::CloseBrace => Self {
+                open: TokenKind::OpenBrace,
+                close: Some(TokenKind::CloseBrace),
+            },
+            TokenKind::Newline | TokenKind::Whitespace | TokenKind::Plain => Self {
+                open: TokenKind::Plain,
+                close: Some(TokenKind::Plain),
+            },
+        }
+    }
+}
+
+impl From<&Token> for TokenDelimiters {
+    fn from(token: &Token) -> Self {
+        Self::from(&token.kind())
+    }
+}
+
+impl TokenDelimiters {
+    /// Returns the [`&str`] representation of opening and, if available, closing delimiter.
+    pub fn as_str(&self) -> (&str, Option<&str>) {
+        (
+            self.open.as_str(),
+            self.close.as_ref().map(TokenKind::as_str),
+        )
+    }
+}
+
 /// Enum representing the spacing surrounding a particular token in Unimarkup document.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Spacing {