Add a Highlight Extension ==for highlights==

Author: pferreir

fuzz/fuzz_targets/all_options.rs

@@ -37,6 +37,7 @@ fuzz_target!(|s: &str| {
         link_url_rewriter: Some(Arc::new(url_rewriter)),
         cjk_friendly_emphasis: true,
         subtext: true,
+        highlight: true,
     };
 
     let cb = |link_ref: options::BrokenLinkReference| {

src/cm.rs

@@ -395,6 +395,7 @@ impl<'a, 'o, 'c> CommonMarkFormatter<'a, 'o, 'c> {
             NodeValue::Emph => self.format_emph(node)?,
             NodeValue::TaskItem(symbol) => self.format_task_item(symbol, node, entering)?,
             NodeValue::Strikethrough => self.format_strikethrough()?,
+            NodeValue::Highlight => self.format_highlight()?,
             NodeValue::Superscript => self.format_superscript()?,
             NodeValue::Link(ref nl) => return self.format_link(node, nl, entering),
             NodeValue::Image(ref nl) => self.format_image(nl, allow_wrap, entering)?,
@@ -781,6 +782,11 @@ impl<'a, 'o, 'c> CommonMarkFormatter<'a, 'o, 'c> {
         Ok(())
     }
 
+    fn format_highlight(&mut self) -> fmt::Result {
+        write!(self, "==")?;
+        Ok(())
+    }
+
     fn format_superscript(&mut self) -> fmt::Result {
         write!(self, "^")?;
         Ok(())

src/html.rs

@@ -440,6 +440,7 @@ pub fn format_node_default<'a, T>(
             render_footnote_reference(context, node, entering, nfr)
         }
         NodeValue::Strikethrough => render_strikethrough(context, node, entering),
+        NodeValue::Highlight => render_highlight(context, node, entering),
         NodeValue::Table(_) => render_table(context, node, entering),
         NodeValue::TableCell => render_table_cell(context, node, entering),
         NodeValue::TableRow(thead) => render_table_row(context, node, entering, thead),
@@ -1034,6 +1035,22 @@ fn render_strikethrough<'a, T>(
     Ok(ChildRendering::HTML)
 }
 
+fn render_highlight<'a, T>(
+    context: &mut Context<T>,
+    node: Node<'a>,
+    entering: bool,
+) -> Result<ChildRendering, fmt::Error> {
+    if entering {
+        context.write_str("<mark")?;
+        render_sourcepos(context, node)?;
+        context.write_str(">")?;
+    } else {
+        context.write_str("</mark>")?;
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
 fn render_table<'a, T>(
     context: &mut Context<T>,
     node: Node<'a>,

src/main.rs

@@ -196,6 +196,7 @@ enum Extension {
     Alerts,
     CjkFriendlyEmphasis,
     Subtext,
+    Highlight,
 }
 
 #[derive(Clone, Copy, Debug, ValueEnum)]
@@ -284,7 +285,8 @@ fn main() -> Result<(), Box<dyn Error>> {
         .alerts(exts.contains(&Extension::Alerts))
         .maybe_front_matter_delimiter(cli.front_matter_delimiter)
         .cjk_friendly_emphasis(exts.contains(&Extension::CjkFriendlyEmphasis))
-        .subtext(exts.contains(&Extension::Subtext));
+        .subtext(exts.contains(&Extension::Subtext))
+        .highlight(exts.contains(&Extension::Highlight));
 
     #[cfg(feature = "shortcodes")]
     let extension = extension.shortcodes(cli.gemoji);

src/nodes.rs

@@ -159,6 +159,9 @@ pub enum NodeValue {
     /// per the GFM spec.
     Strikethrough,
 
+    /// ***Inline**. [Highlight](https://www.markdownlang.com/extended/highlight.html) / mark text
+    Highlight,
+
     /// **Inline**.  Superscript.  Enabled with `ext_superscript` option.
     Superscript,
 
@@ -648,6 +651,7 @@ impl NodeValue {
             NodeValue::HtmlInline(..) => "html_inline",
             NodeValue::Raw(..) => "raw",
             NodeValue::Strikethrough => "strikethrough",
+            NodeValue::Highlight => "highlight",
             NodeValue::FrontMatter(_) => "frontmatter",
             NodeValue::TaskItem { .. } => "taskitem",
             NodeValue::Superscript => "superscript",
@@ -899,6 +903,7 @@ impl<'a> arena_tree::Node<'a, RefCell<Ast>> {
             | NodeValue::Image(..)
             | NodeValue::WikiLink(..)
             | NodeValue::Strikethrough
+            | NodeValue::Highlight
             | NodeValue::Superscript
             | NodeValue::SpoileredText
             | NodeValue::Underline
@@ -921,6 +926,7 @@ impl<'a> arena_tree::Node<'a, RefCell<Ast>> {
                     | NodeValue::Link(..)
                     | NodeValue::Image(..)
                     | NodeValue::Strikethrough
+                    | NodeValue::Highlight
                     | NodeValue::HtmlInline(..)
                     | NodeValue::Math(..)
                     | NodeValue::WikiLink(..)
@@ -943,6 +949,7 @@ impl<'a> arena_tree::Node<'a, RefCell<Ast>> {
                 | NodeValue::Link(..)
                 | NodeValue::Image(..)
                 | NodeValue::Strikethrough
+                | NodeValue::Highlight
                 | NodeValue::HtmlInline(..)
                 | NodeValue::Math(..)
                 | NodeValue::WikiLink(..)

src/parser/inlines.rs

@@ -104,6 +104,10 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
             s.special_chars[b'~' as usize] = true;
             s.skip_chars[b'~' as usize] = true;
         }
+        if options.extension.highlight {
+            s.special_chars[b'=' as usize] = true;
+            s.skip_chars[b'=' as usize] = true;
+        }
         if options.extension.superscript || options.extension.inline_footnotes {
             s.special_chars[b'^' as usize] = true;
         }
@@ -190,6 +194,7 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
             '\0' => return false,
             '\r' | '\n' => Some(self.handle_newline()),
             '`' => Some(self.handle_backticks(&ast.line_offsets)),
+            '=' if self.options.extension.highlight => Some(self.handle_delim(b'=')),
             '\\' => Some(self.handle_backslash()),
             '&' => Some(self.handle_entity()),
             '<' => Some(self.handle_pointy_brace(&ast.line_offsets)),
@@ -635,15 +640,18 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
             self.pos - 1,
         );
 
-        let is_valid_strikethrough_delim = if c == b'~' && self.options.extension.strikethrough {
+        let is_valid_double_delim_if_required = if (c == b'~'
+            && self.options.extension.strikethrough)
+            || (c == b'=' && self.options.extension.highlight)
+        {
             numdelims <= 2
         } else {
             true
         };
 
         if (can_open || can_close)
             && (!(c == b'\'' || c == b'"') || self.options.parse.smart)
-            && is_valid_strikethrough_delim
+            && is_valid_double_delim_if_required
         {
             self.push_delimiter(c, can_open, can_close, inl);
         }
@@ -1116,7 +1124,7 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
         // This array is an important optimization that prevents searching down
         // the stack for openers we've previously searched for and know don't
         // exist, preventing exponential blowup on pathological cases.
-        let mut openers_bottom: [usize; 12] = [stack_bottom; 12];
+        let mut openers_bottom: [usize; 13] = [stack_bottom; 13];
 
         // This is traversing the stack from the top to the bottom, setting `closer` to
         // the delimiter directly above `stack_bottom`. In the case where we are processing
@@ -1146,7 +1154,8 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
                     b'"' => 3,
                     b'\'' => 4,
                     b'_' => 5,
-                    b'*' => 6 + (if c.can_open { 3 } else { 0 }) + (c.length % 3),
+                    b'*' => 7 + (if c.can_open { 3 } else { 0 }) + (c.length % 3),
+                    b'=' => 12,
                     _ => unreachable!(),
                 };
 
@@ -1197,6 +1206,7 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
                         && c.delim_char == b'~')
                     || (self.options.extension.superscript && c.delim_char == b'^')
                     || (self.options.extension.spoiler && c.delim_char == b'|')
+                    || (self.options.extension.highlight && c.delim_char == b'=')
                 {
                     if opener_found {
                         // Finally, here's the happy case where the delimiters
@@ -1373,6 +1383,17 @@ impl<'a, 'r, 'o, 'd, 'c, 'p> Subject<'a, 'r, 'o, 'd, 'c, 'p> {
                 } else {
                     NodeValue::EscapedTag("~~".to_owned())
                 }
+            } else if opener_char == b'=' {
+                // Not emphasis
+                // Unlike for |, these cases have to be handled because they will match
+                // in the event subscript but not strikethrough is enabled
+                if self.options.extension.highlight {
+                    NodeValue::Highlight
+                } else if use_delims == 1 {
+                    NodeValue::EscapedTag("=".to_owned())
+                } else {
+                    NodeValue::EscapedTag("==".to_owned())
+                }
             } else if self.options.extension.superscript && opener_char == b'^' {
                 NodeValue::Superscript
             } else if self.options.extension.spoiler && opener_char == b'|' {

src/parser/options.rs

@@ -526,6 +526,23 @@ pub struct Extension<'c> {
     /// ```
     #[cfg_attr(feature = "bon", builder(default))]
     pub subtext: bool,
+
+    /// Enables highlighting (mark) using `==`.
+    ///
+    /// ```md
+    /// Hey, ==this is important!==
+    /// ```
+    ///
+    /// ```rust
+    /// # use comrak::{markdown_to_html, Options};
+    /// let mut options = Options::default();
+    /// options.extension.highlight = true;
+    ///
+    /// assert_eq!(markdown_to_html("Hey, ==this is important!==", &options),
+    ///           "<p>Hey, <mark>this is important!</mark></p>\n");
+    /// ```
+    #[cfg_attr(feature = "bon", builder(default))]
+    pub highlight: bool,
 }
 
 impl<'c> Extension<'c> {

src/tests.rs

@@ -21,6 +21,7 @@ mod front_matter;
 mod fuzz;
 mod greentext;
 mod header_ids;
+mod highlight;
 #[path = "tests/html.rs"]
 mod html_;
 mod inline_footnotes;

src/tests/highlight.rs

@@ -0,0 +1,23 @@
+use super::*;
+
+#[test]
+fn highlight() {
+    html_opts!(
+        [extension.highlight],
+        concat!(
+            "This is ==important!==.\n",
+            "\n",
+            "This is ==very important== OK?\n",
+            "\n",
+            "==It is a \n shrubbery==\n",
+            "\n",
+            "Vendo ==Opel Corsa **em bom estado**==\n",
+        ),
+        concat!(
+            "<p>This is <mark>important!</mark>.</p>\n",
+            "<p>This is <mark>very important</mark> OK?</p>\n",
+            "<p><mark>It is a\nshrubbery</mark></p>\n",
+            "<p>Vendo <mark>Opel Corsa <strong>em bom estado</strong></mark></p>\n"
+        ),
+    );
+}

src/tests/sourcepos.rs

@@ -298,6 +298,11 @@ const STRIKETHROUGH: TestCase = (
     "hello ~~world~~ between ~~wo\nrld~~ after",
 );
 
+const HIGHLIGHT: TestCase = (
+    &[sourcepos!((1:7-1:15)), sourcepos!((1:25-2:5))],
+    "hello ==world== between ==wo\nrld== after",
+);
+
 const SUPERSCRIPT: TestCase = (
     &[sourcepos!((1:7-1:13)), sourcepos!((1:23-2:4))],
     "hello ^world^ between ^wo\nrld^ after",
@@ -475,6 +480,7 @@ fn node_values() -> HashMap<NodeValueDiscriminants, TestCase> {
                 Emph => EMPH,
                 Strong => STRONG,
                 Strikethrough => STRIKETHROUGH,
+                Highlight => HIGHLIGHT,
                 Superscript => SUPERSCRIPT,
                 Subscript => SUBSCRIPT,
                 Link => LINK,
@@ -508,6 +514,7 @@ fn sourcepos() {
     options.extension.table = true;
     options.extension.tasklist = true;
     options.extension.strikethrough = true;
+    options.extension.highlight = true;
     options.extension.superscript = true;
     options.extension.subscript = true;
     options.extension.autolink = true;