gitlab-glfm-markdown 0.0.39 → 0.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e9457f3f2408a065bd1aae17f04f46ab02279cd28dee3eb4e66e6d62bf89084
-  data.tar.gz: ca43b48e916994c0745009692dfd5b2c5c0978ae954c2164f91e097b546d49be
+  metadata.gz: 958f895a64867a4cf0facd03a03f363398263613493019627df9ed9481dc0d74
+  data.tar.gz: c180c4b058f5c823b2dc00ad32bf63de261a070cba034326d0f29e1131ea6f53
 SHA512:
-  metadata.gz: 433d2c51fbe8d1e744def897f99a701a0eba27ebb1c59db2e0f55a21b1d73aba1642b63e97bfbbc4ebd79bf1d4a1a7c95ea10b45bafe8569ee38c8406588bf56
-  data.tar.gz: fa414e99b8f180c3279c0f292bae94cd379a656309abae06c4e318b53492116be775755f8ab0e3d2de8d51ccf9ca5a6ae39010b9b39b3d78f2550495ece2e633
+  metadata.gz: f1887cab2213baf059cf86655333308a4cd021bed71438a16c32f6a234dde93c29cc0b87522bc6057d6f87acf4150634c712f98ce273032845a90899c6a4806f
+  data.tar.gz: e7c2789aa86e38930c55d9d31520d947bee79cb093338213259d0820b8015abe1d3419ba1ce282af35495ca73fa66846745f983fec574921d97b301f725d9b7a

data/Cargo.lock

@@ -221,9 +221,9 @@ checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "comrak"
-version = "0.48.0"
+version = "0.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48bf2260aceee247c6c5639f5751dc635211895066d782d2a28fb87f2e0d5613"
+checksum = "ab87129dce2f2d7e75e753b1df0e5093b27dec8fa5970b6eb51280faacb25bd6"
 dependencies = [
  "caseless",
  "emojis",
@@ -307,7 +307,7 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "gitlab-glfm-markdown"
-version = "0.0.39"
+version = "0.0.40"
 dependencies = [
  "clap",
  "comrak",

data/README.md

@@ -4,7 +4,7 @@
 [![Latest Release](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/badges/release.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/releases)
 
 Implements GLFM (as used by GitLab) using the Rust-based Markdown parser
-[Comrak](https://github.com/kivikakk/comrak) (0.48.0), providing a Ruby interface.
+[Comrak](https://github.com/kivikakk/comrak) (0.49.0), providing a Ruby interface.
 
 This project is still in constant flux, so interfaces and functionality can change at any time.
 

data/ext/gitlab_glfm_markdown/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gitlab-glfm-markdown"
-version = "0.0.39"
+version = "0.0.40"
 edition = "2021"
 authors = ["digitalmoksha <bwalker@gitlab.com>", "Asherah Connor <aconnor@gitlab.com>"]
 description = "GitLab Flavored Markdown parser and formatter. 100% CommonMark-compatible. Experimental."
@@ -15,7 +15,7 @@ required-features = ["cli"]
 
 [dependencies]
 clap = { version = "=4.4.18", optional = true, features = ["derive", "string"] }
-comrak = { version = "0.48.0", default-features = false, features = ["shortcodes"] }
+comrak = { version = "0.49.0", default-features = false, features = ["shortcodes"] }
 magnus = "0.8.2"
 rb-sys = { version = "0.9.117", default-features = false, features = ["stable-api-compiled-fallback"] }
 regex = "1.11.1"

data/ext/gitlab_glfm_markdown/src/formatter.rs

@@ -2,8 +2,8 @@ use std::fmt::{self, Write};
 use std::sync::LazyLock;
 
 use comrak::html::{collect_text, format_node_default, render_sourcepos, ChildRendering, Context};
-use comrak::nodes::{AstNode, ListType, NodeHeading, NodeLink, NodeList, NodeValue};
-use comrak::{create_formatter, html, node_matches};
+use comrak::nodes::{ListType, NodeHeading, NodeLink, NodeList, NodeTaskItem, NodeValue};
+use comrak::{create_formatter, html, node_matches, Node};
 use regex::Regex;
 
 use crate::glfm::RenderOptions;
@@ -11,6 +11,7 @@ use crate::glfm::RenderOptions;
 static PLACEHOLDER_REGEX: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"%\{(?:\w{1,30})}").unwrap());
 
+#[derive(Default)]
 pub struct RenderUserData {
     pub default_html: bool,
     pub inapplicable_tasks: bool,
@@ -55,8 +56,8 @@ create_formatter!(CustomFormatter<RenderUserData>, {
     NodeValue::List(ref nl) => |context, node, entering| {
         return render_list(context, node, entering, nl);
     },
-    NodeValue::TaskItem(symbol) => |context, node, entering| {
-        return render_task_item(context, node, entering, symbol);
+    NodeValue::TaskItem(ref nti) => |context, node, entering| {
+        return render_task_item(context, node, entering, nti);
     },
     NodeValue::Escaped => |context, node, entering| {
         return render_escaped(context, node, entering);
@@ -66,9 +67,9 @@ create_formatter!(CustomFormatter<RenderUserData>, {
     },
 });
 
-fn render_text<'a>(
+fn render_text(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
     literal: &str,
 ) -> Result<ChildRendering, fmt::Error> {
@@ -99,9 +100,9 @@ fn render_text<'a>(
     Ok(ChildRendering::HTML)
 }
 
-fn render_link<'a>(
+fn render_link(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
     nl: &NodeLink,
 ) -> Result<ChildRendering, fmt::Error> {
@@ -148,9 +149,9 @@ fn render_link<'a>(
     Ok(ChildRendering::HTML)
 }
 
-fn render_image<'a>(
+fn render_image(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
     nl: &NodeLink,
 ) -> Result<ChildRendering, fmt::Error> {
@@ -202,9 +203,9 @@ fn render_image<'a>(
 
 // Overridden to use class `task-list` instead of `contains-task-list`
 // to align with GitLab class usage
-fn render_list<'a>(
+fn render_list(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
     nl: &NodeList,
 ) -> Result<ChildRendering, fmt::Error> {
@@ -239,87 +240,51 @@ fn render_list<'a>(
     Ok(ChildRendering::HTML)
 }
 
-// Overridden to detect inapplicable task list items
-fn render_task_item<'a>(
+// Overridden to:
+// 1. Detect inapplicable task list items; and,
+// 2. Output checkbox sourcepos.
+fn render_task_item(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
-    symbol: Option<char>,
+    nti: &NodeTaskItem,
 ) -> Result<ChildRendering, fmt::Error> {
-    if !context.user.inapplicable_tasks {
-        return html::format_node_default(context, node, entering);
-    }
-
-    let Some(symbol) = symbol else {
-        return html::format_node_default(context, node, entering);
-    };
-
-    if symbol == 'x' || symbol == 'X' {
-        return html::format_node_default(context, node, entering);
-    }
-
-    // We only proceed past this point if:
-    //
-    // * inapplicable_tasks is enabled; and,
-    // * the symbol is present (the tasklist didn't contain a ' '), and isn't 'x' or 'X'.
-    //
-    // There are three possibilities remaining:
-    //
-    // * the symbol is '~': we write out an inapplicable task item.
-    // * the symbol is a different Unicode whitespace: we write out an incomplete task item,
-    //   per Comrak.
-    // * the symbol is something else: we write out the source Markdown that would've been entered,
-    //   to act like a non-match.
-    //
-    // TODO: have Comrak accept a list of acceptable tasklist symbols instead. :)
-
     let write_li = node
         .parent()
         .map(|p| node_matches!(p, NodeValue::List(_)))
         .unwrap_or_default();
 
-    if entering {
-        if symbol == '~' {
-            context.cr()?;
-            if write_li {
-                context.write_str("<li")?;
-                context.write_str(" class=\"inapplicable")?;
-
-                if context.options.render.tasklist_classes {
-                    context.write_str(" task-list-item")?;
-                }
-                context.write_str("\"")?;
-                html::render_sourcepos(context, node)?;
-                context.write_str(">")?;
-            }
-            context.write_str("<input type=\"checkbox\"")?;
-            if !write_li {
-                html::render_sourcepos(context, node)?;
-            }
-            if context.options.render.tasklist_classes {
-                context.write_str(" class=\"task-list-item-checkbox\"")?;
-            }
+    if !entering {
+        if write_li {
+            context.write_str("</li>\n")?;
+        }
+        return Ok(ChildRendering::HTML);
+    }
 
-            context.write_str(" data-inapplicable disabled=\"\"> ")?;
-        } else if symbol.is_whitespace() {
-            context.cr()?;
-            if write_li {
-                context.write_str("<li")?;
-                if context.options.render.tasklist_classes {
-                    context.write_str(" class=\"task-list-item\"")?;
-                }
-                render_sourcepos(context, node)?;
-                context.write_str(">")?;
-            }
-            context.write_str("<input type=\"checkbox\"")?;
-            if !write_li {
-                render_sourcepos(context, node)?;
-            }
-            if context.options.render.tasklist_classes {
-                context.write_str(" class=\"task-list-item-checkbox\"")?;
-            }
-            context.write_str(" disabled=\"\" /> ")?;
-        } else {
+    match nti.symbol {
+        Some('~') => {
+            render_task_item_with(
+                context,
+                node,
+                nti,
+                if context.user.inapplicable_tasks {
+                    TaskItemState::Inapplicable
+                } else {
+                    TaskItemState::Checked
+                },
+                write_li,
+            )?;
+        }
+        None => {
+            render_task_item_with(context, node, nti, TaskItemState::Unchecked, write_li)?;
+        }
+        Some(ws) if ws.is_whitespace() => {
+            render_task_item_with(context, node, nti, TaskItemState::Unchecked, write_li)?;
+        }
+        Some('x' | 'X') => {
+            render_task_item_with(context, node, nti, TaskItemState::Checked, write_li)?;
+        }
+        Some(symbol) => {
             context.cr()?;
             if write_li {
                 context.write_str("<li")?;
@@ -333,16 +298,72 @@ fn render_task_item<'a>(
             context.escape(&symbol.to_string())?;
             context.write_str("] ")?;
         }
-    } else if write_li {
-        context.write_str("</li>\n")?;
     }
 
     Ok(ChildRendering::HTML)
 }
 
-fn render_escaped<'a>(
+#[derive(PartialEq)]
+enum TaskItemState {
+    Checked,
+    Unchecked,
+    Inapplicable,
+}
+
+fn render_task_item_with(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    nti: &NodeTaskItem,
+    state: TaskItemState,
+    write_li: bool,
+) -> fmt::Result {
+    context.cr()?;
+    if write_li {
+        context.write_str("<li")?;
+        if context.options.render.tasklist_classes {
+            context.write_str(" class=\"")?;
+            if state == TaskItemState::Inapplicable {
+                context.write_str("inapplicable ")?;
+            }
+            context.write_str("task-list-item\"")?;
+        }
+        render_sourcepos(context, node)?;
+        context.write_str(">")?;
+    }
+
+    context.write_str("<input type=\"checkbox\"")?;
+    if !write_li {
+        html::render_sourcepos(context, node)?;
+    }
+    if context.options.render.sourcepos {
+        write!(
+            context,
+            " data-checkbox-sourcepos=\"{:?}\"",
+            nti.symbol_sourcepos
+        )?;
+    }
+
+    if context.options.render.tasklist_classes {
+        context.write_str(" class=\"task-list-item-checkbox\"")?;
+    }
+
+    match state {
+        TaskItemState::Checked => {
+            context.write_str(" checked=\"\"")?;
+        }
+        TaskItemState::Unchecked => {}
+        TaskItemState::Inapplicable => {
+            context.write_str(" data-inapplicable")?;
+        }
+    }
+    context.write_str(" disabled=\"\" /> ")?;
+
+    Ok(())
+}
+
+fn render_escaped(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
 ) -> Result<ChildRendering, fmt::Error> {
     if !context.options.render.escaped_char_spans {
@@ -353,7 +374,7 @@ fn render_escaped<'a>(
         .user
         .only_escape_chars
         .as_ref()
-        .map_or(true, |only_escape_chars| {
+        .is_none_or(|only_escape_chars| {
             with_node_text_content(node, false, |content| {
                 content.chars().count() == 1
                     && only_escape_chars.contains(&content.chars().next().unwrap())
@@ -372,9 +393,9 @@ fn render_escaped<'a>(
     Ok(ChildRendering::HTML)
 }
 
-fn render_heading<'a>(
+fn render_heading(
     context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
+    node: Node<'_>,
     entering: bool,
     nh: &NodeHeading,
 ) -> Result<ChildRendering, fmt::Error> {
@@ -415,7 +436,7 @@ fn render_heading<'a>(
 
 /// If the given node has a single text child, apply a function to the text content
 /// of that node. Otherwise, return the given default value.
-fn with_node_text_content<'a, U, F>(node: &'a AstNode<'a>, default: U, f: F) -> U
+fn with_node_text_content<U, F>(node: Node<'_>, default: U, f: F) -> U
 where
     F: FnOnce(&str) -> U,
 {

data/lib/gitlab_glfm_markdown/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-glfm-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.39
+  version: 0.0.40
 platform: ruby
 authors:
 - Brett Walker
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-14 00:00:00.000000000 Z
+date: 2025-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys