flexablelib 2.0.6__tar.gz → 2.0.7__tar.gz

{flexablelib-2.0.6 → flexablelib-2.0.7}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.0.7] - 2026-10-28
+
+### Fixed
+- Generic merge junction algorithm: rule detection no longer treats a lone
+  hyphen inside cell text (e.g. `Beta-1`) as a separator line, so column-only
+  styles still get synthetic caps around multi-column merges.
+- Pure-horizontal junctions keep the rule's own dash glyph (`┄`/`═`/`─`/`-`)
+  instead of substituting a foreign `─`.
+- Synthetic caps blank through taller vertical/2D merges that cross the gap
+  (no ghost `┼` inside a continuing merge).
+- Synthetic caps use the table's outer horizontal style so they match top/bottom.
+- Round-edge end corners (`╰`/`╯`) survive last-row horizontal merge repair.
+
 ## [2.0.4](https://github.com/Opus-Perpetuus/flexablelib/compare/v2.0.3...v2.0.4) (2026-10-28)
 
 ### Bug Fixes

{flexablelib-2.0.6/flexablelib.egg-info → flexablelib-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexablelib
-Version: 2.0.6
+Version: 2.0.7
 Summary: Flexible console and HTML tables for Python
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Download-URL: 

{flexablelib-2.0.6 → flexablelib-2.0.7}/flexablelib/merges.py

@@ -16,6 +16,7 @@ The consequence is that a merged region never widens the table. Content longer
 than the span it was given is truncated, not accommodated.
 """
 
+import re
 from typing import List, NamedTuple, Optional
 
 from .fast import (
@@ -212,12 +213,16 @@ def _region_bounds(region, layout, index_offset):
     )
 
 
-# Replacement for apply() and helpers — pasted into merges.py below Layout helpers.
+# Junction / rule helpers for merge painting.
 
 # Horizontal dash characters used by the shipped styles (and ASCII grids).
 _H_CHARS = set('─━═┄┅┈┉╌╍▬−' '-~=')
+# A real rule has a *run* of dashes. A lone '-' inside "Beta-1" is not a rule.
+_H_RUN = re.compile(r'[─━═┄┅┈┉╌╍▬−\-~=]{2,}')
+_PURE_H = {(0, 0, 1, 1), (0, 0, 1, 0), (0, 0, 0, 1)}
+_ROUND_CORNERS = set('╭╮╰╯')
 
-# Light / heavy / double / ascii junction tables keyed by (N, S, E, W) booleans.
+# Light / heavy / double / ascii / round junction tables keyed by (N, S, E, W).
 _LIGHT = {
     (1, 1, 1, 1): '┼', (1, 1, 1, 0): '├', (1, 1, 0, 1): '┤',
     (1, 0, 1, 1): '┴', (0, 1, 1, 1): '┬', (1, 1, 0, 0): '│',
@@ -225,6 +230,13 @@ _LIGHT = {
     (0, 1, 1, 0): '┌', (0, 1, 0, 1): '┐', (1, 0, 0, 0): '│',
     (0, 1, 0, 0): '│', (0, 0, 1, 0): '─', (0, 0, 0, 1): '─',
 }
+_ROUND = {
+    (1, 1, 1, 1): '┼', (1, 1, 1, 0): '├', (1, 1, 0, 1): '┤',
+    (1, 0, 1, 1): '┴', (0, 1, 1, 1): '┬', (1, 1, 0, 0): '│',
+    (0, 0, 1, 1): '─', (1, 0, 1, 0): '╰', (1, 0, 0, 1): '╯',
+    (0, 1, 1, 0): '╭', (0, 1, 0, 1): '╮', (1, 0, 0, 0): '│',
+    (0, 1, 0, 0): '│', (0, 0, 1, 0): '─', (0, 0, 0, 1): '─',
+}
 _DOUBLE_V_SINGLE_H = {
     (1, 1, 1, 1): '╫', (1, 1, 1, 0): '╟', (1, 1, 0, 1): '╢',
     (1, 0, 1, 1): '╨', (0, 1, 1, 1): '╥', (1, 1, 0, 0): '║',
@@ -265,7 +277,6 @@ def _char_at(line: str, index: int) -> str:
     return slice_by_width(line, index, index + 1)
 
 
-
 def _junction_positions(layout, composition):
     """(x, vertical_glyph) for every vertical rule that can host a junction."""
     v = composition.vertical_table_body_lines
@@ -282,25 +293,36 @@ def _junction_positions(layout, composition):
     return out
 
 
-def _pick_junction(v_glyph: str, h_glyph: str, n: bool, s: bool, e: bool, w: bool) -> str:
+def _pick_junction(v_glyph: str, h_glyph: str, n: bool, s: bool, e: bool, w: bool,
+                   round_corners: bool = False) -> str:
     key = (1 if n else 0, 1 if s else 0, 1 if e else 0, 1 if w else 0)
     if key == (0, 0, 0, 0):
         return ' '
-    if v_glyph in '|+' or h_glyph in '-=':
-        # ASCII grid / pipes family
-        if v_glyph in '|+' and h_glyph in '-=+':
+    # Pure horizontal: keep THIS rule's dash (┄/═/─/-), never a foreign glyph.
+    if key in _PURE_H:
+        if v_glyph in '|+' or (h_glyph and h_glyph in '-=~'):
+            return h_glyph if h_glyph in '-=~' else '-'
+        return h_glyph or '─'
+    if v_glyph in '|+' or (h_glyph and h_glyph in '-=') :
+        if v_glyph in '|+' and (h_glyph in '-=+' or not h_glyph):
             return _ASCII.get(key, '+')
     if v_glyph == '║' and h_glyph == '═':
         return _DOUBLE.get(key, '║')
     if v_glyph == '║':
         return _DOUBLE_V_SINGLE_H.get(key, '║')
-    if h_glyph == '═' and v_glyph in ('│', '┃'):
+    if h_glyph == '═' and v_glyph in ('│', '┃', '┊'):
         return _SINGLE_V_DOUBLE_H.get(key, '│')
+    if round_corners:
+        return _ROUND.get(key, v_glyph or '│')
     return _LIGHT.get(key, v_glyph or '│')
 
 
 def _synthesize_body_rule(composition):
-    """Body SeparatorLine for styles that draw column lines but no row lines."""
+    """Body SeparatorLine for styles that draw column lines but no row lines.
+
+    Uses the table's outer (end/header) horizontal glyph so synthetic caps
+    match the top/bottom border style.
+    """
     from .style_compositions import SeparatorLine
     existing = composition.table_body_line
     if existing is not None and existing.middle:
@@ -308,21 +330,40 @@ def _synthesize_body_rule(composition):
     v = composition.vertical_table_body_lines
     if v is None or not v.middle or v.middle == ' ':
         return None
+    end = composition.table_end_line
+    header = composition.inferior_header_line
+    h = None
+    if end is not None and end.middle:
+        h = end.middle
+    elif header is not None and header.middle:
+        h = header.middle
     if v.middle in '|+':
         return SeparatorLine(
             left='+' if v.left else None,
-            middle='-',
+            middle=h if h in '-=~' else '-',
             intersection='+',
             right='+' if v.right else None,
         )
-    # Unicode column style (pretty_columns, round_edges, …)
+    if h == '═':
+        return SeparatorLine(
+            left='╞' if v.left else None,
+            middle='═',
+            intersection='╪',
+            right='╡' if v.right else None,
+        )
+    # Light / dotted / round outer borders → matching light body rule.
     left = '├' if v.left else None
     right = '┤' if v.right else None
     if v.left == '║':
         left = '╟'
     if v.right == '║':
         right = '╢'
-    return SeparatorLine(left=left, middle='─', intersection='┼', right=right)
+    return SeparatorLine(
+        left=left,
+        middle=h or '─',
+        intersection='┼',
+        right=right,
+    )
 
 
 def _build_rule_line(layout, composition, column_widths, hidden, rule=None):
@@ -359,13 +400,13 @@ def _build_rule_line(layout, composition, column_widths, hidden, rule=None):
     return left + center + right
 
 
-def _looks_like_rule(line: str, h_glyph: str) -> bool:
+def _looks_like_rule(line: str, h_glyph: str = None) -> bool:
+    """True only for real separator lines, not cell text that contains '-'."""
     if not line:
         return False
-    plain = line
-    if h_glyph and h_glyph in plain:
+    if h_glyph and len(h_glyph) >= 1 and (h_glyph * 2) in line:
         return True
-    return any(ch in plain for ch in _H_CHARS)
+    return _H_RUN.search(line) is not None
 
 
 def _repair_rule_junctions(line, layout, composition, h_glyph, missing_south=None, missing_north=None,
@@ -385,6 +426,7 @@ def _repair_rule_junctions(line, layout, composition, h_glyph, missing_south=Non
     if v is None:
         return line
     h_glyph = h_glyph or '─'
+    round_corners = any(ch in line for ch in _ROUND_CORNERS)
     rewritten = line
     for x, v_glyph in _junction_positions(layout, composition):
         if visible_width(rewritten) <= x:
@@ -399,8 +441,10 @@ def _repair_rule_junctions(line, layout, composition, h_glyph, missing_south=Non
         east = _is_h(right)
         north = (not no_north) and (x not in missing_north)
         south = (not no_south) and (x not in missing_south)
-        # A junction with no arms at all becomes the bare vertical.
-        glyph = _pick_junction(v_glyph, h_glyph, north, south, east, west)
+        glyph = _pick_junction(
+            v_glyph, h_glyph, north, south, east, west,
+            round_corners=round_corners,
+        )
         rewritten = _repaint(rewritten, x, x + 1, glyph)
     return rewritten
 
@@ -434,9 +478,11 @@ def apply(lines, row_line_map, regions, column_widths, composition,
     touched_seps = set()
     # Horizontal (or 2D) merges: verticals removed between their columns on
     # their data lines; caps above/below need ┴/┬ repair.
-    horiz_caps = []  # (above_line, below_line, inner_separator_xs)
-    # Column-only styles: insert a synthetic row rule around multi-column merges.
-    col_only_inserts = []  # (after_index, rule_line)  insert AT after_index+1
+    # (above_line, below_line, inner_separator_xs, first_row, last_row)
+    horiz_caps = []
+    # Column-only gaps keyed by logical row *after which* a rule sits
+    # (gap after row G = between G and G+1). Values: miss_s, miss_n, insert_at.
+    gap_plans = {}
 
     synthesized = _synthesize_body_rule(composition)
     col_only = (
@@ -445,6 +491,21 @@ def apply(lines, row_line_map, regions, column_widths, composition,
         and composition.vertical_table_body_lines is not None
         and composition.vertical_table_body_lines.middle not in (None, '', ' ')
     )
+    syn_h = synthesized.middle if synthesized is not None else None
+
+    def _blank_crossings(rule_line, gap_after_row):
+        """Erase horizontal through merges that continue across this gap."""
+        for region in regions:
+            if region.first_row <= gap_after_row and region.last_row >= gap_after_row + 1:
+                bounds = _region_bounds(region, layout, index_offset)
+                if bounds is None:
+                    continue
+                (start, end), _, _, _ = bounds
+                if end > start:
+                    rule_line = _repaint(
+                        rule_line, start, end, filler * (end - start)
+                    )
+        return rule_line
 
     for region in regions:
         bounds = _region_bounds(region, layout, index_offset)
@@ -504,37 +565,30 @@ def apply(lines, row_line_map, regions, column_widths, composition,
         if region.column_count >= 2 and inner_seps:
             above = min(target_lines) - 1
             below = max(target_lines) + 1
-            # Existing rules (body / header / end) get ┴/┬ via horiz_caps.
-            horiz_caps.append((above, below, set(inner_seps)))
+            horiz_caps.append(
+                (above, below, set(inner_seps), region.first_row, region.last_row)
+            )
 
-            if col_only:
-                rule_line = _build_rule_line(
-                    layout, composition, column_widths, hidden_columns, synthesized
-                )
-                if rule_line is not None:
-                    # Only insert a synthetic row rule where the style has no
-                    # rule already. Duplicating a header/end rule looks broken;
-                    # those are repaired in pass 3 instead.
-                    above_is_rule = (
-                        above >= 0 and any(_is_h(ch) for ch in lines[above])
+            if col_only and synthesized is not None:
+                # Cap above: gap after first_row-1 (if any).
+                if region.first_row > 0:
+                    g = region.first_row - 1
+                    plan = gap_plans.setdefault(
+                        g, {'s': set(), 'n': set(), 'at': min(target_lines)}
                     )
-                    below_is_rule = (
-                        below < len(lines) and any(_is_h(ch) for ch in lines[below])
+                    plan['s'] |= set(inner_seps)
+                    plan['at'] = min(plan['at'], min(target_lines))
+                # Cap below: gap after last_row (unless last table row — end
+                # line is repaired in pass 3).
+                max_row = max(row_line_map) if row_line_map else region.last_row
+                if region.last_row < max_row:
+                    g = region.last_row
+                    plan = gap_plans.setdefault(
+                        g, {'s': set(), 'n': set(), 'at': max(target_lines) + 1}
                     )
-                    if not above_is_rule:
-                        capped = _repair_rule_junctions(
-                            rule_line, layout, composition,
-                            synthesized.middle,
-                            missing_south=set(inner_seps),
-                        )
-                        col_only_inserts.append((min(target_lines), capped))
-                    if not below_is_rule:
-                        capped_below = _repair_rule_junctions(
-                            rule_line, layout, composition,
-                            synthesized.middle,
-                            missing_north=set(inner_seps),
-                        )
-                        col_only_inserts.append((max(target_lines) + 1, capped_below))
+                    plan['n'] |= set(inner_seps)
+                    plan['at'] = min(plan.get('at', max(target_lines) + 1),
+                                     max(target_lines) + 1)
 
     # --- Pass 2: repair junctions on body rules touched by vertical blanks ---
     if h_glyph:
@@ -546,11 +600,10 @@ def apply(lines, row_line_map, regions, column_widths, composition,
                 line, layout, composition, h_glyph
             )
 
-    # --- Pass 3: ┴ / ┬ on rules above and below horizontal / 2D merges -----
-    # Combine missing arms when several merges share a cap line.
+    # --- Pass 3: ┴ / ┬ on existing rules above and below H / 2D merges -------
     missing_south_by_line = {}
     missing_north_by_line = {}
-    for above, below, xs in horiz_caps:
+    for above, below, xs, _fr, _lr in horiz_caps:
         if above >= 0:
             missing_south_by_line.setdefault(above, set()).update(xs)
         if below < len(lines):
@@ -559,12 +612,9 @@ def apply(lines, row_line_map, regions, column_widths, composition,
     cap_lines = set(missing_south_by_line) | set(missing_north_by_line)
     for line_index in cap_lines:
         line = lines[line_index]
-        # Header / body / end rules all use horizontal glyphs.
-        if not any(_is_h(ch) for ch in line):
+        if not _looks_like_rule(line, h_glyph):
             continue
-        # Guess h glyph from the line itself.
         line_h = next((ch for ch in line if _is_h(ch)), h_glyph or '─')
-        # Outer borders never grow an arm past the table.
         lines[line_index] = _repair_rule_junctions(
             line, layout, composition, line_h,
             missing_south=missing_south_by_line.get(line_index),
@@ -573,30 +623,46 @@ def apply(lines, row_line_map, regions, column_widths, composition,
             no_north=(line_index == 0),
         )
 
-    # --- Pass 4: insert synthetic row rules for column-only styles ----------
-    # Adjacent multi-column merges on neighbouring rows both want a rule in
-    # the same gap; coalesce those into one line with every missing arm.
-    if col_only_inserts and synthesized is not None:
-        # Map insert index → (missing_south xs, missing_north xs)
-        gap_arms = {}
-        for above, below, xs in horiz_caps:
-            # insert above merge lands at above+1 (== min target_lines)
-            if above + 1 >= 0:
-                arms = gap_arms.setdefault(above + 1, [set(), set()])
-                arms[0] |= set(xs)  # missing south into the merge below
-            arms = gap_arms.setdefault(below, [set(), set()])
-            arms[1] |= set(xs)  # missing north into the merge above
-        # Only keep gaps we actually planned to insert (skip header/end).
-        planned = {at for at, _ in col_only_inserts}
-        for at in sorted(planned, reverse=True):
-            miss_s, miss_n = gap_arms.get(at, [set(), set()])
+    # --- Pass 4: synthetic caps for column-only styles ----------------------
+    # Insert a rule in each planned gap that does not already hold a real
+    # separator. Blank any merge that continues across the gap so taller
+    # vertical/2D merges are not crossed by ghost edges.
+    if col_only and gap_plans and synthesized is not None:
+        for g in sorted(gap_plans.keys(), reverse=True):
+            plan = gap_plans[g]
+            at = plan['at']
+            # If the line already at `at` (or just above the lower row) is a
+            # real rule, repair it in place instead of inserting.
+            existing = None
+            if 0 <= at < len(lines) and _looks_like_rule(lines[at], syn_h):
+                existing = at
+            elif 0 <= at - 1 < len(lines) and _looks_like_rule(lines[at - 1], syn_h):
+                # Header/end sitting where we wanted a gap.
+                existing = at - 1
+
+            if existing is not None:
+                line = lines[existing]
+                line = _blank_crossings(line, g)
+                line_h = next((ch for ch in line if _is_h(ch)), syn_h or '─')
+                lines[existing] = _repair_rule_junctions(
+                    line, layout, composition, line_h,
+                    missing_south=plan['s'] or None,
+                    missing_north=plan['n'] or None,
+                    no_south=(existing >= len(lines) - 1),
+                    no_north=(existing == 0),
+                )
+                continue
+
             rule = _build_rule_line(
                 layout, composition, column_widths, hidden_columns, synthesized
             )
+            if rule is None:
+                continue
+            rule = _blank_crossings(rule, g)
             rule = _repair_rule_junctions(
-                rule, layout, composition, synthesized.middle,
-                missing_south=miss_s or None,
-                missing_north=miss_n or None,
+                rule, layout, composition, syn_h,
+                missing_south=plan['s'] or None,
+                missing_north=plan['n'] or None,
             )
             lines.insert(max(0, min(at, len(lines))), rule)
 

{flexablelib-2.0.6 → flexablelib-2.0.7/flexablelib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexablelib
-Version: 2.0.6
+Version: 2.0.7
 Summary: Flexible console and HTML tables for Python
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Download-URL: 

{flexablelib-2.0.6 → flexablelib-2.0.7}/flexablelib.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tests/test_columns.py
 tests/test_excel.py
 tests/test_features.py
 tests/test_issues.py
+tests/test_merge_edge_matrix.py
 tests/test_merges.py
 tests/test_readme_examples.py
 tests/test_styles.py

{flexablelib-2.0.6 → flexablelib-2.0.7}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flexablelib",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Flexible console and HTML tables for Python: styles, merges, colors, widths, decimal alignment.",
   "main": "__init__.py",
   "scripts": {

flexablelib-2.0.7/tests/test_merge_edge_matrix.py

@@ -0,0 +1,252 @@
+"""Rare merge edge cases: all border styles × call-order permutations.
+
+These assert the generic junction algorithm — never demo names. Each case is a
+small structural table chosen to stress caps, crossings, bottoms, and hyphens.
+"""
+
+import itertools
+import pytest
+
+from flexablelib import Table
+from flexablelib.fast import visible_width
+
+# Styles that ship with vertical column rules (the ones merges must paint).
+STYLES_WITH_VERTICALS = [
+    'pretty_grid',
+    'pretty_columns',
+    'round_edges',
+    'dashes',
+    'grid',
+    'bold_borderline',
+    'thin_borderline',
+    'double_grid',
+    'grid_eheader',
+]
+
+
+def _square(rendered: str) -> None:
+    widths = {visible_width(line) for line in rendered.splitlines()}
+    # Title lines may be shorter; body shares one width.
+    assert len(widths) <= 2, widths
+    assert max(widths) >= 3
+
+
+def _has_h_run(line: str) -> bool:
+    import re
+    return re.search(r'[─━═┄┅┈┉╌╍▬−\-~=]{2,}', line) is not None
+
+
+def _build_base(style: str) -> Table:
+    table = Table(style_name=style)
+    table.add_column('A', ['a0', 'a1', 'a2', 'a3'])
+    table.add_column('B', ['b0', 'b1', 'b2', 'b3'])
+    table.add_column('C', ['c0', 'c1', 'c2', 'c3'])
+    table.add_column('D', ['d0', 'd1', 'd2', 'd3'])
+    return table
+
+
+@pytest.mark.parametrize('style', STYLES_WITH_VERTICALS)
+def test_horizontal_merge_mid_table_keeps_square(style):
+    table = _build_base(style)
+    table.merge_cells(1, 1, last_column=2, value='BC')
+    rendered = str(table)
+    assert 'BC' in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', STYLES_WITH_VERTICALS)
+def test_vertical_merge_mid_table_keeps_square(style):
+    table = _build_base(style)
+    table.merge_cells(1, 0, last_row=2, value='AS')
+    rendered = str(table)
+    assert 'AS' in rendered or 'AS' in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', STYLES_WITH_VERTICALS)
+def test_block_merge_keeps_square(style):
+    table = _build_base(style)
+    table.merge_cells(1, 1, 2, 2, value='BLOCK')
+    rendered = str(table)
+    assert 'BLOCK' in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', STYLES_WITH_VERTICALS)
+def test_last_row_horizontal_merge_bottom_is_not_header_tee(style):
+    table = _build_base(style)
+    table.merge_cells(3, 1, last_column=2, value='BC-end')
+    bottom = str(table).splitlines()[-1]
+    # Header-only tees must not appear on the end line.
+    for bad in ('╞', '╡', '╤', '╪'):
+        # double_grid / pretty_columns end lines use ╘═╧╛ — ╞ would be wrong.
+        if bad in bottom and not bottom.startswith(('╘', '╚', '╙', '╰', '└', '+', '┗')):
+            pytest.fail(f'header tee {bad!r} on bottom: {bottom!r}')
+    _square(str(table))
+
+
+@pytest.mark.parametrize('style', ['pretty_columns', 'round_edges', 'dashes'])
+def test_column_only_multi_col_merge_inserts_cap(style):
+    table = _build_base(style)
+    table.merge_cells(1, 0, last_column=1, value='AB')
+    lines = str(table).splitlines()
+    assert any(_has_h_run(line) and '═' not in line or _has_h_run(line)
+               for line in lines)
+    # There is a body-ish rule that is not only the header double rule.
+    bodyish = [line for line in lines if _has_h_run(line)]
+    assert len(bodyish) >= 2, lines  # header + at least one cap or end
+    _square(str(table))
+
+
+@pytest.mark.parametrize('style', ['pretty_columns', 'round_edges', 'dashes'])
+def test_short_merge_does_not_ghost_through_taller_block(style):
+    table = Table(style_name=style)
+    for c in range(4):
+        table.add_column(f'C{c}', [f'r{r}c{c}' for r in range(4)])
+    table.merge_cells(0, 0, 2, 1, value='TALL')
+    table.merge_cells(0, 2, 1, 3, value='SHORT')
+    rendered = str(table)
+    # Classic ghost: ┼──────┼ under TALL on the SHORT-below rule.
+    assert '┼──────┼──────┼' not in rendered
+    assert '╪══════╪══════╪' not in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', ['round_edges', 'dashes', 'pretty_columns'])
+def test_hyphenated_labels_still_get_caps(style):
+    table = Table(style_name=style)
+    table.add_column('Cat', ['', '', '', ''])
+    table.add_column('Item', ['X-1', 'X-2', 'Y-1', 'Y-2'])
+    table.add_column('V', [1, 2, 3, 4])
+    table.add_column('N', ['n-0', 'n-1', 'n-2', 'n-3'])
+    table.merge_cells(0, 0, last_row=1, value='X')
+    table.merge_cells(2, 0, last_row=3, value='Y')
+    table.merge_cells(2, 2, last_row=3, last_column=3, value='BOX')
+    rendered = str(table)
+    assert 'BOX' in rendered
+    _square(rendered)
+    # Must have a horizontal run flanking BOX (cap or end), not only header.
+    lines = rendered.splitlines()
+    box_i = next(i for i, line in enumerate(lines) if 'BOX' in line)
+    nearby = lines[max(0, box_i - 3): box_i + 4]
+    assert any(_has_h_run(line) for line in nearby), rendered
+
+
+@pytest.mark.parametrize('style', ['dashes'])
+def test_dashes_bottom_merge_has_no_solid_em_dash(style):
+    table = _build_base(style)
+    table.merge_cells(3, 2, last_column=3, value='CD')
+    bottom = str(table).splitlines()[-1]
+    assert '─' not in bottom, bottom
+
+
+@pytest.mark.parametrize('style', ['round_edges'])
+def test_round_end_corners_kept(style):
+    table = _build_base(style)
+    table.merge_cells(3, 1, last_column=2, value='BC')
+    bottom = str(table).splitlines()[-1]
+    assert bottom.startswith('╰') and bottom.endswith('╯'), bottom
+
+
+# --- Call-order permutations -------------------------------------------------
+
+def _orders():
+    """Distinct sequences of building a 2x2 block merge + a vertical stack."""
+    def style_first(style):
+        t = Table(style_name=style)
+        t.add_column('A', ['a0', 'a1', 'a2'])
+        t.add_column('B', ['b0', 'b1', 'b2'])
+        t.add_column('C', ['c0', 'c1', 'c2'])
+        t.merge_cells(0, 0, 1, 1, value='BLK')
+        t.merge_cells(0, 2, last_row=2, value='V')
+        return t
+
+    def merge_then_style(style):
+        t = Table()
+        t.add_column('A', ['a0', 'a1', 'a2'])
+        t.add_column('B', ['b0', 'b1', 'b2'])
+        t.add_column('C', ['c0', 'c1', 'c2'])
+        t.merge_cells(0, 0, 1, 1, value='BLK')
+        t.merge_cells(0, 2, last_row=2, value='V')
+        t.style_name = style
+        return t
+
+    def add_row_then_merge(style):
+        t = Table(style_name=style)
+        t.add_column('A', [])
+        t.add_column('B', [])
+        t.add_column('C', [])
+        for r in range(3):
+            t.add_row([f'a{r}', f'b{r}', f'c{r}'])
+        t.merge_cells(0, 0, 1, 1, value='BLK')
+        t.merge_cells(0, 2, last_row=2, value='V')
+        return t
+
+    def merge_between_rows(style):
+        t = Table(style_name=style)
+        t.add_column('A', ['a0'])
+        t.add_column('B', ['b0'])
+        t.add_column('C', ['c0'])
+        t.add_row(['a1', 'b1', 'c1'])
+        t.merge_cells(0, 0, 1, 1, value='BLK')  # merge early
+        t.add_row(['a2', 'b2', 'c2'])
+        t.merge_cells(0, 2, last_row=2, value='V')
+        return t
+
+    return [
+        ('style_first', style_first),
+        ('merge_then_style', merge_then_style),
+        ('add_row_then_merge', add_row_then_merge),
+        ('merge_between_rows', merge_between_rows),
+    ]
+
+
+@pytest.mark.parametrize('style', ['pretty_grid', 'pretty_columns', 'round_edges', 'grid'])
+@pytest.mark.parametrize('order_name,factory', _orders())
+def test_call_order_permutations_render_square(style, order_name, factory):
+    table = factory(style)
+    rendered = str(table)
+    assert 'BLK' in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('align', ['l', 'c', 'r'])
+@pytest.mark.parametrize('style', ['pretty_grid', 'pretty_columns', 'round_edges'])
+def test_centered_block_has_no_internal_ghost_cross(style, align):
+    table = Table(style_name=style)
+    for c in range(5):
+        table.add_column(f'C{c}', [f'r{r}c{c}' for r in range(4)])
+    table.merge_cells(0, 0, 2, 2, value='CENTER', align=align)
+    rendered = str(table)
+    # Ghost crosses under a 3-col span on a single rule.
+    assert '┼──────┼──────┼' not in rendered
+    assert '╪══════╪══════╪' not in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', ['pretty_grid', 'bold_borderline', 'double_grid'])
+def test_adjacent_vertical_then_horizontal_l_shape(style):
+    table = Table(style_name=style)
+    for c in range(5):
+        table.add_column(f'C{c}', [f'r{r}c{c}' for r in range(5)])
+    table.merge_cells(0, 0, last_row=3, value='STEM')
+    table.merge_cells(3, 1, last_column=3, value='BASE')
+    rendered = str(table)
+    assert 'STEM' in rendered and 'BASE' in rendered
+    _square(rendered)
+
+
+@pytest.mark.parametrize('style', ['pretty_grid', 'pretty_columns', 'dashes'])
+def test_many_nonoverlapping_blocks(style):
+    table = Table(style_name=style)
+    for c in range(6):
+        table.add_column(f'C{c}', [f'r{r}c{c}' for r in range(6)])
+    table.merge_cells(0, 0, 1, 1, value='NW')
+    table.merge_cells(0, 4, 1, 5, value='NE')
+    table.merge_cells(2, 2, 3, 3, value='MID')
+    table.merge_cells(4, 0, 5, 1, value='SW')
+    table.merge_cells(4, 4, 5, 5, value='SE')
+    rendered = str(table)
+    for label in ('NW', 'NE', 'MID', 'SW', 'SE'):
+        assert label in rendered
+    _square(rendered)

{flexablelib-2.0.6 → flexablelib-2.0.7}/tests/test_merges.py

@@ -563,7 +563,10 @@ def test_horizontal_merge_caps_become_tees_above_and_below():
 
 def test_column_only_style_inserts_horizontal_break_under_multi_column_merge():
     """pretty_columns has column lines but no row lines; a multi-column merge
-    must insert a row rule so the grid does not break oddly."""
+    must insert a row rule so the grid does not break oddly.
+
+    Caps use the table's outer horizontal glyph (═ for pretty_columns).
+    """
     table = Table(style_name='pretty_columns')
     table.add_column('A', ['a1', 'a2', 'a3'])
     table.add_column('B', ['b1', 'b2', 'b3'])
@@ -571,8 +574,10 @@ def test_column_only_style_inserts_horizontal_break_under_multi_column_merge():
     table.merge_cells(1, 0, last_column=1, value='AB')
 
     lines = str(table).splitlines()
-    assert any('┴' in line for line in lines)
-    assert any('┬' in line for line in lines)
+    # Light tees (┴/┬) or double-horizontal tees (╧/╤) — both valid depending
+    # on whether the synthesizer mirrors the outer ═ border.
+    assert any(('┴' in line or '╧' in line) for line in lines), lines
+    assert any(('┬' in line or '╤' in line) for line in lines), lines
     assert any('AB' in line for line in lines)
     # The synthetic rules keep the table square.
     assert len({visible_width(line) for line in lines}) == 1
@@ -638,3 +643,142 @@ def test_stress_last_row_merge_bottom_border_is_end_line():
     assert '╤' not in bottom and '╪' not in bottom, bottom
     # Continuous run under H14 (C2–C5): three inner junctions → ═.
     assert '╧═══════════════════════════════╧' in bottom, bottom  # C2–C5: 7+1+7+1+7+1+7
+
+
+# +-------------------------------------------------------------------------+
+# Generic junction / cap algorithm (no demo-specific hardcoding)
+# +-------------------------------------------------------------------------+
+
+def test_hyphen_in_cell_text_does_not_block_column_only_caps():
+    """A lone '-' inside cell text must not be mistaken for a rule line.
+
+    Column-only styles insert synthetic caps around multi-column merges; if
+    'Beta-1' were treated as a rule, those caps would be skipped.
+    """
+    table = Table(style_name='round_edges')
+    table.add_column('Cat', [''] * 5)
+    table.add_column('Item', ['Alpha-1', 'Alpha-2', 'Beta-1', 'Beta-2', 'Beta-3'])
+    table.add_column('V', [1, 2, 3, 4, 5])
+    table.add_column('N', ['n0', 'n1', 'n2', 'n3', 'n4'])
+    table.merge_cells(0, 0, last_row=1, value='Alpha')
+    table.merge_cells(2, 0, last_row=4, value='Beta')
+    table.merge_cells(2, 2, last_row=4, last_column=3, value='BLOCK')
+
+    lines = str(table).splitlines()
+    block_i = next(i for i, line in enumerate(lines) if 'BLOCK' in line)
+    # Cap above the block (between Alpha group and BLOCK) and below (or end).
+    above = lines[block_i - 2]  # one data line of BLOCK above middle, then cap
+    # Find a synthetic/body rule that carries a tee into the V|N span.
+    rule_lines = [line for line in lines if ('┬' in line or '┴' in line or '├' in line) and '═' not in line]
+    assert rule_lines, '\n'.join(lines)
+    # At least one rule must sit next to the BLOCK rows.
+    assert any(
+        abs(i - block_i) <= 3 and ('┬' in line or '┴' in line or '─' in line)
+        for i, line in enumerate(lines)
+        if _looks_like_rule_line(line)
+    ), '\n'.join(lines)
+
+
+def _looks_like_rule_line(line: str) -> bool:
+    import re
+    return re.search(r'[─━═┄┅┈┉╌╍▬−\-~=]{2,}', line) is not None
+
+
+def test_multi_column_merge_in_column_only_style_gets_caps_matching_outer_dash():
+    """Caps above/below a multi-column merge use the table end horizontal glyph."""
+    table = Table(style_name='round_edges')
+    table.add_column('A', ['a1', 'a2', 'a3', 'a4'])
+    table.add_column('B', ['b1', 'b2', 'b3', 'b4'])
+    table.add_column('C', ['c1', 'c2', 'c3', 'c4'])
+    table.merge_cells(1, 1, last_row=2, last_column=2, value='BC')
+
+    rendered = str(table)
+    lines = rendered.splitlines()
+    assert any('BC' in line for line in lines)
+    # Outer end uses ─; synthetic caps must also use ─ (not a foreign dash).
+    rules = [line for line in lines if _looks_like_rule_line(line) and not line.startswith('╭') and not line.startswith('╰') and '═' not in line]
+    assert rules, rendered
+    for line in rules:
+        assert '┄' not in line and '═' not in line, line
+
+
+def test_dashes_style_bottom_under_merge_keeps_dotted_glyph_not_solid():
+    """Suppressing a bottom junction must extend the rule's own h glyph (┄), never ─."""
+    table = Table(style_name='dashes')
+    for d, name in enumerate(['A', 'B', 'C', 'D']):
+        table.add_column(name, [f'r{r}c{d}' for r in range(3)])
+    table.merge_cells(2, 2, last_column=3, value='CD')
+
+    bottom = str(table).splitlines()[-1]
+    assert '─' not in bottom, bottom
+    assert bottom.startswith('└') and bottom.endswith('┘'), bottom
+    # Continuous dotted run under CD (one suppressed inner junction).
+    assert '┴┄┄┄┄┄┄┄┄┄┄┄┄┄┘' in bottom or bottom.count('┄') >= 10, bottom
+
+
+def test_synthetic_rule_blanks_through_taller_crossing_merge():
+    """A short multi-column merge must not leave ghost ┼ inside a taller 2D merge."""
+    table = Table(style_name='pretty_columns')
+    for c in range(6):
+        table.add_column(f'C{c}', [f'r{r}c{c}' for r in range(5)])
+    table.merge_cells(0, 0, 2, 2, value='TALL')
+    table.merge_cells(0, 3, 1, 5, value='SHORT')
+
+    lines = str(table).splitlines()
+    # The rule just under SHORT (still inside TALL's rows) must not show ┼
+    # under TALL's columns — those junctions are ghosts.
+    short_i = next(i for i, line in enumerate(lines) if 'SHORT' in line)
+    # Scan rules after SHORT's text line while TALL still covers row 2.
+    for line in lines[short_i + 1:]:
+        if 'TALL' in line or 'r2c' in line or 'r3c' in line:
+            # data
+            if 'r3c' in line:
+                break
+            continue
+        if not _looks_like_rule_line(line):
+            continue
+        # Under TALL (first three col bands) there must be no ┼ / ╪ ghost.
+        # Left portion before the SHORT columns' reopen.
+        left = line.split('r')[0] if False else line
+        # Take from start through the junction that opens column 3.
+        # Ghost pattern was: ├──────┼──────┼──────┼
+        assert '┼──────┼──────┼' not in line, line
+        assert '╪══════╪══════╪' not in line, line
+        break
+
+
+def test_round_edges_end_corners_survive_last_row_horizontal_merge():
+    """Repairing the end line must keep ╰/╯, not rewrite them as └/┘."""
+    table = Table(style_name='round_edges')
+    table.add_column('A', ['a1', 'a2', 'a3'])
+    table.add_column('B', ['b1', 'b2', 'b3'])
+    table.add_column('C', ['c1', 'c2', 'c3'])
+    table.merge_cells(2, 1, last_column=2, value='BC')
+
+    bottom = str(table).splitlines()[-1]
+    assert bottom.startswith('╰'), bottom
+    assert bottom.endswith('╯'), bottom
+    assert '└' not in bottom and '┘' not in bottom, bottom
+
+
+def test_crossing_vertical_merge_keeps_edge_when_cap_inserted():
+    """When a cap is inserted under a 2D block beside a continuing vertical
+    merge, the vertical merge's column stays an edge (no horizontal through it)."""
+    table = Table(style_name='round_edges')
+    table.add_column('Cat', [''] * 6)
+    table.add_column('Item', [f'i{r}' for r in range(6)])
+    table.add_column('V', list(range(6)))
+    table.add_column('N', [f'n{r}' for r in range(6)])
+    table.merge_cells(0, 0, last_row=5, value='ALL')
+    table.merge_cells(1, 2, last_row=3, last_column=3, value='BOX')
+
+    lines = str(table).splitlines()
+    # Rules flanking BOX must blank the Cat column (ALL continues through).
+    for i, line in enumerate(lines):
+        if not _looks_like_rule_line(line):
+            continue
+        if '═' in line or line.startswith('╭') or line.startswith('╰'):
+            continue
+        # Body synthetic rule: starts with │ (edge through ALL) not ├.
+        if '┬' in line or '┴' in line:
+            assert line.startswith('│'), line