mkdocs2confluence 0.18.0__tar.gz → 0.19.0__tar.gz

{mkdocs2confluence-0.18.0/src/mkdocs2confluence.egg-info → mkdocs2confluence-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.18.0
+Version: 0.19.0
 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
@@ -28,14 +28,14 @@ Requires-Dist: httpx>=0.28
 Requires-Dist: idna>=3.18
 Requires-Dist: tinycss2>=1.5.1
 Provides-Extra: pdf
-Requires-Dist: weasyprint>=69.0; extra == "pdf"
+Requires-Dist: weasyprint>=70.0; extra == "pdf"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
-Requires-Dist: bandit; extra == "dev"
+Requires-Dist: bandit[sarif]; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Dynamic: license-file

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.18.0"
+version = "0.19.0"
 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" }
@@ -44,7 +44,7 @@ Changelog = "https://github.com/jeckyl2010/mkdocs2confluence/releases"
 
 [project.optional-dependencies]
 pdf = [
-  "weasyprint>=69.0",
+  "weasyprint>=70.0",
 ]
 dev = [
   "pytest",
@@ -52,7 +52,7 @@ dev = [
   "ruff",
   "mypy",
   "types-PyYAML",
-  "bandit",
+  "bandit[sarif]",
   "build",
   "pre-commit",
 ]
@@ -74,7 +74,22 @@ where = ["src"]
 line-length = 120
 
 [tool.ruff.lint]
-select = ["E", "F", "I"]
+# S = flake8-bandit (security), B = flake8-bugbear (likely bugs).
+select = ["E", "F", "I", "S", "B"]
+ignore = [
+  # Deliberate throughout: best-effort side effects (content hashes, managed-page
+  # stamps) whose failure is self-healing on the next run. Each site says so.
+  "S110",  # try-except-pass
+  # Fixed argument lists only — `git log` in the footer transform and the macOS
+  # DYLD self-re-exec in cli.py. No user input reaches a subprocess.
+  "S603", "S606", "S607",
+  # Retry jitter in http_retry.py, not a security context.
+  "S311",
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Tests assert freely and use throwaway credentials in fixtures.
+"tests/**" = ["S101", "S105", "S106", "S107"]
 
 [tool.mypy]
 strict = true
@@ -104,7 +119,7 @@ exclude_lines = [
 ]
 
 # Architecture boundaries — enforces the compile pipeline stage separation
-# documented in .github/copilot-instructions.md. Higher layers may import lower
+# documented in AGENTS.md. Higher layers may import lower
 # ones; siblings joined by "|" must stay independent of each other.
 [tool.importlinter]
 root_package = "mkdocs_to_confluence"

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0/src/mkdocs2confluence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.18.0
+Version: 0.19.0
 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
@@ -28,14 +28,14 @@ Requires-Dist: httpx>=0.28
 Requires-Dist: idna>=3.18
 Requires-Dist: tinycss2>=1.5.1
 Provides-Extra: pdf
-Requires-Dist: weasyprint>=69.0; extra == "pdf"
+Requires-Dist: weasyprint>=70.0; extra == "pdf"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
-Requires-Dist: bandit; extra == "dev"
+Requires-Dist: bandit[sarif]; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Dynamic: license-file

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs2confluence.egg-info/requires.txt

@@ -9,9 +9,9 @@ pytest-cov
 ruff
 mypy
 types-PyYAML
-bandit
+bandit[sarif]
 build
 pre-commit
 
 [pdf]
-weasyprint>=69.0
+weasyprint>=70.0

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/cli.py

@@ -274,7 +274,7 @@ def _build_parser() -> argparse.ArgumentParser:
             "Detected targets (all installed when no --tool given):\n"
             "  hermes        ~/.hermes/skills/tooling/mkdocs-changelog/SKILL.md\n"
             "  github-skills .github/skills/tooling/mkdocs-changelog/SKILL.md\n"
-            "  claude        .claude/commands/changelog.md  (frontmatter stripped)\n"
+            "  claude        .claude/commands/mk2conf-changelog.md  (frontmatter stripped)\n"
             "  copilot       .github/instructions/mk2conf-changelog.instructions.md\n"
             "  cursor        .cursor/rules/mk2conf-changelog.mdc\n"
             "\n"

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/loader/config.py

@@ -154,7 +154,11 @@ def load_config(mkdocs_yml: Path) -> MkDocsConfig:
         raise FileNotFoundError(f"mkdocs.yml not found: {mkdocs_yml}")
 
     with mkdocs_yml.open(encoding="utf-8") as fh:
-        raw: object = yaml.load(fh, Loader=_make_env_loader())  # nosec B506
+        # B506 is suppressed below because _make_env_loader() returns a
+        # yaml.SafeLoader subclass — this is a safe load. Bandit cannot resolve the
+        # loader through the function call, so it assumes the worst. Removing the
+        # suppression reintroduces a medium-severity finding that fails CI.
+        raw: object = yaml.load(fh, Loader=_make_env_loader())  # noqa: S506  # nosec B506
 
     if not isinstance(raw, dict):
         raise ConfigError("mkdocs.yml must be a YAML mapping at the top level.")
@@ -276,7 +280,7 @@ def load_config(mkdocs_yml: Path) -> MkDocsConfig:
                     raise ConfigError(
                         f"mkdocs.yml: 'confluence.changelog' path {cl_str!r} "
                         "escapes docs_dir. The path must be relative to the docs directory."
-                    )
+                    ) from None
                 changelog_file = cl_str
 
         # exclude_properties (optional) — raw front matter keys to omit from

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/parser/markdown.py

@@ -256,7 +256,7 @@ _FENCE_OPEN_RE = re.compile(r"^(?P<fence>`{3,}|~{3,})(?P<info>.*)$")
 
 # Matches an admonition opener:  !!! kind  /  !!! kind "title"  /  ??? kind  /  ???+ kind
 _ADMONITION_RE = re.compile(
-    r"""^(?P<marker>!{3}|\?{3}\+?)\s+(?P<kind>\w+)(?:\s+(?P<q>["'])(?P<title>.*?)(?P=q))?$"""
+    r"""^[ ]{0,3}(?P<marker>!{3}|\?{3}\+?)\s+(?P<kind>\w+)(?:\s+(?P<q>["'])(?P<title>.*?)(?P=q))?\s*$"""
 )
 
 # Matches a Material for MkDocs content tab opener:  === "Label"
@@ -296,39 +296,129 @@ _FOOTNOTE_REF_RE = re.compile(r'^\[\^(?P<label>[^\]]+)\]')
 # Matches a definition list definition line:  :   text
 _DEFLIST_DEF_RE = re.compile(r'^:\s+(?P<text>.+)$')
 
-# Matches <div class="grid cards" markdown> (with or without quotes around class value).
-_GRID_CARD_DIV_RE = re.compile(
-    r'^\s*<div\b[^>]*\bclass=["\'][^"\']*\bgrid\s+cards\b[^"\']*["\'][^>]*>\s*$',
+# Matches any <div ... class="..."> opener, capturing the class list.  Material has
+# two grid flavours: ``grid cards`` (each list item / admonition is a card) and a
+# plain ``grid`` (each top-level block is one grid item).
+_DIV_CLASS_RE = re.compile(
+    r'^\s*<div\b[^>]*\bclass=["\'](?P<classes>[^"\']*)["\'][^>]*>\s*$',
     re.IGNORECASE,
 )
+# Any <div> opener, used only for nesting depth so an inner div cannot close the grid.
+_ANY_DIV_OPEN_RE = re.compile(r'^\s*<div\b[^>]*>\s*$', re.IGNORECASE)
 _CLOSE_DIV_RE = re.compile(r'^\s*</div>\s*$', re.IGNORECASE)
 
+# An attr-list line opting a block into card styling:  { .card }
+_CARD_ATTR_RE = re.compile(r'^\s*\{:?\s*\.card\b[^}]*\}\s*$')
 
-def _tokenize_grid_cards(inner_lines: list[str]) -> _GridCardsToken:
-    """Convert the inner lines of a grid cards div into a ``_GridCardsToken``.
 
-    Two card formats are supported:
+def _grid_kind(line: str) -> str | None:
+    """Return ``"cards"``, ``"grid"``, or ``None`` for a ``<div>`` opener line.
 
-    * **Bullet list** — each list item is one card::
+    ``grid cards`` wins over ``grid``; a div without a ``grid`` class is not ours.
+    """
+    m = _DIV_CLASS_RE.match(line)
+    if m is None:
+        return None
+    classes = m.group("classes").split()
+    if "grid" not in classes:
+        return None
+    return "cards" if "cards" in classes else "grid"
+
+
+# Matches a top-level card bullet (no leading indent): ``- ``, ``* ``, ``+ ``.
+_CARD_BULLET_RE = re.compile(r'^(?P<marker>[-*+]\s+)(?P<text>.*)$')
+
+
+def _expand_leading_tabs(line: str) -> str:
+    """Expand tabs in *line*'s leading whitespace to 4-space tab stops.
+
+    Indent width drives every block decision below, and Markdown counts a tab as
+    4 columns.  Only the indent is touched — tabs inside code or text are content.
+    """
+    stripped = line.lstrip(" \t")
+    indent = line[: len(line) - len(stripped)]
+    return indent.expandtabs(4) + stripped
+
+
+def _split_card_blocks(lines: list[str]) -> list[list[str]] | None:
+    """Split *lines* into one block of lines per top-level bullet.
+
+    The bullet marker is removed from the first line of each block and its
+    continuation lines are dedented by the marker width, so each block reads as
+    standalone Markdown.  Returns ``None`` when there are no top-level bullets,
+    leaving the caller on its non-bullet path.
+    """
+    starts = [
+        (i, m) for i, ln in enumerate(lines) if (m := _CARD_BULLET_RE.match(ln)) is not None
+    ]
+    if not starts:
+        return None
+
+    blocks: list[list[str]] = []
+    for n, (start, m) in enumerate(starts):
+        end = starts[n + 1][0] if n + 1 < len(starts) else len(lines)
+        dedent = len(m.group("marker"))
+        body: list[str] = []
+        for raw in lines[start + 1:end]:
+            ln = _expand_leading_tabs(raw)
+            # Only strip indentation that is actually whitespace; a line that is
+            # under-indented keeps whatever it has rather than losing content.
+            body.append(ln[dedent:] if ln[:dedent].isspace() else ln)
+        blocks.append([m.group("text"), *_strip_insignificant_indent(body)])
+    return blocks
+
+
+def _strip_insignificant_indent(lines: list[str]) -> list[str]:
+    """Remove a common leading indent of 1-3 spaces from *lines*.
+
+    Authors routinely indent card bodies by 4 while the list marker is only 2
+    wide, leaving 2 stray spaces after the marker dedent.  Markdown treats fewer
+    than 4 spaces as insignificant, but our block patterns anchor at ``^``, so
+    those strays would stop a ``---``, a code fence or a heading from being
+    recognised.  An indent of 4+ is left alone: that is what delimits an
+    admonition body, and removing it would detach the body from its opener.
+    """
+    indents = [len(ln) - len(ln.lstrip()) for ln in lines if ln.strip()]
+    common = min(indents, default=0)
+    if not 0 < common < 4:
+        return lines
+    return [ln[common:] if ln.strip() else ln for ln in lines]
+
+
+def _tokenize_grid(inner_lines: list[str], *, kind: str) -> _GridCardsToken:
+    """Convert the inner lines of a Material grid div into a ``_GridCardsToken``.
+
+    *kind* is ``"cards"`` for ``<div class="grid cards">`` or ``"grid"`` for a
+    plain ``<div class="grid">``.  Both map onto the same Confluence layout; they
+    differ only in what counts as one item:
+
+    * ``cards`` — each top-level bullet is a card, and the bullet marker is
+      stripped so the item's own block content (admonition, nested list, code
+      block) parses normally::
 
         - :icon: **Title** — description text
+        - !!! tip "Title"
 
-    * **Admonition list** — each admonition is one card::
+      With no bullets present, each top-level block is a card instead, which is
+      the admonition-list form::
 
         !!! tip "Title"
             Body content
+
+    * ``grid`` — each top-level block is one grid item and keeps its own
+      rendering; a bullet list is a single item, not one item per bullet.
+      ``{ .card }`` styling hints are dropped, having no Confluence equivalent.
     """
-    inner_tokens = _tokenize("\n".join(inner_lines))
+    if kind == "cards":
+        blocks = _split_card_blocks(inner_lines)
+        if blocks is not None:
+            return _GridCardsToken(cards=[_tokenize("\n".join(b)) for b in blocks])
+    else:
+        inner_lines = [ln for ln in inner_lines if not _CARD_ATTR_RE.match(ln)]
 
-    # Bullet list: each item becomes a card (a single paragraph).
-    if len(inner_tokens) == 1 and isinstance(inner_tokens[0], _BulletListToken):
-        cards: list[list[_Token]] = [
-            [_ParagraphToken(lines=[item.text])]
-            for item in inner_tokens[0].items
-        ]
-        return _GridCardsToken(cards=cards)
+    inner_tokens = _tokenize("\n".join(inner_lines))
 
-    # All other cases: each top-level token is one card.
+    # Each top-level token is one item.
     return _GridCardsToken(cards=[[tok] for tok in inner_tokens])
 
 
@@ -344,13 +434,15 @@ def _tokenize(text: str) -> list[_Token]:
     while i < len(lines):
         line = lines[i]
 
-        # ── Grid cards div ───────────────────────────────────────────────────
-        if _GRID_CARD_DIV_RE.match(line):
+        # ── Grid div (``grid cards`` or plain ``grid``) ──────────────────────
+        grid_kind = _grid_kind(line)
+        if grid_kind is not None:
             i += 1
             inner_lines: list[str] = []
             depth = 1
             while i < len(lines) and depth > 0:
-                if _GRID_CARD_DIV_RE.match(lines[i]):
+                # Any nested <div> must be counted, or its </div> closes the grid early.
+                if _ANY_DIV_OPEN_RE.match(lines[i]):
                     depth += 1
                 elif _CLOSE_DIV_RE.match(lines[i]):
                     depth -= 1
@@ -360,7 +452,7 @@ def _tokenize(text: str) -> list[_Token]:
                 if depth > 0:
                     inner_lines.append(lines[i])
                 i += 1
-            tokens.append(_tokenize_grid_cards(inner_lines))
+            tokens.append(_tokenize_grid(inner_lines, kind=grid_kind))
             continue
 
         # ── Fenced code block ────────────────────────────────────────────────
@@ -1207,7 +1299,9 @@ def _build_tree(
             def _make_cell(
                 text: str, col: int, is_header: bool = False
             ) -> TableCell:
-                align = aligns[col] if col < len(aligns) else None
+                # B023 is suppressed below: _make_cell is defined and fully consumed
+                # inside a single loop iteration, so aligns cannot be rebound under it.
+                align = aligns[col] if col < len(aligns) else None  # noqa: B023
                 return TableCell(
                     children=_parse_inline(text, fn_map=_fn),
                     align=align,

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/preprocess/includes.py

@@ -294,7 +294,7 @@ def _parse_spec(
             raise IncludeError(
                 f"{source_path}:{lineno}: named-section includes are not yet "
                 f"supported: {raw_spec!r}"
-            )
+            ) from None
         if start < 1 or end < start:
             raise IncludeError(
                 f"{source_path}:{lineno}: invalid line range {start}:{end} "

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/publisher/client.py

@@ -7,6 +7,7 @@ Authentication is HTTP Basic with email + API token.
 from __future__ import annotations
 
 import base64
+from functools import partial
 from pathlib import Path
 from typing import Any, cast
 from urllib.parse import parse_qs, urlparse
@@ -378,7 +379,9 @@ class ConfluenceClient:
                 name = lbl.get("name", "")
                 if name:
                     http_request_with_retry(
-                        lambda: self._http.delete(label_url, params={"name": name}),
+                        # partial binds name now; a closure would late-bind and could
+                        # delete the wrong label if the helper ever defers the call.
+                        partial(self._http.delete, label_url, params={"name": name}),
                         f"set_page_labels({page_id!r})",
                     )
 

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/skill_installer.py

@@ -90,13 +90,13 @@ def install_skill(
             dest.write_text(content_body, encoding="utf-8")
             installed.append(("claude", dest))
 
-    # GitHub Copilot — project-level, body only as .instructions.md
+    # GitHub Copilot — .instructions.md needs applyTo frontmatter or Copilot ignores it
     if _want("copilot"):
         copilot_marker = project_dir / ".github" / "copilot-instructions.md"
         if explicit or copilot_marker.exists():
             dest = project_dir / ".github" / "instructions" / "mk2conf-changelog.instructions.md"
             dest.parent.mkdir(parents=True, exist_ok=True)
-            dest.write_text(content_body, encoding="utf-8")
+            dest.write_text(f'---\napplyTo: "**"\n---\n\n{content_body}', encoding="utf-8")
             installed.append(("copilot", dest))
 
     # Cursor — project-level, body as .mdc

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/transforms/_kroki.py

@@ -53,7 +53,10 @@ def kroki_post(source: str, diagram_type: str, kroki_url: str, fmt: str = "png")
     """POST *source* to Kroki for *diagram_type* and return rendered bytes."""
     url = f"{kroki_url.rstrip('/')}/{diagram_type}/{fmt}"
     body = source.encode("utf-8")
-    req = urllib.request.Request(
+    # kroki_url comes from config, so the scheme is not attacker-controlled, but it is
+    # also not validated. Switching this to httpx (already a dependency) would restrict
+    # it to http/https and remove the urllib import entirely.
+    req = urllib.request.Request(  # noqa: S310
         url,
         data=body,
         headers={

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/src/mkdocs_to_confluence/transforms/mermaid.py

@@ -62,7 +62,7 @@ def _mermaid_ink_png(source: str) -> bytes:
     compressed = zlib.compress(payload.encode("utf-8"))
     encoded = base64.urlsafe_b64encode(compressed).decode().rstrip("=")
     url = f"{_MERMAID_INK_URL}/img/pako:{encoded}?type=png"
-    req = urllib.request.Request(url, headers={"User-Agent": "mk2conf/1.0"})
+    req = urllib.request.Request(url, headers={"User-Agent": "mk2conf/1.0"})  # noqa: S310
     with urllib.request.urlopen(req, timeout=_TIMEOUT) as resp:  # noqa: S310  # nosec B310
         return cast(bytes, resp.read())
 

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/tests/test_parser.py

@@ -1460,3 +1460,211 @@ class TestAnchorNode:
         assert '<ac:link ac:anchor="section-1">' in xhtml
         assert 'ac:structured-macro ac:name="anchor"' in xhtml
         assert "section-1" in xhtml
+
+
+class TestAdmonitionOpenerWhitespace:
+    """Opener lines survive trailing whitespace and <=3 spaces of indent."""
+
+    @pytest.mark.parametrize("opener", [
+        '!!! abstract "Description"',
+        '!!! abstract "Description" ',      # trailing space
+        '   !!! abstract "Description"',    # 3-space indent
+        '??? tip "T"  ',
+    ])
+    def test_opener_variants_parse(self, opener: str) -> None:
+        nodes = parse(f"{opener}\n\n    Body text.\n")
+        assert isinstance(nodes[0], Admonition), f"failed for {opener!r}"
+
+    def test_four_space_indent_is_not_an_admonition(self) -> None:
+        """4 spaces is an indented code block, not an opener."""
+        nodes = parse("text\n\n    !!! abstract \"x\"\n")
+        assert not any(isinstance(n, Admonition) for n in nodes)
+
+
+class TestGridCardAdmonitions:
+    """`- !!! kind "Title"` inside grid cards is a card, not raw paragraph text."""
+
+    DIV = '<div class="grid cards" markdown>\n\n'
+    END = '\n</div>\n'
+
+    def _emit(self, body: str) -> str:
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        return emit(parse(self.DIV + body + self.END))
+
+    def test_bulleted_admonitions_become_admonition_cards(self) -> None:
+        xhtml = self._emit(
+            '- !!! abstract "Description"\n        This is a test\n\n'
+            '- !!! note "Test me"\n        This is hello\n'
+        )
+        assert "!!!" not in xhtml, "admonition opener leaked as raw text"
+        assert xhtml.count('ac:structured-macro ac:name="info"') == 2
+        assert xhtml.count("<ac:layout-cell>") == 2
+        assert "This is a test" in xhtml and "This is hello" in xhtml
+
+    def test_card_body_may_contain_a_bullet_list(self) -> None:
+        """A nested list inside a card must not disable admonition detection."""
+        xhtml = self._emit('- !!! tip "T"\n\n      - one\n      - two\n')
+        assert "!!!" not in xhtml
+        assert 'ac:structured-macro ac:name="tip"' in xhtml
+        assert "<li><p>one</p></li>" in xhtml
+
+    def test_icon_cards_and_admonition_cards_can_mix(self) -> None:
+        xhtml = self._emit('- :material-cog: **Setup**\n\n- !!! tip "T"\n\n      Body.\n')
+        assert "!!!" not in xhtml
+        assert "<strong>Setup</strong>" in xhtml
+        assert 'ac:structured-macro ac:name="tip"' in xhtml
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_card_body_may_contain_a_code_block(self) -> None:
+        xhtml = self._emit('- !!! tip "T"\n\n      ```python\n      x = 1\n      ```\n')
+        assert 'ac:name="code"' in xhtml
+        assert "x = 1" in xhtml
+
+    def test_icon_cards_are_left_alone(self) -> None:
+        xhtml = self._emit('- :material-cog: **Setup**\n- :material-run: **Run**\n')
+        assert "ac:structured-macro" not in xhtml
+        assert "<strong>Setup</strong>" in xhtml
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_icon_card_keeps_its_description_paragraph(self) -> None:
+        xhtml = self._emit('- :material-cog: **Setup**\n\n    Description text.\n')
+        assert "Description text." in xhtml
+
+    def test_non_admonition_triple_marker_stays_literal(self) -> None:
+        """`!?!` is not an admonition marker and must render as text."""
+        assert "!?!" in self._emit('- !?! not an admonition\n')
+
+
+class TestGenericGrid:
+    """`<div class="grid">` — each top-level block is one grid item."""
+
+    def _emit(self, src: str) -> str:
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        return emit(parse(src))
+
+    def _grid(self, body: str, classes: str = "grid") -> str:
+        return f'<div class="{classes}" markdown>\n\n{body}\n</div>\n'
+
+    def test_admonitions_become_grid_items(self) -> None:
+        xhtml = self._emit(self._grid(
+            '!!! tip "A"\n\n    Body A\n\n!!! note "B"\n\n    Body B\n'
+        ))
+        assert "&lt;div" not in xhtml, "grid div leaked as literal text"
+        assert xhtml.count("<ac:layout-cell>") == 2
+        assert 'ac:structured-macro ac:name="tip"' in xhtml
+
+    def test_bullet_list_is_one_item_not_one_per_bullet(self) -> None:
+        """The `cards` card-splitting must not apply to a plain grid."""
+        xhtml = self._emit(self._grid("- one\n- two\n"))
+        assert xhtml.count("<ac:layout-cell>") == 1
+        assert "<li><p>one</p></li>" in xhtml
+
+    def test_card_attr_list_is_dropped(self) -> None:
+        """`{ .card }` is a styling hint with no Confluence equivalent."""
+        xhtml = self._emit(self._grid(
+            "**HTML** for structure\n{ .card }\n\n**JS** for logic\n{ .card }\n"
+        ))
+        assert ".card" not in xhtml
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_grid_cards_still_splits_on_bullets(self) -> None:
+        """Regression guard: `grid cards` keeps one-card-per-bullet."""
+        xhtml = self._emit(self._grid("- one\n- two\n", classes="grid cards"))
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_class_order_does_not_matter(self) -> None:
+        xhtml = self._emit(self._grid("- one\n- two\n", classes="cards grid"))
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_extra_classes_are_tolerated(self) -> None:
+        xhtml = self._emit(self._grid("- one\n- two\n", classes="grid cards custom"))
+        assert xhtml.count("<ac:layout-cell>") == 2
+
+    def test_div_without_grid_class_is_not_a_grid(self) -> None:
+        xhtml = self._emit('<div class="note" markdown>\n\ntext\n\n</div>\n')
+        assert "ac:layout" not in xhtml
+
+    def test_nested_div_does_not_close_the_grid_early(self) -> None:
+        """An inner </div> must not terminate the grid and strand later items."""
+        xhtml = self._emit(self._grid(
+            '<div class="x">\n</div>\n\n!!! tip "A"\n\n    Body\n'
+        ))
+        assert 'ac:structured-macro ac:name="tip"' in xhtml, "item after nested div was lost"
+
+
+class TestGridCardBodyBlocks:
+    """Card bodies keep block structure; a 2-space marker dedent must not break it."""
+
+    def _emit(self, body: str) -> str:
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        return emit(parse(f'<div class="grid cards" markdown>\n\n{body}\n</div>\n'))
+
+    def test_separator_becomes_a_rule(self) -> None:
+        """Material's canonical card syntax uses `---` as a divider."""
+        xhtml = self._emit("- **T**\n\n    ---\n\n    Body.\n")
+        assert "<hr/>" in xhtml
+        assert "<p>---</p>" not in xhtml
+
+    def test_code_fence_stays_a_code_block(self) -> None:
+        xhtml = self._emit("- **T**\n\n    ```python\n    x = 1\n    ```\n")
+        assert 'ac:name="code"' in xhtml
+        assert "<![CDATA[x = 1]]>" in xhtml
+        assert "<code>python" not in xhtml, "fence collapsed into inline code"
+
+    def test_heading_in_card_body(self) -> None:
+        xhtml = self._emit("- **T**\n\n    ## Sub\n\n    Body.\n")
+        assert "<h2>Sub</h2>" in xhtml
+
+    def test_admonition_body_indent_is_preserved(self) -> None:
+        """4+ spaces delimit an admonition body and must survive the dedent."""
+        xhtml = self._emit('- !!! tip "T"\n\n      - one\n      - two\n')
+        assert 'ac:structured-macro ac:name="tip"' in xhtml
+        # The list must be *inside* the panel, not a sibling after it.
+        body = xhtml.split("<ac:rich-text-body>")[1]
+        assert "<li><p>one</p></li>" in body.split("</ac:rich-text-body>")[0]
+
+    def test_material_canonical_complex_example(self) -> None:
+        """The example straight from the Material grids reference page."""
+        xhtml = self._emit(
+            "- :material-clock-fast:{ .lg .middle } __Set up in 5 minutes__\n\n"
+            "    ---\n\n"
+            "    Install it and get up and running in minutes\n\n"
+            "- :fontawesome-brands-markdown:{ .lg .middle } __It's just Markdown__\n\n"
+            "    ---\n\n"
+            "    Focus on your content\n"
+        )
+        assert xhtml.count("<ac:layout-cell>") == 2
+        assert xhtml.count("<hr/>") == 2
+        assert "Set up in 5 minutes" in xhtml and "Focus on your content" in xhtml
+
+
+class TestGridCardIndentEdgeCases:
+    """Marker width and tab indentation must not detach a card's body."""
+
+    def _emit(self, body: str) -> str:
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        return emit(parse(f'<div class="grid cards" markdown>\n\n{body}\n</div>\n'))
+
+    def _panel_body(self, xhtml: str) -> str:
+        return xhtml.split("<ac:rich-text-body>")[1].split("</ac:rich-text-body>")[0]
+
+    def test_tab_indented_admonition_body_stays_inside_the_panel(self) -> None:
+        xhtml = self._emit('- !!! tip "T"\n\n\t\tBody.\n')
+        assert "Body." in self._panel_body(xhtml), "tab-indented body escaped the panel"
+
+    def test_tab_indented_code_fence_in_card(self) -> None:
+        xhtml = self._emit("- **T**\n\n\t```python\n\tx = 1\n\t```\n")
+        assert "<![CDATA[x = 1]]>" in xhtml
+
+    def test_wide_marker_keeps_separator(self) -> None:
+        xhtml = self._emit("-   **T**\n\n    ---\n\n    Body.\n")
+        assert "<hr/>" in xhtml
+
+    def test_wide_marker_keeps_admonition_body(self) -> None:
+        xhtml = self._emit('-   !!! tip "T"\n\n        Body.\n')
+        assert "Body." in self._panel_body(xhtml)
+
+    def test_crlf_line_endings(self) -> None:
+        src = '<div class="grid cards" markdown>\r\n\r\n- !!! tip "T"\r\n\r\n      Body.\r\n\r\n</div>\r\n'
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        assert "Body." in self._panel_body(emit(parse(src)))

{mkdocs2confluence-0.18.0 → mkdocs2confluence-0.19.0}/tests/test_skill_installer.py

@@ -64,6 +64,8 @@ def test_install_skill_copilot(tmp_path: Path) -> None:
     assert dest.name == "mk2conf-changelog.instructions.md"
     content = dest.read_text(encoding="utf-8")
     assert "name: mkdocs-changelog" not in content
+    # Copilot ignores .instructions.md files without applyTo frontmatter
+    assert content.startswith('---\napplyTo: "**"\n---\n\n# MkDocs Changelog Entry')
 
 
 def test_install_skill_cursor(tmp_path: Path) -> None: