mkdocs2confluence 0.10.1__tar.gz → 0.10.2__tar.gz

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.10.1
+Version: 0.10.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.10.1"
+version = "0.10.2"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/src/mkdocs2confluence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.10.1
+Version: 0.10.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/emitter/xhtml.py

@@ -422,15 +422,19 @@ def _emit_task_item(item: ListItem) -> str:
 
 
 def _emit_list_item(item: ListItem) -> str:
-    if any(isinstance(c, _LIST_BLOCK_TYPES) for c in item.children):
-        # Loose list item: children are block nodes (e.g. nested list or paragraph).
-        inner = emit(item.children)
-        return f"  <li>{inner.strip()}</li>\n"
-    # Tight list item: children are inline nodes.  Confluence requires a <p>
-    # wrapper inside <li> for structured inline macros (e.g. <ac:link>) to
-    # render — without it they are silently stripped by the storage parser.
-    inner = _emit_inlines(item.children)
-    return f"  <li><p>{inner}</p></li>\n"
+    first_block = next(
+        (i for i, c in enumerate(item.children) if isinstance(c, _LIST_BLOCK_TYPES)), None
+    )
+    if first_block is None:
+        # All inline — standard tight rendering.
+        inner = _emit_inlines(item.children)
+        return f"  <li><p>{inner}</p></li>\n"
+    # Mixed: inline prefix (if any) wrapped in <p>, followed by block children.
+    parts: list[str] = []
+    if first_block > 0:
+        parts.append(f"<p>{_emit_inlines(item.children[:first_block])}</p>\n")
+    parts.append(emit(item.children[first_block:]))
+    return f"  <li>{''.join(parts).strip()}</li>\n"
 
 
 def _emit_table(node: Table) -> str:

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/src/mkdocs_to_confluence/parser/markdown.py

@@ -158,6 +158,7 @@ class _BlockQuoteToken:
 class _ListItemData:
     text: str
     task: bool | None = None  # None=regular, True=checked, False=unchecked
+    sub_tokens: list[_Token] = field(default_factory=list)
 
 
 @dataclass
@@ -501,7 +502,8 @@ def _tokenize(text: str) -> list[_Token]:
                     task = task_m.group("state").lower() == "x"
                     item_text = task_m.group("rest")
                 i += 1
-                # Collect continuation lines (non-blank, non-list) into this item.
+                # Collect continuation and indented sub-list lines.
+                sub_lines: list[str] = []
                 while i < len(lines) and lines[i].strip():
                     cont = lines[i]
                     bullet_m = _BULLET_RE.match(cont)
@@ -510,9 +512,18 @@ def _tokenize(text: str) -> list[_Token]:
                         ordered_m2 and not ordered_m2.group("indent")
                     ):
                         break
-                    item_text = item_text.rstrip() + " " + cont.strip()
+                    if (bullet_m and bullet_m.group("indent")) or (
+                        ordered_m2 and ordered_m2.group("indent")
+                    ) or sub_lines:
+                        sub_lines.append(cont)
+                    else:
+                        item_text = item_text.rstrip() + " " + cont.strip()
                     i += 1
-                list_items.append(_ListItemData(text=item_text, task=task))
+                _sub: list[_Token] = []
+                if sub_lines:
+                    _ind = min(len(ln) - len(ln.lstrip()) for ln in sub_lines if ln.strip())
+                    _sub = _tokenize("\n".join(ln[_ind:] for ln in sub_lines))
+                list_items.append(_ListItemData(text=item_text, task=task, sub_tokens=_sub))
             tokens.append(_BulletListToken(items=list_items))
             continue
 
@@ -537,7 +548,8 @@ def _tokenize(text: str) -> list[_Token]:
                     break
                 item_text = om.group("text")
                 i += 1
-                # Collect continuation lines (non-blank, non-list) into this item.
+                # Collect continuation and indented sub-list lines.
+                sub_lines_ord: list[str] = []
                 while i < len(lines) and lines[i].strip():
                     cont = lines[i]
                     ordered_m3 = _ORDERED_RE.match(cont)
@@ -546,9 +558,18 @@ def _tokenize(text: str) -> list[_Token]:
                         bullet_m2 and not bullet_m2.group("indent")
                     ):
                         break
-                    item_text = item_text.rstrip() + " " + cont.strip()
+                    if (ordered_m3 and ordered_m3.group("indent")) or (
+                        bullet_m2 and bullet_m2.group("indent")
+                    ) or sub_lines_ord:
+                        sub_lines_ord.append(cont)
+                    else:
+                        item_text = item_text.rstrip() + " " + cont.strip()
                     i += 1
-                ord_items.append(_ListItemData(text=item_text))
+                _sub_ord: list[_Token] = []
+                if sub_lines_ord:
+                    _ind_ord = min(len(ln) - len(ln.lstrip()) for ln in sub_lines_ord if ln.strip())
+                    _sub_ord = _tokenize("\n".join(ln[_ind_ord:] for ln in sub_lines_ord))
+                ord_items.append(_ListItemData(text=item_text, sub_tokens=_sub_ord))
             tokens.append(_OrderedListToken(start=start, items=ord_items))
             continue
 
@@ -1030,6 +1051,32 @@ class _OpenSection:
     children: list[IRNode] = field(default_factory=list)
 
 
+def _build_sub_list_nodes(tokens: list[_Token], fn_map: dict[str, int] | None) -> tuple[IRNode, ...]:
+    """Recursively convert sub-list tokens (from indented continuation) to IR nodes."""
+    nodes: list[IRNode] = []
+    for token in tokens:
+        if isinstance(token, _BulletListToken):
+            items = tuple(
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=fn_map)
+                    + _build_sub_list_nodes(item.sub_tokens, fn_map),
+                    task=item.task,
+                )
+                for item in token.items
+            )
+            nodes.append(BulletList(items=items))
+        elif isinstance(token, _OrderedListToken):
+            items = tuple(
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=fn_map)
+                    + _build_sub_list_nodes(item.sub_tokens, fn_map),
+                )
+                for item in token.items
+            )
+            nodes.append(OrderedList(items=items, start=token.start))
+    return tuple(nodes)
+
+
 def _build_tree(
     tokens: list[_Token],
     fn_map: dict[str, int] | None = None,
@@ -1101,14 +1148,21 @@ def _build_tree(
 
         elif isinstance(token, _BulletListToken):
             items = tuple(
-                ListItem(children=_parse_inline(item.text, fn_map=_fn), task=item.task)
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=_fn)
+                    + _build_sub_list_nodes(item.sub_tokens, _fn),
+                    task=item.task,
+                )
                 for item in token.items
             )
             _append_content(BulletList(items=items), stack, root)
 
         elif isinstance(token, _OrderedListToken):
             items = tuple(
-                ListItem(children=_parse_inline(item.text, fn_map=_fn))
+                ListItem(
+                    children=_parse_inline(item.text, fn_map=_fn)
+                    + _build_sub_list_nodes(item.sub_tokens, _fn),
+                )
                 for item in token.items
             )
             _append_content(OrderedList(items=items, start=token.start), stack, root)

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/tests/test_emitter.py

@@ -235,6 +235,32 @@ class TestListEmitters:
         assert "<ul>" in out
         assert "<ac:task-list>" not in out
 
+    def test_nested_bullet_list(self) -> None:
+        nested = BulletList(items=(ListItem((TextNode("child"),)),))
+        items = (ListItem((TextNode("parent"), nested)),)
+        out = emit((BulletList(items=items),))
+        assert out.count("<ul>") == 2
+        assert out.count("</ul>") == 2
+        assert "<p>parent</p>" in out
+        assert "<p>child</p>" in out
+
+    def test_nested_ordered_list(self) -> None:
+        nested = OrderedList(items=(ListItem((TextNode("sub"),)),))
+        items = (ListItem((TextNode("top"), nested)),)
+        out = emit((OrderedList(items=items),))
+        assert "<ol>" in out
+        assert "<ul>" not in out
+        assert "<p>top</p>" in out
+        assert "<p>sub</p>" in out
+
+    def test_nested_list_no_inline_prefix(self) -> None:
+        """A list item with only a nested sub-list (no inline text) renders cleanly."""
+        nested = BulletList(items=(ListItem((TextNode("only child"),)),))
+        items = (ListItem((nested,)),)
+        out = emit((BulletList(items=items),))
+        assert out.count("<ul>") == 2
+        assert "<p>only child</p>" in out
+
 
 class TestHorizontalRule:
     def test_hr(self) -> None:

{mkdocs2confluence-0.10.1 → mkdocs2confluence-0.10.2}/tests/test_parser.py

@@ -1021,6 +1021,49 @@ class TestListParsing:
         )
         assert "Continuation" in item_text or "First point" in item_text
 
+    def test_nested_bullet_list(self) -> None:
+        md = "- item 1\n  - nested 1\n  - nested 2\n- item 2\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        assert len(bl.items) == 2
+        # First item must have a nested BulletList as a child.
+        nested = next((c for c in bl.items[0].children if isinstance(c, BulletList)), None)
+        assert nested is not None, "expected nested BulletList in first item"
+        assert len(nested.items) == 2
+        assert nested.items[0].children[0].text == "nested 1"  # type: ignore[union-attr]
+        assert nested.items[1].children[0].text == "nested 2"  # type: ignore[union-attr]
+
+    def test_nested_ordered_list(self) -> None:
+        md = "1. first\n   1. sub one\n   2. sub two\n2. second\n"
+        nodes = parse(md)
+        ol = first(nodes, OrderedList)
+        assert isinstance(ol, OrderedList)
+        nested = next((c for c in ol.items[0].children if isinstance(c, OrderedList)), None)
+        assert nested is not None, "expected nested OrderedList in first item"
+        assert len(nested.items) == 2
+
+    def test_deeply_nested_bullet_list(self) -> None:
+        md = "- a\n  - b\n    - c\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        level2 = next((c for c in bl.items[0].children if isinstance(c, BulletList)), None)
+        assert level2 is not None
+        level3 = next((c for c in level2.items[0].children if isinstance(c, BulletList)), None)
+        assert level3 is not None
+        assert level3.items[0].children[0].text == "c"  # type: ignore[union-attr]
+
+    def test_mixed_nested_list(self) -> None:
+        """Bullet list item containing an ordered sub-list."""
+        md = "- item\n  1. sub one\n  2. sub two\n"
+        nodes = parse(md)
+        bl = first(nodes, BulletList)
+        assert isinstance(bl, BulletList)
+        nested_ol = next((c for c in bl.items[0].children if isinstance(c, OrderedList)), None)
+        assert nested_ol is not None
+        assert len(nested_ol.items) == 2
+
 
 # ── Definition list parsing ───────────────────────────────────────────────────