fix(renderer): render plugin list and table nodes

Refs #441, #419, #401.

Author: lepture

src/mistune/renderers/_list.py

@@ -22,13 +22,17 @@ def render_list(renderer: "BaseRenderer", token: Dict[str, Any], state: "BlockSt
     return strip_end(text) + "\n"
 
 
-def _render_list_item(
+def render_list_item(
     renderer: "BaseRenderer",
-    parent: Dict[str, Any],
     item: Dict[str, Any],
     state: "BlockState",
+    marker: str = "",
 ) -> str:
-    leading = cast(str, parent["leading"])
+    parent = item.get("parent")
+    if not parent:
+        parent = {"leading": "- ", "tight": False}
+
+    leading = cast(str, parent["leading"]) + marker
     text = ""
     for tok in item["children"]:
         if tok["type"] == "list":
@@ -53,12 +57,15 @@ def _render_ordered_list(renderer: "BaseRenderer", token: Dict[str, Any], state:
     start = attrs.get("start", 1)
     for item in token["children"]:
         leading = str(start) + token["bullet"] + " "
-        parent = {
+        item["parent"] = {
             "leading": leading,
             "tight": token["tight"],
         }
-        yield _render_list_item(renderer, parent, item, state)
-        start += 1
+        try:
+            yield renderer.render_token(item, state)
+        finally:
+            item.pop("parent", None)
+            start += 1
 
 
 def _render_unordered_list(renderer: "BaseRenderer", token: Dict[str, Any], state: "BlockState") -> Iterable[str]:
@@ -67,4 +74,8 @@ def _render_unordered_list(renderer: "BaseRenderer", token: Dict[str, Any], stat
         "tight": token["tight"],
     }
     for item in token["children"]:
-        yield _render_list_item(renderer, parent, item, state)
+        item["parent"] = parent
+        try:
+            yield renderer.render_token(item, state)
+        finally:
+            item.pop("parent", None)

src/mistune/renderers/markdown.py

@@ -4,7 +4,7 @@
 
 from ..core import BaseRenderer, BlockState
 from ..util import strip_end
-from ._list import render_list
+from ._list import render_list, render_list_item
 
 fenced_re = re.compile(r"^[`~]+", re.M)
 
@@ -134,6 +134,45 @@ def block_error(self, token: Dict[str, Any], state: BlockState) -> str:
     def list(self, token: Dict[str, Any], state: BlockState) -> str:
         return render_list(self, token, state)
 
+    def list_item(self, token: Dict[str, Any], state: BlockState) -> str:
+        return render_list_item(self, token, state)
+
+    def task_list_item(self, token: Dict[str, Any], state: BlockState) -> str:
+        checked = token.get("attrs", {}).get("checked")
+        marker = "[x] " if checked else "[ ] "
+        return render_list_item(self, token, state, marker)
+
+    def table(self, token: Dict[str, Any], state: BlockState) -> str:
+        children = token.get("children", [])
+        if not children:
+            return "\n"
+
+        head = children[0]
+        body = children[1] if len(children) > 1 else None
+        head_cells = head.get("children", [])
+        align = [_table_cell_align(cell) for cell in head_cells]
+        lines = [
+            _render_table_row(self, head_cells, state),
+            _render_table_delimiter(align),
+        ]
+        if body:
+            for row in body.get("children", []):
+                lines.append(_render_table_row(self, row.get("children", []), state))
+        return "\n".join(lines) + "\n\n"
+
+    def table_head(self, token: Dict[str, Any], state: BlockState) -> str:
+        cells = token.get("children", [])
+        return _render_table_row(self, cells, state) + "\n" + _render_table_delimiter([_table_cell_align(c) for c in cells])
+
+    def table_body(self, token: Dict[str, Any], state: BlockState) -> str:
+        return "\n".join(self.render_token(row, state).rstrip("\n") for row in token.get("children", []))
+
+    def table_row(self, token: Dict[str, Any], state: BlockState) -> str:
+        return _render_table_row(self, token.get("children", []), state) + "\n"
+
+    def table_cell(self, token: Dict[str, Any], state: BlockState) -> str:
+        return _render_table_cell(self, token, state)
+
 
 def _escape_block_prefix(text: str) -> str:
     """Backslash-escape a leading block marker on each line so that literal
@@ -168,3 +207,33 @@ def _get_fenced_marker(code: str) -> str:
     if not waves:
         return "~~~"
     return "`" * (max(ticks) + 1)
+
+
+def _render_table_row(renderer: MarkdownRenderer, cells: Iterable[Dict[str, Any]], state: BlockState) -> str:
+    return "| " + " | ".join(_render_table_cell(renderer, cell, state) for cell in cells) + " |"
+
+
+def _render_table_delimiter(aligns: Iterable[Any]) -> str:
+    cells = []
+    for align in aligns:
+        if align == "left":
+            cells.append(":---")
+        elif align == "center":
+            cells.append(":---:")
+        elif align == "right":
+            cells.append("---:")
+        else:
+            cells.append("---")
+    return "| " + " | ".join(cells) + " |"
+
+
+def _render_table_cell(renderer: MarkdownRenderer, token: Dict[str, Any], state: BlockState) -> str:
+    if "children" in token:
+        text = renderer.render_children(token, state)
+    else:
+        text = cast(str, token.get("raw", ""))
+    return text.replace("\n", " ").replace("|", "\\|").strip()
+
+
+def _table_cell_align(token: Dict[str, Any]) -> Any:
+    return token.get("attrs", {}).get("align")

src/mistune/renderers/rst.py

@@ -3,7 +3,7 @@
 
 from ..core import BaseRenderer, BlockState
 from ..util import strip_end
-from ._list import render_list
+from ._list import render_list, render_list_item
 
 
 class RSTRenderer(BaseRenderer):
@@ -147,3 +147,11 @@ def block_error(self, token: Dict[str, Any], state: BlockState) -> str:
 
     def list(self, token: Dict[str, Any], state: BlockState) -> str:
         return render_list(self, token, state)
+
+    def list_item(self, token: Dict[str, Any], state: BlockState) -> str:
+        return render_list_item(self, token, state)
+
+    def task_list_item(self, token: Dict[str, Any], state: BlockState) -> str:
+        checked = token.get("attrs", {}).get("checked")
+        marker = "[x] " if checked else "[ ] "
+        return render_list_item(self, token, state, marker)

tests/test_renderers.py

@@ -81,3 +81,35 @@ def render_wiki(renderer, key, title):
             renderer.render_token(token, BlockState()),
             '<a href="/wiki/python">Python</a>',
         )
+
+
+class TestMarkdownRendererPlugins(TestCase):
+    def test_task_list_item_can_be_overridden(self):
+        class MyRenderer(MarkdownRenderer):
+            def task_list_item(self, token, state):
+                return "TASK\n"
+
+        md = create_markdown(renderer=MyRenderer(), plugins=["task_lists"])
+        self.assertEqual(md("- [x] a task"), "TASK\n")
+
+    def test_task_list_item_default_markdown(self):
+        md = create_markdown(renderer=MarkdownRenderer(), plugins=["task_lists"])
+        self.assertEqual(md("- [x] a task"), "- [x] a task\n")
+
+    def test_table_markdown(self):
+        md = create_markdown(renderer=MarkdownRenderer(), plugins=["table"])
+        result = md("| A | B |\n|---|---|\n| 1 | 2 |\n")
+        self.assertEqual(result, "| A | B |\n| --- | --- |\n| 1 | 2 |\n")
+
+    def test_standalone_list_item(self):
+        renderer = MarkdownRenderer()
+        token = {
+            "type": "list_item",
+            "children": [
+                {
+                    "type": "paragraph",
+                    "children": [{"type": "text", "raw": "x"}],
+                }
+            ],
+        }
+        self.assertEqual(renderer.render_token(token, BlockState()), "- x\n\n")