termrender 0.7.1__tar.gz → 0.7.3__tar.gz

{termrender-0.7.1 → termrender-0.7.3}/CHANGELOG.md

@@ -1,6 +1,36 @@
 # CHANGELOG
 
 
+## v0.7.3 (2026-04-15)
+
+### Bug Fixes
+
+- **code**: Wrap long code lines to fit layout width
+  ([`31c6e59`](https://github.com/CaptainCrouton89/termrender/commit/31c6e595a438c4ced8c61fff679b59d4ae55f938))
+
+Code blocks previously used raw line count for height and let render_box grow beyond the layout
+  allocation. Now wraps source lines to the available content width in both layout and renderer.
+
+- **parser**: Add directive trace and file-absolute line numbers to error messages
+  ([`0f99ea0`](https://github.com/CaptainCrouton89/termrender/commit/0f99ea0310116f8fa06e933cd26126246d7a3b43))
+
+Stray-closer and unclosed-directive errors now print the full open/close trace and, when nested
+  directives share a colon count, name the specific cause and suggest the fix. Recursive body
+  parsing reports file-absolute line numbers via _line_offset threading through parse →
+  _split_directives → _directive_to_block.
+
+
+## v0.7.2 (2026-04-09)
+
+### Bug Fixes
+
+- **cli**: Default --tmux pane to 1/3 window width
+  ([`d9c1bcc`](https://github.com/CaptainCrouton89/termrender/commit/d9c1bccbe95a4e5cf1f975b82cbafde6d9d3807a))
+
+Instead of preview-rendering at 80 cols to measure content width, default to (window_width - 2) // 3
+  for a consistent 1/3 split.
+
+
 ## v0.7.1 (2026-04-08)
 
 ### Bug Fixes

{termrender-0.7.1 → termrender-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 0.7.1
+Version: 0.7.3
 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-0.7.1 → termrender-0.7.3}/src/termrender/__main__.py

@@ -298,17 +298,9 @@ def main() -> None:
             from termrender.parser import parse as _parse
             _parse(source)
         except DirectiveError as e:
-            _error(
-                f"syntax error: {e}",
-                fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"syntax error: {e}", code=EXIT_SYNTAX)
         except ValueError as e:
-            _error(
-                f"nesting error: {e}",
-                fix="reduce directive nesting depth (max 50 levels)",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"nesting error: {e}", code=EXIT_SYNTAX)
 
         import shlex
         import subprocess
@@ -343,28 +335,17 @@ def main() -> None:
             if args.width:
                 pane_width = args.width
             else:
-                # Preview render to measure content width
-                from termrender.style import visual_len
+                # Default: 1/3 of window width (minus separator)
                 try:
-                    preview = render(source, width=80, color=False)
-                    max_w = max(
-                        (visual_len(line) for line in preview.split('\n') if line),
-                        default=40,
+                    result = subprocess.run(
+                        ["tmux", "display-message", "-p", "#{window_width}"],
+                        capture_output=True, text=True, check=True,
                     )
-                    pane_width = max(max_w, 40)
+                    window_width = int(result.stdout.strip())
+                    pane_width = (window_width - 2) // 3
                 except Exception:
-                    pane_width = 80
+                    pane_width = 60
 
-            # Cap to available tmux space (leave room for the source pane)
-            try:
-                result = subprocess.run(
-                    ["tmux", "display-message", "-p", "#{pane_width}"],
-                    capture_output=True, text=True, check=True,
-                )
-                available = int(result.stdout.strip())
-                pane_width = min(pane_width, available - 10)
-            except Exception:
-                pass
             pane_width = max(pane_width, 20)  # absolute minimum
 
         # Watch mode points the new pane at the user's real file so edits
@@ -458,17 +439,9 @@ def main() -> None:
             from termrender.parser import parse
             parse(source)
         except DirectiveError as e:
-            _error(
-                f"syntax error: {e}",
-                fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"syntax error: {e}", code=EXIT_SYNTAX)
         except ValueError as e:
-            _error(
-                f"nesting error: {e}",
-                fix="reduce directive nesting depth (max 50 levels)",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"nesting error: {e}", code=EXIT_SYNTAX)
         print("ok", file=sys.stderr)
         sys.exit(EXIT_OK)
 
@@ -485,18 +458,9 @@ def main() -> None:
             code=EXIT_TERMINAL,
         )
     except DirectiveError as e:
-        _error(
-            f"syntax error: {e}",
-            fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-            hint="run: termrender --check <file> to validate before rendering",
-            code=EXIT_SYNTAX,
-        )
+        _error(f"syntax error: {e}", code=EXIT_SYNTAX)
     except ValueError as e:
-        _error(
-            f"nesting error: {e}",
-            fix="reduce directive nesting depth (max 50 levels)",
-            code=EXIT_SYNTAX,
-        )
+        _error(f"nesting error: {e}", code=EXIT_SYNTAX)
 
     sys.stdout.write(output)
 

{termrender-0.7.1 → termrender-0.7.3}/src/termrender/layout.py

@@ -92,8 +92,11 @@ def resolve_height(block: Block) -> None:
 
     elif bt == BlockType.CODE:
         source = block.attrs.get("source") or _plain_text(block.text)
-        code_lines = source.split("\n") if source else [""]
-        block.height = len(code_lines) + 2
+        raw_lines = source.split("\n") if source else [""]
+        border_v = visual_len("│")
+        content_w = max(width - 2 * border_v - 2, 1)
+        total_lines = sum(len(wrap_text(line, content_w)) for line in raw_lines)
+        block.height = total_lines + 2
 
     elif bt == BlockType.COLUMNS:
         block.height = max((c.height or 0 for c in block.children), default=0)

{termrender-0.7.1 → termrender-0.7.3}/src/termrender/parser.py

@@ -405,21 +405,80 @@ def _parse_markdown(source: str, _depth: int = 0) -> list[Block]:
     return _convert_ast(ast_nodes, _depth=_depth)
 
 
-def _split_directives(source: str) -> list[dict]:
+def _find_nested_directives(body_lines: list[str]) -> list[str]:
+    """Return names of directive openers found in body lines."""
+    names: list[str] = []
+    for line in body_lines:
+        m = _DIRECTIVE_OPEN.match(line)
+        if m:
+            names.append(m.group(2))
+    return names
+
+
+def _stray_closer_message(
+    abs_line: int, close_colons: str, trace: list[str],
+    last_closed: dict | None,
+) -> str:
+    """Format a stray-closer error with trace and fix suggestion."""
+    msg = f"line {abs_line}: stray '{close_colons}' closer — no directive is open"
+    if trace:
+        msg += "\n\n  directive trace:\n" + "\n".join(trace)
+
+    if last_closed:
+        nested = _find_nested_directives(last_closed["body_lines"])
+        if nested:
+            outer = last_closed["name"]
+            inner = nested[0]
+            fix_colons = ":" * (last_closed["colon_count"] + 1)
+            msg += (
+                f"\n\n  Likely cause: :::{outer} at line {last_closed['open_line']} "
+                f"contains a nested :::{inner} with the same colon count.\n"
+                f"  The inner ':::' closer (line {last_closed['close_line']}) "
+                f"matched the outer directive instead.\n"
+                f"  Fix: use {fix_colons}{outer} for the outer directive"
+            )
+            return msg
+
+    msg += (
+        "\n\n  Fix: remove this stray closer, or if nesting is intended,\n"
+        "  use more colons on outer directives (::::outer wraps :::inner)"
+    )
+    return msg
+
+
+def _unclosed_directive_message(
+    open_line: int, colons: str, name: str, trace: list[str],
+    body_lines: list[str],
+) -> str:
+    """Format an unclosed-directive error with trace and fix suggestion."""
+    msg = f"line {open_line}: unclosed '{colons}{name}' — add '{colons}' on a new line to close it"
+    if trace:
+        msg += "\n\n  directive trace:\n" + "\n".join(trace)
+    return msg
+
+
+def _split_directives(source: str, _line_offset: int = 0) -> list[dict]:
     """Split source into directive and markdown segments.
 
     Returns a list of segments, each being either:
       {"type": "markdown", "content": str}
-      {"type": "directive", "name": str, "attrs": dict, "body": str}
+      {"type": "directive", "name": str, "attrs": dict, "body": str,
+       "body_start_offset": int}
+
+    On error, raises DirectiveError with a directive trace showing the
+    sequence of opens/closes that led to the error state.
     """
     lines = source.split("\n")
     segments: list[dict] = []
     current_md_lines: list[str] = []
     stack: list[dict] = []  # stack of open directives
+    trace: list[str] = []   # event log for error diagnostics
+    last_closed: dict | None = None  # most recently closed directive entry
 
     i = 0
     while i < len(lines):
         line = lines[i]
+        abs_line = _line_offset + i + 1  # 1-indexed file-absolute line number
 
         # Check for directive opener
         m_open = _DIRECTIVE_OPEN.match(line)
@@ -440,6 +499,8 @@ def _split_directives(source: str) -> list[dict]:
                     "attrs_raw": attrs_raw,
                     "body_lines": [],
                     "colon_count": len(colons),
+                    "open_line": abs_line,
+                    "body_start_offset": _line_offset + i + 1,
                 }
                 # Self-closing directives (no body content expected)
                 if entry["name"] in _SELF_CLOSING_DIRECTIVES:
@@ -448,9 +509,12 @@ def _split_directives(source: str) -> list[dict]:
                         "name": entry["name"],
                         "attrs": _parse_attrs(entry["attrs_raw"]),
                         "body": "",
+                        "body_start_offset": entry["body_start_offset"],
                     })
+                    trace.append(f"    line {abs_line}: {colons}{name}  (self-closing)")
                 else:
                     stack.append(entry)
+                    trace.append(f"    line {abs_line}: {colons}{name}  opened")
             else:
                 # Nested directive — always treat as body content
                 stack[-1]["body_lines"].append(line)
@@ -462,8 +526,9 @@ def _split_directives(source: str) -> list[dict]:
         if m_close and not stack:
             if not _any_self_closing_before(lines, i):
                 close_colons = m_close.group(1)
+                trace.append(f"    line {abs_line}: {close_colons}  stray closer (nothing is open)")
                 raise DirectiveError(
-                    f"line {i + 1}: stray '{close_colons}' closer with no open directive"
+                    _stray_closer_message(abs_line, close_colons, trace, last_closed)
                 )
             # Stray closer after a self-closing directive like divider — skip
             i += 1
@@ -476,11 +541,30 @@ def _split_directives(source: str) -> list[dict]:
             else:
                 # Closing the open directive
                 entry = stack.pop()
+                closed_colons = ":" * entry["colon_count"]
+                nested = _find_nested_directives(entry["body_lines"])
+                nested_note = ""
+                if nested:
+                    names = ", ".join(f":::{n}" for n in nested[:3])
+                    nested_note = f"  — body has nested {names}"
+                trace.append(
+                    f"    line {abs_line}: {closed_colons}  "
+                    f"closed {entry['name']} (opened line {entry['open_line']})"
+                    f"{nested_note}"
+                )
+                last_closed = {
+                    "name": entry["name"],
+                    "colon_count": entry["colon_count"],
+                    "open_line": entry["open_line"],
+                    "close_line": abs_line,
+                    "body_lines": entry["body_lines"],
+                }
                 segments.append({
                     "type": "directive",
                     "name": entry["name"],
                     "attrs": _parse_attrs(entry["attrs_raw"]),
                     "body": "\n".join(entry["body_lines"]),
+                    "body_start_offset": entry["body_start_offset"],
                 })
             i += 1
             continue
@@ -504,8 +588,10 @@ def _split_directives(source: str) -> list[dict]:
         unclosed = stack[-1]
         colons = ":" * unclosed["colon_count"]
         name = unclosed["name"]
+        open_line = unclosed["open_line"]
+        trace.append(f"    line {open_line}: {colons}{name}  ← still open at end of input")
         raise DirectiveError(
-            f"unclosed directive '{colons}{name}' — missing closing '{colons}'"
+            _unclosed_directive_message(open_line, colons, name, trace, unclosed["body_lines"])
         )
 
     return segments
@@ -514,7 +600,7 @@ def _split_directives(source: str) -> list[dict]:
 _MAX_PARSE_DEPTH = 50
 
 
-def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int = 0) -> Block:
+def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int = 0, _line_offset: int = 0) -> Block:
     """Convert a parsed directive into a Block."""
     # Strip option lines from body; inline attrs take precedence over options
     options, body = _strip_options(body)
@@ -545,12 +631,12 @@ def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int
 
     # Stat: optional caption body parsed as markdown
     if block_type == BlockType.STAT:
-        body_doc = parse(body, _depth=_depth + 1) if body.strip() else Block(type=BlockType.DOCUMENT)
+        body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset) if body.strip() else Block(type=BlockType.DOCUMENT)
         return Block(type=block_type, children=body_doc.children, attrs=attrs)
 
     # Tasklist alias: parse body, find the inner list, force tasklist styling
     if name == "tasklist":
-        body_doc = parse(body, _depth=_depth + 1)
+        body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset)
         for child in body_doc.children:
             if child.type == BlockType.LIST:
                 child.attrs["tasklist"] = True
@@ -563,7 +649,7 @@ def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int
         return Block(type=BlockType.LIST, attrs={"tasklist": True, **attrs})
 
     # Recursively parse the body through the full two-pass pipeline
-    body_doc = parse(body, _depth=_depth + 1)
+    body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset)
     return Block(
         type=block_type,
         children=body_doc.children,
@@ -641,14 +727,14 @@ def _apply_tasklist_markers(block: Block) -> Block:
     return block
 
 
-def parse(source: str, _depth: int = 0) -> Block:
+def parse(source: str, _depth: int = 0, _line_offset: int = 0) -> Block:
     """Parse markdown+directive source into a Block tree.
 
     Returns a Block with type=DOCUMENT as root.
     """
     if _depth > _MAX_PARSE_DEPTH:
         raise ValueError(f"Maximum directive nesting depth ({_MAX_PARSE_DEPTH}) exceeded")
-    segments = _split_directives(source)
+    segments = _split_directives(source, _line_offset=_line_offset)
     children: list[Block] = []
 
     for seg in segments:
@@ -657,6 +743,7 @@ def parse(source: str, _depth: int = 0) -> Block:
         else:
             children.append(_directive_to_block(
                 seg["name"], seg["attrs"], seg["body"], _depth=_depth,
+                _line_offset=seg.get("body_start_offset", 0),
             ))
 
     # Walk the tree to auto-promote any markdown list with [ ]/[x] markers

{termrender-0.7.1 → termrender-0.7.3}/src/termrender/renderers/code.py

@@ -10,6 +10,7 @@ from pygments.lexers import TextLexer, get_lexer_by_name
 
 from termrender.blocks import Block
 from termrender.renderers.borders import render_box
+from termrender.style import visual_len, wrap_text
 
 
 def render(
@@ -19,18 +20,29 @@ def render(
     source = block.attrs.get("source", "")
     lang = block.attrs.get("lang")
 
+    # Wrap raw source lines to fit within the box before highlighting,
+    # so render_box doesn't need to grow beyond the layout allocation.
+    border_v = visual_len("│")
+    content_w = max((block.width or 1) - 2 * border_v - 2, 1)
+    raw_lines = source.split("\n") if source else [""]
+    wrapped_lines = []
+    for line in raw_lines:
+        wrapped_lines.extend(wrap_text(line, content_w))
+
+    wrapped_source = "\n".join(wrapped_lines)
+
     # Syntax highlight (or plain text)
-    if color and source:
+    if color and wrapped_source:
         try:
             lexer = get_lexer_by_name(lang) if lang else TextLexer()
         except Exception:
             lexer = TextLexer()
-        highlighted = highlight(source, lexer, TerminalFormatter())
+        highlighted = highlight(wrapped_source, lexer, TerminalFormatter())
         # Pygments adds a trailing newline — strip it
         highlighted = highlighted.rstrip("\n")
         code_lines = highlighted.split("\n")
     else:
-        code_lines = source.split("\n") if source else [""]
+        code_lines = wrapped_lines
 
     return render_box(
         code_lines,