mkdocs2confluence 0.16.0__tar.gz → 0.16.1__tar.gz

{mkdocs2confluence-0.16.0/src/mkdocs2confluence.egg-info → mkdocs2confluence-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.16.0
+Version: 0.16.1
 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.16.0 → mkdocs2confluence-0.16.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.16.0"
+version = "0.16.1"
 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.16.0 → mkdocs2confluence-0.16.1/src/mkdocs2confluence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.16.0
+Version: 0.16.1
 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.16.0 → mkdocs2confluence-0.16.1}/src/mkdocs_to_confluence/compiler/page.py

@@ -8,7 +8,7 @@ from mkdocs_to_confluence.ir.nodes import ChildrenMacro, FrontMatter, SourceFoot
 from mkdocs_to_confluence.loader.config import MkDocsConfig
 from mkdocs_to_confluence.loader.nav import NavNode
 from mkdocs_to_confluence.loader.page import load_page
-from mkdocs_to_confluence.parser.markdown import parse
+from mkdocs_to_confluence.parser.markdown import parse, parse_inline
 from mkdocs_to_confluence.preprocess.abbrevs import (
     extract_abbreviations,
     strip_abbreviation_defs,
@@ -79,7 +79,9 @@ def compile_page(
     ir_nodes = strip_links_in_admonition_titles(ir_nodes, node.docs_path or "")
     if is_section_index:
         ir_nodes = ir_nodes + (ChildrenMacro(),)
-    ir_nodes = apply_abbreviations(ir_nodes, abbrevs, page_text=preprocessed)
+    # Parse definitions as inline markdown so links etc. survive into the glossary.
+    parsed_abbrevs = {abbr: parse_inline(defn) for abbr, defn in abbrevs.items()}
+    ir_nodes = apply_abbreviations(ir_nodes, parsed_abbrevs, page_text=preprocessed)
     ir_nodes, attachments = resolve_local_assets(
         ir_nodes,
         page_path=node.source_path,

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/src/mkdocs_to_confluence/emitter/xhtml.py

@@ -623,11 +623,11 @@ def _emit_abbrev_glossary_block(node: AbbrevGlossaryBlock) -> str:
             f"</ac:structured-macro>"
         )
         abbr = html.escape(fn.abbr)
-        defn = html.escape(fn.definition)
+        defn = _emit_inlines(fn.definition)
         parts.append(f"<li>{anchor_macro}<strong>{abbr}</strong> — {defn}</li>\n")
-    for abbr, defn in node.extras:
+    for fn in node.extras:
         # No anchor — these only appeared in headings/titles, no inline superscript links here.
-        parts.append(f"<li><strong>{html.escape(abbr)}</strong> — {html.escape(defn)}</li>\n")
+        parts.append(f"<li><strong>{html.escape(fn.abbr)}</strong> — {_emit_inlines(fn.definition)}</li>\n")
     parts.append("</ol>\n")
     return "".join(parts)
 

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/src/mkdocs_to_confluence/ir/nodes.py

@@ -497,11 +497,16 @@ class AbbrevFootnoteNode(IRNode):
 
     The emitter renders ``ABBR<sup>[N]</sup>`` where ``[N]`` links to the
     corresponding entry in the end-of-page :class:`AbbrevGlossaryBlock`.
+
+    ``definition`` holds the definition text parsed as inline IR nodes so
+    that links and other inline formatting survive into the glossary.
     """
 
     abbr: str
-    definition: str
-    number: int  # 1-based, assigned by the transform in order of first encounter
+    definition: tuple[IRNode, ...]
+    # 1-based, assigned by the transform in order of first encounter.
+    # ``None`` for glossary-only entries (no inline superscript, no anchor).
+    number: int | None
 
 
 @dataclass(frozen=True)
@@ -509,17 +514,17 @@ class AbbrevGlossaryBlock(IRNode):
     """End-of-page abbreviations reference block.
 
     Rendered as a numbered list (with Confluence anchor targets for the
-    back-links) followed by an optional bullet list of abbreviations that
-    only appeared in headings or other non-expandable contexts.
+    back-links) followed by entries for abbreviations that only appeared
+    in headings or other non-expandable contexts.
 
     Attributes:
         footnoted: Abbreviations annotated inline, ordered by first encounter.
-        extras:    ``(abbr, definition)`` pairs for abbreviations that could
+        extras:    Entries (``number=None``) for abbreviations that could
                    not be annotated inline, sorted alphabetically.
     """
 
     footnoted: tuple[AbbrevFootnoteNode, ...]
-    extras: tuple[tuple[str, str], ...]
+    extras: tuple[AbbrevFootnoteNode, ...]
 
 
 # ── Footnotes ────────────────────────────────────────────────────────────────

mkdocs2confluence-0.16.1/src/mkdocs_to_confluence/parser/__init__.py

@@ -0,0 +1,5 @@
+"""Markdown parser: convert preprocessed markdown text into IR nodes."""
+
+from mkdocs_to_confluence.parser.markdown import parse, parse_inline
+
+__all__ = ["parse", "parse_inline"]

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/src/mkdocs_to_confluence/parser/markdown.py

@@ -111,6 +111,16 @@ def parse(text: str) -> tuple[IRNode, ...]:
     return _build_tree(tokens)
 
 
+def parse_inline(text: str) -> tuple[IRNode, ...]:
+    """Parse a standalone snippet of inline markdown into IR inline nodes.
+
+    Used for one-line fragments that live outside the main document flow,
+    e.g. abbreviation definitions, where links and other inline formatting
+    must still be honoured.
+    """
+    return _parse_inline(text)
+
+
 # ── Internal token types ──────────────────────────────────────────────────────
 
 

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/src/mkdocs_to_confluence/transforms/abbrevs.py

@@ -65,7 +65,7 @@ _BLOCK_TYPES = (
 class _State:
     """Mutable transform state threaded through the recursive walk."""
 
-    def __init__(self, abbrevs: dict[str, str]) -> None:
+    def __init__(self, abbrevs: dict[str, tuple[IRNode, ...]]) -> None:
         self.abbrevs = abbrevs
         self._expanded_list: list[str] = []  # ordered by first encounter
         self._expanded_set: set[str] = set()  # fast membership test
@@ -207,7 +207,7 @@ def _transform_inline(node: IRNode, state: _State, safe: bool) -> tuple[IRNode,
 # ── Glossary builder ──────────────────────────────────────────────────────────
 
 
-def _find_mentioned(text: str, abbrevs: dict[str, str]) -> set[str]:
+def _find_mentioned(text: str, abbrevs: dict[str, tuple[IRNode, ...]]) -> set[str]:
     """Return abbreviations that appear as whole words anywhere in *text*."""
     return {
         abbr
@@ -221,7 +221,7 @@ def _find_mentioned(text: str, abbrevs: dict[str, str]) -> set[str]:
 
 def apply_abbreviations(
     nodes: tuple[IRNode, ...],
-    abbrevs: dict[str, str],
+    abbrevs: dict[str, tuple[IRNode, ...]],
     *,
     page_text: str = "",
 ) -> tuple[IRNode, ...]:
@@ -229,8 +229,12 @@ def apply_abbreviations(
 
     Args:
         nodes:      Top-level IR nodes returned by :func:`parse`.
-        abbrevs:    ``{abbreviation: definition}`` mapping, typically from
-                    :func:`~mkdocs_to_confluence.preprocess.abbrevs.extract_abbreviations`.
+        abbrevs:    ``{abbreviation: definition}`` mapping where each
+                    definition is parsed inline IR nodes (the caller parses
+                    the raw definition strings from
+                    :func:`~mkdocs_to_confluence.preprocess.abbrevs.extract_abbreviations`
+                    with :func:`~mkdocs_to_confluence.parser.parse_inline` so
+                    links and other inline formatting are preserved).
         page_text:  The preprocessed page text (after stripping abbreviation
                     definition lines) used to detect which abbreviations are
                     actually present on the page.
@@ -255,7 +259,7 @@ def apply_abbreviations(
         for i, abbr in enumerate(state._expanded_list)
     )
     extras = tuple(
-        (abbr, abbrevs[abbr])
+        AbbrevFootnoteNode(abbr=abbr, definition=abbrevs[abbr], number=None)
         for abbr in sorted(mentioned - state._expanded_set)
     )
 

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/tests/test_abbrevs.py

@@ -8,6 +8,7 @@ from mkdocs_to_confluence.ir.nodes import (
     Admonition,
     BoldNode,
     CodeBlock,
+    IRNode,
     LinkNode,
     Paragraph,
     Section,
@@ -16,11 +17,25 @@ from mkdocs_to_confluence.ir.nodes import (
     TableRow,
     TextNode,
 )
+from mkdocs_to_confluence.parser import parse_inline
 from mkdocs_to_confluence.preprocess.abbrevs import (
     extract_abbreviations,
     strip_abbreviation_defs,
 )
-from mkdocs_to_confluence.transforms.abbrevs import apply_abbreviations
+from mkdocs_to_confluence.transforms.abbrevs import (
+    apply_abbreviations as _apply_abbreviations,
+)
+
+
+def apply_abbreviations(
+    nodes: tuple[IRNode, ...],
+    abbrevs: dict[str, str],
+    *,
+    page_text: str = "",
+) -> tuple[IRNode, ...]:
+    """Parse string definitions inline (as the compiler does) and apply."""
+    parsed = {abbr: parse_inline(defn) for abbr, defn in abbrevs.items()}
+    return _apply_abbreviations(nodes, parsed, page_text=page_text)
 
 # ── extract_abbreviations ─────────────────────────────────────────────────────
 
@@ -94,7 +109,7 @@ def test_expands_first_occurrence_as_footnote():
     fn = children[1]
     assert isinstance(fn, AbbrevFootnoteNode)
     assert fn.abbr == "IAM"
-    assert fn.definition == "Identity and Access Management"
+    assert fn.definition == (TextNode("Identity and Access Management"),)
     assert fn.number == 1
     # Second occurrence left as plain text
     assert isinstance(children[2], TextNode)
@@ -141,7 +156,10 @@ def test_glossary_block_appended_for_heading_only_abbrev():
     glossary = result[1]
     assert isinstance(glossary, AbbrevGlossaryBlock)
     assert len(glossary.footnoted) == 0
-    assert glossary.extras == (("IAM", "Identity and Access Management"),)
+    assert len(glossary.extras) == 1
+    assert glossary.extras[0].abbr == "IAM"
+    assert glossary.extras[0].definition == (TextNode("Identity and Access Management"),)
+    assert glossary.extras[0].number is None
 
 
 def test_no_glossary_when_abbrev_footnoted_inline():
@@ -232,7 +250,7 @@ def test_extras_sorted_alphabetically():
     result = apply_abbreviations((section,), abbrevs, page_text="IAM and RBAC Overview")
     glossary = result[-1]
     assert isinstance(glossary, AbbrevGlossaryBlock)
-    extra_abbrs = [abbr for abbr, _ in glossary.extras]
+    extra_abbrs = [fn.abbr for fn in glossary.extras]
     assert extra_abbrs == sorted(extra_abbrs)
 
 
@@ -254,3 +272,29 @@ def test_expands_in_loose_list_item():
     result = apply_abbreviations(nodes, abbrevs, page_text="Use the API here.")
     para_children = result[0].items[0].children[0].children  # type: ignore[union-attr]
     assert any(isinstance(c, AbbrevFootnoteNode) and c.abbr == "API" for c in para_children)
+
+
+# ── Markdown in definitions ──────────────────────────────────────────────────
+
+
+def test_definition_with_link_parsed_to_link_node():
+    abbrevs = {"FB": "The [Foo](http://forr.bar) service"}
+    nodes = (_para("Use FB here."),)
+    result = apply_abbreviations(nodes, abbrevs, page_text="Use FB here.")
+    glossary = result[-1]
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    definition = glossary.footnoted[0].definition
+    links = [n for n in definition if isinstance(n, LinkNode)]
+    assert len(links) == 1
+    assert links[0].href == "http://forr.bar"
+    assert links[0].children == (TextNode("Foo"),)
+
+
+def test_extra_definition_with_link_parsed_to_link_node():
+    abbrevs = {"FB": "The [Foo](http://forr.bar) service"}
+    section = Section(level=2, anchor="fb", title=(TextNode("FB Platform"),), children=())
+    result = apply_abbreviations((section,), abbrevs, page_text="FB Platform")
+    glossary = result[-1]
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    definition = glossary.extras[0].definition
+    assert any(isinstance(n, LinkNode) and n.href == "http://forr.bar" for n in definition)

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.16.1}/tests/test_emitter.py

@@ -474,10 +474,10 @@ class TestFootnoteEmitter:
         """Abbreviations only in headings/titles must appear in <ol>, not <ul>."""
         from mkdocs_to_confluence.emitter.xhtml import emit
         from mkdocs_to_confluence.ir.nodes import AbbrevFootnoteNode, AbbrevGlossaryBlock
-        fn = AbbrevFootnoteNode(abbr="API", definition="Application Programming Interface", number=1)
+        fn = AbbrevFootnoteNode(abbr="API", definition=(TextNode("Application Programming Interface"),), number=1)
         block = AbbrevGlossaryBlock(
             footnoted=(fn,),
-            extras=(("AD", "Active Directory"),),
+            extras=(AbbrevFootnoteNode(abbr="AD", definition=(TextNode("Active Directory"),), number=None),),
         )
         out = emit((block,))
         assert "<ol>" in out
@@ -488,6 +488,22 @@ class TestFootnoteEmitter:
         # extras must NOT get an anchor macro
         assert out.count('ac:name="anchor"') == 1  # only for the footnoted entry
 
+    def test_abbrev_glossary_definition_with_link(self) -> None:
+        """A markdown link in a definition must render as an <a>, not raw text."""
+        from mkdocs_to_confluence.ir.nodes import AbbrevFootnoteNode, AbbrevGlossaryBlock
+        defn = (
+            TextNode("The "),
+            LinkNode(href="http://forr.bar", children=(TextNode("Foo"),)),
+            TextNode(" service"),
+        )
+        block = AbbrevGlossaryBlock(
+            footnoted=(AbbrevFootnoteNode(abbr="FB", definition=defn, number=1),),
+            extras=(AbbrevFootnoteNode(abbr="BZ", definition=defn, number=None),),
+        )
+        out = emit((block,))
+        assert out.count('<a href="http://forr.bar">Foo</a>') == 2
+        assert "[Foo]" not in out
+
 
 # ── Inline HTML emitters ──────────────────────────────────────────────────────
 

mkdocs2confluence-0.16.0/src/mkdocs_to_confluence/parser/__init__.py

@@ -1,5 +0,0 @@
-"""Markdown parser: convert preprocessed markdown text into IR nodes."""
-
-from mkdocs_to_confluence.parser.markdown import parse
-
-__all__ = ["parse"]