DOP-5110: Convert nested list-tables into nested rows

snooty/n.py

@@ -323,14 +323,29 @@ class DefinitionList(Parent[DefinitionListItem]):
     type = "definitionList"
 
 
+@dataclass
+class Directive(Parent[Node]):
+    __slots__ = ("domain", "name", "argument", "options")
+    type = "directive"
+    domain: str
+    name: str
+    argument: MutableSequence["Text"]
+    options: Dict[str, str]
+
+    def verify(self) -> None:
+        super().verify()
+        for arg in self.argument:
+            arg.verify()
+
+
 @dataclass
 class ListNodeItem(Parent[Node]):
     __slots__ = ()
     type = "listItem"
 
 
 @dataclass
-class ListNode(Parent[ListNodeItem]):
+class ListNode(Parent[Union[ListNodeItem, Directive]]):
     __slots__ = ("enumtype", "startat")
     type = "list"
     enumtype: ListEnumType
@@ -349,21 +364,6 @@ class LineBlock(Parent[Line]):
     type = "line_block"
 
 
-@dataclass
-class Directive(Parent[Node]):
-    __slots__ = ("domain", "name", "argument", "options")
-    type = "directive"
-    domain: str
-    name: str
-    argument: MutableSequence["Text"]
-    options: Dict[str, str]
-
-    def verify(self) -> None:
-        super().verify()
-        for arg in self.argument:
-            arg.verify()
-
-
 class TocTreeDirectiveEntry(NamedTuple):
     title: Optional[str]
     url: Optional[str]

snooty/postprocess.py

@@ -2143,6 +2143,72 @@ def exit_page(self, fileid_stack: FileIdStack, page: Page) -> None:
             page.ast.children.remove(node)
 
 
+class ListTableHandler(Handler):
+    def __init__(self, context: Context) -> None:
+        super().__init__(context)
+
+    def __identify_expandable_content(self, node: n.Directive) -> None:
+        # List tables have nested list nodes and list items, so we attempt to destructure them
+        # .. table::
+        #    .. list:: <row list>
+        #       .. list-item:: <row>
+        #          .. list:: <cell list>
+        #             .. list-item:: <cell>
+
+        list_node = node.children[0]
+        assert isinstance(list_node, n.ListNode)
+        rows = list_node.children
+
+        # Need to determine if any cell in a row has a nested table. If that's the case, any list-table, and any sibling
+        # after it, will be in a nested row directive
+        for row in rows:
+            list_node = row.children[0]
+            assert isinstance(list_node, n.ListNode)
+            cells = list_node.children
+            nested_row_cells: MutableSequence[n.Node] = []
+            found_nested_list_table = False
+
+            for cell in cells:
+                nested_row_cell_content: MutableSequence[n.Node] = []
+                nested_list_table_index = next(
+                    (
+                        i
+                        for i, cell_content_node in enumerate(cell.children)
+                        if isinstance(cell_content_node, n.Directive)
+                        and cell_content_node.name == "list-table"
+                    ),
+                    -1,
+                )
+                if cell.children and nested_list_table_index > -1:
+                    nested_row_cell_content = cell.children[nested_list_table_index:]
+                    cell.children = cell.children[:nested_list_table_index]
+                    found_nested_list_table = True
+
+                nested_row_cell = n.Directive(
+                    (0,), nested_row_cell_content, "mongodb", "cell", [], {}
+                )
+                nested_row_cells.append(nested_row_cell)
+
+            if found_nested_list_table:
+                # We append a nested row to the end of the cells to simulate the rST structure:
+                # .. table::
+                #    .. row::
+                #       .. cell::
+                #          Content
+                #       .. row:: (nested)
+                #          ...
+                #    .. row::
+                nested_row = n.Directive(
+                    (0,), nested_row_cells, "mongodb", "row", [], {}
+                )
+                cells.append(nested_row)
+
+    def enter_node(self, fileid_stack: FileIdStack, node: n.Node) -> None:
+        if not isinstance(node, n.Directive) or node.name != "list-table":
+            return
+        self.__identify_expandable_content(node)
+
+
 class PostprocessorResult(NamedTuple):
     pages: Dict[FileId, Page]
     metadata: Dict[str, SerializableType]
@@ -2213,6 +2279,7 @@ class Postprocessor:
             WayfindingHandler,
             MethodSelectorHandler,
             MultiPageTutorialHandler,
+            ListTableHandler,
         ],
         [TargetHandler, IAHandler, NamedReferenceHandlerPass1],
         [RefsHandler, NamedReferenceHandlerPass2],