⬆️ UPDATE: Sync with mdformat 0.6.0 (tree rendering) (#7)

Author: hukkinj1

.github/workflows/tests.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9.0-rc.1]
+        python-version: [3.6, 3.7, 3.8, 3.9]
         os: [ubuntu-latest, windows-latest]
 
     steps:

.pre-commit-config.yaml

@@ -1,29 +1,29 @@
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v3.2.0
+  rev: v3.4.0
   hooks:
   - id: end-of-file-fixer
   - id: mixed-line-ending
   - id: trailing-whitespace
   - id: check-yaml
   - id: check-toml
 - repo: https://github.com/pre-commit/pygrep-hooks
-  rev: v1.6.0
+  rev: v1.8.0
   hooks:
   - id: python-check-blanket-noqa
 - repo: https://github.com/timothycrosley/isort
-  rev: 5.5.3
+  rev: 5.6.4
   hooks:
   - id: isort
 - repo: https://github.com/psf/black
   rev: 20.8b1
   hooks:
   - id: black
 - repo: https://gitlab.com/pycqa/flake8
-  rev: 3.8.3
+  rev: 3.8.4
   hooks:
   - id: flake8
     additional_dependencies:
-    - flake8-bugbear==20.1.4
+    - flake8-bugbear==20.11.1
     - flake8-builtins==1.5.3
-    - flake8-comprehensions==3.2.3
+    - flake8-comprehensions==3.3.1

.pre-commit-test.yaml

@@ -1,11 +1,12 @@
+# A pre-commit hook for testing unreleased changes.
+# This is a system hook that will NOT be given a virtual environment.
+# Thus you will need to `pip install .` before running.
 repos:
   - repo: local
     hooks:
     - id: mdformat
-      name: mdformat
+      name: mdformat-no-venv
       entry: mdformat
       files: "tests/pre-commit-test.md"
       types: [markdown]
       language: system
-      additional_dependencies:
-        - mdformat-tables

mdformat_tables/__init__.py

@@ -1,5 +1,5 @@
 """An mdformat plugin for rendering tables."""
 
-from .plugin import render_token, update_mdit  # noqa: F401
-
 __version__ = "0.2.1"
+
+from .plugin import RENDERER_FUNCS, update_mdit  # noqa: F401

mdformat_tables/plugin.py

@@ -1,9 +1,9 @@
 from collections import OrderedDict
-from typing import List, Optional, Tuple
+from typing import Any, List, Mapping, MutableMapping
 
 from markdown_it import MarkdownIt
-from markdown_it.token import Token
-from mdformat.renderer import MARKERS, MDRenderer
+from mdformat.renderer import RenderTreeNode
+from mdformat.renderer.typing import RendererFunc
 
 
 def update_mdit(mdit: MarkdownIt) -> None:
@@ -12,26 +12,18 @@ def update_mdit(mdit: MarkdownIt) -> None:
 
 
 def _parse_cells(
-    rows: List[List[List[Token]]], renderer: MDRenderer, options: dict, env: dict
+    rows: List[List[RenderTreeNode]],
+    renderer_funcs: Mapping[str, RendererFunc],
+    options: Mapping[str, Any],
+    env: MutableMapping,
 ) -> List[List[str]]:
-    """Convert tokens in each cell to strings."""
-    for i, row in enumerate(rows):
-        for j, cell_tokens in enumerate(row):
-            rows[i][j] = (
-                renderer.render(
-                    [Token("paragraph_open", "p", 1)] + cell_tokens
-                    or [Token("text", "", 0)] + [Token("paragraph_close", "p", -1)],
-                    options,
-                    env,
-                    finalize=False,
-                )
-                .replace(MARKERS.BLOCK_SEPARATOR, "")
-                .rstrip()
-            )
-    return rows
+    """Convert nodes in each cell to strings."""
+    return [[cell.render(renderer_funcs, options, env) for cell in row] for row in rows]
 
 
-def _to_string(rows: List[List[str]], align: List[str], widths: dict) -> List[str]:
+def _to_string(
+    rows: List[List[str]], align: List[List[str]], widths: Mapping[int, int]
+) -> List[str]:
     lines = []
     lines.append(
         "| "
@@ -63,57 +55,54 @@ def _to_string(rows: List[List[str]], align: List[str], widths: dict) -> List[st
     return lines
 
 
-def render_token(
-    renderer: MDRenderer,
-    tokens: List[Token],
-    index: int,
-    options: dict,
-    env: dict,
-) -> Optional[Tuple[str, int]]:
-    """Convert token(s) to a string, or return None if no render method available.
-
-    :returns: (text, index) where index is of the final "consumed" token
-    """
-    if tokens[index].type != "table_open":
-        return None
-
-    # gather all cell tokens into row * column array
-    rows = []
-    align = []
-    while index < len(tokens) and tokens[index].type != "table_close":
-        index += 1
-        if tokens[index].type == "tr_open":
-            rows.append([])
-            align.append([])
-            continue
-        for tag in ["th", "td"]:
-            if tokens[index].type != f"{tag}_open":
-                continue
-            rows[-1].append([])
-            style = tokens[index].attrGet("style") or ""
-            if "text-align:right" in style:
-                align[-1].append(">")
-            elif "text-align:left" in style:
-                align[-1].append("<")
-            elif "text-align:center" in style:
-                align[-1].append("^")
-            else:
-                align[-1].append("")
-            while index < len(tokens) and tokens[index].type != f"{tag}_close":
-                index += 1
-                rows[-1][-1].append(tokens[index])
+def _render_table(
+    node: RenderTreeNode,
+    renderer_funcs: Mapping[str, RendererFunc],
+    options: Mapping[str, Any],
+    env: MutableMapping,
+) -> str:
+    """Render a `RenderTreeNode` of type "table"."""
+    # gather all cell nodes into row * column array
+    rows: List[List[RenderTreeNode]] = []
+    align: List[List[str]] = []
+
+    def _gather_cell_nodes(node: RenderTreeNode) -> None:
+        """Recursively gather cell nodes and alignment to `rows` and
+        `align`."""
+        for child in node.children:
+            if child.type == "tr":
+                rows.append([])
+                align.append([])
+            elif child.type in ("th", "td"):
+                style = child.attrs.get("style") or ""
+                if "text-align:right" in style:
+                    align[-1].append(">")
+                elif "text-align:left" in style:
+                    align[-1].append("<")
+                elif "text-align:center" in style:
+                    align[-1].append("^")
+                else:
+                    align[-1].append("")
+                inline_node = child.children[0]
+                rows[-1].append(inline_node)
+            _gather_cell_nodes(child)
+
+    _gather_cell_nodes(node)
 
     # parse all cells
-    rows = _parse_cells(rows, renderer, options, env)
+    parsed_rows = _parse_cells(rows, renderer_funcs, options, env)
 
     # work out the widths for each column
-    widths = OrderedDict()
-    for row in rows:
+    widths: MutableMapping[int, int] = OrderedDict()
+    for row in parsed_rows:
         for j, cell_text in enumerate(row):
             widths[j] = max(widths.get(j, 3), len(cell_text))
 
     # write content
     # note: assuming always one header row
-    lines = _to_string(rows, align, widths)
+    lines = _to_string(parsed_rows, align, widths)
+
+    return "\n".join(lines)
+
 
-    return "\n".join(lines) + MARKERS.BLOCK_SEPARATOR, index
+RENDERER_FUNCS: Mapping[str, RendererFunc] = {"table": _render_table}

pyproject.toml

@@ -17,7 +17,7 @@ classifiers = [
 keywords = "mdformat,markdown,markdown-it"
 
 requires-python=">=3.6"
-requires=["mdformat>=0.3.2,<0.6.0"]
+requires=["mdformat>=0.6.0,<0.7.0"]
 
 [tool.flit.metadata.requires-extra]
 test = [