fix(converters): show checked/unchecked status for checklists

Author: nlopes

converters/html/src/list.rs

@@ -1,6 +1,9 @@
 use std::io::Write;
 
-use acdc_parser::{DescriptionList, DescriptionListItem, ListItem, OrderedList, UnorderedList};
+use acdc_parser::{
+    DescriptionList, DescriptionListItem, ListItem, ListItemCheckedStatus, OrderedList,
+    UnorderedList,
+};
 
 use crate::{Processor, Render, RenderOptions};
 
@@ -41,6 +44,7 @@ impl Render for OrderedList {
 }
 
 /// Render nested list items hierarchically
+#[tracing::instrument(skip(w, processor))]
 fn render_nested_list_items<W: Write>(
     items: &[ListItem],
     w: &mut W,
@@ -62,21 +66,45 @@ fn render_nested_list_items<W: Write>(
             // Render item at current level
             writeln!(w, "<li>")?;
             writeln!(w, "<p>")?;
+            render_checked_status(item.checked.as_ref(), w)?;
             crate::inlines::render_inlines(&item.content, w, processor, options)?;
             writeln!(w, "</p>")?;
 
             // Check if next items are nested (higher level)
             if i + 1 < items.len() && items[i + 1].level > expected_level {
                 // Find all items at the next level
                 let next_level = items[i + 1].level;
+                let inner_item = &items[i + 1];
 
                 // Open nested list
                 if is_ordered {
-                    writeln!(w, "<div class=\"olist arabic\">")?;
-                    writeln!(w, "<ol class=\"arabic\">")?;
+                    writeln!(w, "<div class=\"olist arabic")?;
+                    if inner_item.checked.is_some() {
+                        writeln!(w, " checklist\">")?;
+                    } else {
+                        writeln!(w, "\">")?;
+                    }
+
+                    write!(w, "<ol class=\"arabic")?;
+                    if inner_item.checked.is_some() {
+                        writeln!(w, " checklist\">")?;
+                    } else {
+                        writeln!(w, "\">")?;
+                    }
                 } else {
-                    writeln!(w, "<div class=\"ulist\">")?;
-                    writeln!(w, "<ul>")?;
+                    // check if the item is a checkbox item
+                    write!(w, "<div class=\"ulist")?;
+                    if inner_item.checked.is_some() {
+                        writeln!(w, " checklist\">")?;
+                    } else {
+                        writeln!(w, "\">")?;
+                    }
+                    write!(w, "<ul")?;
+                    if inner_item.checked.is_some() {
+                        writeln!(w, " class=\"checklist\">")?;
+                    } else {
+                        writeln!(w, ">")?;
+                    }
                 }
 
                 // Recursively render nested items
@@ -111,11 +139,7 @@ fn render_nested_list_items<W: Write>(
         } else {
             // Item at higher level than expected, shouldn't happen in well-formed input
             // but handle gracefully by treating as same level
-            writeln!(w, "<li>")?;
-            writeln!(w, "<p>")?;
-            crate::inlines::render_inlines(&item.content, w, processor, options)?;
-            writeln!(w, "</p>")?;
-            writeln!(w, "</li>")?;
+            item.render(w, processor, options)?;
             i += 1;
         }
     }
@@ -133,6 +157,7 @@ impl Render for ListItem {
     ) -> Result<(), Self::Error> {
         writeln!(w, "<li>")?;
         writeln!(w, "<p>")?;
+        render_checked_status(self.checked.as_ref(), w)?;
         crate::inlines::render_inlines(&self.content, w, processor, options)?;
         writeln!(w, "</p>")?;
         writeln!(w, "</li>")?;
@@ -185,3 +210,20 @@ impl Render for DescriptionListItem {
         Ok(())
     }
 }
+
+#[tracing::instrument(skip(w))]
+fn render_checked_status<W: Write>(
+    checked: Option<&ListItemCheckedStatus>,
+    w: &mut W,
+) -> Result<(), crate::Error> {
+    match checked {
+        Some(ListItemCheckedStatus::Checked) => {
+            write!(w, "&#10003; ")?; // Checked box
+        }
+        Some(ListItemCheckedStatus::Unchecked) => {
+            write!(w, "&#10063; ")?; // Unchecked box
+        }
+        None => {}
+    }
+    Ok(())
+}

converters/terminal/src/list.rs

@@ -16,13 +16,14 @@ use crate::{Processor, Render};
 ///
 /// This helper function renders a collection of inline nodes, inserting a space
 /// between each node. It uses a peekable iterator to avoid adding a trailing space.
+#[tracing::instrument(skip(w, processor))]
 fn render_nodes_with_spaces<W: Write, N>(
     nodes: &[N],
     w: &mut W,
     processor: &Processor,
 ) -> Result<(), crate::Error>
 where
-    N: Render<Error = crate::Error>,
+    N: Render<Error = crate::Error> + std::fmt::Debug,
 {
     let mut iter = nodes.iter().peekable();
     while let Some(node) = iter.next() {
@@ -38,13 +39,14 @@ where
 ///
 /// This helper function renders inline nodes to a buffer, converts to a string,
 /// trims whitespace, and applies italic styling for terminal output.
+#[tracing::instrument(skip(w, processor))]
 fn render_styled_title<W: Write, N>(
     title: &[N],
     w: &mut W,
     processor: &Processor,
 ) -> Result<(), crate::Error>
 where
-    N: Render<Error = crate::Error>,
+    N: Render<Error = crate::Error> + std::fmt::Debug,
 {
     if !title.is_empty() {
         let mut inner = std::io::BufWriter::new(Vec::new());
@@ -63,6 +65,7 @@ where
 }
 
 /// Render nested list items with proper indentation based on their level
+#[tracing::instrument(skip(w, processor))]
 fn render_nested_list_items<W: Write>(
     items: &[ListItem],
     w: &mut W,
@@ -124,6 +127,7 @@ fn render_nested_list_items<W: Write>(
 }
 
 /// Render a single list item with the specified indentation
+#[tracing::instrument(skip(w, processor))]
 fn render_list_item_with_indent<W: Write>(
     item: &ListItem,
     w: &mut W,
@@ -142,15 +146,7 @@ fn render_list_item_with_indent<W: Write>(
         write!(w, "*")?;
     }
 
-    if let Some(checked) = &item.checked {
-        write!(w, " ")?;
-        if checked == &ListItemCheckedStatus::Checked {
-            w.queue(PrintStyledContent("✔".bold()))?;
-        } else {
-            w.queue(PrintStyledContent("✘".bold()))?;
-        }
-    }
-
+    render_checked_status(item.checked.as_ref(), w)?;
     write!(w, " ")?;
 
     // Render each node with a space between them
@@ -159,6 +155,22 @@ fn render_list_item_with_indent<W: Write>(
     Ok(())
 }
 
+#[tracing::instrument(skip(w))]
+fn render_checked_status<W: Write>(
+    checked: Option<&ListItemCheckedStatus>,
+    w: &mut W,
+) -> Result<(), crate::Error> {
+    if let Some(checked) = checked {
+        write!(w, " ")?;
+        if checked == &ListItemCheckedStatus::Checked {
+            w.queue(PrintStyledContent("[✔]".bold()))?;
+        } else {
+            w.queue(PrintStyledContent("[ ]".bold()))?;
+        }
+    }
+    Ok(())
+}
+
 impl Render for UnorderedList {
     type Error = crate::Error;
 
@@ -198,14 +210,7 @@ impl Render for ListItem {
 
     fn render<W: Write>(&self, w: &mut W, processor: &Processor) -> Result<(), Self::Error> {
         write!(w, "{}", self.marker)?;
-        if let Some(checked) = &self.checked {
-            write!(w, " ")?;
-            if checked == &ListItemCheckedStatus::Checked {
-                w.queue(PrintStyledContent("✔".bold()))?;
-            } else {
-                w.queue(PrintStyledContent("✘".bold()))?;
-            }
-        }
+        render_checked_status(self.checked.as_ref(), w)?;
         write!(w, " ")?;
         // render each node with a space between them
         render_nodes_with_spaces(&self.content, w, processor)?;