commonmarker 2.10.0 → 2.10.1

data/ext/commonmarker/src/node.rs

@@ -1,3 +1,4 @@
+use crate::rctree::Node;
 use comrak::arena_tree::Node as ComrakNode;
 use comrak::nodes::{
     AlertType, Ast as ComrakAst, AstNode as ComrakAstNode, ListDelimType, ListType, NodeAlert,
@@ -8,7 +9,6 @@ use comrak::nodes::{
 };
 use magnus::{function, method, scan_args, Module, Object, RHash, RModule, Symbol, Value};
 use magnus::{RArray, Ruby};
-use rctree::Node;
 use typed_arena::Arena;
 
 use std::cell::RefCell;
@@ -599,42 +599,50 @@ impl CommonmarkerNode {
         })
     }
 
+    /// Copies a comrak tree into a Ruby-visible tree, failing if any node sits
+    /// more than `max_nesting_depth` levels below the root.
     pub fn new_from_comrak_node<'a>(
+        ruby: &Ruby,
         comrak_root_node: &'a ComrakAstNode<'a>,
+        max_nesting_depth: usize,
     ) -> Result<CommonmarkerNode, magnus::Error> {
-        let comrak_ast = comrak_root_node.data.clone().into_inner();
-
-        fn iter_nodes<'a>(comrak_node: &'a ComrakAstNode<'a>) -> CommonmarkerNode {
-            let comrak_node_ast = comrak_node.data.clone().into_inner();
-            let commonmark_node = CommonmarkerNode {
-                inner: Node::new(CommonmarkerAst {
-                    data: comrak_node_ast,
-                }),
+        let commonmarker_root_node = Node::new(CommonmarkerAst {
+            data: comrak_root_node.data.borrow().clone(),
+        });
+
+        // Depth-first walk with an explicit stack instead of recursion, so that
+        // deeply nested input (e.g. thousands of nested blockquotes) cannot
+        // overflow the native stack. Each entry pairs an iterator over a comrak
+        // node's remaining children with the copy of that node the children get
+        // appended to.
+        let mut stack = vec![(comrak_root_node.children(), commonmarker_root_node.clone())];
+
+        loop {
+            // The stack holds one entry per ancestor, so its length is the
+            // depth of the next child produced.
+            let depth = stack.len();
+            let Some((children, parent)) = stack.last_mut() else {
+                break;
+            };
+            let Some(comrak_child) = children.next() else {
+                stack.pop();
+                continue;
             };
 
-            for c in comrak_node.children() {
-                match commonmark_node.append_child_node(&iter_nodes(c)) {
-                    Ok(_) => {}
-                    Err(e) => {
-                        panic!("cannot append node: {}", e);
-                    }
-                }
+            if depth > max_nesting_depth {
+                return Err(crate::nesting::exceeded_error(ruby, max_nesting_depth));
             }
 
-            commonmark_node
-        }
-
-        let commonmarker_root_node = CommonmarkerNode {
-            inner: Node::new(CommonmarkerAst { data: comrak_ast }),
-        };
-
-        for child in comrak_root_node.children() {
-            let new_child = iter_nodes(child);
-
-            commonmarker_root_node.append_child_node(&new_child)?;
+            let node = Node::new(CommonmarkerAst {
+                data: comrak_child.data.borrow().clone(),
+            });
+            parent.append(node.clone());
+            stack.push((comrak_child.children(), node));
         }
 
-        Ok(commonmarker_root_node)
+        Ok(CommonmarkerNode {
+            inner: commonmarker_root_node,
+        })
     }
 
     fn type_to_symbol(ruby: &Ruby, rb_self: &Self) -> Symbol {
@@ -1127,6 +1135,39 @@ impl CommonmarkerNode {
         }
     }
 
+    /// Copies this node and its descendants into `arena` as a comrak tree so that
+    /// comrak's formatters can render it.
+    ///
+    /// Depth-first walk with an explicit stack instead of recursion, so that
+    /// deeply nested input cannot overflow the native stack. Each entry pairs an
+    /// iterator over a node's remaining children with the copy of that node the
+    /// children get appended to.
+    fn to_comrak_node<'a>(&self, arena: &'a Arena<ComrakAstNode<'a>>) -> &'a ComrakAstNode<'a> {
+        let comrak_root_node: &'a ComrakAstNode<'a> = arena.alloc(ComrakNode::new(RefCell::new(
+            self.inner.borrow().data.clone(),
+        )));
+
+        let mut stack = vec![(self.inner.children(), comrak_root_node)];
+
+        loop {
+            let Some((children, parent)) = stack.last_mut() else {
+                break;
+            };
+            let parent: &'a ComrakAstNode<'a> = parent;
+            let Some(child) = children.next() else {
+                stack.pop();
+                continue;
+            };
+
+            let comrak_node: &'a ComrakAstNode<'a> =
+                arena.alloc(ComrakNode::new(RefCell::new(child.borrow().data.clone())));
+            parent.append(comrak_node);
+            stack.push((child.children(), comrak_node));
+        }
+
+        comrak_root_node
+    }
+
     fn to_html(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, magnus::Error> {
         let args = scan_args::scan_args::<(), (), (), (), _, ()>(args)?;
 
@@ -1171,42 +1212,18 @@ impl CommonmarkerNode {
         };
 
         match syntect_adapter {
-            Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+            Some(ref adapter) => {
+                comrak_plugins.render.codefence_syntax_highlighter = Some(adapter.as_ref())
+            }
             None => comrak_plugins.render.codefence_syntax_highlighter = None,
         }
 
         let arena: Arena<ComrakAstNode> = Arena::new();
-        fn iter_nodes<'a>(
-            arena: &'a Arena<comrak::arena_tree::Node<'a, RefCell<ComrakAst>>>,
-            node: &CommonmarkerNode,
-        ) -> &'a comrak::arena_tree::Node<'a, std::cell::RefCell<comrak::nodes::Ast>> {
-            let comrak_node: &'a mut ComrakAstNode = arena.alloc(ComrakNode::new(RefCell::new(
-                node.inner.borrow().data.clone(),
-            )));
-
-            for c in node.inner.children() {
-                let child = CommonmarkerNode { inner: c };
-                let child_node = iter_nodes(arena, &child);
-                comrak_node.append(child_node);
-            }
-
-            comrak_node
-        }
-
-        let comrak_root_node: ComrakNode<RefCell<ComrakAst>> =
-            ComrakNode::new(RefCell::new(rb_self.inner.borrow().data.clone()));
-
-        for c in rb_self.inner.children() {
-            let child = CommonmarkerNode { inner: c };
-
-            let new_child = iter_nodes(&arena, &child);
-
-            comrak_root_node.append(new_child);
-        }
+        let comrak_root_node = rb_self.to_comrak_node(&arena);
 
         let mut output = String::new();
         match comrak::format_html_with_plugins(
-            &comrak_root_node,
+            comrak_root_node,
             &comrak_options,
             &mut output,
             &comrak_plugins,
@@ -1267,42 +1284,18 @@ impl CommonmarkerNode {
         };
 
         match syntect_adapter {
-            Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+            Some(ref adapter) => {
+                comrak_plugins.render.codefence_syntax_highlighter = Some(adapter.as_ref())
+            }
             None => comrak_plugins.render.codefence_syntax_highlighter = None,
         }
 
         let arena: Arena<ComrakAstNode> = Arena::new();
-        fn iter_nodes<'a>(
-            arena: &'a Arena<comrak::arena_tree::Node<'a, RefCell<ComrakAst>>>,
-            node: &CommonmarkerNode,
-        ) -> &'a comrak::arena_tree::Node<'a, std::cell::RefCell<comrak::nodes::Ast>> {
-            let comrak_node: &'a mut ComrakAstNode = arena.alloc(ComrakNode::new(RefCell::new(
-                node.inner.borrow().data.clone(),
-            )));
-
-            for c in node.inner.children() {
-                let child = CommonmarkerNode { inner: c };
-                let child_node = iter_nodes(arena, &child);
-                comrak_node.append(child_node);
-            }
-
-            comrak_node
-        }
-
-        let comrak_root_node: ComrakNode<RefCell<ComrakAst>> =
-            ComrakNode::new(RefCell::new(rb_self.inner.borrow().data.clone()));
-
-        for c in rb_self.inner.children() {
-            let child = CommonmarkerNode { inner: c };
-
-            let new_child = iter_nodes(&arena, &child);
-
-            comrak_root_node.append(new_child);
-        }
+        let comrak_root_node = rb_self.to_comrak_node(&arena);
 
         let mut output = String::new();
         match comrak::format_commonmark_with_plugins(
-            &comrak_root_node,
+            comrak_root_node,
             &comrak_options,
             &mut output,
             &comrak_plugins,
@@ -1311,7 +1304,7 @@ impl CommonmarkerNode {
             Err(e) => {
                 return Err(magnus::Error::new(
                     ruby.exception_runtime_error(),
-                    format!("cannot convert into html: {}", e),
+                    format!("cannot convert into commonmark: {}", e),
                 ));
             }
         }

data/ext/commonmarker/src/options.rs

@@ -117,7 +117,6 @@ pub fn iterate_render_options(comrak_options: &mut comrak::options::Render, opti
 }
 
 const EXTENSION_STRIKETHROUGH: &str = "strikethrough";
-const EXTENSION_TAGFILTER: &str = "tagfilter";
 const EXTENSION_TABLE: &str = "table";
 const EXTENSION_AUTOLINK: &str = "autolink";
 const EXTENSION_TASKLIST: &str = "tasklist";
@@ -156,9 +155,6 @@ pub fn iterate_extension_options(
                 Cow::Borrowed(EXTENSION_STRIKETHROUGH) => {
                     comrak_options.strikethrough = TryConvert::try_convert(value)?;
                 }
-                Cow::Borrowed(EXTENSION_TAGFILTER) => {
-                    comrak_options.tagfilter = TryConvert::try_convert(value)?;
-                }
                 Cow::Borrowed(EXTENSION_TABLE) => {
                     comrak_options.table = TryConvert::try_convert(value)?;
                 }

data/ext/commonmarker/src/plugins/syntax_highlighting.rs

@@ -1,4 +1,5 @@
 use std::path::PathBuf;
+use std::sync::{Arc, OnceLock};
 
 use comrak::plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder};
 
@@ -11,7 +12,7 @@ use crate::EMPTY_STR;
 pub fn construct_syntax_highlighter_from_plugin(
     ruby: &Ruby,
     rb_plugins: Option<RHash>,
-) -> Result<Option<SyntectAdapter>, magnus::Error> {
+) -> Result<Option<Arc<SyntectAdapter>>, magnus::Error> {
     match rb_plugins {
         None => Ok(None),
         Some(rb_plugins) => {
@@ -34,8 +35,11 @@ pub fn construct_syntax_highlighter_from_plugin(
                 Some(theme) => {
                     if theme.is_empty() {
                         // no theme? uss css classes
-                        adapter = SyntectAdapter::new(None);
-                        Ok(Some(adapter))
+                        // Avoid reloading syntax sets and recompiling regexes for every CSS-mode render.
+                        static CSS_ADAPTER: OnceLock<Arc<SyntectAdapter>> = OnceLock::new();
+                        Ok(Some(Arc::clone(
+                            CSS_ADAPTER.get_or_init(|| Arc::new(SyntectAdapter::new(None))),
+                        )))
                     } else {
                         let path = match rb_plugins
                             .get(ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN))
@@ -80,7 +84,7 @@ pub fn construct_syntax_highlighter_from_plugin(
 
                             adapter = builder.theme_set(ts).theme(&theme).build();
 
-                            Ok(Some(adapter))
+                            Ok(Some(Arc::new(adapter)))
                         } else {
                             // no path? default theme lookup
                             ThemeSet::load_defaults()
@@ -93,7 +97,7 @@ pub fn construct_syntax_highlighter_from_plugin(
                                     )
                                 })?;
                             adapter = SyntectAdapter::new(Some(&theme));
-                            Ok(Some(adapter))
+                            Ok(Some(Arc::new(adapter)))
                         }
                     }
                 }