commonmarker 1.1.3 → 1.1.5

data/README.md

@@ -151,11 +151,12 @@ Note that there is a distinction in comrak for "parse" options and "render" opti
 
 ### Parse options
 
-| Name                  | Description                                                                                                                                | Default |
-| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
-| `smart`               | Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation.                                                       | `false` |
-| `default_info_string` | The default info string for fenced code blocks.                                                                                            | `""`    |
-| `relaxed_autolinks`   | Enable relaxing of the autolink extension parsing, allowing links to be recognized when in brackets, as well as permitting any url scheme. | `false` |
+| Name                          | Description                                                                                                                                 | Default |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
+| `smart`                       | Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation.                                                        | `false` |
+| `default_info_string`         | The default info string for fenced code blocks.                                                                                             | `""`    |
+| `relaxed_tasklist_matching`   | Enables relaxing of the tasklist extension matching, allowing any non-space to be used for the "checked" state instead of only `x` and `X`. | `false` |
+| `relaxed_autolinks`           | Enable relaxing of the autolink extension parsing, allowing links to be recognized when in brackets, as well as permitting any url scheme.  | `false` |
 
 ### Render options
 
@@ -163,38 +164,48 @@ Note that there is a distinction in comrak for "parse" options and "render" opti
 | -------------------- | ------------------------------------------------------------------------------------------------------ | ------- |
 | `hardbreaks`         | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks. | `true`  |
 | `github_pre_lang`    | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                         | `true`  |
+| `full_info_string`   | Gives info string data after a space in a `data-meta` attribute on code blocks.                        | `false` |
 | `width`              | The wrap column when outputting CommonMark.                                                            | `80`    |
 | `unsafe`             | Allow rendering of raw HTML and potentially dangerous links.                                           | `false` |
 | `escape`             | Escape raw HTML instead of clobbering it.                                                              | `false` |
 | `sourcepos`          | Include source position attribute in HTML and XML output.                                              | `false` |
-| `escaped_char_spans` | Wrap escaped characters in span tags                                                                   | `true`  |
+| `escaped_char_spans` | Wrap escaped characters in span tags.                                                                  | `true`  |
+| `ignore_setext`      | Ignores setext-style headings.                                                                         | `false` |
+| `ignore_empty_links` | Ignores empty links, leaving the Markdown text in place.                                               | `false` |
+| `gfm_quirks`         | Outputs HTML with GFM-style quirks; namely, not nesting `<strong>` inlines.                            | `false` |
+| `prefer_fenced`      | Always output fenced code blocks, even where an indented one could be used.                            | `false` |
 
 As well, there are several extensions which you can toggle in the same manner:
 
 ```ruby
 Commonmarker.to_html('"Hi *there*"', options: {
     extension: { footnotes: true, description_lists: true },
-    render: { hardbreaks: false}
+    render: { hardbreaks: false }
 })
 ```
 
 ### Extension options
 
-| Name                        | Description                                                                                                         | Default |
-| --------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------- |
-| `strikethrough`             | Enables the [strikethrough extension](https://github.github.com/gfm/#strikethrough-extension-) from the GFM spec.   | `true`  |
-| `tagfilter`                 | Enables the [tagfilter extension](https://github.github.com/gfm/#disallowed-raw-html-extension-) from the GFM spec. | `true`  |
-| `table`                     | Enables the [table extension](https://github.github.com/gfm/#tables-extension-) from the GFM spec.                  | `true`  |
-| `autolink`                  | Enables the [autolink extension](https://github.github.com/gfm/#autolinks-extension-) from the GFM spec.            | `true`  |
-| `tasklist`                  | Enables the [task list extension](https://github.github.com/gfm/#task-list-items-extension-) from the GFM spec.     | `true`  |
-| `superscript`               | Enables the superscript Comrak extension.                                                                           | `false` |
-| `header_ids`                | Enables the header IDs Comrak extension. from the GFM spec.                                                         | `""`    |
-| `footnotes`                 | Enables the footnotes extension per `cmark-gfm`.                                                                    | `false` |
-| `description_lists`         | Enables the description lists extension.                                                                            | `false` |
-| `front_matter_delimiter`    | Enables the front matter extension.                                                                                 | `""`    |
-| `shortcodes`                | Enables the shortcodes extension.                                                                                   | `true`  |
-| `multiline_block_quotes`    | Enables the multiline block quotes extension.                                                                       | `false` |
-| `math_dollars`, `math_code` | Enables the math extension.                                                                                         | `false` |
+| Name                          | Description                                                                                                         | Default |
+| ---------------------------   | ------------------------------------------------------------------------------------------------------------------- | ------- |
+| `strikethrough`               | Enables the [strikethrough extension](https://github.github.com/gfm/#strikethrough-extension-) from the GFM spec.   | `true`  |
+| `tagfilter`                   | Enables the [tagfilter extension](https://github.github.com/gfm/#disallowed-raw-html-extension-) from the GFM spec. | `true`  |
+| `table`                       | Enables the [table extension](https://github.github.com/gfm/#tables-extension-) from the GFM spec.                  | `true`  |
+| `autolink`                    | Enables the [autolink extension](https://github.github.com/gfm/#autolinks-extension-) from the GFM spec.            | `true`  |
+| `tasklist`                    | Enables the [task list extension](https://github.github.com/gfm/#task-list-items-extension-) from the GFM spec.     | `true`  |
+| `superscript`                 | Enables the superscript Comrak extension.                                                                           | `false` |
+| `header_ids`                  | Enables the header IDs Comrak extension. from the GFM spec.                                                         | `""`    |
+| `footnotes`                   | Enables the footnotes extension per `cmark-gfm`.                                                                    | `false` |
+| `description_lists`           | Enables the description lists extension.                                                                            | `false` |
+| `front_matter_delimiter`      | Enables the front matter extension.                                                                                 | `""`    |
+| `multiline_block_quotes`      | Enables the multiline block quotes extension.                                                                       | `false` |
+| `math_dollars`, `math_code`   | Enables the math extension.                                                                                         | `false` |
+| `shortcodes`                  | Enables the shortcodes extension.                                                                                   | `true`  |
+| `wikilinks_title_before_pipe` | Enables the wikilinks extension, placing the title before the dividing pipe.                                        | `false` |
+| `wikilinks_title_after_pipe`  | Enables the shortcodes extension, placing the title after the dividing pipe.                                        | `false` |
+| `underline`                   | Enables the underline extension.                                                                                    | `false` |
+| `spoiler`                     | Enables the spoiler extension.                                                                                      | `false` |
+| `greentext`                   | Enables the greentext extension.                                                                                    | `false` |
 
 For more information on these options, see [the comrak documentation](https://github.com/kivikakk/comrak#usage).
 

data/ext/commonmarker/Cargo.toml

@@ -6,11 +6,11 @@ rust-version = "1.75.0"
 publish = false
 
 [dependencies]
-magnus = { version = "0.6", features = ["rb-sys"] }
+magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }
-comrak = { version = "0.23", features = ["shortcodes"] }
+comrak = { version = "0.26", features = ["shortcodes"] }
 syntect = { version = "5.2", features = ["plist-load"] }
 typed-arena = "2.0"
 rctree = "0.6"

data/ext/commonmarker/src/lib.rs

@@ -1,27 +1,15 @@
 extern crate core;
 
-use std::path::PathBuf;
-
-use ::syntect::highlighting::ThemeSet;
-use comrak::{
-    adapters::SyntaxHighlighterAdapter,
-    markdown_to_html, markdown_to_html_with_plugins, parse_document,
-    plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder},
-    ComrakOptions, ComrakPlugins,
-};
-use magnus::{
-    define_module, exception, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value,
-};
+use comrak::{markdown_to_html_with_plugins, parse_document, ComrakOptions};
+use magnus::{define_module, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value};
 use node::CommonmarkerNode;
+use plugins::syntax_highlighting::construct_syntax_highlighter_from_plugin;
 
 mod options;
 use options::iterate_options_hash;
 
 mod plugins;
-use plugins::{
-    syntax_highlighting::{fetch_syntax_highlighter_path, fetch_syntax_highlighter_theme},
-    SYNTAX_HIGHLIGHTER_PLUGIN,
-};
+
 use typed_arena::Arena;
 
 mod node;
@@ -63,6 +51,32 @@ fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
     )?;
     let (rb_options, rb_plugins) = kwargs.optional;
 
+    let comrak_options = match format_options(rb_options) {
+        Ok(options) => options,
+        Err(err) => return Err(err),
+    };
+
+    let mut comrak_plugins = comrak::Plugins::default();
+
+    let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+        Ok(Some(adapter)) => Some(adapter),
+        Ok(None) => None,
+        Err(err) => return Err(err),
+    };
+
+    match syntect_adapter {
+        Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+        None => comrak_plugins.render.codefence_syntax_highlighter = None,
+    }
+
+    Ok(markdown_to_html_with_plugins(
+        &rb_commonmark,
+        &comrak_options,
+        &comrak_plugins,
+    ))
+}
+
+fn format_options<'c>(rb_options: Option<RHash>) -> Result<comrak::Options<'c>, magnus::Error> {
     let mut comrak_options = ComrakOptions::default();
 
     if let Some(rb_options) = rb_options {
@@ -72,101 +86,7 @@ fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
         })?;
     }
 
-    if let Some(rb_plugins) = rb_plugins {
-        let mut comrak_plugins = ComrakPlugins::default();
-
-        let syntax_highlighter: Option<&dyn SyntaxHighlighterAdapter>;
-        let adapter: SyntectAdapter;
-
-        let theme = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
-            Some(syntax_highlighter_options) => {
-                match fetch_syntax_highlighter_theme(syntax_highlighter_options) {
-                    Ok(theme) => theme,
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-            None => None, // no `syntax_highlighter:` defined
-        };
-
-        match theme {
-            None => syntax_highlighter = None,
-            Some(theme) => {
-                if theme.is_empty() {
-                    // no theme? uss css classes
-                    adapter = SyntectAdapter::new(None);
-                    syntax_highlighter = Some(&adapter);
-                } else {
-                    let path = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
-                        Some(syntax_highlighter_options) => {
-                            fetch_syntax_highlighter_path(syntax_highlighter_options)?
-                        }
-                        None => PathBuf::from("".to_string()), // no `syntax_highlighter:` defined
-                    };
-
-                    if path.exists() {
-                        if !path.is_dir() {
-                            return Err(Error::new(
-                                exception::arg_error(),
-                                "`path` needs to be a directory",
-                            ));
-                        }
-
-                        let builder = SyntectAdapterBuilder::new();
-                        let mut ts = ThemeSet::load_defaults();
-
-                        match ts.add_from_folder(&path) {
-                            Ok(_) => {}
-                            Err(e) => {
-                                return Err(Error::new(
-                                    exception::arg_error(),
-                                    format!("failed to load theme set from path: {e}"),
-                                ));
-                            }
-                        }
-
-                        // check if the theme exists in the dir
-                        match ts.themes.get(&theme) {
-                            Some(theme) => theme,
-                            None => {
-                                return Err(Error::new(
-                                    exception::arg_error(),
-                                    format!("theme `{}` does not exist", theme),
-                                ));
-                            }
-                        };
-
-                        adapter = builder.theme_set(ts).theme(&theme).build();
-
-                        syntax_highlighter = Some(&adapter);
-                    } else {
-                        // no path? default theme lookup
-                        ThemeSet::load_defaults()
-                            .themes
-                            .get(&theme)
-                            .ok_or_else(|| {
-                                Error::new(
-                                    exception::arg_error(),
-                                    format!("theme `{}` does not exist", theme),
-                                )
-                            })?;
-                        adapter = SyntectAdapter::new(Some(&theme));
-                        syntax_highlighter = Some(&adapter);
-                    }
-                }
-            }
-        }
-        comrak_plugins.render.codefence_syntax_highlighter = syntax_highlighter;
-
-        Ok(markdown_to_html_with_plugins(
-            &rb_commonmark,
-            &comrak_options,
-            &comrak_plugins,
-        ))
-    } else {
-        Ok(markdown_to_html(&rb_commonmark, &comrak_options))
-    }
+    Ok(comrak_options)
 }
 
 #[magnus::init]

data/ext/commonmarker/src/node.rs

@@ -1,20 +1,20 @@
+use comrak::arena_tree::Node as ComrakNode;
 use comrak::nodes::{
     Ast as ComrakAst, AstNode as ComrakAstNode, ListDelimType, ListType, NodeCode, NodeCodeBlock,
     NodeDescriptionItem, NodeFootnoteDefinition, NodeFootnoteReference, NodeHeading, NodeHtmlBlock,
     NodeLink, NodeList, NodeMath, NodeMultilineBlockQuote, NodeShortCode, NodeTable,
-    NodeValue as ComrakNodeValue, TableAlignment,
+    NodeValue as ComrakNodeValue, NodeWikiLink, TableAlignment,
 };
-use comrak::{arena_tree::Node as ComrakNode, ComrakOptions};
 use magnus::RArray;
-use magnus::{
-    function, method, r_hash::ForEach, scan_args, Module, Object, RHash, RModule, Symbol, Value,
-};
+use magnus::{function, method, scan_args, Module, Object, RHash, RModule, Symbol, Value};
 use rctree::Node;
 use typed_arena::Arena;
 
 use std::cell::RefCell;
 
-use crate::options::iterate_options_hash;
+use crate::format_options;
+
+use crate::plugins::syntax_highlighting::construct_syntax_highlighter_from_plugin;
 
 #[derive(Debug, Clone)]
 #[magnus::wrap(class = "Commonmarker::Node::Ast", size, mark)]
@@ -238,8 +238,9 @@ impl CommonmarkerNode {
                 let (alignments, num_columns, num_rows, num_nonempty_cells) = kwargs.required;
 
                 let mut comrak_alignments = vec![];
-                alignments.each().for_each(|alignment| {
-                    match alignment.unwrap().to_string().as_str() {
+                alignments
+                    .into_iter()
+                    .for_each(|alignment| match alignment.to_string().as_str() {
                         "left" => {
                             comrak_alignments.push(TableAlignment::Left);
                         }
@@ -252,8 +253,7 @@ impl CommonmarkerNode {
                         _ => {
                             comrak_alignments.push(TableAlignment::None);
                         }
-                    }
-                });
+                    });
                 ComrakNodeValue::Table(NodeTable {
                     // The table alignments
                     alignments: comrak_alignments,
@@ -401,12 +401,12 @@ impl CommonmarkerNode {
 
                 let (code,) = kwargs.required;
 
-                match NodeShortCode::try_from(code.as_str()) {
-                    Ok(shortcode) => ComrakNodeValue::ShortCode(shortcode),
-                    _ => {
+                match NodeShortCode::resolve(code.as_str()) {
+                    Some(shortcode) => ComrakNodeValue::ShortCode(shortcode),
+                    None => {
                         return Err(magnus::Error::new(
                             magnus::exception::arg_error(),
-                            "list type must be `bullet` or `ordered`",
+                            "could not resolve shortcode",
                         ));
                     }
                 }
@@ -453,6 +453,15 @@ impl CommonmarkerNode {
             }
 
             "escaped" => ComrakNodeValue::Escaped,
+
+            "wikilink" => {
+                let kwargs =
+                    scan_args::get_kwargs::<_, (String,), (), ()>(args.keywords, &["url"], &[])?;
+
+                let (url,) = kwargs.required;
+
+                ComrakNodeValue::WikiLink(NodeWikiLink { url })
+            }
             _ => panic!("unknown node type {}", node_type),
         };
 
@@ -539,6 +548,10 @@ impl CommonmarkerNode {
             ComrakNodeValue::MultilineBlockQuote(_) => Symbol::new("multiline_block_quote"),
             ComrakNodeValue::Escaped => Symbol::new("escaped"),
             ComrakNodeValue::Math(..) => Symbol::new("math"),
+            ComrakNodeValue::WikiLink(..) => Symbol::new("wikilink"),
+            ComrakNodeValue::Underline => Symbol::new("underline"),
+            ComrakNodeValue::SpoileredText => Symbol::new("spoilered_text"),
+            ComrakNodeValue::EscapedTag(_) => Symbol::new("escaped_tag"),
         }
     }
 
@@ -895,15 +908,24 @@ impl CommonmarkerNode {
             &[],
             &["options", "plugins"],
         )?;
-        let (rb_options, _rb_plugins) = kwargs.optional;
+        let (rb_options, rb_plugins) = kwargs.optional;
 
-        let mut comrak_options = ComrakOptions::default();
+        let comrak_options = match format_options(rb_options) {
+            Ok(options) => options,
+            Err(err) => return Err(err),
+        };
+
+        let mut comrak_plugins = comrak::Plugins::default();
+
+        let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+            Ok(Some(adapter)) => Some(adapter),
+            Ok(None) => None,
+            Err(err) => return Err(err),
+        };
 
-        if let Some(rb_options) = rb_options {
-            rb_options.foreach(|key: Symbol, value: RHash| {
-                iterate_options_hash(&mut comrak_options, key, value)?;
-                Ok(ForEach::Continue)
-            })?;
+        match syntect_adapter {
+            Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+            None => comrak_plugins.render.codefence_syntax_highlighter = None,
         }
 
         let arena: Arena<ComrakAstNode> = Arena::new();
@@ -936,7 +958,12 @@ impl CommonmarkerNode {
         }
 
         let mut output = vec![];
-        match comrak::format_html(&comrak_root_node, &comrak_options, &mut output) {
+        match comrak::format_html_with_plugins(
+            &comrak_root_node,
+            &comrak_options,
+            &mut output,
+            &comrak_plugins,
+        ) {
             Ok(_) => {}
             Err(e) => {
                 return Err(magnus::Error::new(
@@ -963,15 +990,25 @@ impl CommonmarkerNode {
             &[],
             &["options", "plugins"],
         )?;
-        let (rb_options, _rb_plugins) = kwargs.optional;
+        let (rb_options, rb_plugins) = kwargs.optional;
 
-        let mut comrak_options = ComrakOptions::default();
+        let _comrak_options = format_options(rb_options);
+        let comrak_options = match format_options(rb_options) {
+            Ok(options) => options,
+            Err(err) => return Err(err),
+        };
+
+        let mut comrak_plugins = comrak::Plugins::default();
+
+        let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+            Ok(Some(adapter)) => Some(adapter),
+            Ok(None) => None,
+            Err(err) => return Err(err),
+        };
 
-        if let Some(rb_options) = rb_options {
-            rb_options.foreach(|key: Symbol, value: RHash| {
-                iterate_options_hash(&mut comrak_options, key, value)?;
-                Ok(ForEach::Continue)
-            })?;
+        match syntect_adapter {
+            Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+            None => comrak_plugins.render.codefence_syntax_highlighter = None,
         }
 
         let arena: Arena<ComrakAstNode> = Arena::new();
@@ -1004,7 +1041,12 @@ impl CommonmarkerNode {
         }
 
         let mut output = vec![];
-        match comrak::format_commonmark(&comrak_root_node, &comrak_options, &mut output) {
+        match comrak::format_commonmark_with_plugins(
+            &comrak_root_node,
+            &comrak_options,
+            &mut output,
+            &comrak_plugins,
+        ) {
             Ok(_) => {}
             Err(e) => {
                 return Err(magnus::Error::new(

data/ext/commonmarker/src/options.rs

@@ -10,6 +10,7 @@ use crate::utils::try_convert_string;
 
 const PARSE_SMART: &str = "smart";
 const PARSE_DEFAULT_INFO_STRING: &str = "default_info_string";
+const PARSE_RELAXED_TASKLIST_MATCHING: &str = "relaxed_tasklist_matching";
 const PARSE_RELAXED_AUTOLINKS: &str = "relaxed_autolinks";
 
 fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
@@ -22,6 +23,10 @@ fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash
                 Ok(Cow::Borrowed(PARSE_DEFAULT_INFO_STRING)) => {
                     comrak_options.parse.default_info_string = try_convert_string(value);
                 }
+                Ok(Cow::Borrowed(PARSE_RELAXED_TASKLIST_MATCHING)) => {
+                    comrak_options.parse.relaxed_tasklist_matching =
+                        TryConvert::try_convert(value)?;
+                }
                 Ok(Cow::Borrowed(PARSE_RELAXED_AUTOLINKS)) => {
                     comrak_options.parse.relaxed_autolinks = TryConvert::try_convert(value)?;
                 }
@@ -34,11 +39,16 @@ fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash
 
 const RENDER_HARDBREAKS: &str = "hardbreaks";
 const RENDER_GITHUB_PRE_LANG: &str = "github_pre_lang";
+const RENDER_FULL_INFO_STRING: &str = "full_info_string";
 const RENDER_WIDTH: &str = "width";
 const RENDER_UNSAFE: &str = "unsafe";
 const RENDER_ESCAPE: &str = "escape";
 const RENDER_SOURCEPOS: &str = "sourcepos";
 const RENDER_ESCAPED_CHAR_SPANS: &str = "escaped_char_spans";
+const RENDER_IGNORE_SETEXT: &str = "ignore_setext";
+const RENDER_IGNORE_EMPTY_LINKS: &str = "ignore_empty_links";
+const RENDER_GFM_QUIRKS: &str = "gfm_quirks";
+const RENDER_PREFER_FENCED: &str = "prefer_fenced";
 
 fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
     options_hash
@@ -50,6 +60,9 @@ fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHas
                 Ok(Cow::Borrowed(RENDER_GITHUB_PRE_LANG)) => {
                     comrak_options.render.github_pre_lang = TryConvert::try_convert(value)?;
                 }
+                Ok(Cow::Borrowed(RENDER_FULL_INFO_STRING)) => {
+                    comrak_options.render.full_info_string = TryConvert::try_convert(value)?;
+                }
                 Ok(Cow::Borrowed(RENDER_WIDTH)) => {
                     comrak_options.render.width = TryConvert::try_convert(value)?;
                 }
@@ -65,6 +78,18 @@ fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHas
                 Ok(Cow::Borrowed(RENDER_ESCAPED_CHAR_SPANS)) => {
                     comrak_options.render.escaped_char_spans = TryConvert::try_convert(value)?;
                 }
+                Ok(Cow::Borrowed(RENDER_IGNORE_SETEXT)) => {
+                    comrak_options.render.ignore_setext = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_IGNORE_EMPTY_LINKS)) => {
+                    comrak_options.render.ignore_empty_links = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_GFM_QUIRKS)) => {
+                    comrak_options.render.gfm_quirks = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_PREFER_FENCED)) => {
+                    comrak_options.render.prefer_fenced = TryConvert::try_convert(value)?;
+                }
                 _ => {}
             }
             Ok(ForEach::Continue)
@@ -82,10 +107,15 @@ const EXTENSION_HEADER_IDS: &str = "header_ids";
 const EXTENSION_FOOTNOTES: &str = "footnotes";
 const EXTENSION_DESCRIPTION_LISTS: &str = "description_lists";
 const EXTENSION_FRONT_MATTER_DELIMITER: &str = "front_matter_delimiter";
-const EXTENSION_SHORTCODES: &str = "shortcodes";
 const EXTENSION_MULTILINE_BLOCK_QUOTES: &str = "multiline_block_quotes";
 const EXTENSION_MATH_DOLLARS: &str = "math_dollars";
 const EXTENSION_MATH_CODE: &str = "math_code";
+const EXTENSION_SHORTCODES: &str = "shortcodes";
+const EXTENSION_WIKILINKS_TITLE_AFTER_PIPE: &str = "wikilinks_title_after_pipe";
+const EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE: &str = "wikilinks_title_before_pipe";
+const EXTENSION_UNDERLINE: &str = "underline";
+const EXTENSION_SPOILER: &str = "spoiler";
+const EXTENSION_GREENTEXT: &str = "greentext";
 
 fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
     options_hash
@@ -125,9 +155,6 @@ fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: R
                         }
                     }
                 }
-                Ok(Cow::Borrowed(EXTENSION_SHORTCODES)) => {
-                    comrak_options.extension.shortcodes = TryConvert::try_convert(value)?;
-                }
                 Ok(Cow::Borrowed(EXTENSION_MULTILINE_BLOCK_QUOTES)) => {
                     comrak_options.extension.multiline_block_quotes =
                         TryConvert::try_convert(value)?;
@@ -138,6 +165,26 @@ fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: R
                 Ok(Cow::Borrowed(EXTENSION_MATH_CODE)) => {
                     comrak_options.extension.math_code = TryConvert::try_convert(value)?;
                 }
+                Ok(Cow::Borrowed(EXTENSION_SHORTCODES)) => {
+                    comrak_options.extension.shortcodes = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_AFTER_PIPE)) => {
+                    comrak_options.extension.wikilinks_title_after_pipe =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE)) => {
+                    comrak_options.extension.wikilinks_title_before_pipe =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_UNDERLINE)) => {
+                    comrak_options.extension.underline = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SPOILER)) => {
+                    comrak_options.extension.spoiler = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_GREENTEXT)) => {
+                    comrak_options.extension.greentext = TryConvert::try_convert(value)?;
+                }
                 _ => {}
             }
             Ok(ForEach::Continue)