commonmarker 2.9.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;
@@ -31,6 +31,39 @@ pub struct CommonmarkerNode {
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for CommonmarkerNode {}
 
+/// Reports whether a node value supports a given property, where "property" is
+/// a method name with any trailing `=` or `?` removed.
+///
+/// `None` means the property is not type-dependent at all
+/// (`walk`, `type`, `delete`, ...).
+fn value_supports(value: &ComrakNodeValue, property: &str) -> Option<bool> {
+    let supported = match property {
+        "string_content" => matches!(
+            value,
+            ComrakNodeValue::Text(_) | ComrakNodeValue::Code(_) | ComrakNodeValue::CodeBlock(_)
+        ),
+        "literal" => matches!(
+            value,
+            ComrakNodeValue::Text(_)
+                | ComrakNodeValue::Code(_)
+                | ComrakNodeValue::CodeBlock(_)
+                | ComrakNodeValue::HtmlBlock(_)
+                | ComrakNodeValue::HtmlInline(_)
+                | ComrakNodeValue::Raw(_)
+                | ComrakNodeValue::Math(_)
+                | ComrakNodeValue::FrontMatter(_)
+        ),
+        "url" | "title" => matches!(value, ComrakNodeValue::Link(_) | ComrakNodeValue::Image(_)),
+        "header_level" => matches!(value, ComrakNodeValue::Heading(_)),
+        "list_type" | "list_start" | "list_tight" => matches!(value, ComrakNodeValue::List(_)),
+        "fenced" | "fence_info" => matches!(value, ComrakNodeValue::CodeBlock(_)),
+        "alert_type" => matches!(value, ComrakNodeValue::Alert(_)),
+        _ => return None,
+    };
+
+    Some(supported)
+}
+
 impl CommonmarkerNode {
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, magnus::Error> {
         let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
@@ -566,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 {
@@ -784,6 +825,63 @@ impl CommonmarkerNode {
         }
     }
 
+    /// Returns `true` or `false` if the given method is only available for
+    /// certain node types, and `nil` if its availability does not depend on
+    /// the node's type. Backs `Node#respond_to?`.
+    fn supports_method(rb_self: &Self, name: Symbol) -> Option<bool> {
+        let node = rb_self.inner.borrow();
+        let name = name.to_string();
+        let property = name.trim_end_matches('=').trim_end_matches('?');
+
+        value_supports(&node.data.value, property)
+    }
+
+    fn get_literal(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
+
+        match &node.data.value {
+            ComrakNodeValue::Text(text) => Ok(text.to_string()),
+            ComrakNodeValue::Code(code) => Ok(code.literal.to_string()),
+            ComrakNodeValue::CodeBlock(code_block) => Ok(code_block.literal.to_string()),
+            ComrakNodeValue::HtmlBlock(html_block) => Ok(html_block.literal.to_string()),
+            ComrakNodeValue::HtmlInline(html_inline) => Ok(html_inline.to_string()),
+            ComrakNodeValue::Raw(raw) => Ok(raw.to_string()),
+            ComrakNodeValue::Math(math) => Ok(math.literal.to_string()),
+            ComrakNodeValue::FrontMatter(front_matter) => Ok(front_matter.to_string()),
+            _ => Err(magnus::Error::new(
+                ruby.exception_type_error(),
+                "node does not have a literal",
+            )),
+        }
+    }
+
+    fn set_literal(
+        ruby: &Ruby,
+        rb_self: &Self,
+        new_literal: String,
+    ) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
+
+        match node.data.value {
+            ComrakNodeValue::Text(ref mut text) => *text = new_literal.into(),
+            ComrakNodeValue::Code(ref mut code) => code.literal = new_literal,
+            ComrakNodeValue::CodeBlock(ref mut code_block) => code_block.literal = new_literal,
+            ComrakNodeValue::HtmlBlock(ref mut html_block) => html_block.literal = new_literal,
+            ComrakNodeValue::HtmlInline(ref mut html_inline) => *html_inline = new_literal,
+            ComrakNodeValue::Raw(ref mut raw) => *raw = new_literal,
+            ComrakNodeValue::Math(ref mut math) => math.literal = new_literal,
+            ComrakNodeValue::FrontMatter(ref mut front_matter) => *front_matter = new_literal,
+            _ => {
+                return Err(magnus::Error::new(
+                    ruby.exception_type_error(),
+                    "node does not have a literal",
+                ))
+            }
+        }
+
+        Ok(true)
+    }
+
     fn get_title(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
         let node = rb_self.inner.borrow();
 
@@ -1037,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)?;
 
@@ -1081,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,
@@ -1177,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,
@@ -1221,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),
                 ));
             }
         }
@@ -1292,6 +1375,14 @@ pub fn init(ruby: &Ruby, m_commonmarker: RModule) -> Result<(), magnus::Error> {
         method!(CommonmarkerNode::set_string_content, 1),
     )?;
 
+    c_node.define_method("literal", method!(CommonmarkerNode::get_literal, 0))?;
+    c_node.define_method("literal=", method!(CommonmarkerNode::set_literal, 1))?;
+
+    c_node.define_method(
+        "node_supports?",
+        method!(CommonmarkerNode::supports_method, 1),
+    )?;
+
     c_node.define_method("url", method!(CommonmarkerNode::get_url, 0))?;
     c_node.define_method("url=", method!(CommonmarkerNode::set_url, 1))?;
     c_node.define_method("title", method!(CommonmarkerNode::get_title, 0))?;

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)))
                         }
                     }
                 }