commonmarker 2.5.0 → 2.6.0

data/ext/commonmarker/src/options.rs

@@ -1,10 +1,7 @@
 use std::borrow::Cow;
 
-use comrak::ComrakOptions;
-
-use magnus::value::ReprValue;
 use magnus::TryConvert;
-use magnus::{r_hash::ForEach, Error, RHash, Symbol, Value};
+use magnus::{r_hash::ForEach, RHash, Symbol, Value};
 
 use crate::utils::try_convert_string;
 
@@ -12,23 +9,29 @@ 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";
+const PARSE_LEAVE_FOOTNOTE_DEFINITIONS: &str = "leave_footnote_definitions";
 
-fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+pub fn iterate_parse_options(comrak_options: &mut comrak::options::Parse, options_hash: RHash) {
     options_hash
         .foreach(|key: Symbol, value: Value| {
             match key.name()? {
                 Cow::Borrowed(PARSE_SMART) => {
-                    comrak_options.parse.smart = TryConvert::try_convert(value)?;
+                    comrak_options.smart = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(PARSE_DEFAULT_INFO_STRING) => {
-                    comrak_options.parse.default_info_string = try_convert_string(value);
+                    comrak_options.default_info_string = try_convert_string(value);
                 }
                 Cow::Borrowed(PARSE_RELAXED_TASKLIST_MATCHING) => {
-                    comrak_options.parse.relaxed_tasklist_matching =
-                        TryConvert::try_convert(value)?;
+                    comrak_options.relaxed_tasklist_matching = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_IGNORE_SETEXT) => {
+                    comrak_options.ignore_setext = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(PARSE_RELAXED_AUTOLINKS) => {
-                    comrak_options.parse.relaxed_autolinks = TryConvert::try_convert(value)?;
+                    comrak_options.relaxed_autolinks = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(PARSE_LEAVE_FOOTNOTE_DEFINITIONS) => {
+                    comrak_options.leave_footnote_definitions = TryConvert::try_convert(value)?;
                 }
                 _ => {}
             }
@@ -51,48 +54,45 @@ const RENDER_GFM_QUIRKS: &str = "gfm_quirks";
 const RENDER_PREFER_FENCED: &str = "prefer_fenced";
 const RENDER_TASKLIST_CLASSES: &str = "tasklist_classes";
 
-fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+pub fn iterate_render_options(comrak_options: &mut comrak::options::Render, options_hash: RHash) {
     options_hash
         .foreach(|key: Symbol, value: Value| {
             match key.name()? {
                 Cow::Borrowed(RENDER_HARDBREAKS) => {
-                    comrak_options.render.hardbreaks = TryConvert::try_convert(value)?;
+                    comrak_options.hardbreaks = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_GITHUB_PRE_LANG) => {
-                    comrak_options.render.github_pre_lang = TryConvert::try_convert(value)?;
+                    comrak_options.github_pre_lang = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_FULL_INFO_STRING) => {
-                    comrak_options.render.full_info_string = TryConvert::try_convert(value)?;
+                    comrak_options.full_info_string = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_WIDTH) => {
-                    comrak_options.render.width = TryConvert::try_convert(value)?;
+                    comrak_options.width = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_UNSAFE) => {
-                    comrak_options.render.unsafe_ = TryConvert::try_convert(value)?;
+                    comrak_options.r#unsafe = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_ESCAPE) => {
-                    comrak_options.render.escape = TryConvert::try_convert(value)?;
+                    comrak_options.escape = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_SOURCEPOS) => {
-                    comrak_options.render.sourcepos = TryConvert::try_convert(value)?;
+                    comrak_options.sourcepos = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_ESCAPED_CHAR_SPANS) => {
-                    comrak_options.render.escaped_char_spans = TryConvert::try_convert(value)?;
-                }
-                Cow::Borrowed(RENDER_IGNORE_SETEXT) => {
-                    comrak_options.render.ignore_setext = TryConvert::try_convert(value)?;
+                    comrak_options.escaped_char_spans = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_IGNORE_EMPTY_LINKS) => {
-                    comrak_options.render.ignore_empty_links = TryConvert::try_convert(value)?;
+                    comrak_options.ignore_empty_links = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_GFM_QUIRKS) => {
-                    comrak_options.render.gfm_quirks = TryConvert::try_convert(value)?;
+                    comrak_options.gfm_quirks = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_PREFER_FENCED) => {
-                    comrak_options.render.prefer_fenced = TryConvert::try_convert(value)?;
+                    comrak_options.prefer_fenced = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(RENDER_TASKLIST_CLASSES) => {
-                    comrak_options.render.tasklist_classes = TryConvert::try_convert(value)?;
+                    comrak_options.tasklist_classes = TryConvert::try_convert(value)?;
                 }
                 _ => {}
             }
@@ -122,89 +122,96 @@ const EXTENSION_UNDERLINE: &str = "underline";
 const EXTENSION_SPOILER: &str = "spoiler";
 const EXTENSION_GREENTEXT: &str = "greentext";
 const EXTENSION_SUBSCRIPT: &str = "subscript";
+const EXTENSION_SUBTEXT: &str = "subtext";
 const EXTENSION_ALERTS: &str = "alerts";
 const EXTENSION_CJK_FRIENDLY_EMPHASIS: &str = "cjk_friendly_emphasis";
+const EXTENSION_HIGHLIGHT: &str = "highlight";
 
-fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+pub fn iterate_extension_options(
+    comrak_options: &mut comrak::options::Extension,
+    options_hash: RHash,
+) {
     options_hash
         .foreach(|key: Symbol, value: Value| {
             match key.name()? {
                 Cow::Borrowed(EXTENSION_STRIKETHROUGH) => {
-                    comrak_options.extension.strikethrough = TryConvert::try_convert(value)?;
+                    comrak_options.strikethrough = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_TAGFILTER) => {
-                    comrak_options.extension.tagfilter = TryConvert::try_convert(value)?;
+                    comrak_options.tagfilter = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_TABLE) => {
-                    comrak_options.extension.table = TryConvert::try_convert(value)?;
+                    comrak_options.table = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_AUTOLINK) => {
-                    comrak_options.extension.autolink = TryConvert::try_convert(value)?;
+                    comrak_options.autolink = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_TASKLIST) => {
-                    comrak_options.extension.tasklist = TryConvert::try_convert(value)?;
+                    comrak_options.tasklist = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_SUPERSCRIPT) => {
-                    comrak_options.extension.superscript = TryConvert::try_convert(value)?;
+                    comrak_options.superscript = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_HEADER_IDS) => {
-                    comrak_options.extension.header_ids = try_convert_string(value);
+                    comrak_options.header_ids = try_convert_string(value);
                 }
                 Cow::Borrowed(EXTENSION_FOOTNOTES) => {
-                    comrak_options.extension.footnotes = TryConvert::try_convert(value)?;
+                    comrak_options.footnotes = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_INLINE_FOOTNOTES) => {
-                    comrak_options.extension.inline_footnotes = TryConvert::try_convert(value)?;
+                    comrak_options.inline_footnotes = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_DESCRIPTION_LISTS) => {
-                    comrak_options.extension.description_lists = TryConvert::try_convert(value)?;
+                    comrak_options.description_lists = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_FRONT_MATTER_DELIMITER) => {
                     if let Some(option) = try_convert_string(value) {
                         if !option.is_empty() {
-                            comrak_options.extension.front_matter_delimiter = Some(option);
+                            comrak_options.front_matter_delimiter = Some(option);
                         }
                     }
                 }
                 Cow::Borrowed(EXTENSION_MULTILINE_BLOCK_QUOTES) => {
-                    comrak_options.extension.multiline_block_quotes =
-                        TryConvert::try_convert(value)?;
+                    comrak_options.multiline_block_quotes = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_MATH_DOLLARS) => {
-                    comrak_options.extension.math_dollars = TryConvert::try_convert(value)?;
+                    comrak_options.math_dollars = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_MATH_CODE) => {
-                    comrak_options.extension.math_code = TryConvert::try_convert(value)?;
+                    comrak_options.math_code = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_SHORTCODES) => {
-                    comrak_options.extension.shortcodes = TryConvert::try_convert(value)?;
+                    comrak_options.shortcodes = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_AFTER_PIPE) => {
-                    comrak_options.extension.wikilinks_title_after_pipe =
-                        TryConvert::try_convert(value)?;
+                    comrak_options.wikilinks_title_after_pipe = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE) => {
-                    comrak_options.extension.wikilinks_title_before_pipe =
-                        TryConvert::try_convert(value)?;
+                    comrak_options.wikilinks_title_before_pipe = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_UNDERLINE) => {
-                    comrak_options.extension.underline = TryConvert::try_convert(value)?;
+                    comrak_options.underline = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_SPOILER) => {
-                    comrak_options.extension.spoiler = TryConvert::try_convert(value)?;
+                    comrak_options.spoiler = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_GREENTEXT) => {
-                    comrak_options.extension.greentext = TryConvert::try_convert(value)?;
+                    comrak_options.greentext = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_SUBSCRIPT) => {
-                    comrak_options.extension.subscript = TryConvert::try_convert(value)?;
+                    comrak_options.subscript = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SUBTEXT) => {
+                    comrak_options.subtext = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_ALERTS) => {
-                    comrak_options.extension.alerts = TryConvert::try_convert(value)?;
+                    comrak_options.alerts = TryConvert::try_convert(value)?;
                 }
                 Cow::Borrowed(EXTENSION_CJK_FRIENDLY_EMPHASIS) => {
-                    comrak_options.extension.cjk_friendly_emphasis =
-                        TryConvert::try_convert(value)?;
+                    comrak_options.cjk_friendly_emphasis = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_HIGHLIGHT) => {
+                    comrak_options.highlight = TryConvert::try_convert(value)?;
                 }
                 _ => {}
             }
@@ -212,23 +219,3 @@ fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: R
         })
         .unwrap();
 }
-
-pub fn iterate_options_hash(
-    comrak_options: &mut ComrakOptions,
-    key: Symbol,
-    value: RHash,
-) -> Result<ForEach, Error> {
-    let ruby = magnus::Ruby::get().unwrap();
-    assert!(value.is_kind_of(ruby.class_hash()));
-
-    if key.name().unwrap() == "parse" {
-        iterate_parse_options(comrak_options, value);
-    }
-    if key.name().unwrap() == "render" {
-        iterate_render_options(comrak_options, value);
-    }
-    if key.name().unwrap() == "extension" {
-        iterate_extension_options(comrak_options, value);
-    }
-    Ok(ForEach::Continue)
-}

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

@@ -3,21 +3,21 @@ use std::path::PathBuf;
 use comrak::plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder};
 
 use magnus::value::ReprValue;
-use magnus::{RHash, TryConvert, Value};
+use magnus::{RHash, Ruby, TryConvert, Value};
 use syntect::highlighting::ThemeSet;
 
 use crate::EMPTY_STR;
 
 pub fn construct_syntax_highlighter_from_plugin(
+    ruby: &Ruby,
     rb_plugins: Option<RHash>,
 ) -> Result<Option<SyntectAdapter>, magnus::Error> {
     match rb_plugins {
         None => Ok(None),
         Some(rb_plugins) => {
-            let ruby = magnus::Ruby::get_with(rb_plugins);
             let theme = match rb_plugins.get(ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN)) {
                 Some(syntax_highlighter_options) => {
-                    match fetch_syntax_highlighter_theme(syntax_highlighter_options) {
+                    match fetch_syntax_highlighter_theme(ruby, syntax_highlighter_options) {
                         Ok(theme) => theme,
                         Err(e) => {
                             return Err(e);
@@ -41,7 +41,7 @@ pub fn construct_syntax_highlighter_from_plugin(
                             .get(ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN))
                         {
                             Some(syntax_highlighter_options) => {
-                                fetch_syntax_highlighter_path(syntax_highlighter_options)?
+                                fetch_syntax_highlighter_path(ruby, syntax_highlighter_options)?
                             }
                             None => PathBuf::from("".to_string()), // no `syntax_highlighter:` defined
                         };
@@ -102,8 +102,10 @@ pub fn construct_syntax_highlighter_from_plugin(
     }
 }
 
-fn fetch_syntax_highlighter_theme(value: Value) -> Result<Option<String>, magnus::Error> {
-    let ruby = magnus::Ruby::get_with(value);
+fn fetch_syntax_highlighter_theme(
+    ruby: &Ruby,
+    value: Value,
+) -> Result<Option<String>, magnus::Error> {
     if value.is_nil() {
         // `syntax_highlighter: nil`
         return Ok(None);
@@ -143,14 +145,13 @@ fn fetch_syntax_highlighter_theme(value: Value) -> Result<Option<String>, magnus
     }
 }
 
-fn fetch_syntax_highlighter_path(value: Value) -> Result<PathBuf, magnus::Error> {
+fn fetch_syntax_highlighter_path(ruby: &Ruby, value: Value) -> Result<PathBuf, magnus::Error> {
     if value.is_nil() {
         // `syntax_highlighter: nil`
         return Ok(PathBuf::from(EMPTY_STR));
     }
 
     let syntax_highlighter_plugin: RHash = TryConvert::try_convert(value)?;
-    let ruby = magnus::Ruby::get_with(value);
     let path_key = ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN_PATH_KEY);
 
     match syntax_highlighter_plugin.get(path_key) {

data/lib/commonmarker/config.rb

@@ -10,6 +10,7 @@ module Commonmarker
         default_info_string: "",
         relaxed_tasklist_matching: false,
         relaxed_autolinks: false,
+        leave_footnote_definitions: false,
       }.freeze,
       render: {
         hardbreaks: true,
@@ -48,8 +49,10 @@ module Commonmarker
         spoiler: false,
         greentext: false,
         subscript: false,
+        subtext: false,
         alerts: false,
         cjk_friendly_emphasis: false,
+        highlight: false,
       }.freeze,
       format: [:html].freeze,
     }.freeze

data/lib/commonmarker/node.rb

@@ -44,7 +44,7 @@ module Commonmarker
       opts = Config.process_options(options)
       plugins = Config.process_plugins(plugins)
 
-      node_to_html(options: opts, plugins: plugins).force_encoding("utf-8")
+      node_to_html(render: opts[:render], parse: opts[:parse], extension: opts[:extension], plugins: plugins).force_encoding("utf-8")
     end
 
     # Public: Convert the node to a CommonMark string.
@@ -59,7 +59,7 @@ module Commonmarker
       opts = Config.process_options(options)
       plugins = Config.process_plugins(plugins)
 
-      node_to_commonmark(options: opts, plugins: plugins).force_encoding("utf-8")
+      node_to_commonmark(render: opts[:render], parse: opts[:parse], extension: opts[:extension], plugins: plugins).force_encoding("utf-8")
     end
   end
 end

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Commonmarker
-  VERSION = "2.5.0"
+  VERSION = "2.6.0"
 end

data/lib/commonmarker.rb

@@ -23,7 +23,7 @@ module Commonmarker
 
       opts = Config.process_options(options)
 
-      commonmark_parse(text, options: opts)
+      commonmark_parse(text, parse: opts.fetch(:parse, {}), render: opts.fetch(:render, {}), extension: opts.fetch(:extension, {}))
     end
 
     # Public: Parses a CommonMark string into an HTML string.
@@ -41,7 +41,7 @@ module Commonmarker
       opts = Config.process_options(options)
       plugins = Config.process_plugins(plugins)
 
-      commonmark_to_html(text, options: opts, plugins: plugins)
+      commonmark_to_html(text, parse: opts.fetch(:parse, {}), render: opts.fetch(:render, {}), extension: opts.fetch(:extension, {}), plugins: plugins)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commonmarker
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Garen Torikian
 - Ashe Connor
 bindir: exe
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2025-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -94,12 +94,15 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '3.4'
 requirements: []