make syntext plugin report if syntax is not found

Author: rlidwka

CHANGELOG.md

@@ -13,6 +13,7 @@
 ### Changed
 
  - `Node::walk_*` methods now return `Result`, which allows you to terminate traversing early
+ - `syntext` rule now trims spaces in fence info string
 
 ### Migration
 

Cargo.toml

@@ -36,6 +36,7 @@ derive_more  = ">= 0.99.0, < 1"
 downcast-rs  = ">= 1.0.2, < 2"
 entities     = ">= 0.1.0, < 2"
 html-escape  = ">= 0.1.0, < 0.3"
+indoc        = ">= 0.3.4, < 3"
 linkify      = { version = ">= 0.5.0, < 0.10", optional = true }
 mdurl        = ">= 0.3.1, < 0.4"
 once_cell    = ">= 1.0.1, < 2"

src/plugins/extra/syntect.rs

@@ -1,4 +1,5 @@
 //! Syntax highlighting for code blocks
+use anyhow::anyhow;
 use syntect::highlighting::ThemeSet;
 use syntect::html::highlighted_html_for_string;
 use syntect::parsing::SyntaxSet;
@@ -7,7 +8,7 @@ use crate::parser::core::CoreRule;
 use crate::parser::extset::MarkdownItExt;
 use crate::plugins::cmark::block::code::CodeBlock;
 use crate::plugins::cmark::block::fence::CodeFence;
-use crate::{MarkdownIt, Node, NodeValue, Renderer};
+use crate::{MarkdownIt, Node, NodeValue, Renderer, Result};
 
 #[derive(Debug)]
 pub struct SyntectSnippet {
@@ -40,7 +41,18 @@ pub fn set_theme(md: &mut MarkdownIt, theme: &'static str) {
 
 pub struct SyntectRule;
 impl CoreRule for SyntectRule {
+    fn try_run(root: &mut Node, md: &MarkdownIt) -> Result<()> {
+        Self::_run::<true>(root, md)?;
+        Ok(())
+    }
+
     fn run(root: &mut Node, md: &MarkdownIt) {
+        let _ = Self::_run::<false>(root, md);
+    }
+}
+
+impl SyntectRule {
+    fn _run<const CAN_FAIL: bool>(root: &mut Node, md: &MarkdownIt) -> Result<()> {
         let ss = SyntaxSet::load_defaults_newlines();
         let ts = ThemeSet::load_defaults();
         let theme = &ts.themes[md.ext.get::<SyntectSettings>().copied().unwrap_or_default().0];
@@ -59,17 +71,135 @@ impl CoreRule for SyntectRule {
             if let Some(content) = content {
                 let mut syntax = None;
                 if let Some(language) = language {
-                    syntax = ss.find_syntax_by_token(&language);
+                    let language = language.trim();
+                    if !language.is_empty() {
+                        syntax = ss.find_syntax_by_token(language);
+
+                        if CAN_FAIL && syntax.is_none() {
+                            return Err(anyhow!("syntax not found for language `{language}`"));
+                        }
+                    }
                 }
-                let syntax = syntax.unwrap_or_else(|| ss.find_syntax_plain_text());
 
+                let syntax = syntax.unwrap_or_else(|| ss.find_syntax_plain_text());
                 let html = highlighted_html_for_string(content, &ss, syntax, theme);
 
                 if let Ok(html) = html {
                     node.replace(SyntectSnippet { html });
                 }
             }
             Ok(())
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use indoc::{indoc, formatdoc};
+
+    fn run(input: &str) -> String {
+        let md = &mut crate::MarkdownIt::new();
+        crate::plugins::cmark::block::fence::add(md);
+        crate::plugins::extra::syntect::add(md);
+        let node = md.parse(&(input.to_owned() + "\n"));
+        node.walk(|node, _| {
+            assert!(node.srcmap.is_some());
+            Ok(())
+        }).unwrap();
+        node.render()
+    }
+
+    fn try_run(input: &str) -> crate::Result<String> {
+        let md = &mut crate::MarkdownIt::new();
+        crate::plugins::cmark::block::fence::add(md);
+        crate::plugins::extra::syntect::add(md);
+        let node = md.try_parse(&(input.to_owned() + "\n"))?;
+        node.walk(|node, _| {
+            assert!(node.srcmap.is_some());
+            Ok(())
         }).unwrap();
+        Ok(node.render())
+    }
+
+    #[test]
+    fn no_lang_prefix() {
+        let input = indoc!(r#"
+            ```
+            hello
+            ```
+        "#);
+
+        let output = indoc!(r#"
+            <pre style="background-color:#ffffff;">
+            <span style="color:#323232;">hello
+            </span></pre>
+        "#);
+
+        assert_eq!(run(input), output);
+        assert_eq!(try_run(input).ok().unwrap(), output);
+    }
+
+    #[test]
+    fn rust_highlight() {
+        let input = indoc!(r#"
+            ```rust
+            let hello = "world";
+            ```
+        "#);
+
+        let output = indoc!(r#"
+            <pre style="background-color:#ffffff;">
+            <span style="font-weight:bold;color:#a71d5d;">let</span>
+            <span style="color:#323232;"> hello </span>
+            <span style="font-weight:bold;color:#a71d5d;">= </span>
+            <span style="color:#183691;">&quot;world&quot;</span>
+            <span style="color:#323232;">;</span>
+            </pre>
+        "#);
+
+        assert_eq!(run(input).replace('\n', ""), output.replace('\n', ""));
+        assert_eq!(try_run(input).ok().unwrap().replace('\n', ""), output.replace('\n', ""));
+    }
+
+    #[test]
+    fn rust_highlight_trim_spaces() {
+        let input = &formatdoc!(r#"
+            ```  rust{}
+            let hello = "world";
+            ```
+        "#, "  ");
+
+        let output = indoc!(r#"
+            <pre style="background-color:#ffffff;">
+            <span style="font-weight:bold;color:#a71d5d;">let</span>
+            <span style="color:#323232;"> hello </span>
+            <span style="font-weight:bold;color:#a71d5d;">= </span>
+            <span style="color:#183691;">&quot;world&quot;</span>
+            <span style="color:#323232;">;</span>
+            </pre>
+        "#);
+
+        assert_eq!(run(input).replace('\n', ""), output.replace('\n', ""));
+        assert_eq!(try_run(input).ok().unwrap().replace('\n', ""), output.replace('\n', ""));
+    }
+
+    #[test]
+    fn unknown_lang() {
+        let input = indoc!(r#"
+            ```some-unknown-language
+            hello
+            ```
+        "#);
+
+        let output = indoc!(r#"
+            <pre style="background-color:#ffffff;">
+            <span style="color:#323232;">hello
+            </span></pre>
+        "#);
+
+        assert_eq!(run(input), output);
+        assert!(
+            format!("{:?}", try_run(input).err().unwrap()).contains("syntax not found for language")
+        );
     }
 }