commonmarker 2.5.0 → 2.6.0

data/README.md

@@ -156,12 +156,13 @@ 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_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` |
+| 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` |
+| `leave_footnote_definitions` | Allow footnote definitions to remain in their original positions instead of being moved to the document's end (only affects AST)            | `false` |
 
 ### Render options
 
@@ -213,9 +214,11 @@ Commonmarker.to_html('"Hi *there*"', options: {
 | `underline`                   | Enables the underline extension.                                                                                    | `false` |
 | `spoiler`                     | Enables the spoiler extension.                                                                                      | `false` |
 | `greentext`                   | Enables the greentext extension.                                                                                    | `false` |
+| `subtext`                     | Enables the subtext extension.                                                                                      | `false` |
 | `subscript`                   | Enables the subscript extension.                                                                                    | `false` |
 | `alerts`                      | Enables the alerts extension.                                                                                       | `false` |
 | `cjk_friendly_emphasis`       | Enables the [CJK friendly emphasis](https://github.com/tats-u/markdown-cjk-friendly) extension.                     | `false` |
+| `highlight`                   | Enables highlighting via `==`                                                                                       | `false` |
 
 For more information on these options, see [the comrak documentation](https://github.com/kivikakk/comrak#usage).
 

data/ext/commonmarker/Cargo.toml

@@ -10,7 +10,7 @@ magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }
-comrak = { version = "0.44", features = ["shortcodes"] }
+comrak = { version = "0.48", features = ["shortcodes"] }
 syntect = { version = "5.3", features = ["plist-load"] }
 typed-arena = "2.0"
 rctree = "0.6"

data/ext/commonmarker/src/lib.rs

@@ -1,17 +1,18 @@
 extern crate core;
 
-use comrak::{markdown_to_html_with_plugins, parse_document, ComrakOptions};
-use magnus::{function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value};
+use comrak::{markdown_to_html_with_plugins, parse_document};
+use magnus::{function, scan_args, RHash, Ruby, Value};
 use node::CommonmarkerNode;
 use plugins::syntax_highlighting::construct_syntax_highlighter_from_plugin;
 
 mod options;
-use options::iterate_options_hash;
 
 mod plugins;
 
 use typed_arena::Arena;
 
+use crate::options::{iterate_extension_options, iterate_parse_options, iterate_render_options};
+
 mod node;
 mod utils;
 
@@ -21,18 +22,32 @@ fn commonmark_parse(args: &[Value]) -> Result<CommonmarkerNode, magnus::Error> {
     let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
     let (rb_commonmark,): (String,) = args.required;
 
-    let kwargs =
-        scan_args::get_kwargs::<_, (), (Option<RHash>,), ()>(args.keywords, &[], &["options"])?;
-    let (rb_options,) = kwargs.optional;
+    let kwargs = scan_args::get_kwargs::<_, (), (Option<RHash>, Option<RHash>, Option<RHash>), ()>(
+        args.keywords,
+        &[],
+        &["parse", "render", "extension"],
+    )?;
+    let (rb_parse, rb_render, rb_extension) = kwargs.optional;
 
-    let mut comrak_options = ComrakOptions::default();
+    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_options) = rb_options {
-        rb_options.foreach(|key: Symbol, value: RHash| {
-            iterate_options_hash(&mut comrak_options, key, value)?;
-            Ok(ForEach::Continue)
-        })?;
+    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 arena = Arena::new();
     let root = parse_document(&arena, &rb_commonmark, &comrak_options);
@@ -40,22 +55,39 @@ fn commonmark_parse(args: &[Value]) -> Result<CommonmarkerNode, magnus::Error> {
     CommonmarkerNode::new_from_comrak_node(root)
 }
 
-fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
+fn commonmark_to_html(ruby: &Ruby, args: &[Value]) -> Result<String, magnus::Error> {
     let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
     let (rb_commonmark,): (String,) = args.required;
 
-    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 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();
 
-    let mut comrak_plugins = comrak::Plugins::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 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),
@@ -66,6 +98,12 @@ fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
         None => comrak_plugins.render.codefence_syntax_highlighter = None,
     }
 
+    let comrak_options = comrak::Options {
+        parse: comrak_parse_options,
+        render: comrak_render_options,
+        extension: comrak_extension_options,
+    };
+
     Ok(markdown_to_html_with_plugins(
         &rb_commonmark,
         &comrak_options,
@@ -73,29 +111,15 @@ fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
     ))
 }
 
-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 {
-        rb_options.foreach(|key: Symbol, value: RHash| {
-            iterate_options_hash(&mut comrak_options, key, value)?;
-            Ok(ForEach::Continue)
-        })?;
-    }
-
-    Ok(comrak_options)
-}
-
 #[magnus::init]
-fn init() -> Result<(), Error> {
-    let ruby = magnus::Ruby::get().unwrap();
+fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
     let m_commonmarker = ruby.define_module("Commonmarker")?;
 
     m_commonmarker.define_module_function("commonmark_parse", function!(commonmark_parse, -1))?;
     m_commonmarker
         .define_module_function("commonmark_to_html", function!(commonmark_to_html, -1))?;
 
-    node::init(m_commonmarker).expect("cannot define Commonmarker::Node class");
+    node::init(ruby, m_commonmarker).expect("cannot define Commonmarker::Node class");
 
     Ok(())
 }