Merge pull request #417 from commonmark/issue-413

TextContentRenderer: Fix nested lists on the same line

Author: robinst

CHANGELOG.md

@@ -10,6 +10,7 @@ with the exception that 0.x versions can break between minor versions.
 ### Fixed
 - Line(s) after a hard line break would sometimes also get an unwanted hard
   line break, e.g. if they ended in emphasis or other non-text inlines (#415)
+- `TextContentRenderer` (for plain text): Fix nested lists on the same line (#413)
 
 ## [0.27.0] - 2025-10-12
 ### Added

commonmark/src/main/java/org/commonmark/internal/renderer/text/BulletListHolder.java

@@ -1,8 +1,5 @@
 package org.commonmark.renderer.text;
 
-import org.commonmark.internal.renderer.text.BulletListHolder;
-import org.commonmark.internal.renderer.text.ListHolder;
-import org.commonmark.internal.renderer.text.OrderedListHolder;
 import org.commonmark.node.*;
 import org.commonmark.renderer.NodeRenderer;
 
@@ -161,19 +158,30 @@ public void visit(Link link) {
     @Override
     public void visit(ListItem listItem) {
         if (listHolder != null && listHolder instanceof OrderedListHolder) {
-            OrderedListHolder orderedListHolder = (OrderedListHolder) listHolder;
-            String indent = stripNewlines() ? "" : orderedListHolder.getIndent();
-            textContent.write(indent + orderedListHolder.getCounter() + orderedListHolder.getDelimiter() + " ");
+            var orderedListHolder = (OrderedListHolder) listHolder;
+            var marker = orderedListHolder.getCounter() + orderedListHolder.getDelimiter();
+            var spaces = " ";
+            textContent.write(marker);
+            textContent.write(spaces);
+            textContent.pushPrefix(repeat(" ", marker.length() + spaces.length()));
             visitChildren(listItem);
             textContent.block();
+            textContent.popPrefix();
             orderedListHolder.increaseCounter();
         } else if (listHolder != null && listHolder instanceof BulletListHolder) {
             BulletListHolder bulletListHolder = (BulletListHolder) listHolder;
             if (!stripNewlines()) {
-                textContent.write(bulletListHolder.getIndent() + bulletListHolder.getMarker() + " ");
+                var marker = bulletListHolder.getMarker();
+                var spaces = " ";
+                textContent.write(marker);
+                textContent.write(spaces);
+                textContent.pushPrefix(repeat(" ", marker.length() + spaces.length()));
             }
             visitChildren(listItem);
             textContent.block();
+            if (!stripNewlines()) {
+                textContent.popPrefix();
+            }
         }
     }
 
@@ -268,4 +276,61 @@ private static String stripTrailingNewline(String s) {
             return s;
         }
     }
+
+    // Keep for Android compat (String.repeat only available on Android 12 and later)
+    private static String repeat(String s, int count) {
+        var sb = new StringBuilder(s.length() * count);
+        for (int i = 0; i < count; i++) {
+            sb.append(s);
+        }
+        return sb.toString();
+    }
+
+    private static class BulletListHolder extends ListHolder {
+        private final String marker;
+
+        public BulletListHolder(ListHolder parent, BulletList list) {
+            super(parent);
+            marker = list.getMarker();
+        }
+
+        public String getMarker() {
+            return marker;
+        }
+    }
+
+    private abstract static class ListHolder {
+        private final ListHolder parent;
+
+        ListHolder(ListHolder parent) {
+            this.parent = parent;
+        }
+
+        public ListHolder getParent() {
+            return parent;
+        }
+    }
+
+    private static class OrderedListHolder extends ListHolder {
+        private final String delimiter;
+        private int counter;
+
+        public OrderedListHolder(ListHolder parent, OrderedList list) {
+            super(parent);
+            delimiter = list.getMarkerDelimiter() != null ? list.getMarkerDelimiter() : ".";
+            counter = list.getMarkerStartNumber() != null ? list.getMarkerStartNumber() : 1;
+        }
+
+        public String getDelimiter() {
+            return delimiter;
+        }
+
+        public int getCounter() {
+            return counter;
+        }
+
+        public void increaseCounter() {
+            counter++;
+        }
+    }
 }

commonmark/src/main/java/org/commonmark/internal/renderer/text/ListHolder.java

@@ -8,6 +8,7 @@ public class TextContentWriter {
     private final Appendable buffer;
     private final LineBreakRendering lineBreakRendering;
 
+    private final LinkedList<String> prefixes = new LinkedList<>();
     private final LinkedList<Boolean> tight = new LinkedList<>();
 
     private String blockSeparator = null;
@@ -36,6 +37,7 @@ public void colon() {
 
     public void line() {
         append('\n');
+        writePrefixes();
     }
 
     public void block() {
@@ -61,6 +63,32 @@ public void write(char c) {
         append(c);
     }
 
+    /**
+     * Push a prefix onto the top of the stack. All prefixes are written at the beginning of each line, until the
+     * prefix is popped again.
+     *
+     * @param prefix the raw prefix string
+     */
+    public void pushPrefix(String prefix) {
+        prefixes.addLast(prefix);
+    }
+
+    /**
+     * Write a prefix.
+     *
+     * @param prefix the raw prefix string to write
+     */
+    public void writePrefix(String prefix) {
+        write(prefix);
+    }
+
+    /**
+     * Remove the last prefix from the top of the stack.
+     */
+    public void popPrefix() {
+        prefixes.removeLast();
+    }
+
     /**
      * Change whether blocks are tight or loose. Loose is the default where blocks are separated by a blank line. Tight
      * is where blocks are not separated by a blank line. Tight blocks are used in lists, if there are no blank lines
@@ -84,12 +112,26 @@ private boolean isTight() {
         return !tight.isEmpty() && tight.getLast();
     }
 
+    private void writePrefixes() {
+        for (String prefix : prefixes) {
+            append(prefix);
+        }
+    }
+
     /**
      * If a block separator has been enqueued with {@link #block()} but not yet written, write it now.
      */
     private void flushBlockSeparator() {
         if (blockSeparator != null) {
-            append(blockSeparator);
+            if (blockSeparator.equals("\n") || blockSeparator.equals("\n\n")) {
+                for (int i = 0; i < blockSeparator.length(); i++) {
+                    var sep = blockSeparator.charAt(i);
+                    append(sep);
+                    writePrefixes();
+                }
+            } else {
+                append(blockSeparator);
+            }
             blockSeparator = null;
         }
     }

commonmark/src/main/java/org/commonmark/internal/renderer/text/OrderedListHolder.java

@@ -116,14 +116,14 @@ public void textContentLists() {
         assertSeparate(s, "bar\n\n1. foo\n   1. bar\n2. foo");
         assertStripped(s, "bar 1. foo 1. bar 2. foo");
 
-        s = "bar\n* foo\n   - bar\n* foo";
-        assertCompact(s, "bar\n* foo\n   - bar\n* foo");
-        assertSeparate(s, "bar\n\n* foo\n   - bar\n* foo");
+        s = "bar\n* foo\n  - bar\n* foo";
+        assertCompact(s, "bar\n* foo\n  - bar\n* foo");
+        assertSeparate(s, "bar\n\n* foo\n  - bar\n* foo");
         assertStripped(s, "bar foo bar foo");
 
-        s = "bar\n* foo\n   1. bar\n   2. bar\n* foo";
-        assertCompact(s, "bar\n* foo\n   1. bar\n   2. bar\n* foo");
-        assertSeparate(s, "bar\n\n* foo\n   1. bar\n   2. bar\n* foo");
+        s = "bar\n* foo\n  1. bar\n  2. bar\n* foo";
+        assertCompact(s, "bar\n* foo\n  1. bar\n  2. bar\n* foo");
+        assertSeparate(s, "bar\n\n* foo\n  1. bar\n  2. bar\n* foo");
         assertStripped(s, "bar foo 1. bar 2. bar foo");
 
         s = "bar\n1. foo\n   * bar\n   * bar\n2. foo";
@@ -196,6 +196,17 @@ public void textContentHtml() {
         assertAll(html, html);
     }
 
+    @Test
+    public void testContentNestedLists() {
+        var s = "List:\n" +
+                "1. 2) 3. \n" +
+                "end";
+        assertCompact(s, s);
+
+        var s2 = "1. A\n   1) B\n      1. Test";
+        assertCompact(s2, s2);
+    }
+
     @Test
     public void testOverrideNodeRendering() {
         var nodeRendererFactory = new TextContentNodeRendererFactory() {