docalign 0.1.0__py3-none-any.whl

docalign/__init__.py

@@ -0,0 +1,2 @@
+from docalign.cli import run_checks as run_checks
+from docalign.cli import run_fixes as run_fixes

docalign/checks/arrows.py

@@ -0,0 +1,100 @@
+from docalign.constants import ARROW_CHARS, ARROW_SEARCH_RANGE, BOX_CHARS, HORIZ_ARROW_CHARS
+from docalign.parser import iter_code_blocks
+from docalign.utils import _is_standalone_arrow
+
+
+def check(lines):
+    errors = []
+    for _, code_lines in iter_code_blocks(lines):
+        errors.extend(_check_arrows(code_lines))
+    return errors
+
+
+def fix(lines):
+    result = list(lines)
+    for code_indices, _ in iter_code_blocks(lines):
+        _fix_arrows_in_block(code_indices, result)
+    return result
+
+
+def _check_arrows(code_lines):
+    errors = []
+    for idx, (i, raw) in enumerate(code_lines):
+        for j, c in enumerate(raw):
+            if c in ARROW_CHARS:
+                if _is_standalone_arrow(raw, j):
+                    expected = _find_arrow_target(code_lines, idx, j, c)
+                    if expected is not None and expected != j:
+                        errors.append(f"L{i + 1} arrow '{c}' at col {j}, expected col {expected}")
+                elif _is_embedded_in_horiz_border(raw, j):
+                    errors.append(f"L{i + 1} arrow '{c}' embedded in border at col {j}")
+            elif c in HORIZ_ARROW_CHARS and _is_embedded_in_vert_border(code_lines, idx, j):
+                errors.append(f"L{i + 1} arrow '{c}' embedded in border at col {j}")
+    return errors
+
+
+def _is_embedded_in_horiz_border(raw, j):
+    left = raw[j - 1] if j > 0 else " "
+    right = raw[j + 1] if j < len(raw) - 1 else " "
+    return left == "─" or right == "─"
+
+
+def _is_embedded_in_vert_border(code_lines, line_idx, col):
+    above = line_idx - 1
+    below = line_idx + 1
+    has_above = above >= 0 and col < len(code_lines[above][1]) and code_lines[above][1][col] == "│"
+    has_below = below < len(code_lines) and col < len(code_lines[below][1]) and code_lines[below][1][col] == "│"
+    return has_above or has_below
+
+
+def _find_arrow_target(code_lines, arrow_idx, arrow_col, arrow_char):
+    search_range = range(arrow_idx - 1, -1, -1) if arrow_char == "v" else range(arrow_idx + 1, len(code_lines))
+    for si in search_range:
+        _, sraw = code_lines[si]
+        for dc in [i for r in range(ARROW_SEARCH_RANGE + 1) for i in ([0] if r == 0 else [-r, r])]:
+            col = arrow_col + dc
+            if 0 <= col < len(sraw) and sraw[col] in BOX_CHARS:
+                return col if dc != 0 else None
+        break
+    return None
+
+
+def _fix_arrows_in_block(code_indices, all_lines):
+    code_lines = [(i, all_lines[i].rstrip("\n")) for i in code_indices]
+    for idx, (i, raw) in enumerate(code_lines):
+        arrows = [(j, c) for j, c in enumerate(raw) if c in ARROW_CHARS and _is_standalone_arrow(raw, j)]
+        if not arrows:
+            continue
+        corrections = []
+        for j, c in arrows:
+            expected = _find_arrow_target(code_lines, idx, j, c)
+            if expected is not None and expected != j:
+                corrections.append((j, expected))
+        if not corrections:
+            continue
+        new_raw = raw
+        for j, expected in sorted(corrections, key=lambda x: -x[0]):
+            delta = expected - j
+            if delta > 0:
+                spaces_after = 0
+                for k in range(j + 1, len(new_raw)):
+                    if new_raw[k] == " ":
+                        spaces_after += 1
+                    else:
+                        break
+                if spaces_after >= delta:
+                    new_raw = new_raw[:j] + " " * delta + new_raw[j] + new_raw[j + 1 + delta :]
+                elif j + 1 + spaces_after >= len(new_raw):
+                    new_raw = new_raw[:j] + " " * delta + new_raw[j]
+            elif delta < 0:
+                remove = abs(delta)
+                spaces_before = 0
+                for k in range(j - 1, -1, -1):
+                    if new_raw[k] == " ":
+                        spaces_before += 1
+                    else:
+                        break
+                if spaces_before >= remove:
+                    new_raw = new_raw[: j - remove] + new_raw[j] + " " * remove + new_raw[j + 1 :]
+        if new_raw != raw:
+            all_lines[i] = new_raw + "\n"

docalign/checks/box_padding.py

@@ -0,0 +1,117 @@
+from collections import Counter
+
+from docalign.constants import BOX_CHARS, MAX_PAD_DRIFT
+from docalign.parser import iter_code_blocks
+from docalign.utils import _find_boxes, _is_tree_block
+
+
+def check(lines):
+    errors = []
+    for _, code_lines in iter_code_blocks(lines):
+        errors.extend(_check_padding(code_lines))
+    return errors
+
+
+def fix(lines):
+    result = list(lines)
+    for code_indices, _ in iter_code_blocks(lines):
+        _fix_padding_in_block(code_indices, result)
+    return result
+
+
+def _get_left_padding(raw, col_left, col_right):
+    if col_left >= len(raw) or raw[col_left] != "│":
+        return None
+    if col_right >= len(raw) or raw[col_right] not in BOX_CHARS:
+        return None
+    inner = raw[col_left + 1 : col_right]
+    if not inner.strip():
+        return None
+    if any(c in BOX_CHARS for c in inner):
+        return None
+    pad = 0
+    for c in inner:
+        if c == " ":
+            pad += 1
+        else:
+            break
+    return pad
+
+
+def _expected_padding(paddings):
+    counts = Counter(paddings)
+    max_count = max(counts.values())
+    candidates = [p for p, c in counts.items() if c == max_count]
+    if len(candidates) == 1:
+        return candidates[0]
+    if 0 in candidates:
+        non_zero = [c for c in candidates if c > 0]
+        return min(non_zero)
+    return None
+
+
+def _has_layout_intent(pad_values):
+    return max(pad_values) - min(pad_values) >= MAX_PAD_DRIFT
+
+
+def _check_padding(code_lines):
+    errors = []
+    if _is_tree_block(code_lines):
+        return errors
+
+    for col_left, col_right, _, _, content_indices in _find_boxes(code_lines):
+        paddings = []
+        for ci in content_indices:
+            line_idx, raw = code_lines[ci]
+            pad = _get_left_padding(raw, col_left, col_right)
+            if pad is not None:
+                paddings.append((line_idx, pad))
+
+        if len(paddings) < 2 or _has_layout_intent([p for _, p in paddings]):
+            continue
+
+        expected = _expected_padding([p for _, p in paddings])
+        if expected is None:
+            continue
+
+        for line_idx, pad in paddings:
+            if pad != expected:
+                errors.append(f"L{line_idx + 1} box padding={pad}, expected={expected}")
+
+    return errors
+
+
+def _fix_padding_in_block(code_indices, all_lines):
+    code_lines = [(i, all_lines[i].rstrip("\n")) for i in code_indices]
+    if _is_tree_block(code_lines):
+        return
+
+    for col_left, col_right, _, _, content_indices in _find_boxes(code_lines):
+        paddings = []
+        for ci in content_indices:
+            line_idx, raw = code_lines[ci]
+            pad = _get_left_padding(raw, col_left, col_right)
+            if pad is not None:
+                paddings.append((ci, line_idx, pad))
+
+        if len(paddings) < 2 or _has_layout_intent([p for _, _, p in paddings]):
+            continue
+
+        expected = _expected_padding([p for _, _, p in paddings])
+        if expected is None:
+            continue
+
+        for ci, line_idx, pad in paddings:
+            if pad == expected:
+                continue
+            raw = all_lines[line_idx].rstrip("\n")
+            inner = raw[col_left + 1 : col_right]
+            content = inner.strip()
+            total_width = col_right - col_left - 1
+            new_inner = " " * expected + content
+            remaining = total_width - len(new_inner)
+            if remaining < 1:
+                continue
+            new_inner = new_inner + " " * remaining
+            new_raw = raw[: col_left + 1] + new_inner + raw[col_right:]
+            all_lines[line_idx] = new_raw + "\n"

docalign/checks/box_spacing.py

@@ -0,0 +1,213 @@
+from docalign.constants import (
+    BORDER_CHARS,
+    BOX_CHARS,
+    LARGE_SPACE_GAP,
+    MAX_FIX_ITERATIONS,
+    MIN_PAD,
+)
+from docalign.parser import iter_code_blocks
+from docalign.utils import _find_boxes, _is_tree_block
+
+
+def check(lines):
+    errors = []
+    for _, code_lines in iter_code_blocks(lines):
+        errors.extend(_check_spacing(code_lines))
+    return errors
+
+
+def fix(lines):
+    result = list(lines)
+    for code_indices, _ in iter_code_blocks(result):
+        _fix_spacing_in_block(code_indices, result)
+    return result
+
+
+def _get_right_padding(raw, col_left, col_right):
+    if col_left >= len(raw) or raw[col_left] != "│":
+        return None
+    if col_right >= len(raw) or raw[col_right] not in BOX_CHARS:
+        return None
+    inner = raw[col_left + 1 : col_right]
+    if not inner.strip():
+        return None
+    if any(c in BOX_CHARS for c in inner):
+        return None
+    return len(inner) - len(inner.rstrip())
+
+
+def _get_left_padding(raw, col_left, col_right):
+    if col_left >= len(raw) or raw[col_left] != "│":
+        return None
+    if col_right >= len(raw) or raw[col_right] not in BOX_CHARS:
+        return None
+    inner = raw[col_left + 1 : col_right]
+    if not inner.strip():
+        return None
+    if any(c in BOX_CHARS for c in inner):
+        return None
+    return len(inner) - len(inner.lstrip())
+
+
+def _check_spacing(code_lines):
+    errors = []
+    if _is_tree_block(code_lines):
+        return errors
+
+    for col_left, col_right, _, _, content_indices in _find_boxes(code_lines):
+        for ci in content_indices:
+            line_idx, raw = code_lines[ci]
+            rpad = _get_right_padding(raw, col_left, col_right)
+            if rpad is not None and rpad < MIN_PAD:
+                errors.append(f"L{line_idx + 1} box right spacing={rpad}, minimum={MIN_PAD}")
+            lpad = _get_left_padding(raw, col_left, col_right)
+            if lpad is not None and lpad < MIN_PAD:
+                errors.append(f"L{line_idx + 1} box left spacing={lpad}, minimum={MIN_PAD}")
+
+    return errors
+
+
+def _find_connectors_in_range(raw, col_left, col_right):
+    connectors = []
+    for col in range(col_left, col_right + 1):
+        if col < len(raw) and raw[col] in ("┬", "┴"):
+            connectors.append(col)
+    return connectors
+
+
+def _collect_box_insertions(code_lines):
+    all_boxes = list(_find_boxes(code_lines))
+
+    def get_parent_info(col_left, col_right):
+        for other_left, other_right, opening_ci, *_ in all_boxes:
+            if other_left < col_left and col_right < other_right:
+                return (other_left, other_right, opening_ci)
+        return None
+
+    def has_sibling_after(col_right, opener_raw):
+        after = opener_raw[col_right + 1 :]
+        if "┌" not in after:
+            return False
+        corner_pos = after.index("┌")
+        between = after[:corner_pos]
+        return LARGE_SPACE_GAP in between
+
+    box_insertions = []
+    for col_left, col_right, opening_ci, closing_ci, content_indices in all_boxes:
+        parent_info = get_parent_info(col_left, col_right)
+        if parent_info is not None:
+            _, parent_right, parent_opening_ci = parent_info
+            parent_opener_raw = code_lines[parent_opening_ci][1]
+            if has_sibling_after(parent_right, parent_opener_raw):
+                continue
+
+        min_rpad = None
+        min_lpad = None
+        for ci in content_indices:
+            _, raw = code_lines[ci]
+            rpad = _get_right_padding(raw, col_left, col_right)
+            if rpad is not None:
+                if min_rpad is None or rpad < min_rpad:
+                    min_rpad = rpad
+            lpad = _get_left_padding(raw, col_left, col_right)
+            if lpad is not None:
+                if min_lpad is None or lpad < min_lpad:
+                    min_lpad = lpad
+
+        all_ci = [opening_ci] + content_indices + [closing_ci]
+        line_indices = [code_lines[ci][0] for ci in all_ci]
+
+        opener_raw = code_lines[opening_ci][1]
+        closer_raw = code_lines[closing_ci][1]
+        connectors = _find_connectors_in_range(opener_raw, col_left, col_right)
+        connectors.extend(_find_connectors_in_range(closer_raw, col_left, col_right))
+
+        if min_rpad is not None and min_rpad < MIN_PAD:
+            deficit = MIN_PAD - min_rpad
+            box_insertions.append((col_right, deficit, "right", line_indices, []))
+
+        if min_lpad is not None and min_lpad < MIN_PAD:
+            deficit = MIN_PAD - min_lpad
+            box_insertions.append((col_left + 1, deficit, "left", line_indices, connectors))
+
+    return box_insertions
+
+
+def _trace_connected_pipes(code_indices, all_lines, box_lines, connector_col):
+    connected = set()
+    max_box = max(box_lines)
+    for line_idx in code_indices:
+        if line_idx <= max_box:
+            continue
+        raw = all_lines[line_idx].rstrip("\n")
+        if connector_col >= len(raw):
+            break
+        char = raw[connector_col]
+        if char == "│":
+            connected.add(line_idx)
+        elif char in ("┬", "┴"):
+            if "┌" in raw or "└" in raw:
+                break
+            connected.add(line_idx)
+            break
+        else:
+            break
+    return connected
+
+
+def _is_complex_multi_column(box_insertions):
+    left_insertions = [ins for ins in box_insertions if ins[2] == "left"]
+    if len(left_insertions) <= 1:
+        return False
+    cols = set(ins[0] for ins in left_insertions)
+    if len(cols) <= 1:
+        return False
+    line_sets = [set(ins[3]) for ins in left_insertions]
+    for i, lines_a in enumerate(line_sets):
+        for lines_b in line_sets[i + 1 :]:
+            if not lines_a & lines_b:
+                return True
+    return False
+
+
+def _apply_box_insertions(all_lines, box_insertions, code_indices):
+    if not box_insertions:
+        return False
+
+    if _is_complex_multi_column(box_insertions):
+        return False
+
+    sorted_insertions = sorted(box_insertions, key=lambda x: -x[0])
+
+    for col, deficit, ins_type, line_indices, connectors in sorted_insertions:
+        extended = set(line_indices)
+        if ins_type == "left" and connectors:
+            for connector_col in connectors:
+                connected = _trace_connected_pipes(code_indices, all_lines, set(line_indices), connector_col)
+                extended.update(connected)
+
+        for line_idx in extended:
+            raw = all_lines[line_idx].rstrip("\n")
+            if col > len(raw):
+                continue
+            if col == 0:
+                insert = " " * deficit
+            elif col <= len(raw) and raw[col - 1] in BORDER_CHARS:
+                insert = "─" * deficit
+            else:
+                insert = " " * deficit
+            new_raw = raw[:col] + insert + raw[col:]
+            all_lines[line_idx] = new_raw + "\n"
+
+    return True
+
+
+def _fix_spacing_in_block(code_indices, all_lines):
+    if _is_tree_block([(i, all_lines[i].rstrip("\n")) for i in code_indices]):
+        return
+
+    for _ in range(MAX_FIX_ITERATIONS):
+        code_lines = [(i, all_lines[i].rstrip("\n")) for i in code_indices]
+        box_insertions = _collect_box_insertions(code_lines)
+        if not _apply_box_insertions(all_lines, box_insertions, code_indices):
+            break

docalign/checks/box_walls.py

@@ -0,0 +1,249 @@
+from docalign.constants import (
+    BOX_CHARS,
+    BOX_WALL_DRIFT,
+    LARGE_SPACE_GAP,
+    MIN_BOX_WIDTH,
+    MIN_PIPES_FOR_ADJACENT,
+)
+from docalign.parser import iter_code_blocks
+from docalign.utils import (
+    _find_box_closer,
+    _find_nearby_closer_start,
+    _find_nearby_pipe,
+    _fix_closer,
+    _is_tree_block,
+    _shift_pipe,
+)
+
+
+def check(lines):
+    errors = []
+    for _, code_lines in iter_code_blocks(lines):
+        errors.extend(_check_box_walls(code_lines))
+    return errors
+
+
+def fix(lines):
+    result = list(lines)
+    for code_indices, _ in iter_code_blocks(lines):
+        _fix_box_walls_in_block(code_indices, result)
+    return result
+
+
+def _has_independent_box_after(raw, col):
+    after = raw[col + 1 :] if col + 1 < len(raw) else ""
+    if not after:
+        return False
+    has_box_structure = "┌" in after or "└" in after
+    if not has_box_structure:
+        return False
+    pipe_indices = [i for i, c in enumerate(after) if c == "│"]
+    if len(pipe_indices) < MIN_PIPES_FOR_ADJACENT:
+        return False
+    first_pipe = pipe_indices[0]
+    second_pipe = pipe_indices[1]
+    between_pipes = after[first_pipe + 1 : second_pipe]
+    return LARGE_SPACE_GAP in between_pipes
+
+
+def _check_box_walls(code_lines):
+    errors = []
+    if _is_tree_block(code_lines):
+        return errors
+
+    for idx, (line_idx, raw) in enumerate(code_lines):
+        j = 0
+        while j < len(raw):
+            if raw[j] != "┌":
+                j += 1
+                continue
+
+            col_left = j
+            col_right_open = _find_box_closer(raw, "┌", "┐", j)
+            if col_right_open is None or col_right_open - col_left < MIN_BOX_WIDTH:
+                j += 1
+                continue
+
+            closing_idx = None
+            fuzzy_col_left = None
+            for si in range(idx + 1, len(code_lines)):
+                _, sraw = code_lines[si]
+                if col_left < len(sraw) and sraw[col_left] == "└":
+                    closing_idx = si
+                    break
+                nc = _find_nearby_closer_start(sraw, col_left, col_right_open)
+                if nc is not None:
+                    closing_idx = si
+                    fuzzy_col_left = nc
+                    break
+
+            if closing_idx is None or closing_idx - idx < 3:
+                j = col_right_open + 1
+                continue
+
+            closing_line_idx, closing_raw = code_lines[closing_idx]
+            actual_col_left = fuzzy_col_left if fuzzy_col_left is not None else col_left
+            col_right_close = _find_box_closer(closing_raw, "└", "┘", actual_col_left)
+
+            if fuzzy_col_left is not None:
+                errors.append(
+                    f"L{closing_line_idx + 1} box └ at col {fuzzy_col_left}, "
+                    f"expected col {col_left} "
+                    f"(box ┌ at L{line_idx + 1} col {col_left})"
+                )
+
+            if col_right_close is not None:
+                if abs(col_right_close - col_right_open) > BOX_WALL_DRIFT:
+                    j = col_right_open + 1
+                    continue
+                expected_right = max(col_right_open, col_right_close)
+            else:
+                expected_right = col_right_open
+
+            if col_right_open != expected_right:
+                errors.append(f"L{line_idx + 1} box ┐ at col {col_right_open}, expected col {expected_right}")
+
+            if col_right_close is not None and col_right_close != expected_right:
+                errors.append(f"L{closing_line_idx + 1} box ┘ at col {col_right_close}, expected col {expected_right}")
+
+            for mi in range(idx + 1, closing_idx):
+                m_line_idx, m_raw = code_lines[mi]
+                right_ok = expected_right < len(m_raw) and m_raw[expected_right] in BOX_CHARS
+                if not right_ok:
+                    found = _find_nearby_pipe(m_raw, expected_right, BOX_WALL_DRIFT)
+                    if found is not None:
+                        errors.append(
+                            f"L{m_line_idx + 1} box wall │ at col {found}, "
+                            f"expected col {expected_right} "
+                            f"(box ┌ at L{line_idx + 1} col {col_left})"
+                        )
+                if col_left < len(m_raw):
+                    if m_raw[col_left] not in BOX_CHARS:
+                        found = _find_nearby_pipe(m_raw, col_left, BOX_WALL_DRIFT)
+                        if found is not None:
+                            errors.append(
+                                f"L{m_line_idx + 1} box wall │ at col {found}, "
+                                f"expected col {col_left} "
+                                f"(box ┌ at L{line_idx + 1} col {col_left})"
+                            )
+
+            j = col_right_open + 1
+
+    return errors
+
+
+def _fix_box_walls_in_block(code_indices, all_lines):
+    code_lines = [(i, all_lines[i].rstrip("\n")) for i in code_indices]
+    if _is_tree_block(code_lines):
+        return
+
+    for idx, (line_idx, raw) in enumerate(code_lines):
+        j = 0
+        while j < len(raw):
+            if raw[j] != "┌":
+                j += 1
+                continue
+
+            col_left = j
+            col_right_open = _find_box_closer(raw, "┌", "┐", j)
+            if col_right_open is None or col_right_open - col_left < MIN_BOX_WIDTH:
+                j += 1
+                continue
+
+            closing_idx = None
+            fuzzy_col_left = None
+            for si in range(idx + 1, len(code_lines)):
+                si_idx = code_lines[si][0]
+                sraw = all_lines[si_idx].rstrip("\n")
+                if col_left < len(sraw) and sraw[col_left] == "└":
+                    closing_idx = si
+                    break
+                nc = _find_nearby_closer_start(sraw, col_left, col_right_open)
+                if nc is not None:
+                    closing_idx = si
+                    fuzzy_col_left = nc
+                    break
+
+            if closing_idx is None or closing_idx - idx < 3:
+                j = col_right_open + 1
+                continue
+
+            closing_line_idx = code_lines[closing_idx][0]
+            closing_raw = all_lines[closing_line_idx].rstrip("\n")
+            actual_col_left = fuzzy_col_left if fuzzy_col_left is not None else col_left
+            col_right_close = _find_box_closer(closing_raw, "└", "┘", actual_col_left)
+
+            if col_right_close is not None:
+                if abs(col_right_close - col_right_open) > BOX_WALL_DRIFT:
+                    j = col_right_open + 1
+                    continue
+                expected_right = max(col_right_open, col_right_close)
+            else:
+                expected_right = col_right_open
+
+            changed = False
+
+            if fuzzy_col_left is not None:
+                from docalign.utils import _realign_box_chars
+
+                cur = all_lines[closing_line_idx].rstrip("\n")
+                actual_positions = [k for k, c in enumerate(cur) if c in BOX_CHARS]
+                expected_positions = []
+                for ap in actual_positions:
+                    if ap == fuzzy_col_left:
+                        expected_positions.append(col_left)
+                    elif ap == col_right_close and col_right_close is not None:
+                        expected_positions.append(col_right_open)
+                    else:
+                        expected_positions.append(ap)
+                fixed = _realign_box_chars(cur, actual_positions, expected_positions).rstrip(" ")
+                if fixed != cur:
+                    all_lines[closing_line_idx] = fixed + "\n"
+                    closing_raw = fixed
+                    col_right_close = col_right_open
+                    expected_right = col_right_open
+                    changed = True
+
+            if col_right_open != expected_right:
+                fixed = _fix_closer(raw, col_right_open, expected_right, "┐")
+                if fixed != raw:
+                    all_lines[line_idx] = fixed + "\n"
+                    changed = True
+
+            if col_right_close is not None and col_right_close != expected_right:
+                cur = all_lines[closing_line_idx].rstrip("\n")
+                fixed = _fix_closer(cur, col_right_close, expected_right, "┘")
+                if fixed != cur:
+                    all_lines[closing_line_idx] = fixed + "\n"
+                    changed = True
+
+            has_adjacent_box_on_line = "┌" in raw[col_right_open + 1 :]
+
+            for mi in range(idx + 1, closing_idx):
+                m_line_idx = code_lines[mi][0]
+                m_raw = all_lines[m_line_idx].rstrip("\n")
+                has_box_after_right = _has_independent_box_after(m_raw, expected_right)
+                has_box_after_left = _has_independent_box_after(m_raw, col_left)
+                right_ok = expected_right < len(m_raw) and m_raw[expected_right] in BOX_CHARS
+                if not right_ok:
+                    found = _find_nearby_pipe(m_raw, expected_right, BOX_WALL_DRIFT)
+                    if found is not None and not has_box_after_right and not has_adjacent_box_on_line:
+                        fixed = _shift_pipe(m_raw, found, expected_right)
+                        if fixed != m_raw:
+                            all_lines[m_line_idx] = fixed + "\n"
+                            m_raw = fixed
+                            changed = True
+                if col_left < len(m_raw):
+                    if m_raw[col_left] not in BOX_CHARS:
+                        found = _find_nearby_pipe(m_raw, col_left, BOX_WALL_DRIFT)
+                        if found is not None and not has_box_after_left and not has_adjacent_box_on_line:
+                            fixed = _shift_pipe(m_raw, found, col_left)
+                            if fixed != m_raw:
+                                all_lines[m_line_idx] = fixed + "\n"
+                                changed = True
+
+            if changed:
+                code_lines = [(i, all_lines[i].rstrip("\n")) for i in code_indices]
+                raw = all_lines[line_idx].rstrip("\n")
+
+            j = col_right_open + 1