Enhance list rendering in md2term.py to support proper nesting and indentation for ordered and unordered lists. Update tests in test_md2term.py to validate nested lists, deeply nested lists, and mixed list types, ensuring accurate output formatting. Update snapshots to reflect changes in rendering behavior.

Author: statico

md2term.py

@@ -300,11 +300,14 @@ def _render_callout(self, content: str, callout_info: Dict[str, str]) -> None:
         )
         self.console.print(panel)
 
-    def _render_list(self, token: Dict[str, Any]) -> None:
-        """Render ordered or unordered lists."""
+    def _render_list(self, token: Dict[str, Any], indent_level: int = 0) -> None:
+        """Render ordered or unordered lists with proper nesting support."""
         ordered = token["attrs"].get("ordered", False)
         start = token["attrs"].get("start", 1)
 
+        # Calculate indentation for this level
+        indent = "  " * indent_level  # 2 spaces per level
+
         for i, item in enumerate(token["children"]):
             if ordered:
                 marker = f"{start + i}."
@@ -313,45 +316,55 @@ def _render_list(self, token: Dict[str, Any]) -> None:
                 marker = "•"
                 marker_style = "bold yellow"
 
-            # Create the marker text
-            marker_text = Text(marker, style=marker_style)
+            # Process the list item children
+            has_paragraph = False
+            nested_lists = []
+            paragraph_content = Text()
 
-            # Render list item content as Rich Text objects
-            content_text = Text()
             for child in item["children"]:
                 if child["type"] == "paragraph":
-                    # For paragraphs, render inline tokens directly
+                    has_paragraph = True
+                    # Render inline tokens for the paragraph
                     for inline_child in child["children"]:
                         if inline_child["type"] == "text":
-                            content_text.append(inline_child["raw"])
+                            paragraph_content.append(inline_child["raw"])
                         else:
                             # Render other inline tokens
                             inline_text = self._render_inline_tokens([inline_child])
-                            content_text.append_text(inline_text)
+                            paragraph_content.append_text(inline_text)
+                elif child["type"] == "list":
+                    # Store nested lists to render after the main content
+                    nested_lists.append(child)
                 else:
-                    # For other types, fall back to the old method
-                    old_console = self.console
-                    buffer = StringIO()
-                    temp_console = Console(
-                        file=buffer,
-                        width=self.console.size.width - 4,
-                        force_terminal=True,
-                        color_system="256",
-                        legacy_windows=False,
-                    )
-                    self.console = temp_console
-                    self._render_token(child)
-                    self.console = old_console
-                    content_text.append(buffer.getvalue().rstrip())
-
-            # Combine marker and content
-            line_text = Text()
-            line_text.append_text(marker_text)
-            line_text.append(" ")
-            line_text.append_text(content_text)
-
-            # Print the complete line
-            self.console.print(line_text)
+                    # Handle other block elements (shouldn't happen in well-formed markdown)
+                    if not has_paragraph:
+                        # If no paragraph, treat as direct content
+                        old_console = self.console
+                        buffer = StringIO()
+                        temp_console = Console(
+                            file=buffer,
+                            width=self.console.size.width - len(indent) - 4,
+                            force_terminal=True,
+                            color_system="256",
+                            legacy_windows=False,
+                        )
+                        self.console = temp_console
+                        self._render_token(child)
+                        self.console = old_console
+                        paragraph_content.append(buffer.getvalue().rstrip())
+
+            # Render the main list item line
+            if has_paragraph or paragraph_content.plain:
+                line_text = Text()
+                line_text.append(indent)
+                line_text.append(marker, style=marker_style)
+                line_text.append(" ")
+                line_text.append_text(paragraph_content)
+                self.console.print(line_text)
+
+            # Render any nested lists with increased indentation
+            for nested_list in nested_lists:
+                self._render_list(nested_list, indent_level + 1)
 
     def _render_thematic_break(self) -> None:
         """Render a horizontal rule."""

tests/__snapshots__/test_md2term.ambr

@@ -34,7 +34,7 @@
 # ---
 # name: TestCLIInterface.test_cli_version
   '''
-  main, version 0.1.0
+  main, version 1.0.1
 
   '''
 # ---
@@ -135,6 +135,24 @@
 
   '''
 # ---
+# name: TestMarkdownFeatures.test_cheesecake_recipe
+  '''
+  Classic New York Style Cheesecake
+  
+  Ingredients:
+  
+  • Crust:
+    • 2 cups graham cracker crumbs (about 40 full crackers)
+    • 1/3 cup granulated sugar
+    • 1/2 cup unsalted butter, melted
+  • Cheese Filling:
+    • 4 packages (8 oz each) cream cheese, at room temperature
+    • 1 cup granulated sugar
+    • 1 tablespoon vanilla extract
+    • 4 large eggs
+  
+  '''
+# ---
 # name: TestMarkdownFeatures.test_code_blocks_bash
   '''
   ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -374,6 +392,20 @@
 
   '''
 # ---
+# name: TestMarkdownFeatures.test_deeply_nested_lists
+  '''
+  • Level 1 item
+    • Level 2 item
+      • Level 3 item
+        • Level 4 item
+      • Another level 3 item
+    • Another level 2 item
+  • Another level 1 item
+    • Level 2 under second item
+      • Level 3 under second item
+  
+  '''
+# ---
 # name: TestMarkdownFeatures.test_headings_all_levels
   '''
   ────────────────────────────────────────────────────────────────────────────────
@@ -414,6 +446,20 @@
 
   '''
 # ---
+# name: TestMarkdownFeatures.test_mixed_list_types
+  '''
+  1. First ordered item
+    • Unordered sub-item
+    • Another unordered sub-item
+      1. Nested ordered item
+      2. Another nested ordered item
+  2. Second ordered item
+    • Mixed content here
+      • Deep nesting
+        1. Very deep ordered item
+  
+  '''
+# ---
 # name: TestMarkdownFeatures.test_multiple_blockquotes
   '''
   │ This is a blockquote with some important information.
@@ -422,6 +468,41 @@
 
   '''
 # ---
+# name: TestMarkdownFeatures.test_nested_lists
+  '''
+  Classic New York Style Cheesecake
+  
+  Ingredients:
+  
+  • Crust:
+    • 2 cups graham cracker crumbs (about 40 full crackers)
+    • 1/3 cup granulated sugar
+    • 1/2 cup unsalted butter, melted
+  • Cheese Filling:
+    • 4 packages (8 oz each) cream cheese, at room temperature
+    • 1 cup granulated sugar
+    • 1 tablespoon vanilla extract
+    • 4 large eggs
+  
+  Instructions:
+  
+  1. Prepare the crust:
+    1. Preheat oven to 350°F (175°C)
+    2. Mix graham cracker crumbs and sugar
+    3. Add melted butter and mix well
+    4. Press into bottom of springform pan
+  2. Make the filling:
+    1. Beat cream cheese until smooth
+    2. Gradually add sugar
+    3. Add vanilla extract
+    4. Beat in eggs one at a time
+  3. Bake and cool:
+    1. Pour filling over crust
+    2. Bake for 50-60 minutes
+    3. Cool completely before serving
+  
+  '''
+# ---
 # name: TestMarkdownFeatures.test_ordered_lists
   '''
   1. First numbered item

tests/test_md2term.py

@@ -202,6 +202,132 @@ def test_ordered_lists(self, snapshot):
         result = output.getvalue()
         assert result == snapshot
 
+    def test_nested_lists(self, snapshot):
+        """Test nested lists with proper indentation."""
+        markdown = """### Classic New York Style Cheesecake
+
+#### Ingredients:
+- **Crust:**
+  - 2 cups graham cracker crumbs (about 40 full crackers)
+  - 1/3 cup granulated sugar
+  - 1/2 cup unsalted butter, melted
+
+- **Cheese Filling:**
+  - 4 packages (8 oz each) cream cheese, at room temperature
+  - 1 cup granulated sugar
+  - 1 tablespoon vanilla extract
+  - 4 large eggs
+
+#### Instructions:
+1. **Prepare the crust:**
+   1. Preheat oven to 350°F (175°C)
+   2. Mix graham cracker crumbs and sugar
+   3. Add melted butter and mix well
+   4. Press into bottom of springform pan
+
+2. **Make the filling:**
+   1. Beat cream cheese until smooth
+   2. Gradually add sugar
+   3. Add vanilla extract
+   4. Beat in eggs one at a time
+
+3. **Bake and cool:**
+   1. Pour filling over crust
+   2. Bake for 50-60 minutes
+   3. Cool completely before serving"""
+
+        output = io.StringIO()
+        console = create_test_console(output)
+        renderer = TerminalRenderer(console)
+
+        import mistune
+
+        markdown_parser = mistune.create_markdown(renderer=None)
+        tokens = markdown_parser(markdown)
+        renderer.render(tokens)
+
+        result = output.getvalue()
+        assert result == snapshot
+
+    def test_deeply_nested_lists(self, snapshot):
+        """Test deeply nested lists (3+ levels)."""
+        markdown = """- Level 1 item
+  - Level 2 item
+    - Level 3 item
+      - Level 4 item
+    - Another level 3 item
+  - Another level 2 item
+- Another level 1 item
+  - Level 2 under second item
+    - Level 3 under second item"""
+
+        output = io.StringIO()
+        console = create_test_console(output)
+        renderer = TerminalRenderer(console)
+
+        import mistune
+
+        markdown_parser = mistune.create_markdown(renderer=None)
+        tokens = markdown_parser(markdown)
+        renderer.render(tokens)
+
+        result = output.getvalue()
+        assert result == snapshot
+
+    def test_mixed_list_types(self, snapshot):
+        """Test mixing ordered and unordered lists."""
+        markdown = """1. First ordered item
+   - Unordered sub-item
+   - Another unordered sub-item
+     1. Nested ordered item
+     2. Another nested ordered item
+2. Second ordered item
+   - Mixed content here
+     - Deep nesting
+       1. Very deep ordered item"""
+
+        output = io.StringIO()
+        console = create_test_console(output)
+        renderer = TerminalRenderer(console)
+
+        import mistune
+
+        markdown_parser = mistune.create_markdown(renderer=None)
+        tokens = markdown_parser(markdown)
+        renderer.render(tokens)
+
+        result = output.getvalue()
+        assert result == snapshot
+
+    def test_cheesecake_recipe(self, snapshot):
+        """Test the original cheesecake recipe example that had nested list issues."""
+        markdown = """### Classic New York Style Cheesecake
+
+#### Ingredients:
+- **Crust:**
+  - 2 cups graham cracker crumbs (about 40 full crackers)
+  - 1/3 cup granulated sugar
+  - 1/2 cup unsalted butter, melted
+
+- **Cheese Filling:**
+  - 4 packages (8 oz each) cream cheese, at room temperature
+  - 1 cup granulated sugar
+  - 1 tablespoon vanilla extract
+  - 4 large eggs"""
+
+        output = io.StringIO()
+        console = create_test_console(output)
+        renderer = TerminalRenderer(console)
+
+        import mistune
+
+        markdown_parser = mistune.create_markdown(renderer=None)
+        tokens = markdown_parser(markdown)
+        renderer.render(tokens)
+
+        result = output.getvalue()
+        assert result == snapshot
+
     def test_blockquotes(self, snapshot):
         """Test blockquotes with formatting."""
         markdown = """> This is a blockquote with some important information.