termrender 4.10.0__tar.gz → 4.10.1__tar.gz

{termrender-4.10.0 → termrender-4.10.1}/CHANGELOG.md

@@ -1,6 +1,30 @@
 # CHANGELOG
 
 
+## v4.10.1 (2026-07-07)
+
+### Bug Fixes
+
+- **mermaid-flow**: Constant inter-layer gap regardless of node height
+  ([`eb1726f`](https://github.com/crouton-labs/termrender/commit/eb1726fa4bd05a57d29026b10715edc067ac4113))
+
+The rank-band gap override that widens spacing to fit a labeled edge scaled with visual_len(label)
+  (the label's *text width*) even on TB/BT diagrams, where the label is drawn horizontally across a
+  vertical connector and only ever needs one clear row, not one row per character. Since ER/class
+  diagrams route almost every edge through a label (relationship text, cardinality), this made
+  compartmented-node TB layouts burn ~15-17 blank connector rows per edge hop while 1-line-node
+  flowcharts stayed compact — node height was a red herring; the real driver was label width feeding
+  a row count.
+
+_rank_gap_overrides is now direction-aware: LR/RL keeps the width-scaled gap (the transpose turns
+  that native row-band into the final horizontal run the label reads along, so it genuinely needs
+  the width). TB/BT gets a small constant, _LABELED_ROW_GAP=3, regardless of label length.
+
+Updates the two TB labeled-edge goldens in test_mermaid_flow_corpus.py to the new compact spacing,
+  and adds a regression test in test_mermaid_er.py pinning a row budget for compartmented entities
+  so this doesn't regress.
+
+
 ## v4.10.0 (2026-07-07)
 
 ### Features

{termrender-4.10.0 → termrender-4.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 4.10.0
+Version: 4.10.1
 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.10.0 → termrender-4.10.1}/src/termrender/renderers/mermaid_flow_layout.py

@@ -831,24 +831,45 @@ _GAP_X = 3          # minimum border-to-border gap between boxes in one rank/ban
 _ROW_GAP = 2         # minimum gap between rank bands
 _COMPONENT_GUTTER = 4  # gap between independently-laid-out components
 _LABEL_GAP_PAD = 1   # cells of breathing room either side of a label's own text
-                     # when it forces a rank-band gap wider than _ROW_GAP.
+                     # when it forces a rank-band gap wider than _ROW_GAP
+                     # along the axis the label's text actually runs.
+_LABELED_ROW_GAP = 3  # inter-rank gap when a label sits on that band's vertical
+                      # run in *final* screen space (TB/BT): one blank row, the
+                      # label's own row, one more blank row. A constant, not
+                      # scaled by the label's text length — the label reads
+                      # horizontally on a single row regardless of how many
+                      # characters it has, so the row *count* needed is fixed.
 
 
 def _rank_gap_overrides(
-    edges: list[FlowEdge], rank_of: dict[str, int]
+    edges: list[FlowEdge], rank_of: dict[str, int], direction: Direction
 ) -> dict[int, int]:
     """Minimum inter-rank-band gap keyed by the *lower* rank of each
     adjacent-rank transition, widened past ``_ROW_GAP`` wherever a labeled
     edge directly connects that transition's two ranks. A forward edge
     between adjacent ranks routes as a single straight run (or a Z path
     that still crosses the same inter-rank band) whose only clear space is
-    this gap — at the base ``_ROW_GAP`` a label wider than a couple of
-    cells has nowhere to go but onto the boxes it connects, which is
-    exactly the short LR/adjacent-rank clipped-label bug this closes.
+    this gap.
+
+    The rank axis is native rows here, pre-direction-transform (see the
+    adapter docstring) — whether that ends up as *vertical* or
+    *horizontal* space on screen depends on ``direction``. For LR/RL the
+    transpose turns this band into the final horizontal run the label
+    reads along, so it genuinely needs ``visual_len(label)`` cells of
+    width — at the base ``_ROW_GAP`` a label wider than a couple of cells
+    has nowhere to go but onto the boxes it connects (the short
+    LR/adjacent-rank clipped-label bug this closes). For TB/BT the band
+    stays vertical on screen and the label is drawn horizontally *across*
+    the connector column (:func:`_draw_label_on_segment`'s vertical-segment
+    branch) — it needs a little row headroom to have its own clear row,
+    not a row per character, so it gets the small constant
+    ``_LABELED_ROW_GAP`` regardless of the label's length.
+
     Non-adjacent-rank edges (back-edges, multi-rank spans) don't constrain
     the gap here — they route through their own side lane, not this band.
     """
     overrides: dict[int, int] = {}
+    horizontal_on_screen = direction in (Direction.LR, Direction.RL)
     for e in edges:
         if e.src == e.dst or not e.label:
             continue
@@ -859,7 +880,10 @@ def _rank_gap_overrides(
         lo_r, hi_r = (r_src, r_dst) if r_src <= r_dst else (r_dst, r_src)
         if hi_r - lo_r != 1:
             continue
-        needed = visual_len(e.label) + 2 * _LABEL_GAP_PAD
+        if horizontal_on_screen:
+            needed = visual_len(e.label) + 2 * _LABEL_GAP_PAD
+        else:
+            needed = _LABELED_ROW_GAP
         overrides[lo_r] = max(overrides.get(lo_r, _ROW_GAP), needed)
     return overrides
 
@@ -922,7 +946,7 @@ def _place_nodes(
             ranks[sug.grx[v].rank].append(v)
 
         rank_of = {v.data: sug.grx[v].rank for v in comp_vertices}
-        gap_overrides = _rank_gap_overrides(edges, rank_of)
+        gap_overrides = _rank_gap_overrides(edges, rank_of, direction)
 
         band_top_for_rank: dict[int, int] = {}
         cursor = 0

{termrender-4.10.0 → termrender-4.10.1}/tests/test_mermaid_er.py

@@ -265,6 +265,66 @@ def test_order_example_golden_topology():
     assert cust_row < order_row < line_item_row
 
 
+# --------------------------------------------------------------------------
+# Vertical compactness (regression: constant inter-layer gap regardless of
+# node height — see mermaid_flow_layout._LABELED_ROW_GAP)
+# --------------------------------------------------------------------------
+
+
+def test_compartmented_entities_get_constant_gap_not_height_scaled():
+    # Two tall (compartmented) entities joined by one labeled relationship
+    # used to burn ~15-17 blank connector rows for this single edge hop —
+    # the inter-rank gap scaled with the edge label's *text length*
+    # (visual_len), not with node height, but on ER/class diagrams nearly
+    # every edge carries a label, so the effect showed up exactly when
+    # nodes were tall. The gap between adjacent-rank boxes must now stay a
+    # small constant: enough for a connector row, the label's own row, and
+    # one more connector row — independent of both the label's length and
+    # the boxes' height.
+    src = (
+        "erDiagram\n"
+        "    CUSTOMER ||--o{ ORDER : places\n"
+        "    CUSTOMER {\n"
+        "        string name PK\n"
+        "        string email\n"
+        "    }\n"
+        "    ORDER {\n"
+        "        int orderNumber PK\n"
+        "        string status\n"
+        "    }\n"
+    )
+    lines = _lines(src, width=100)
+    assert _has_box_glyphs(lines)
+    joined = "\n".join(lines)
+
+    # Full row budget: two 6-row compartmented boxes plus a small constant
+    # gap between them — well under the ~27 rows the scaling bug produced.
+    assert len(lines) <= 18, f"expected a compact render, got {len(lines)} rows:\n{joined}"
+
+    # The label survives in full, uncorrupted, and every box border row is
+    # single-glyph clean (no overlapping glyphs from a collapsed gap).
+    assert "places" in joined
+    for attr in ("string name PK", "string email", "int orderNumber PK", "string status"):
+        assert attr in joined
+
+    cust_row, _ = _row_col(lines, "CUSTOMER")
+    order_row, _ = _row_col(lines, "ORDER")
+    label_row, _ = _row_col(lines, "places")
+    assert cust_row < label_row < order_row
+
+    # The connector gap between the two boxes is a small constant, not
+    # scaled by the label's width: the blank/connector run directly above
+    # and below the label row is short.
+    cust_bottom = next(
+        r for r in range(cust_row, len(lines)) if "└" in lines[r]
+    )
+    order_top = next(
+        r for r in range(order_row, -1, -1) if "┌" in lines[r]
+    )
+    gap_rows = order_top - cust_bottom - 1
+    assert gap_rows <= 5, f"inter-layer gap grew to {gap_rows} rows:\n{joined}"
+
+
 # --------------------------------------------------------------------------
 # Degradation: malformed input, empty body, literal-glyph sanitization
 # --------------------------------------------------------------------------

{termrender-4.10.0 → termrender-4.10.1}/tests/test_mermaid_flow_corpus.py

@@ -195,9 +195,10 @@ def test_edge_style_bidirectional_golden():
 
 
 def test_pipe_label_golden():
-    # The rank-band gap widens to fit the label in full (see
-    # mermaid_flow_layout._rank_gap_overrides) — a 2-char label needs a
-    # taller gap than the base _ROW_GAP alone provides.
+    # The rank-band gap widens past the unlabeled _ROW_GAP to a small
+    # constant (see mermaid_flow_layout._LABELED_ROW_GAP) so the label gets
+    # its own clear row — the constant does not scale with the label's
+    # text length.
     assert _lines("graph TD\nA-->|hi|B\n") == [
         "┌───┐",
         "│ A │",
@@ -205,7 +206,6 @@ def test_pipe_label_golden():
         "  │",
         " hi",
         "  │",
-        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",
@@ -213,19 +213,16 @@ def test_pipe_label_golden():
 
 
 def test_inline_label_golden():
-    # Same rank-band widening as above, scaled to the longer "go now" label.
+    # Same constant rank-band gap as above — "go now" is longer than "hi"
+    # but the vertical gap stays the same _LABELED_ROW_GAP; only the
+    # label's own row is wider.
     assert _lines("graph TD\nA -- go now --> B\n") == [
         "┌───┐",
         "│ A │",
         "└───┘",
         "  │",
-        "  │",
-        "  │",
         "go now",
         "  │",
-        "  │",
-        "  │",
-        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",