gitlab-glfm-markdown 0.0.29-aarch64-linux-musl → 0.0.31-aarch64-linux-musl

data/ext/glfm_markdown/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "glfm_markdown"
-version = "0.0.29"
+version = "0.0.31"
 edition = "2021"
 authors = ["digitalmoksha <bwalker@gitlab.com>"]
 description = "GitLab Flavored Markdown parser and formatter. 100% CommonMark-compatible. Experimental."
@@ -14,10 +14,12 @@ name = "glfm_markdown"
 required-features = ["cli"]
 
 [dependencies]
-clap = { version = "4.0", optional = true, features = ["derive", "string"] }
-comrak = { version = "0.38.0", default-features = false, features = ["shortcodes"] }
+clap = { version = "=4.4.18", optional = true, features = ["derive", "string"] }
+comrak = { version = "0.39.0", default-features = false, features = ["shortcodes"] }
 magnus = "0.6.2"
 rb-sys = { version = "0.9.86", default-features = false, features = ["stable-api-compiled-fallback"] }
+regex = "1.11.1"
+lazy_static = "1.5.0"
 
 [features]
 cli = ["clap", "comrak/syntect"]

data/ext/glfm_markdown/extconf.rb

@@ -5,4 +5,6 @@ require 'rb_sys/mkmf'
 
 create_rust_makefile('glfm_markdown/glfm_markdown') do |r|
   r.auto_install_rust_toolchain = false
+  # Ensure all Rust dependencies are pinned when building
+  r.extra_cargo_args = ["--locked"]
 end

data/ext/glfm_markdown/src/glfm.rs

@@ -1,4 +1,16 @@
-#[derive(Debug)]
+use comrak::html::{ChildRendering, Context};
+use comrak::nodes::{AstNode, NodeValue};
+use comrak::{create_formatter, html, parse_document, Arena, Plugins};
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::io;
+use std::io::{BufWriter, Write};
+
+lazy_static! {
+    static ref PLACEHOLDER_REGEX: Regex = Regex::new(r"%(\{|%7B)(\w{1,30})(}|%7D)").unwrap();
+}
+
+#[derive(Debug, Clone)]
 pub struct RenderOptions {
     pub alerts: bool,
     pub autolink: bool,
@@ -38,56 +50,277 @@ pub struct RenderOptions {
     pub wikilinks_title_after_pipe: bool,
     pub wikilinks_title_before_pipe: bool,
 
+    /// Only use default comrak HTML formatting
+    pub default_html: bool,
+
+    /// Detect and mark potential placeholder variables, which
+    /// have the format `%{PLACEHOLDER}`
+    pub placeholder_detection: bool,
+
     pub debug: bool,
 }
 
+pub struct RenderUserData {
+    pub default_html: bool,
+    pub placeholder_detection: bool,
+    pub debug: bool,
+}
+
+impl From<&RenderOptions> for RenderUserData {
+    fn from(options: &RenderOptions) -> Self {
+        RenderUserData {
+            default_html: options.default_html,
+            placeholder_detection: options.placeholder_detection,
+            debug: options.debug,
+        }
+    }
+}
+
+impl From<&RenderOptions> for comrak::Options<'_> {
+    fn from(options: &RenderOptions) -> Self {
+        let mut comrak_options = comrak::Options::default();
+
+        comrak_options.extension.alerts = options.alerts;
+        comrak_options.extension.autolink = options.autolink;
+        comrak_options.extension.description_lists = options.description_lists;
+        comrak_options.extension.footnotes = options.footnotes;
+        // comrak_options.extension.front_matter_delimiter = options.front_matter_delimiter;
+        comrak_options.extension.greentext = options.greentext;
+        comrak_options.extension.header_ids = options.header_ids.clone();
+        comrak_options.extension.math_code = options.math_code;
+        comrak_options.extension.math_dollars = options.math_dollars;
+        comrak_options.extension.multiline_block_quotes = options.multiline_block_quotes;
+        comrak_options.extension.shortcodes = options.gemojis;
+        comrak_options.extension.spoiler = options.spoiler;
+        comrak_options.extension.strikethrough = options.strikethrough;
+        comrak_options.extension.subscript = options.subscript;
+        comrak_options.extension.superscript = options.superscript;
+        comrak_options.extension.table = options.table;
+        comrak_options.extension.tagfilter = options.tagfilter;
+        comrak_options.extension.tasklist = options.tasklist;
+        comrak_options.extension.underline = options.underline;
+        comrak_options.extension.wikilinks_title_after_pipe = options.wikilinks_title_after_pipe;
+        comrak_options.extension.wikilinks_title_before_pipe = options.wikilinks_title_before_pipe;
+
+        comrak_options.render.escape = options.escape;
+        comrak_options.render.escaped_char_spans = options.escaped_char_spans;
+        comrak_options.render.figure_with_caption = options.figure_with_caption;
+        comrak_options.render.full_info_string = options.full_info_string;
+        comrak_options.render.gfm_quirks = options.gfm_quirks;
+        comrak_options.render.github_pre_lang = options.github_pre_lang;
+        comrak_options.render.hardbreaks = options.hardbreaks;
+        comrak_options.render.ignore_empty_links = options.ignore_empty_links;
+        comrak_options.render.ignore_setext = options.ignore_setext;
+        comrak_options.render.sourcepos = options.sourcepos;
+        // comrak_options.render.syntax_highlighting = options.syntax_highlighting;
+
+        comrak_options.render.unsafe_ = options.unsafe_;
+
+        // comrak_options.parse.default_info_string = options.default_info_string;
+        comrak_options.parse.relaxed_autolinks = options.relaxed_autolinks;
+        comrak_options.parse.relaxed_tasklist_matching = options.relaxed_tasklist_character;
+        comrak_options.parse.smart = options.smart;
+
+        comrak_options
+    }
+}
+
 pub fn render(text: String, options: RenderOptions) -> String {
-    render_comrak(text, options)
+    render_with_plugins(text, options, &comrak::Plugins::default())
+}
+
+fn render_with_plugins(text: String, render_options: RenderOptions, plugins: &Plugins) -> String {
+    let user_data = RenderUserData::from(&render_options);
+    let options = comrak::Options::from(&render_options);
+
+    if user_data.default_html {
+        return comrak::markdown_to_html_with_plugins(&text, &options, plugins);
+    }
+
+    let arena = Arena::new();
+    let root = parse_document(&arena, &text, &options);
+    let mut bw = BufWriter::new(Vec::new());
+
+    CustomFormatter::format_document_with_plugins(root, &options, &mut bw, plugins, user_data)
+        .unwrap();
+    String::from_utf8(bw.into_inner().unwrap()).unwrap()
 }
 
-fn render_comrak(text: String, options: RenderOptions) -> String {
-    let mut comrak_options = comrak::ComrakOptions::default();
-
-    comrak_options.extension.alerts = options.alerts;
-    comrak_options.extension.autolink = options.autolink;
-    comrak_options.extension.description_lists = options.description_lists;
-    comrak_options.extension.footnotes = options.footnotes;
-    // comrak_options.extension.front_matter_delimiter = options.front_matter_delimiter;
-    comrak_options.extension.greentext = options.greentext;
-    comrak_options.extension.header_ids = options.header_ids;
-    comrak_options.extension.math_code = options.math_code;
-    comrak_options.extension.math_dollars = options.math_dollars;
-    comrak_options.extension.multiline_block_quotes = options.multiline_block_quotes;
-    comrak_options.extension.shortcodes = options.gemojis;
-    comrak_options.extension.spoiler = options.spoiler;
-    comrak_options.extension.strikethrough = options.strikethrough;
-    comrak_options.extension.subscript = options.subscript;
-    comrak_options.extension.superscript = options.superscript;
-    comrak_options.extension.table = options.table;
-    comrak_options.extension.tagfilter = options.tagfilter;
-    comrak_options.extension.tasklist = options.tasklist;
-    comrak_options.extension.underline = options.underline;
-    comrak_options.extension.wikilinks_title_after_pipe = options.wikilinks_title_after_pipe;
-    comrak_options.extension.wikilinks_title_before_pipe = options.wikilinks_title_before_pipe;
-
-    comrak_options.render.escape = options.escape;
-    comrak_options.render.escaped_char_spans = options.escaped_char_spans;
-    comrak_options.render.figure_with_caption = options.figure_with_caption;
-    comrak_options.render.full_info_string = options.full_info_string;
-    comrak_options.render.gfm_quirks = options.gfm_quirks;
-    comrak_options.render.github_pre_lang = options.github_pre_lang;
-    comrak_options.render.hardbreaks = options.hardbreaks;
-    comrak_options.render.ignore_empty_links = options.ignore_empty_links;
-    comrak_options.render.ignore_setext = options.ignore_setext;
-    comrak_options.render.sourcepos = options.sourcepos;
-    // comrak_options.render.syntax_highlighting = options.syntax_highlighting;
-
-    comrak_options.render.unsafe_ = options.unsafe_;
-
-    // comrak_options.parse.default_info_string = options.default_info_string;
-    comrak_options.parse.relaxed_autolinks = options.relaxed_autolinks;
-    comrak_options.parse.relaxed_tasklist_matching = options.relaxed_tasklist_character;
-    comrak_options.parse.smart = options.smart;
-
-    comrak::markdown_to_html(&text, &comrak_options)
+// The important thing to remember is that this overrides the default behavior of the
+// specified nodes. If we do override a node, then it's our responsibility to ensure that
+// any changes in the `comrak` code for those nodes is backported to here, such as when
+// `figcaption` support was added.
+// One idea to limit that would be having the ability to specify attributes that would
+// be inserted when a node is rendered. That would allow us to (in many cases) just
+// inject the changes we need. Such a feature would need to be added to `comrak`.
+create_formatter!(CustomFormatter<RenderUserData>, {
+    NodeValue::Text(_) => |context, node, entering| {
+        return render_text(context, node, entering);
+    },
+    NodeValue::Link(_) => |context, node, entering| {
+        return render_link(context, node, entering);
+    },
+    NodeValue::Image(_) => |context, node, entering| {
+        return render_image(context, node, entering);
+    }
+});
+
+fn render_image<'a>(
+    context: &mut Context<RenderUserData>,
+    node: &'a AstNode<'a>,
+    entering: bool,
+) -> io::Result<ChildRendering> {
+    let NodeValue::Image(ref nl) = node.data.borrow().value else {
+        panic!("Attempt to render invalid node as image")
+    };
+
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(nl.url.as_str())) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    if entering {
+        if context.options.render.figure_with_caption {
+            context.write_all(b"<figure>")?;
+        }
+        context.write_all(b"<img")?;
+        html::render_sourcepos(context, node)?;
+        context.write_all(b" src=\"")?;
+        let url = nl.url.as_bytes();
+        if context.options.render.unsafe_ || !html::dangerous_url(url) {
+            if let Some(rewriter) = &context.options.extension.image_url_rewriter {
+                context.escape_href(rewriter.to_html(&nl.url).as_bytes())?;
+            } else {
+                context.escape_href(url)?;
+            }
+        }
+
+        context.write_all(b"\"")?;
+
+        if PLACEHOLDER_REGEX.is_match(nl.url.as_str()) {
+            context.write_all(b" data-placeholder")?;
+        }
+
+        context.write_all(b" alt=\"")?;
+
+        return Ok(ChildRendering::Plain);
+    } else {
+        if !nl.title.is_empty() {
+            context.write_all(b"\" title=\"")?;
+            context.escape(nl.title.as_bytes())?;
+        }
+        context.write_all(b"\" />")?;
+        if context.options.render.figure_with_caption {
+            if !nl.title.is_empty() {
+                context.write_all(b"<figcaption>")?;
+                context.escape(nl.title.as_bytes())?;
+                context.write_all(b"</figcaption>")?;
+            }
+            context.write_all(b"</figure>")?;
+        };
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+fn render_link<'a>(
+    context: &mut Context<RenderUserData>,
+    node: &'a AstNode<'a>,
+    entering: bool,
+) -> io::Result<ChildRendering> {
+    let NodeValue::Link(ref nl) = node.data.borrow().value else {
+        panic!("Attempt to render invalid node as link")
+    };
+
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(nl.url.as_str())) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    let parent_node = node.parent();
+
+    if !context.options.parse.relaxed_autolinks
+        || (parent_node.is_none()
+            || !matches!(
+                parent_node.unwrap().data.borrow().value,
+                NodeValue::Link(..)
+            ))
+    {
+        if entering {
+            context.write_all(b"<a")?;
+            html::render_sourcepos(context, node)?;
+            context.write_all(b" href=\"")?;
+            let url = nl.url.as_bytes();
+            if context.options.render.unsafe_ || !html::dangerous_url(url) {
+                if let Some(rewriter) = &context.options.extension.link_url_rewriter {
+                    context.escape_href(rewriter.to_html(&nl.url).as_bytes())?;
+                } else {
+                    context.escape_href(url)?;
+                }
+            }
+            context.write_all(b"\"")?;
+
+            if !nl.title.is_empty() {
+                context.write_all(b" title=\"")?;
+                context.escape(nl.title.as_bytes())?;
+            }
+
+            if PLACEHOLDER_REGEX.is_match(nl.url.as_str()) {
+                context.write_all(b" data-placeholder")?;
+            }
+
+            context.write_all(b">")?;
+        } else {
+            context.write_all(b"</a>")?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+fn render_text<'a>(
+    context: &mut Context<RenderUserData>,
+    node: &'a AstNode<'a>,
+    entering: bool,
+) -> io::Result<ChildRendering> {
+    let NodeValue::Text(ref literal) = node.data.borrow().value else {
+        panic!("Attempt to render invalid node as text")
+    };
+
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(literal)) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    // Don't currently support placeholders in the text inside links or images.
+    // If the text has an underscore in it, then the parser will not combine
+    // the multiple text nodes in `comrak`'s `postprocess_text_nodes`, breaking up
+    // the placeholder into multiple text nodes.
+    // For example, `[%{a_b}](link)`.
+    let parent = node.parent().unwrap();
+    if matches!(
+        parent.data.borrow().value,
+        NodeValue::Link(_) | NodeValue::Image(_)
+    ) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    if entering {
+        let mut cursor: usize = 0;
+
+        for mat in PLACEHOLDER_REGEX.find_iter(literal) {
+            if mat.start() > cursor {
+                context.escape(literal[cursor..mat.start()].as_bytes())?;
+            }
+
+            context.write_all(b"<span data-placeholder>")?;
+            context.escape(literal[mat.start()..mat.end()].as_bytes())?;
+            context.write_all(b"</span>")?;
+
+            cursor = mat.end();
+        }
+
+        if cursor < literal.len() {
+            context.escape(literal[cursor..literal.len()].as_bytes())?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
 }

data/ext/glfm_markdown/src/lib.rs

@@ -53,6 +53,8 @@ pub fn render_to_html_rs(text: String, options: RHash) -> String {
         wikilinks_title_after_pipe: get_bool_opt("wikilinks_title_after_pipe", options),
         wikilinks_title_before_pipe: get_bool_opt("wikilinks_title_before_pipe", options),
 
+        default_html: get_bool_opt("default_html", options),
+        placeholder_detection: get_bool_opt("placeholder_detection", options),
         debug: get_bool_opt("debug", options),
     };
 

data/ext/glfm_markdown/src/main.rs

@@ -32,6 +32,10 @@ struct Args {
     #[arg(long)]
     escaped_char_spans: bool,
 
+    /// Render the image as a figure element with the title as its caption
+    #[arg(long)]
+    figure_with_caption: bool,
+
     /// Enable 'footnotes' extension
     #[arg(long)]
     footnotes: bool,
@@ -158,6 +162,15 @@ struct Args {
     #[arg(long)]
     wikilinks_title_before_pipe: bool,
 
+    /// Only use default comrak HTML formatting
+    #[arg(long)]
+    default_html: bool,
+
+    /// Detect and marks potential placeholder variables, which
+    /// have the format `%{PLACEHOLDER}`
+    #[arg(long)]
+    placeholder_detection: bool,
+
     /// Show debug information
     #[arg(long)]
     debug: bool,
@@ -184,6 +197,7 @@ fn main() {
         description_lists: cli.description_lists,
         escape: cli.escape,
         escaped_char_spans: cli.escaped_char_spans,
+        figure_with_caption: cli.figure_with_caption,
         footnotes: cli.footnotes,
         // front_matter_delimiter:
         full_info_string: cli.full_info_string,
@@ -214,6 +228,9 @@ fn main() {
         unsafe_: cli.unsafe_,
         wikilinks_title_after_pipe: cli.wikilinks_title_after_pipe,
         wikilinks_title_before_pipe: cli.wikilinks_title_before_pipe,
+
+        default_html: cli.default_html,
+        placeholder_detection: cli.placeholder_detection,
         debug: cli.debug,
     };
 

data/lib/glfm_markdown/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GLFMMarkdown
-  VERSION = '0.0.29'
+  VERSION = '0.0.31'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-glfm-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.31
 platform: aarch64-linux-musl
 authors:
 - Brett Walker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-07 00:00:00.000000000 Z
+date: 2025-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -62,6 +62,7 @@ files:
 - Cargo.lock
 - LICENSE
 - README.md
+- ext/glfm_markdown/Cargo.lock
 - ext/glfm_markdown/Cargo.toml
 - ext/glfm_markdown/extconf.rb
 - ext/glfm_markdown/src/glfm.rs