termrender 4.3.1__tar.gz → 4.3.2__tar.gz

{termrender-4.3.1 → termrender-4.3.2}/CHANGELOG.md

@@ -1,6 +1,26 @@
 # CHANGELOG
 
 
+## v4.3.2 (2026-07-06)
+
+### Bug Fixes
+
+- **mermaid**: Strip %% comments/directives from journey/mindmap/timeline
+  ([`d61f113`](https://github.com/crouton-labs/termrender/commit/d61f113cf750c9379f00825e2f6fc7b3898e7b8f))
+
+The dispatcher (mermaid.py) only used strip_prelude_lines() for type sniffing, then passed the
+  untouched original source to the native renderers, so a leading %%{init}%% directive or a mid-body
+  %% comment leaked into rendered output as fake tree nodes, task rows, or timeline events in the
+  journey/mindmap/timeline renderers.
+
+- mermaid.py: pass prelude-stripped source to the three native renderers; the Go-binary fallback
+  path keeps receiving the raw source untouched. - mermaid_journey.py, mermaid_mindmap.py,
+  mermaid_timeline.py: skip %%-prefixed lines anywhere in the body, not just the leading prelude,
+  mirroring mermaid_sequence.py's existing handling.
+
+Adds regression tests pinning each confirmed repro to render nothing from the comment/directive.
+
+
 ## v4.3.1 (2026-07-06)
 
 ### Bug Fixes

{termrender-4.3.1 → termrender-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 4.3.1
+Version: 4.3.2
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender

{termrender-4.3.1 → termrender-4.3.2}/src/termrender/renderers/mermaid.py

@@ -139,6 +139,16 @@ def _first_line_type(source: str) -> str:
     return first.lower()
 
 
+def _stripped(source: str) -> str:
+    """Return ``source`` with its leading prelude (comments/directives/
+    frontmatter) removed, for native renderers that don't otherwise skip it.
+
+    The Go-binary fallback path (``_render_via_binary``) must keep receiving
+    the untouched original source — its behavior stays byte-for-byte.
+    """
+    return "\n".join(strip_prelude_lines(source.splitlines()))
+
+
 def _render_via_binary(source: str) -> str:
     """Render via the vendored mermaid-ascii binary, falling back to source.
 
@@ -182,11 +192,11 @@ def render_mermaid_lines(source: str, width: int) -> list[str]:
     if diagram_type.startswith("sequencediagram"):
         return mermaid_sequence.render_sequence(source, width)
     if diagram_type.startswith("mindmap"):
-        return mermaid_mindmap.render(source, width)
+        return mermaid_mindmap.render(_stripped(source), width)
     if diagram_type.startswith("journey"):
-        return mermaid_journey.render(source, width)
+        return mermaid_journey.render(_stripped(source), width)
     if diagram_type.startswith("timeline"):
-        return mermaid_timeline.render(source, width)
+        return mermaid_timeline.render(_stripped(source), width)
     return _render_via_binary(source).split("\n")
 
 

{termrender-4.3.1 → termrender-4.3.2}/src/termrender/renderers/mermaid_journey.py

@@ -40,7 +40,8 @@ def parse_journey(source: str) -> dict:
     still captured with ``score=None``; a non-numeric score is likewise
     tolerated (``score=None``) rather than raising. A task line before any
     ``section`` header lands in an unnamed leading section. Sections with
-    no tasks are dropped.
+    no tasks are dropped. ``%%`` comment and directive lines are skipped
+    wherever they appear in the body, not just in the leading prelude.
 
     Returns ``{"title": str | None, "sections": [{"name": str | None,
     "tasks": [{"name": str, "score": int | None, "actors": list[str]}]}]}``.
@@ -51,6 +52,8 @@ def parse_journey(source: str) -> dict:
     for line in source.splitlines():
         if not line.strip() or _HEADER_RE.match(line):
             continue
+        if line.strip().startswith("%%"):
+            continue
 
         m = _TITLE_RE.match(line)
         if m:

{termrender-4.3.1 → termrender-4.3.2}/src/termrender/renderers/mermaid_mindmap.py

@@ -64,12 +64,14 @@ def _node_label(text: str) -> str:
 def parse_mindmap(source: str) -> str:
     """Parse mermaid mindmap syntax into ``tree.py``'s plain indented format.
 
-    Drops the ``mindmap`` header line and any ``::icon(...)``/``:::class``
-    decoration lines (termrender's tree has no icon/class concept); every
-    other line's original indentation is preserved (depth comes from
-    indentation, exactly as ``tree.py`` already expects) with its node-shape
-    delimiters stripped down to label text. Returns the transformed
-    multi-line indented string, empty if nothing survived.
+    Drops the ``mindmap`` header line, any ``%%`` comment/directive line
+    (wherever it appears in the body, not just in the leading prelude), and
+    any ``::icon(...)``/``:::class`` decoration lines (termrender's tree has
+    no icon/class concept); every other line's original indentation is
+    preserved (depth comes from indentation, exactly as ``tree.py`` already
+    expects) with its node-shape delimiters stripped down to label text.
+    Returns the transformed multi-line indented string, empty if nothing
+    survived.
     """
     out_lines: list[str] = []
     for raw_line in source.splitlines():
@@ -78,6 +80,8 @@ def parse_mindmap(source: str) -> str:
         if _HEADER_RE.match(raw_line):
             continue
         stripped = raw_line.strip()
+        if stripped.startswith("%%"):
+            continue
         if _ICON_RE.match(stripped) or _CLASS_RE.match(stripped):
             continue
         indent = raw_line[: len(raw_line) - len(raw_line.lstrip(" "))]

{termrender-4.3.1 → termrender-4.3.2}/src/termrender/renderers/mermaid_timeline.py

@@ -44,7 +44,8 @@ def parse_timeline(source: str) -> dict:
 
     Returns ``{"title": str | None, "sections": [{"name": str | None,
     "entries": [{"date": str, "event": str}]}]}``. Sections with no
-    entries are dropped.
+    entries are dropped. ``%%`` comment and directive lines are skipped
+    wherever they appear in the body, not just in the leading prelude.
     """
     title: str | None = None
     sections: list[dict] = [{"name": None, "entries": []}]
@@ -53,6 +54,8 @@ def parse_timeline(source: str) -> dict:
     for line in source.splitlines():
         if not line.strip() or _HEADER_RE.match(line):
             continue
+        if line.strip().startswith("%%"):
+            continue
 
         m = _TITLE_RE.match(line)
         if m:

{termrender-4.3.1 → termrender-4.3.2}/tests/test_mermaid_dispatch.py

@@ -190,6 +190,36 @@ class TestMermaidDispatch(unittest.TestCase):
         self.assertIn("Launch", joined)
         self.assertIn("●", joined)
 
+    def test_init_directive_does_not_leak_into_journey_output(self):
+        # Regression: the dispatcher must pass prelude-stripped source to
+        # the native journey renderer, not just use the prelude for sniffing.
+        src = (
+            '%%{init: {"theme": "dark"}}%%\n'
+            "journey\n"
+            "  title T\n"
+            "  section S\n"
+            "    Task: 4: Me\n"
+        )
+        joined = "\n".join(mermaid.render_mermaid_lines(src, 60))
+        self.assertNotIn("init", joined)
+        self.assertNotIn("theme", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Task", joined)
+
+    def test_init_directive_does_not_leak_into_mindmap_output(self):
+        src = '%%{init: {"theme": "dark"}}%%\nmindmap\n  root\n    Origins\n'
+        joined = "\n".join(mermaid.render_mermaid_lines(src, 60))
+        self.assertNotIn("init", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Origins", joined)
+
+    def test_init_directive_does_not_leak_into_timeline_output(self):
+        src = '%%{init: {"theme": "dark"}}%%\ntimeline\n    2024 : Launch\n'
+        joined = "\n".join(mermaid.render_mermaid_lines(src, 60))
+        self.assertNotIn("init", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Launch", joined)
+
 
 if __name__ == "__main__":
     unittest.main()

{termrender-4.3.1 → termrender-4.3.2}/tests/test_mermaid_journey.py

@@ -59,6 +59,29 @@ class TestParseJourney(unittest.TestCase):
         parsed = parse_journey("journey\n    title Empty Journey\n")
         self.assertEqual(parsed["sections"], [])
 
+    def test_init_directive_before_header_skipped(self):
+        parsed = parse_journey(
+            '%%{init: {"theme": "dark"}}%%\n'
+            "journey\n"
+            "    title T\n"
+            "    section S\n"
+            "    Task: 4: Me\n"
+        )
+        self.assertEqual(parsed["title"], "T")
+        self.assertEqual(len(parsed["sections"]), 1)
+        self.assertEqual(parsed["sections"][0]["tasks"], [{"name": "Task", "score": 4, "actors": ["Me"]}])
+
+    def test_mid_body_comment_skipped(self):
+        parsed = parse_journey(
+            "journey\n"
+            "    section S\n"
+            "    Task: 4: Me\n"
+            "    %% mid comment: 3: X\n"
+            "    Other: 2: Me\n"
+        )
+        names = [t["name"] for t in parsed["sections"][0]["tasks"]]
+        self.assertEqual(names, ["Task", "Other"])
+
 
 class TestRenderJourney(unittest.TestCase):
 
@@ -123,6 +146,40 @@ class TestRenderJourney(unittest.TestCase):
             if ln:
                 self.assertEqual(visual_len(ln), 50)
 
+    def test_init_directive_produces_no_fake_task_row(self):
+        # Regression: a leading %%{init}%% directive must not leak into the
+        # rendered output as a garbled task row.
+        src = (
+            '%%{init: {"theme": "dark"}}%%\n'
+            "journey\n"
+            "  title T\n"
+            "  section S\n"
+            "    Task: 4: Me\n"
+        )
+        lines = render_journey(src, width=40)
+        joined = "\n".join(lines)
+        self.assertNotIn("init", joined)
+        self.assertNotIn("theme", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Task", joined)
+
+    def test_mid_body_comment_produces_no_fake_task_row(self):
+        # Regression: a %% comment line anywhere in the body must not
+        # render as a task with stars.
+        src = (
+            "journey\n"
+            "    section S\n"
+            "    Task: 4: Me\n"
+            "    %% mid comment: 3: X\n"
+            "    Other: 2: Me\n"
+        )
+        lines = render_journey(src, width=40)
+        joined = "\n".join(lines)
+        self.assertNotIn("comment", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Task", joined)
+        self.assertIn("Other", joined)
+
 
 if __name__ == "__main__":
     unittest.main()

{termrender-4.3.1 → termrender-4.3.2}/tests/test_mermaid_mindmap.py

@@ -66,6 +66,18 @@ class TestParseMindmap(unittest.TestCase):
     def test_only_header_yields_empty(self):
         self.assertEqual(parse_mindmap("mindmap\n"), "")
 
+    def test_indented_comment_line_dropped(self):
+        out = parse_mindmap("mindmap\n  root\n    %% a comment\n    Origins\n")
+        self.assertNotIn("comment", out)
+        self.assertNotIn("%%", out)
+        self.assertIn("Origins", out)
+
+    def test_init_directive_before_header_dropped(self):
+        out = parse_mindmap('%%{init: {"theme": "dark"}}%%\nmindmap\n  root\n    Origins\n')
+        self.assertNotIn("init", out)
+        self.assertNotIn("%%", out)
+        self.assertIn("Origins", out)
+
 
 class TestRenderMindmap(unittest.TestCase):
 
@@ -110,6 +122,16 @@ class TestRenderMindmap(unittest.TestCase):
             if ln:
                 self.assertEqual(visual_len(ln), 45)
 
+    def test_indented_comment_produces_no_fake_tree_node(self):
+        # Regression: an indented %% comment line must not render as a
+        # tree node.
+        src = "mindmap\n  root\n    %% a comment\n    Origins\n"
+        lines = render_mindmap(src, width=40)
+        joined = "\n".join(lines)
+        self.assertNotIn("comment", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("Origins", joined)
+
 
 if __name__ == "__main__":
     unittest.main()

{termrender-4.3.1 → termrender-4.3.2}/tests/test_mermaid_timeline.py

@@ -53,6 +53,23 @@ class TestParseTimeline(unittest.TestCase):
         parsed = parse_timeline("timeline\n    title Empty\n")
         self.assertEqual(parsed["sections"], [])
 
+    def test_comment_line_skipped(self):
+        parsed = parse_timeline(
+            "timeline\n    2002 : LinkedIn\n    %% comment : fake\n    2004 : Facebook\n"
+        )
+        entries = parsed["sections"][0]["entries"]
+        self.assertEqual(
+            entries,
+            [{"date": "2002", "event": "LinkedIn"}, {"date": "2004", "event": "Facebook"}],
+        )
+
+    def test_init_directive_before_header_skipped(self):
+        parsed = parse_timeline(
+            '%%{init: {"theme": "dark"}}%%\ntimeline\n    2002 : LinkedIn\n'
+        )
+        entries = parsed["sections"][0]["entries"]
+        self.assertEqual(entries, [{"date": "2002", "event": "LinkedIn"}])
+
 
 class TestRenderTimeline(unittest.TestCase):
 
@@ -102,6 +119,17 @@ class TestRenderTimeline(unittest.TestCase):
             if ln:
                 self.assertEqual(visual_len(ln), 50)
 
+    def test_comment_produces_no_fake_timeline_event(self):
+        # Regression: a %% comment line must not render as a timeline event.
+        src = "timeline\n    2002 : LinkedIn\n    %% comment : fake\n    2004 : Facebook\n"
+        lines = render_timeline(src, width=40)
+        joined = "\n".join(lines)
+        self.assertNotIn("comment", joined)
+        self.assertNotIn("fake", joined)
+        self.assertNotIn("%%", joined)
+        self.assertIn("LinkedIn", joined)
+        self.assertIn("Facebook", joined)
+
 
 if __name__ == "__main__":
     unittest.main()