commonmarker 2.5.0 → 2.6.1

data/ext/commonmarker/src/node.rs

@@ -3,17 +3,17 @@ use comrak::nodes::{
     AlertType, Ast as ComrakAst, AstNode as ComrakAstNode, ListDelimType, ListType, NodeAlert,
     NodeCode, NodeCodeBlock, NodeDescriptionItem, NodeFootnoteDefinition, NodeFootnoteReference,
     NodeHeading, NodeHtmlBlock, NodeLink, NodeList, NodeMath, NodeMultilineBlockQuote,
-    NodeShortCode, NodeTable, NodeValue as ComrakNodeValue, NodeWikiLink, TableAlignment,
+    NodeShortCode, NodeTable, NodeTaskItem, NodeValue as ComrakNodeValue, NodeWikiLink,
+    TableAlignment,
 };
-use magnus::RArray;
 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;
 
-use crate::format_options;
-
+use crate::options::{iterate_extension_options, iterate_parse_options, iterate_render_options};
 use crate::plugins::syntax_highlighting::construct_syntax_highlighter_from_plugin;
 
 #[derive(Debug, Clone)]
@@ -32,8 +32,7 @@ pub struct CommonmarkerNode {
 unsafe impl Send for CommonmarkerNode {}
 
 impl CommonmarkerNode {
-    pub fn new(args: &[Value]) -> Result<Self, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
+    pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, magnus::Error> {
         let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
         let (node_type,): (Symbol,) = args.required;
 
@@ -162,6 +161,7 @@ impl CommonmarkerNode {
                         Option<usize>,
                         Option<String>,
                         Option<String>,
+                        Option<bool>,
                     ),
                     (),
                 >(
@@ -173,12 +173,14 @@ impl CommonmarkerNode {
                         "fence_offset",
                         "info",
                         "literal",
+                        "closed",
                     ],
                 )?;
                 let (fenced,) = kwargs.required;
-                let (fence_char, fence_length, fence_offset, info, literal) = kwargs.optional;
+                let (fence_char, fence_length, fence_offset, info, literal, closed) =
+                    kwargs.optional;
 
-                ComrakNodeValue::CodeBlock(NodeCodeBlock {
+                ComrakNodeValue::CodeBlock(Box::new(NodeCodeBlock {
                     // Whether the code block is fenced.
                     fenced,
                     // For fenced code blocks, the fence character itself (`` ` `` or `~`).
@@ -196,7 +198,12 @@ impl CommonmarkerNode {
                     // all, they are contained within this structure, rather than inserted into a child inline of
                     // any kind.
                     literal: literal.unwrap_or(String::new()),
-                })
+
+                    // For fenced code blocks, whether the code block is closed.  (If not, it was terminated by
+                    // some other condition, like the end of the document, or the end of the indentation level the
+                    // code block was introduced at.)
+                    closed: closed.unwrap_or(true),
+                }))
             }
             "html_block" => {
                 let kwargs = scan_args::get_kwargs::<_, (), (Option<u8>, Option<String>), ()>(
@@ -216,20 +223,24 @@ impl CommonmarkerNode {
             }
             "paragraph" => ComrakNodeValue::Paragraph,
             "heading" => {
-                let kwargs = scan_args::get_kwargs::<_, (u8,), (Option<bool>,), ()>(
+                let kwargs = scan_args::get_kwargs::<_, (u8,), (Option<bool>, Option<bool>), ()>(
                     args.keywords,
                     &["level"],
-                    &["setext"],
+                    &["setext", "closed"],
                 )?;
 
                 let (level,) = kwargs.required;
-                let (setext,) = kwargs.optional;
+                let (setext, closed) = kwargs.optional;
 
                 ComrakNodeValue::Heading(NodeHeading {
-                    // Number of spaces before the list marker.
+                    // The heading level.  For setext headings, an underline made of "=" characters is level 1, and made of
+                    // "-" is level 2.  For ATX headings, the number of leading "#" characters (from 1 to 6) is its level.
                     level,
-                    // Number of characters between the start of the list marker and the item text (including the list marker(s)).
+                    // Whether the heading is setext style (marked by an underline).  If not, it is ATX style (marked by leading,
+                    // and possibly trailing, "#" characters).
                     setext: setext.unwrap_or(false),
+                    // For ATX headings, whether the the leading "#" are terminated by a sequence of closing "#" characters.
+                    closed: closed.unwrap_or(false),
                 })
             }
             "thematic_break" => ComrakNodeValue::ThematicBreak,
@@ -264,7 +275,7 @@ impl CommonmarkerNode {
                             comrak_alignments.push(TableAlignment::None);
                         }
                     });
-                ComrakNodeValue::Table(NodeTable {
+                ComrakNodeValue::Table(Box::new(NodeTable {
                     // The table alignments
                     alignments: comrak_alignments,
 
@@ -276,7 +287,7 @@ impl CommonmarkerNode {
 
                     // Number of non-empty, non-autocompleted cells
                     num_nonempty_cells,
-                })
+                }))
             }
             "table_row" => {
                 let kwargs =
@@ -296,7 +307,7 @@ impl CommonmarkerNode {
 
                 let (content,) = kwargs.optional;
 
-                ComrakNodeValue::Text(content.unwrap_or("".to_string()))
+                ComrakNodeValue::Text(content.unwrap_or_default().into())
             }
             "taskitem" => {
                 let kwargs = scan_args::get_kwargs::<_, (), (Option<char>,), ()>(
@@ -307,7 +318,10 @@ impl CommonmarkerNode {
 
                 let (mark,) = kwargs.optional;
 
-                ComrakNodeValue::TaskItem(mark)
+                ComrakNodeValue::TaskItem(NodeTaskItem {
+                    symbol: mark,
+                    symbol_sourcepos: (0, 0, 0, 0).into(),
+                })
             }
             "softbreak" => ComrakNodeValue::SoftBreak,
             "linebreak" => ComrakNodeValue::LineBreak,
@@ -356,7 +370,7 @@ impl CommonmarkerNode {
                 let (url,) = kwargs.required;
                 let (title,) = kwargs.optional;
 
-                ComrakNodeValue::Link(NodeLink {
+                ComrakNodeValue::Link(Box::new(NodeLink {
                     // The URL for the link destination or image source.
                     url,
                     // The title for the link or image.
@@ -364,7 +378,7 @@ impl CommonmarkerNode {
                     // Note this field is used for the `title` attribute by the HTML formatter even for images;
                     // `alt` text is supplied in the image inline text.
                     title: title.unwrap_or_default(),
-                })
+                }))
             }
             "image" => {
                 let kwargs = scan_args::get_kwargs::<_, (String,), (Option<String>,), ()>(
@@ -376,7 +390,7 @@ impl CommonmarkerNode {
                 let (url,) = kwargs.required;
                 let (title,) = kwargs.optional;
 
-                ComrakNodeValue::Image(NodeLink {
+                ComrakNodeValue::Image(Box::new(NodeLink {
                     // The URL for the link destination or image source.
                     url,
                     // The title for the link or image.
@@ -384,7 +398,7 @@ impl CommonmarkerNode {
                     // Note this field is used for the `title` attribute by the HTML formatter even for images;
                     // `alt` text is supplied in the image inline text.
                     title: title.unwrap_or_default(),
-                })
+                }))
             }
             "footnote_reference" => {
                 let kwargs = scan_args::get_kwargs::<_, (String,), (Option<u32>, Option<u32>), ()>(
@@ -396,14 +410,16 @@ impl CommonmarkerNode {
                 let (name,) = kwargs.required;
                 let (ref_num, ix) = kwargs.optional;
 
-                ComrakNodeValue::FootnoteReference(NodeFootnoteReference {
+                ComrakNodeValue::FootnoteReference(Box::new(NodeFootnoteReference {
                     // The name of the footnote.
                     name,
+                    // The original text and sourcepos column spans that comprised the footnote ref.
+                    texts: vec![],
                     // The index of reference to the same footnote
                     ref_num: ref_num.unwrap_or(0),
                     // The index of the footnote in the document.
                     ix: ix.unwrap_or(0),
-                })
+                }))
             }
             // #[cfg(feature = "shortcodes")]
             "shortcode" => {
@@ -413,7 +429,7 @@ impl CommonmarkerNode {
                 let (code,) = kwargs.required;
 
                 match NodeShortCode::resolve(code.as_str()) {
-                    Some(shortcode) => ComrakNodeValue::ShortCode(shortcode),
+                    Some(shortcode) => ComrakNodeValue::ShortCode(Box::new(shortcode)),
                     None => {
                         return Err(magnus::Error::new(
                             ruby.exception_arg_error(),
@@ -514,7 +530,7 @@ impl CommonmarkerNode {
                     }
                 };
 
-                ComrakNodeValue::Alert(NodeAlert {
+                ComrakNodeValue::Alert(Box::new(NodeAlert {
                     alert_type,
                     // Overridden title. If None, then use the default title.
                     title,
@@ -524,7 +540,7 @@ impl CommonmarkerNode {
                     fence_length: fence_length.unwrap_or(0),
                     // The indentation level of the fence marker (multiline only)
                     fence_offset: fence_offset.unwrap_or(0),
-                })
+                }))
             }
 
             _ => panic!("unknown node type {}", node_type),
@@ -575,53 +591,9 @@ impl CommonmarkerNode {
         Ok(commonmarker_root_node)
     }
 
-    fn type_to_symbol(&self) -> Symbol {
-        let node = self.inner.borrow();
-        let ruby = magnus::Ruby::get().unwrap();
-        match node.data.value {
-            ComrakNodeValue::Document => ruby.to_symbol("document"),
-            ComrakNodeValue::BlockQuote => ruby.to_symbol("block_quote"),
-            ComrakNodeValue::FootnoteDefinition(_) => ruby.to_symbol("footnote_definition"),
-            ComrakNodeValue::List(..) => ruby.to_symbol("list"),
-            ComrakNodeValue::DescriptionList => ruby.to_symbol("description_list"),
-            ComrakNodeValue::DescriptionItem(_) => ruby.to_symbol("description_item"),
-            ComrakNodeValue::DescriptionTerm => ruby.to_symbol("description_term"),
-            ComrakNodeValue::DescriptionDetails => ruby.to_symbol("description_details"),
-            ComrakNodeValue::Item(..) => ruby.to_symbol("item"),
-            ComrakNodeValue::CodeBlock(..) => ruby.to_symbol("code_block"),
-            ComrakNodeValue::HtmlBlock(..) => ruby.to_symbol("html_block"),
-            ComrakNodeValue::Paragraph => ruby.to_symbol("paragraph"),
-            ComrakNodeValue::Heading(..) => ruby.to_symbol("heading"),
-            ComrakNodeValue::ThematicBreak => ruby.to_symbol("thematic_break"),
-            ComrakNodeValue::Table(..) => ruby.to_symbol("table"),
-            ComrakNodeValue::TableRow(..) => ruby.to_symbol("table_row"),
-            ComrakNodeValue::TableCell => ruby.to_symbol("table_cell"),
-            ComrakNodeValue::Text(..) => ruby.to_symbol("text"),
-            ComrakNodeValue::SoftBreak => ruby.to_symbol("softbreak"),
-            ComrakNodeValue::LineBreak => ruby.to_symbol("linebreak"),
-            ComrakNodeValue::Image(..) => ruby.to_symbol("image"),
-            ComrakNodeValue::Link(..) => ruby.to_symbol("link"),
-            ComrakNodeValue::Emph => ruby.to_symbol("emph"),
-            ComrakNodeValue::Raw(..) => ruby.to_symbol("raw"),
-            ComrakNodeValue::Strong => ruby.to_symbol("strong"),
-            ComrakNodeValue::Code(..) => ruby.to_symbol("code"),
-            ComrakNodeValue::HtmlInline(..) => ruby.to_symbol("html_inline"),
-            ComrakNodeValue::Strikethrough => ruby.to_symbol("strikethrough"),
-            ComrakNodeValue::FrontMatter(_) => ruby.to_symbol("frontmatter"),
-            ComrakNodeValue::TaskItem { .. } => ruby.to_symbol("taskitem"),
-            ComrakNodeValue::Superscript => ruby.to_symbol("superscript"),
-            ComrakNodeValue::FootnoteReference(..) => ruby.to_symbol("footnote_reference"),
-            ComrakNodeValue::ShortCode(_) => ruby.to_symbol("shortcode"),
-            ComrakNodeValue::MultilineBlockQuote(_) => ruby.to_symbol("multiline_block_quote"),
-            ComrakNodeValue::Escaped => ruby.to_symbol("escaped"),
-            ComrakNodeValue::Math(..) => ruby.to_symbol("math"),
-            ComrakNodeValue::WikiLink(..) => ruby.to_symbol("wikilink"),
-            ComrakNodeValue::Underline => ruby.to_symbol("underline"),
-            ComrakNodeValue::Subscript => ruby.to_symbol("subscript"),
-            ComrakNodeValue::SpoileredText => ruby.to_symbol("spoilered_text"),
-            ComrakNodeValue::EscapedTag(_) => ruby.to_symbol("escaped_tag"),
-            ComrakNodeValue::Alert(..) => ruby.to_symbol("alert"),
-        }
+    fn type_to_symbol(ruby: &Ruby, rb_self: &Self) -> Symbol {
+        let node = rb_self.inner.borrow();
+        ruby.to_symbol(node.data.value.xml_node_name())
     }
 
     fn get_parent(&self) -> Option<CommonmarkerNode> {
@@ -677,10 +649,9 @@ impl CommonmarkerNode {
         })
     }
 
-    fn get_sourcepos(&self) -> Result<RHash, magnus::Error> {
-        let node = self.inner.borrow();
+    fn get_sourcepos(ruby: &Ruby, rb_self: &Self) -> Result<RHash, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
-        let ruby = magnus::Ruby::get().unwrap();
         let result = ruby.hash_new();
         result.aset(ruby.to_symbol("start_line"), node.data.sourcepos.start.line)?;
         result.aset(
@@ -717,9 +688,8 @@ impl CommonmarkerNode {
         Ok(true)
     }
 
-    fn get_url(&self) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_url(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::Link(link) => Ok(link.url.to_string()),
@@ -731,9 +701,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_url(&self, new_url: String) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_url(ruby: &Ruby, rb_self: &Self, new_url: String) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::Link(ref mut link) => {
@@ -751,9 +720,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_string_content(&self) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_string_content(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match node.data.value {
             ComrakNodeValue::Code(ref code) => return Ok(code.literal.to_string()),
@@ -772,9 +740,12 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_string_content(&self, new_content: String) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_string_content(
+        ruby: &Ruby,
+        rb_self: &Self,
+        new_content: String,
+    ) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::Code(ref mut code) => {
@@ -790,7 +761,7 @@ impl CommonmarkerNode {
 
         match node.data.value.text_mut() {
             Some(s) => {
-                *s = new_content;
+                *s = new_content.into();
                 Ok(true)
             }
             None => Err(magnus::Error::new(
@@ -800,9 +771,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_title(&self) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_title(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::Link(link) => Ok(link.title.to_string()),
@@ -814,9 +784,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_title(&self, new_title: String) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_title(ruby: &Ruby, rb_self: &Self, new_title: String) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::Link(ref mut link) => {
@@ -834,9 +803,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_header_level(&self) -> Result<u8, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_header_level(ruby: &Ruby, rb_self: &Self) -> Result<u8, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::Heading(heading) => Ok(heading.level),
@@ -847,9 +815,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_header_level(&self, new_level: u8) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_header_level(ruby: &Ruby, rb_self: &Self, new_level: u8) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::Heading(ref mut heading) => {
@@ -863,9 +830,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_list_type(&self) -> Result<Symbol, magnus::Error> {
-        let node = self.inner.borrow();
-        let ruby = magnus::Ruby::get().unwrap();
+    fn get_list_type(ruby: &Ruby, rb_self: &Self) -> Result<Symbol, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::List(list) => match list.list_type {
@@ -879,9 +845,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_list_type(&self, new_type: Symbol) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_list_type(ruby: &Ruby, rb_self: &Self, new_type: Symbol) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::List(ref mut list) => {
@@ -899,9 +864,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_list_start(&self) -> Result<usize, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_list_start(ruby: &Ruby, rb_self: &Self) -> Result<usize, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::List(list) => Ok(list.start),
@@ -912,9 +876,12 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_list_start(&self, new_start: usize) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_list_start(
+        ruby: &Ruby,
+        rb_self: &Self,
+        new_start: usize,
+    ) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::List(ref mut list) => {
@@ -928,9 +895,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_list_tight(&self) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_list_tight(ruby: &Ruby, rb_self: &Self) -> Result<bool, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::List(list) => Ok(list.tight),
@@ -941,9 +907,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_list_tight(&self, new_tight: bool) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_list_tight(ruby: &Ruby, rb_self: &Self, new_tight: bool) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::List(ref mut list) => {
@@ -957,9 +922,8 @@ impl CommonmarkerNode {
         }
     }
 
-    fn get_fence_info(&self) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let node = self.inner.borrow();
+    fn get_fence_info(ruby: &Ruby, rb_self: &Self) -> Result<String, magnus::Error> {
+        let node = rb_self.inner.borrow();
 
         match &node.data.value {
             ComrakNodeValue::CodeBlock(code_block) => Ok(code_block.info.to_string()),
@@ -970,9 +934,12 @@ impl CommonmarkerNode {
         }
     }
 
-    fn set_fence_info(&self, new_info: String) -> Result<bool, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
-        let mut node = self.inner.borrow_mut();
+    fn set_fence_info(
+        ruby: &Ruby,
+        rb_self: &Self,
+        new_info: String,
+    ) -> Result<bool, magnus::Error> {
+        let mut node = rb_self.inner.borrow_mut();
 
         match node.data.value {
             ComrakNodeValue::CodeBlock(ref mut code_block) => {
@@ -986,25 +953,44 @@ impl CommonmarkerNode {
         }
     }
 
-    fn to_html(&self, args: &[Value]) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
+    fn to_html(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, magnus::Error> {
         let args = scan_args::scan_args::<(), (), (), (), _, ()>(args)?;
 
-        let kwargs = scan_args::get_kwargs::<_, (), (Option<RHash>, Option<RHash>), ()>(
+        let kwargs = scan_args::get_kwargs::<
+            _,
+            (),
+            (Option<RHash>, Option<RHash>, Option<RHash>, Option<RHash>),
+            (),
+        >(
             args.keywords,
             &[],
-            &["options", "plugins"],
+            &["parse", "render", "extension", "plugins"],
         )?;
-        let (rb_options, rb_plugins) = kwargs.optional;
+        let (rb_parse, rb_render, rb_extension, rb_plugins) = kwargs.optional;
 
-        let comrak_options = match format_options(rb_options) {
-            Ok(options) => options,
-            Err(err) => return Err(err),
+        let mut comrak_parse_options = comrak::options::Parse::default();
+        let mut comrak_render_options = comrak::options::Render::default();
+        let mut comrak_extension_options = comrak::options::Extension::default();
+
+        if let Some(rb_parse) = rb_parse {
+            iterate_parse_options(&mut comrak_parse_options, rb_parse);
+        }
+        if let Some(rb_render) = rb_render {
+            iterate_render_options(&mut comrak_render_options, rb_render);
+        }
+        if let Some(rb_extension) = rb_extension {
+            iterate_extension_options(&mut comrak_extension_options, rb_extension);
+        }
+
+        let comrak_options = comrak::Options {
+            parse: comrak_parse_options,
+            render: comrak_render_options,
+            extension: comrak_extension_options,
         };
 
-        let mut comrak_plugins = comrak::Plugins::default();
+        let mut comrak_plugins = comrak::options::Plugins::default();
 
-        let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+        let syntect_adapter = match construct_syntax_highlighter_from_plugin(ruby, rb_plugins) {
             Ok(Some(adapter)) => Some(adapter),
             Ok(None) => None,
             Err(err) => return Err(err),
@@ -1034,9 +1020,9 @@ impl CommonmarkerNode {
         }
 
         let comrak_root_node: ComrakNode<RefCell<ComrakAst>> =
-            ComrakNode::new(RefCell::new(self.inner.borrow().data.clone()));
+            ComrakNode::new(RefCell::new(rb_self.inner.borrow().data.clone()));
 
-        for c in self.inner.children() {
+        for c in rb_self.inner.children() {
             let child = CommonmarkerNode { inner: c };
 
             let new_child = iter_nodes(&arena, &child);
@@ -1063,23 +1049,44 @@ impl CommonmarkerNode {
         Ok(output)
     }
 
-    fn to_commonmark(&self, args: &[Value]) -> Result<String, magnus::Error> {
-        let ruby = magnus::Ruby::get().unwrap();
+    fn to_commonmark(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, magnus::Error> {
         let args = scan_args::scan_args::<(), (), (), (), _, ()>(args)?;
 
-        let kwargs = scan_args::get_kwargs::<_, (), (Option<RHash>, Option<RHash>), ()>(
+        let kwargs = scan_args::get_kwargs::<
+            _,
+            (),
+            (Option<RHash>, Option<RHash>, Option<RHash>, Option<RHash>),
+            (),
+        >(
             args.keywords,
             &[],
-            &["options", "plugins"],
+            &["render", "parse", "extension", "plugins"],
         )?;
-        let (rb_options, rb_plugins) = kwargs.optional;
+        let (rb_render, rb_parse, rb_extension, rb_plugins) = kwargs.optional;
 
-        let _comrak_options = format_options(rb_options);
-        let comrak_options = format_options(rb_options)?;
+        let mut comrak_parse_options = comrak::options::Parse::default();
+        let mut comrak_render_options = comrak::options::Render::default();
+        let mut comrak_extension_options = comrak::options::Extension::default();
+
+        if let Some(rb_parse) = rb_parse {
+            iterate_parse_options(&mut comrak_parse_options, rb_parse);
+        }
+        if let Some(rb_render) = rb_render {
+            iterate_render_options(&mut comrak_render_options, rb_render);
+        }
+        if let Some(rb_extension) = rb_extension {
+            iterate_extension_options(&mut comrak_extension_options, rb_extension);
+        }
+
+        let comrak_options = comrak::Options {
+            parse: comrak_parse_options,
+            render: comrak_render_options,
+            extension: comrak_extension_options,
+        };
 
-        let mut comrak_plugins = comrak::Plugins::default();
+        let mut comrak_plugins = comrak::options::Plugins::default();
 
-        let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+        let syntect_adapter = match construct_syntax_highlighter_from_plugin(ruby, rb_plugins) {
             Ok(Some(adapter)) => Some(adapter),
             Ok(None) => None,
             Err(err) => return Err(err),
@@ -1109,9 +1116,9 @@ impl CommonmarkerNode {
         }
 
         let comrak_root_node: ComrakNode<RefCell<ComrakAst>> =
-            ComrakNode::new(RefCell::new(self.inner.borrow().data.clone()));
+            ComrakNode::new(RefCell::new(rb_self.inner.borrow().data.clone()));
 
-        for c in self.inner.children() {
+        for c in rb_self.inner.children() {
             let child = CommonmarkerNode { inner: c };
 
             let new_child = iter_nodes(&arena, &child);
@@ -1139,8 +1146,7 @@ impl CommonmarkerNode {
     }
 }
 
-pub fn init(m_commonmarker: RModule) -> Result<(), magnus::Error> {
-    let ruby = magnus::Ruby::get().unwrap();
+pub fn init(ruby: &Ruby, m_commonmarker: RModule) -> Result<(), magnus::Error> {
     let c_node = m_commonmarker
         .define_class("Node", ruby.class_object())
         .expect("cannot define class Commonmarker::Node");