termrender 0.1.0__py3-none-any.whl

termrender/renderers/borders.py

@@ -0,0 +1,70 @@
+"""Shared box-drawing border helper for termrender renderers."""
+
+from __future__ import annotations
+
+from termrender.style import style, visual_len, visual_ljust
+
+
+def render_box(
+    content_lines: list[str],
+    width: int,
+    color: bool,
+    title: str | None = None,
+    border_color: str | None = None,
+    dim: bool = False,
+) -> list[str]:
+    """Render content lines inside a box-drawing border.
+
+    Args:
+        content_lines: Pre-rendered content to wrap in a box.
+        width: Total width of the box including borders.
+        color: Whether ANSI styling is enabled.
+        title: Optional title to display in the top border.
+        border_color: Color name for the border (used by panels).
+        dim: Whether to dim the border (used by code blocks).
+    """
+    inner_w = width - 2  # border chars on each side
+    content_w = inner_w - 2  # 1-char padding on each side
+
+    # Build style kwargs for borders
+    style_kw: dict = {"enabled": color}
+    if border_color:
+        style_kw["color"] = border_color
+    if dim:
+        style_kw["dim"] = True
+
+    # Top border
+    if title:
+        title_part = f"─ {title} "
+        fill_count = max(0, inner_w - visual_len(title_part))
+        top_raw = "┌" + title_part + "─" * fill_count + "┐"
+    else:
+        top_raw = "┌" + "─" * inner_w + "┐"
+    top = style(top_raw, **style_kw)
+    top = visual_ljust(top, width)
+
+    # Bottom border
+    bot_raw = "└" + "─" * inner_w + "┘"
+    bot = style(bot_raw, **style_kw)
+    bot = visual_ljust(bot, width)
+
+    # Side borders
+    left = style("│", **style_kw)
+    right = style("│", **style_kw)
+
+    # Build output lines
+    lines = [top]
+    for cl in content_lines:
+        padded = visual_ljust(cl, content_w)
+        line = left + " " + padded + " " + right
+        line = visual_ljust(line, width)
+        lines.append(line)
+
+    # If no content, add one empty line
+    if not content_lines:
+        empty = left + " " + " " * content_w + " " + right
+        empty = visual_ljust(empty, width)
+        lines.append(empty)
+
+    lines.append(bot)
+    return lines

termrender/renderers/code.py

@@ -0,0 +1,41 @@
+"""Syntax-highlighted code block renderer for termrender."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from pygments import highlight
+from pygments.formatters import TerminalFormatter
+from pygments.lexers import TextLexer, get_lexer_by_name
+
+from termrender.blocks import Block
+from termrender.renderers.borders import render_box
+
+
+def render(
+    block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]
+) -> list[str]:
+    """Render a code block with syntax highlighting and box-drawing borders."""
+    source = block.attrs.get("source", "")
+    lang = block.attrs.get("lang")
+
+    # Syntax highlight (or plain text)
+    if color and source:
+        try:
+            lexer = get_lexer_by_name(lang) if lang else TextLexer()
+        except Exception:
+            lexer = TextLexer()
+        highlighted = highlight(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 [""]
+
+    return render_box(
+        code_lines,
+        width=block.width,
+        color=color,
+        title=lang,
+        dim=True,
+    )

termrender/renderers/columns.py

@@ -0,0 +1,34 @@
+"""Column layout renderer (DES-008)."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from termrender.blocks import Block
+from termrender.style import visual_ljust
+
+
+def render(block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]) -> list[str]:
+    """Render a COLUMNS block by zipping child COL blocks horizontally."""
+    col_outputs: list[tuple[int, list[str]]] = []
+    max_height = 0
+
+    for col in block.children:
+        lines = render_child(col, color)
+        col_outputs.append((col.width, lines))
+        if len(lines) > max_height:
+            max_height = len(lines)
+
+    if not col_outputs:
+        return [' ' * block.width] if block.width else ['']
+
+    result: list[str] = []
+    for row in range(max_height):
+        parts: list[str] = []
+        for col_width, lines in col_outputs:
+            line = lines[row] if row < len(lines) else ''
+            parts.append(visual_ljust(line, col_width))
+        joined = ' '.join(parts)
+        result.append(visual_ljust(joined, block.width))
+
+    return result

termrender/renderers/divider.py

@@ -0,0 +1,23 @@
+"""Horizontal divider renderer for termrender."""
+
+from __future__ import annotations
+
+from termrender.blocks import Block
+from termrender.style import style, visual_center, visual_ljust
+
+
+def render(block: Block, color: bool) -> list[str]:
+    """Render a horizontal divider, optionally with a centered label."""
+    w = block.width
+    label = block.attrs.get("label")
+
+    if label:
+        # Center label with surrounding dashes: ──── Label ────
+        inner = f" {label} "
+        line = visual_center(inner, w, "─")
+    else:
+        line = "─" * w
+
+    line = style(line, dim=True, enabled=color)
+    line = visual_ljust(line, w)
+    return [line]

termrender/renderers/mermaid.py

@@ -0,0 +1,34 @@
+"""Mermaid diagram renderer for termrender."""
+
+from __future__ import annotations
+
+import subprocess
+
+from termrender.blocks import Block
+from termrender.style import visual_ljust
+
+
+def render(block: Block, color: bool) -> list[str]:
+    """Render a mermaid diagram from pre-rendered or on-the-fly ASCII output."""
+    w = block.width
+    rendered = block.attrs.get("_rendered")
+
+    if rendered is None:
+        source = block.attrs.get("source", "")
+        try:
+            result = subprocess.run(
+                ["mermaid-ascii", "-f", "-"],
+                input=source,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            rendered = result.stdout
+        except Exception:
+            rendered = source
+
+    lines: list[str] = []
+    for raw_line in rendered.split("\n"):
+        lines.append(visual_ljust(raw_line, w))
+
+    return lines

termrender/renderers/panel.py

@@ -0,0 +1,64 @@
+"""Panel and callout renderers for termrender."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from termrender.blocks import Block, BlockType
+from termrender.renderers.borders import render_box
+
+
+def render(
+    block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]
+) -> list[str]:
+    """Render a panel block with box-drawing borders."""
+    border_color = block.attrs.get("color")
+    title = block.attrs.get("title")
+
+    # Render children content
+    content_lines: list[str] = []
+    for child in block.children:
+        content_lines.extend(render_child(child, color))
+
+    return render_box(
+        content_lines,
+        width=block.width,
+        color=color,
+        title=title,
+        border_color=border_color,
+    )
+
+
+# Callout type -> (color, icon)
+_CALLOUT_MAP = {
+    "info": ("blue", "ℹ"),
+    "warning": ("yellow", "⚠"),
+    "error": ("red", "✖"),
+    "success": ("green", "✔"),
+}
+
+
+def render_callout(
+    block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]
+) -> list[str]:
+    """Render a callout block by delegating to panel rendering."""
+    callout_type = block.attrs.get("type", "info")
+    callout_color, icon = _CALLOUT_MAP.get(callout_type, ("blue", "ℹ"))
+
+    title = f"{icon} {callout_type.capitalize()}"
+
+    # Create a copy of attrs with title and color set
+    patched_attrs = dict(block.attrs)
+    patched_attrs["title"] = title
+    patched_attrs["color"] = callout_color
+
+    # Build a proxy block with the patched attrs
+    proxy = Block(
+        type=BlockType.PANEL,
+        children=block.children,
+        text=block.text,
+        attrs=patched_attrs,
+        width=block.width,
+        height=block.height,
+    )
+    return render(proxy, color, render_child)

termrender/renderers/quote.py

@@ -0,0 +1,32 @@
+"""Blockquote renderer for termrender."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from termrender.blocks import Block
+from termrender.style import style, visual_ljust
+
+
+def render(
+    block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]
+) -> list[str]:
+    """Render a blockquote with a left border bar and optional attribution."""
+    w = block.width
+    bar = style("│ ", color="gray", enabled=color)
+    bar_width = 2  # visual width of "│ "
+    inner_w = w - bar_width
+
+    lines: list[str] = []
+    for child in block.children:
+        for cl in render_child(child, color):
+            padded = visual_ljust(cl, inner_w)
+            lines.append(visual_ljust(bar + padded, w))
+
+    by = block.attrs.get("by")
+    if by:
+        attr_text = style(f"— {by}", dim=True, enabled=color)
+        attr_line = visual_ljust(bar + visual_ljust(attr_text, inner_w), w)
+        lines.append(attr_line)
+
+    return lines

termrender/renderers/text.py

@@ -0,0 +1,157 @@
+"""Paragraph, heading, list, and list-item renderers for termrender."""
+
+from __future__ import annotations
+
+from termrender.blocks import Block, BlockType, InlineSpan
+from termrender.style import style, visual_len, visual_ljust, wrap_text, render_spans
+
+
+def _render_wrapped_spans(
+    spans: list[InlineSpan],
+    width: int,
+    color: bool,
+    first_prefix: str = "",
+    cont_prefix: str = "",
+    total_width: int | None = None,
+) -> list[str]:
+    """Wrap spans into styled lines with optional prefixes and padding."""
+    if total_width is None:
+        total_width = width
+
+    plain = "".join(span.text for span in spans)
+    wrapped = wrap_text(plain, max(width, 1))
+
+    lines: list[str] = []
+    char_offset = 0
+    for i, raw_line in enumerate(wrapped):
+        line_len = len(raw_line)
+        styled = _render_span_slice(spans, char_offset, char_offset + line_len, color)
+        prefix = first_prefix if i == 0 else cont_prefix
+        lines.append(visual_ljust(prefix + styled, total_width))
+        char_offset += line_len
+        if char_offset < len(plain) and plain[char_offset] == " ":
+            char_offset += 1
+
+    return lines
+
+
+def _render_paragraph(block: Block, color: bool) -> list[str]:
+    if not block.text:
+        return [visual_ljust("", block.width)]
+
+    return _render_wrapped_spans(block.text, block.width, color)
+
+
+def _render_span_slice(
+    spans: list[InlineSpan], start: int, end: int, color: bool
+) -> str:
+    """Render the portion of spans covering character range [start, end)."""
+    parts: list[str] = []
+    offset = 0
+    for span in spans:
+        span_start = offset
+        span_end = offset + len(span.text)
+        # Find overlap with [start, end)
+        overlap_start = max(span_start, start)
+        overlap_end = min(span_end, end)
+        if overlap_start < overlap_end:
+            slice_text = span.text[overlap_start - span_start : overlap_end - span_start]
+            if span.code:
+                slice_text = style(slice_text, dim=True, enabled=color)
+            elif span.bold or span.italic:
+                slice_text = style(slice_text, bold=span.bold, italic=span.italic, enabled=color)
+            parts.append(slice_text)
+        offset = span_end
+        if offset >= end:
+            break
+    return "".join(parts)
+
+
+def _render_heading(block: Block, color: bool) -> list[str]:
+    level = block.attrs.get("level", 1)
+    text = render_spans(block.text, color=False)  # plain text first
+
+    if level == 1:
+        styled = style(text, color="blue", bold=True, enabled=color)
+    elif level == 2:
+        styled = style(text, bold=True, enabled=color)
+    elif level == 3:
+        styled = style(text, italic=True, enabled=color)
+    else:
+        styled = style(text, dim=True, enabled=color)
+
+    return [visual_ljust(styled, block.width)]
+
+
+def _render_list(block: Block, color: bool) -> list[str]:
+    if not block.children:
+        return [visual_ljust("", block.width)]
+
+    ordered = block.attrs.get("ordered", False)
+    lines: list[str] = []
+
+    for i, child in enumerate(block.children):
+        if child.type == BlockType.LIST_ITEM:
+            prefix = f"{i + 1}. " if ordered else "• "
+            item_lines = _render_list_item(child, prefix, color)
+            lines.extend(item_lines)
+        elif child.type == BlockType.LIST:
+            # Nested list — indent by 2
+            nested = Block(
+                type=child.type,
+                children=child.children,
+                text=child.text,
+                attrs=child.attrs,
+                width=(child.width or block.width) - 2,
+                height=child.height,
+            )
+            nested_lines = _render_list(nested, color)
+            for nl in nested_lines:
+                lines.append(visual_ljust("  " + nl.rstrip(), block.width))
+
+    return lines if lines else [visual_ljust("", block.width)]
+
+
+def _render_list_item(block: Block, prefix: str, color: bool) -> list[str]:
+    w = block.width
+    indent = " " * len(prefix)
+    text_width = w - len(prefix)
+
+    if not block.text:
+        return [visual_ljust(prefix, w)]
+
+    lines = _render_wrapped_spans(
+        block.text, text_width, color,
+        first_prefix=prefix, cont_prefix=indent, total_width=w,
+    )
+
+    # Render nested children (e.g., nested lists inside list items)
+    for child in block.children:
+        if child.type == BlockType.LIST:
+            nested = Block(
+                type=child.type,
+                children=child.children,
+                text=child.text,
+                attrs=child.attrs,
+                width=w - len(prefix),
+                height=child.height,
+            )
+            nested_lines = _render_list(nested, color)
+            for nl in nested_lines:
+                lines.append(visual_ljust(indent + nl.rstrip(), w))
+
+    return lines
+
+
+def render(block: Block, color: bool) -> list[str]:
+    """Render a text block (paragraph, heading, list, or list item)."""
+    if block.type == BlockType.PARAGRAPH:
+        return _render_paragraph(block, color)
+    elif block.type == BlockType.HEADING:
+        return _render_heading(block, color)
+    elif block.type == BlockType.LIST:
+        return _render_list(block, color)
+    elif block.type == BlockType.LIST_ITEM:
+        return _render_list_item(block, "• ", color)
+    else:
+        return [visual_ljust("", block.width or 0)]

termrender/renderers/tree.py

@@ -0,0 +1,164 @@
+"""Tree rendering with Unicode guide lines (DES-010)."""
+
+from __future__ import annotations
+
+import re
+
+from termrender.blocks import Block, InlineSpan
+from termrender.style import style, visual_ljust, render_spans
+
+# Unicode box-drawing guide characters
+BRANCH = "├── "
+LAST_BRANCH = "└── "
+CONTINUATION = "│   "
+BLANK = "    "
+
+# Status marker patterns
+STATUS_MARKERS = {
+    "[x]": ("✔", "green"),
+    "[!]": ("⚠", "yellow"),
+}
+
+
+def _detect_indent(lines: list[str]) -> int:
+    """Auto-detect indent level (2 or 4 spaces) from source lines."""
+    for line in lines:
+        if not line or not line[0] == " ":
+            continue
+        stripped = line.lstrip(" ")
+        indent = len(line) - len(stripped)
+        if indent > 0:
+            return 2 if indent <= 2 else (indent if indent <= 4 else 4)
+    return 2
+
+
+def _parse_tree(lines: list[str], indent_size: int) -> list[tuple[int, str]]:
+    """Parse indented lines into (depth, label) pairs."""
+    result: list[tuple[int, str]] = []
+    for line in lines:
+        if not line.strip():
+            continue
+        stripped = line.lstrip(" ")
+        spaces = len(line) - len(stripped)
+        depth = spaces // indent_size
+        result.append((depth, stripped))
+    return result
+
+
+def _apply_status_markers(label: str, color: bool) -> str:
+    """Replace status markers like [x] and [!] with styled symbols."""
+    for marker, (symbol, clr) in STATUS_MARKERS.items():
+        if marker in label:
+            styled_symbol = style(symbol, color=clr, enabled=color)
+            label = label.replace(marker, styled_symbol)
+    return label
+
+
+_INLINE_RE = re.compile(
+    r'(\*\*(.+?)\*\*)'   # **bold**
+    r'|(\*(.+?)\*)'      # *italic*
+)
+
+
+def _label_to_spans(label: str) -> list[InlineSpan]:
+    """Convert a label string with markdown inline formatting to InlineSpans."""
+    spans: list[InlineSpan] = []
+    last_end = 0
+    for m in _INLINE_RE.finditer(label):
+        # Add any plain text before this match
+        if m.start() > last_end:
+            spans.append(InlineSpan(text=label[last_end:m.start()]))
+        if m.group(2) is not None:
+            # **bold**
+            spans.append(InlineSpan(text=m.group(2), bold=True))
+        elif m.group(4) is not None:
+            # *italic*
+            spans.append(InlineSpan(text=m.group(4), italic=True))
+        last_end = m.end()
+    # Trailing plain text
+    if last_end < len(label):
+        spans.append(InlineSpan(text=label[last_end:]))
+    return spans if spans else [InlineSpan(text=label)]
+
+
+def _style_guide(text: str, guide_color: str | None, color: bool) -> str:
+    """Style a guide line character with the tree's color attribute."""
+    if guide_color and color:
+        return style(text, color=guide_color, enabled=True)
+    return text
+
+
+def render(block: Block, color: bool) -> list[str]:
+    """Render a tree block with Unicode guide lines."""
+    source = block.attrs.get("source", "")
+    guide_color = block.attrs.get("color")
+    raw_lines = source.split("\n")
+    indent_size = _detect_indent(raw_lines)
+    nodes = _parse_tree(raw_lines, indent_size)
+    width = block.width or 80
+
+    if not nodes:
+        return [visual_ljust("", width)]
+
+    # For each node, determine its guide prefix based on depth and siblings
+    output: list[str] = []
+
+    # Build sibling relationships: for each node, is it the last among its siblings?
+    is_last: list[bool] = []
+    for i, (depth, _label) in enumerate(nodes):
+        # Look ahead to find if there's another node at the same depth
+        # under the same parent
+        last = True
+        for j in range(i + 1, len(nodes)):
+            jdepth, _ = nodes[j]
+            if jdepth == depth:
+                last = False
+                break
+            if jdepth < depth:
+                # We've gone back up past our parent, so we are last
+                break
+        is_last.append(last)
+
+    # Track which depth levels have continuing lines
+    # active_levels[d] = True means depth d still has children coming
+    for i, (depth, label) in enumerate(nodes):
+        # Apply status markers
+        label = _apply_status_markers(label, color)
+
+        # Build the prefix for this line
+        if depth == 0:
+            # Root-level items get no guide prefix
+            styled_label = render_spans(_label_to_spans(label), color)
+            line = styled_label
+        else:
+            # Build prefix from depth 1 to depth-1 (continuation/blank)
+            # then the branch character for current depth
+            prefix_parts: list[str] = []
+            for d in range(1, depth):
+                # Check if depth d has more siblings coming after this point
+                has_more = False
+                for j in range(i + 1, len(nodes)):
+                    jdepth, _ = nodes[j]
+                    if jdepth == d:
+                        has_more = True
+                        break
+                    if jdepth < d:
+                        break
+                if has_more:
+                    prefix_parts.append(_style_guide(CONTINUATION, guide_color, color))
+                else:
+                    prefix_parts.append(BLANK)
+
+            # Current depth connector
+            if is_last[i]:
+                prefix_parts.append(_style_guide(LAST_BRANCH, guide_color, color))
+            else:
+                prefix_parts.append(_style_guide(BRANCH, guide_color, color))
+
+            prefix = "".join(prefix_parts)
+            styled_label = render_spans(_label_to_spans(label), color)
+            line = prefix + styled_label
+
+        output.append(visual_ljust(line, width))
+
+    return output