remove need to clone attribute values too.

Author: kivikakk

examples/syntax_highlighter.rs

@@ -2,6 +2,7 @@
 
 use comrak::adapters::SyntaxHighlighterAdapter;
 use comrak::{markdown_to_html_with_plugins, Options, Plugins};
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt::{self, Write};
 
@@ -35,7 +36,7 @@ impl SyntaxHighlighterAdapter for PotatoSyntaxAdapter {
     fn write_pre_tag(
         &self,
         output: &mut dyn Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<str>>,
     ) -> fmt::Result {
         if attributes.contains_key("lang") {
             write!(output, "<pre lang=\"{}\">", attributes["lang"])
@@ -47,7 +48,7 @@ impl SyntaxHighlighterAdapter for PotatoSyntaxAdapter {
     fn write_code_tag(
         &self,
         output: &mut dyn Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<str>>,
     ) -> fmt::Result {
         if attributes.contains_key("class") {
             write!(output, "<code class=\"{}\">", attributes["class"])

src/adapters.rs

@@ -2,6 +2,7 @@
 //!
 //! Each plugin has to implement one of the traits available in this module.
 
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt;
 
@@ -24,20 +25,20 @@ pub trait SyntaxHighlighterAdapter: Send + Sync {
     /// `<pre>` tag possibly with some HTML attribute pre-filled.
     ///
     /// `attributes`: A map of HTML attributes provided by comrak.
-    fn write_pre_tag(
+    fn write_pre_tag<'s>(
         &self,
         output: &mut dyn fmt::Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<'s, str>>,
     ) -> fmt::Result;
 
     /// Generates the opening `<code>` tag. Some syntax highlighter libraries might include their own
     /// `<code>` tag possibly with some HTML attribute pre-filled.
     ///
     /// `attributes`: A map of HTML attributes provided by comrak.
-    fn write_code_tag(
+    fn write_code_tag<'s>(
         &self,
         output: &mut dyn fmt::Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<'s, str>>,
     ) -> fmt::Result;
 }
 

src/html.rs

@@ -530,8 +530,8 @@ fn render_code_block<'a, T>(
             context.cr()?;
 
             let mut first_tag = 0;
-            let mut pre_attributes: HashMap<&str, String> = HashMap::new();
-            let mut code_attributes: HashMap<&str, String> = HashMap::new();
+            let mut pre_attributes: HashMap<&str, Cow<str>> = HashMap::new();
+            let mut code_attributes: HashMap<&str, Cow<str>> = HashMap::new();
             let code_attr: String;
 
             let literal = &ncb.literal;
@@ -544,27 +544,27 @@ fn render_code_block<'a, T>(
                 }
 
                 let lang_str = &info[..first_tag];
-                let info_str = &info[first_tag..].trim();
+                let info_str = info[first_tag..].trim();
 
                 if context.options.render.github_pre_lang {
-                    pre_attributes.insert("lang", lang_str.to_string());
+                    pre_attributes.insert("lang", lang_str.into());
 
                     if context.options.render.full_info_string && !info_str.is_empty() {
-                        pre_attributes.insert("data-meta", info_str.trim().to_string());
+                        pre_attributes.insert("data-meta", info_str.trim().into());
                     }
                 } else {
                     code_attr = format!("language-{}", lang_str);
-                    code_attributes.insert("class", code_attr);
+                    code_attributes.insert("class", code_attr.into());
 
                     if context.options.render.full_info_string && !info_str.is_empty() {
-                        code_attributes.insert("data-meta", info_str.to_string());
+                        code_attributes.insert("data-meta", info_str.into());
                     }
                 }
             }
 
             if context.options.render.sourcepos {
                 let ast = node.data.borrow();
-                pre_attributes.insert("data-sourcepos", ast.sourcepos.to_string());
+                pre_attributes.insert("data-sourcepos", ast.sourcepos.to_string().into());
             }
 
             match context.plugins.render.codefence_syntax_highlighter {
@@ -1314,7 +1314,7 @@ pub fn render_math<'a, T>(
     nm: &NodeMath,
 ) -> Result<ChildRendering, fmt::Error> {
     if entering {
-        let mut tag_attributes: Vec<(Cow<str>, Cow<str>)> = Vec::new();
+        let mut tag_attributes: Vec<(&str, Cow<str>)> = Vec::new();
         let style_attr = if nm.display_math { "display" } else { "inline" };
         let tag: &str = if nm.dollar_math { "span" } else { "code" };
 
@@ -1343,8 +1343,8 @@ pub fn render_math_code_block<'a, T>(
 
     // use vectors to ensure attributes always written in the same order,
     // for testing stability
-    let mut pre_attributes: Vec<(Cow<str>, Cow<str>)> = Vec::new();
-    let mut code_attributes: Vec<(Cow<str>, Cow<str>)> = Vec::new();
+    let mut pre_attributes: Vec<(&str, Cow<str>)> = Vec::new();
+    let mut code_attributes: Vec<(&str, Cow<str>)> = Vec::new();
     let lang_str = "math";
 
     if context.options.render.github_pre_lang {

src/parser/mod.rs

@@ -1140,6 +1140,7 @@ pub struct RenderPlugins<'p> {
     /// ```
     /// # use comrak::{markdown_to_html, Options, Plugins, markdown_to_html_with_plugins};
     /// # use comrak::adapters::SyntaxHighlighterAdapter;
+    /// use std::borrow::Cow;
     /// use std::collections::HashMap;
     /// use std::fmt::{self, Write};
     /// let options = Options::default();
@@ -1155,11 +1156,11 @@ pub struct RenderPlugins<'p> {
     ///         write!(output, "<span class=\"lang-{}\">{}</span>", lang.unwrap(), code)
     ///     }
     ///
-    ///     fn write_pre_tag(&self, output: &mut dyn fmt::Write, _attributes: HashMap<String, String>) -> fmt::Result {
+    ///     fn write_pre_tag<'s>(&self, output: &mut dyn fmt::Write, _attributes: HashMap<&'static str, Cow<'s, str>>) -> fmt::Result {
     ///         output.write_str("<pre lang=\"rust\">")
     ///     }
     ///
-    ///     fn write_code_tag(&self, output: &mut dyn fmt::Write, _attributes: HashMap<String, String>) -> fmt::Result {
+    ///     fn write_code_tag<'s>(&self, output: &mut dyn fmt::Write, _attributes: HashMap<&'static str, Cow<'s, str>>) -> fmt::Result {
     ///         output.write_str("<code class=\"language-rust\">")
     ///     }
     /// }

src/plugins/syntect.rs

@@ -1,7 +1,6 @@
 //! Adapter for the Syntect syntax highlighter plugin.
 
-use crate::adapters::SyntaxHighlighterAdapter;
-use crate::html;
+use std::borrow::Cow;
 use std::collections::{hash_map, HashMap};
 use std::fmt::{self, Write};
 use syntect::easy::HighlightLines;
@@ -13,6 +12,9 @@ use syntect::parsing::{SyntaxReference, SyntaxSet};
 use syntect::util::LinesWithEndings;
 use syntect::Error;
 
+use crate::adapters::SyntaxHighlighterAdapter;
+use crate::html;
+
 #[derive(Debug)]
 /// Syntect syntax highlighter plugin.
 pub struct SyntectAdapter {
@@ -103,10 +105,10 @@ impl SyntaxHighlighterAdapter for SyntectAdapter {
         }
     }
 
-    fn write_pre_tag(
+    fn write_pre_tag<'s>(
         &self,
         output: &mut dyn Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<'s, str>>,
     ) -> fmt::Result {
         match &self.theme {
             Some(theme) => {
@@ -129,29 +131,29 @@ impl SyntaxHighlighterAdapter for SyntectAdapter {
         }
     }
 
-    fn write_code_tag(
+    fn write_code_tag<'s>(
         &self,
         output: &mut dyn Write,
-        attributes: HashMap<&'static str, String>,
+        attributes: HashMap<&'static str, Cow<'s, str>>,
     ) -> fmt::Result {
         html::write_opening_tag(output, "code", attributes)
     }
 }
 
-struct SyntectPreAttributes {
+struct SyntectPreAttributes<'s> {
     syntect_style: String,
-    attributes: HashMap<&'static str, String>,
+    attributes: HashMap<&'static str, Cow<'s, str>>,
 }
 
-impl SyntectPreAttributes {
-    fn new(attributes: HashMap<&'static str, String>, syntect_style: &str) -> Self {
+impl<'s> SyntectPreAttributes<'s> {
+    fn new(attributes: HashMap<&'static str, Cow<'s, str>>, syntect_style: &str) -> Self {
         Self {
             syntect_style: syntect_style.into(),
             attributes,
         }
     }
 
-    fn iter_mut(&mut self) -> SyntectPreAttributesIter<'_> {
+    fn iter_mut(&mut self) -> SyntectPreAttributesIter<'_, 's> {
         SyntectPreAttributesIter {
             iter_mut: self.attributes.iter_mut(),
             syntect_style: &self.syntect_style,
@@ -160,20 +162,20 @@ impl SyntectPreAttributes {
     }
 }
 
-struct SyntectPreAttributesIter<'a> {
-    iter_mut: hash_map::IterMut<'a, &'static str, String>,
+struct SyntectPreAttributesIter<'a, 's> {
+    iter_mut: hash_map::IterMut<'a, &'static str, Cow<'s, str>>,
     syntect_style: &'a str,
     style_written: bool,
 }
 
-impl<'a> Iterator for SyntectPreAttributesIter<'a> {
+impl<'a, 's> Iterator for SyntectPreAttributesIter<'a, 's> {
     type Item = (&'a str, &'a str);
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter_mut.next() {
             Some((k, v)) if *k == "style" && !self.style_written => {
                 self.style_written = true;
-                v.insert_str(0, self.syntect_style);
+                v.to_mut().insert_str(0, self.syntect_style);
                 Some((k, v))
             }
             Some((k, v)) => Some((k, v)),

src/tests/plugins.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::{
     adapters::{HeadingAdapter, HeadingMeta, SyntaxHighlighterAdapter},
     nodes::Sourcepos,
@@ -22,15 +24,15 @@ fn syntax_highlighter_plugin() {
         fn write_pre_tag(
             &self,
             output: &mut dyn std::fmt::Write,
-            attributes: HashMap<&'static str, String>,
+            attributes: HashMap<&'static str, Cow<str>>,
         ) -> std::fmt::Result {
             html::write_opening_tag(output, "pre", attributes)
         }
 
         fn write_code_tag(
             &self,
             output: &mut dyn std::fmt::Write,
-            attributes: HashMap<&'static str, String>,
+            attributes: HashMap<&'static str, Cow<str>>,
         ) -> std::fmt::Result {
             html::write_opening_tag(output, "code", attributes)
         }