iac-code 0.1.0__py3-none-any.whl

iac_code/ui/components/select.py

@@ -0,0 +1,319 @@
+"""Enhanced selector component with TextOption and InputOption support."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from iac_code.ui.components.search_box import SearchBox
+from iac_code.ui.core.key_event import KeyEvent
+
+
+@dataclass
+class TextOption:
+    """A selectable text option."""
+
+    label: str
+    value: Any
+    description: str = ""
+    disabled: bool = False
+
+
+@dataclass
+class InputOption:
+    """An option that opens an inline text input when selected."""
+
+    label: str
+    value: Any
+    placeholder: str = ""
+    initial_value: str = ""
+    on_change: Callable[[str], None] | None = None
+
+
+OptionType = TextOption | InputOption
+
+
+class SelectLayout(Enum):
+    COMPACT = "compact"
+    EXPANDED = "expanded"
+    COMPACT_VERTICAL = "compact_vertical"
+
+
+@dataclass
+class SelectState:
+    focused_index: int = 0
+    visible_from: int = 0
+    visible_to: int = 0
+    is_in_input: bool = False
+    input_values: dict[Any, str] = field(default_factory=dict)
+
+
+class Select:
+    """An enhanced selector component that supports TextOption and InputOption.
+
+    Navigation:
+        ↑/↓/Ctrl+P/Ctrl+N move focus (skipping disabled options).
+        PageUp/PageDown moves by visible_count.
+        No wrapping at edges.
+        Enter selects TextOption or enters edit mode for InputOption.
+        Escape cancels (or exits edit mode if in one).
+    """
+
+    def __init__(
+        self,
+        options: list[OptionType],
+        default_value: Any = None,
+        layout: SelectLayout = SelectLayout.EXPANDED,
+        visible_count: int = 10,
+        keybinding_manager: object | None = None,
+    ) -> None:
+        self._options = options
+        self._layout = layout
+        self._visible_count = visible_count
+        self._keybinding_manager = keybinding_manager
+
+        self.state = SelectState()
+
+        # Callbacks set externally or by run()
+        self._on_select: Callable[[Any], None] | None = None
+        self._on_cancel: Callable[[], None] | None = None
+        self._done: bool = False
+        self._result: Any = None
+
+        # Active search box for InputOption editing
+        self._active_search_box: SearchBox | None = None
+
+        # Set initial focus based on default_value
+        if default_value is not None:
+            for i, opt in enumerate(options):
+                if opt.value == default_value:
+                    self.state.focused_index = i
+                    break
+
+        # Initialize viewport
+        self._update_viewport()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def run(self) -> Any | None:
+        """Blocking mode: enter raw input and loop until selection or cancel."""
+        from rich.console import Console
+
+        from iac_code.ui.core.in_place_render import InPlaceRenderer
+        from iac_code.ui.core.raw_input import RawInputCapture
+
+        renderer = InPlaceRenderer(Console())
+        result_holder: list[Any] = []
+        cancelled = [False]
+
+        def on_select(value: Any) -> None:
+            result_holder.append(value)
+            self._done = True
+
+        def on_cancel() -> None:
+            cancelled[0] = True
+            self._done = True
+
+        self._on_select = on_select
+        self._on_cancel = on_cancel
+
+        try:
+            with RawInputCapture() as cap:
+                while not self._done:
+                    renderer.render(self.render())
+                    key_event = cap.read_key(timeout=0.1)
+                    if key_event is not None:
+                        self.handle_key(key_event)
+        finally:
+            renderer.clear()
+
+        if cancelled[0]:
+            return None
+        return result_holder[0] if result_holder else None
+
+    def render(self) -> RenderableType:
+        """Render the select component."""
+        lines: list[RenderableType] = []
+        visible_opts = self._options[self.state.visible_from : self.state.visible_to]
+        for i, opt in enumerate(visible_opts):
+            abs_i = self.state.visible_from + i
+            is_focused = abs_i == self.state.focused_index
+            lines.append(self._render_option(opt, is_focused, abs_i))
+        return Group(*lines)
+
+    def handle_key(self, key_event: KeyEvent) -> bool:
+        """Handle a key event. Returns True if consumed."""
+        key = key_event.key
+        ctrl = key_event.ctrl
+
+        # If we're in input edit mode, delegate to search box
+        if self.state.is_in_input and self._active_search_box is not None:
+            if key == "escape":
+                # Exit edit mode without cancelling
+                self.state.is_in_input = False
+                self._active_search_box = None
+                return True
+            if key == "enter":
+                # Commit the input value
+                opt = self._options[self.state.focused_index]
+                self.state.input_values[opt.value] = self._active_search_box.value
+                self.state.is_in_input = False
+                if self._on_select is not None:
+                    self._on_select(opt.value)
+                self._active_search_box = None
+                return True
+            return self._active_search_box.handle_key(key_event)
+
+        # Navigation
+        if key == "up" or (ctrl and key == "p"):
+            self._move_focus(-1)
+            return True
+
+        if key == "down" or (ctrl and key == "n"):
+            self._move_focus(1)
+            return True
+
+        if key == "pageup":
+            self._move_focus(-self._visible_count)
+            return True
+
+        if key == "pagedown":
+            self._move_focus(self._visible_count)
+            return True
+
+        # Selection / cancel
+        if key == "enter":
+            return self._handle_enter()
+
+        if key == "escape":
+            if self._on_cancel is not None:
+                self._on_cancel()
+            return True
+
+        return False
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _move_focus(self, delta: int) -> None:
+        """Move focus by delta steps, skipping disabled options, clamping at edges."""
+        n = len(self._options)
+        if n == 0:
+            return
+
+        current = self.state.focused_index
+        step = 1 if delta > 0 else -1
+        remaining = abs(delta)
+
+        while remaining > 0:
+            next_idx = current + step
+            if next_idx < 0 or next_idx >= n:
+                break  # No wrapping
+            current = next_idx
+            opt = self._options[current]
+            is_disabled = isinstance(opt, TextOption) and opt.disabled
+            if not is_disabled:
+                remaining -= 1
+
+        self.state.focused_index = current
+        self._update_viewport()
+
+    def _handle_enter(self) -> bool:
+        """Handle enter key press."""
+        if not self._options:
+            return False
+
+        opt = self._options[self.state.focused_index]
+
+        # Don't allow selection of disabled options
+        if isinstance(opt, TextOption) and opt.disabled:
+            return False
+
+        if isinstance(opt, InputOption):
+            # Enter edit mode
+            initial = self.state.input_values.get(opt.value, opt.initial_value)
+            on_change = opt.on_change
+            self._active_search_box = SearchBox(
+                placeholder=opt.placeholder,
+                initial_value=initial,
+                on_change=on_change,
+            )
+            self.state.is_in_input = True
+            return True
+
+        # TextOption: select it
+        if self._on_select is not None:
+            self._on_select(opt.value)
+        return True
+
+    def _update_viewport(self) -> None:
+        """Update visible_from and visible_to so focused_index is visible."""
+        n = len(self._options)
+        count = min(self._visible_count, n)
+
+        if count == 0:
+            self.state.visible_from = 0
+            self.state.visible_to = 0
+            return
+
+        # Clamp focused_index
+        fi = max(0, min(self.state.focused_index, n - 1))
+
+        vf = self.state.visible_from
+        vt = self.state.visible_to
+
+        # Initialise if not set
+        if vt == 0:
+            vt = count
+
+        # Scroll down
+        if fi >= vt:
+            vt = fi + 1
+            vf = vt - count
+
+        # Scroll up
+        if fi < vf:
+            vf = fi
+            vt = vf + count
+
+        # Clamp
+        vf = max(0, vf)
+        vt = min(n, vt)
+
+        self.state.visible_from = vf
+        self.state.visible_to = vt
+
+    def _render_option(self, opt: OptionType, is_focused: bool, index: int) -> Text:
+        """Render a single option line."""
+        text = Text()
+
+        if is_focused:
+            text.append("❯ ", style="bold cyan")
+        else:
+            text.append("  ")
+
+        if isinstance(opt, TextOption):
+            style = "dim" if opt.disabled else ("bold" if is_focused else "")
+            text.append(opt.label, style=style)
+            if opt.description:
+                text.append(f"  {opt.description}", style="dim")
+        elif isinstance(opt, InputOption):
+            text.append(opt.label, style="bold" if is_focused else "")
+            # Show current value if we have one
+            current_val = self.state.input_values.get(opt.value, opt.initial_value)
+            if self.state.is_in_input and is_focused and self._active_search_box is not None:
+                text.append(": ")
+                text.append_text(self._active_search_box.render())
+            elif current_val:
+                text.append(f": {current_val}", style="cyan")
+            elif opt.placeholder:
+                text.append(f": {opt.placeholder}", style="dim")
+
+        return text

iac_code/ui/components/status_icon.py

@@ -0,0 +1,42 @@
+"""StatusIcon component with coloured status symbols."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from rich.text import Text
+
+
+class Status(Enum):
+    """Enumeration of supported status values."""
+
+    SUCCESS = "success"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    PENDING = "pending"
+    RUNNING = "running"
+
+
+_ICONS: dict[Status, tuple[str, str]] = {
+    Status.SUCCESS: ("✓", "green"),
+    Status.ERROR: ("✗", "red"),
+    Status.WARNING: ("⚠", "yellow"),
+    Status.INFO: ("●", "blue"),
+    Status.PENDING: ("○", "dim"),
+    Status.RUNNING: ("◐", "blue"),
+}
+
+
+class StatusIcon:
+    """Renders a coloured status icon as Rich Text."""
+
+    def __init__(self, status: Status) -> None:
+        self.status = status
+
+    def render(self) -> Text:
+        """Return the status icon as Rich Text."""
+        icon, style = _ICONS[self.status]
+        text = Text()
+        text.append(icon, style=style)
+        return text

iac_code/ui/components/tabs.py

@@ -0,0 +1,128 @@
+"""Tabs component for switching between named content panes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, cast
+
+from rich.console import Group, RenderableType
+from rich.rule import Rule
+from rich.text import Text
+
+from iac_code.ui.core.key_event import KeyEvent
+
+
+@dataclass
+class Tab:
+    """Definition of a single tab."""
+
+    id: str
+    title: str
+    content: RenderableType | Callable[[], RenderableType]
+
+
+class Tabs:
+    """A tab-bar component.
+
+    Renders as:
+        [Selected] | Other | Other
+        ────────────────────────────
+        <content of selected tab>
+
+    Navigation:
+        ← / → move between tabs without wrapping at edges.
+    """
+
+    def __init__(
+        self,
+        tabs: list[Tab],
+        default_tab: str | None = None,
+        on_tab_change: Callable[[str], None] | None = None,
+        keybinding_manager: object | None = None,
+    ) -> None:
+        self._tabs = tabs
+        self._on_tab_change = on_tab_change
+        self._keybinding_manager = keybinding_manager
+
+        if default_tab is not None:
+            self._selected = default_tab
+        elif tabs:
+            self._selected = tabs[0].id
+        else:
+            self._selected = ""
+
+    # ------------------------------------------------------------------
+    # Properties
+    # ------------------------------------------------------------------
+
+    @property
+    def selected_tab(self) -> str:
+        return self._selected
+
+    # ------------------------------------------------------------------
+    # Key handling
+    # ------------------------------------------------------------------
+
+    def handle_key(self, key_event: KeyEvent) -> bool:
+        """Handle left/right arrow keys to switch tabs.
+
+        Returns True if the key was consumed, False otherwise.
+        """
+        key = key_event.key
+
+        if key not in ("left", "right"):
+            return False
+
+        ids = [t.id for t in self._tabs]
+        if not ids:
+            return True  # consumed even if nothing to do
+
+        try:
+            idx = ids.index(self._selected)
+        except ValueError:
+            return True
+
+        if key == "right":
+            new_idx = min(idx + 1, len(ids) - 1)
+        else:
+            new_idx = max(idx - 1, 0)
+
+        if new_idx != idx:
+            self._selected = ids[new_idx]
+            if self._on_tab_change is not None:
+                self._on_tab_change(self._selected)
+
+        return True
+
+    # ------------------------------------------------------------------
+    # Rendering
+    # ------------------------------------------------------------------
+
+    def render(self) -> RenderableType:
+        """Render the tab bar, rule, and active tab content."""
+        tab_bar = self._render_tab_bar()
+        rule = Rule(style="dim")
+        content = self._get_content()
+        return Group(tab_bar, rule, content)
+
+    def _render_tab_bar(self) -> Text:
+        """Build the tab header line."""
+        text = Text()
+        for i, tab in enumerate(self._tabs):
+            if i > 0:
+                text.append(" | ", style="dim")
+            if tab.id == self._selected:
+                text.append(f"[{tab.title}]", style="bold cyan")
+            else:
+                text.append(tab.title, style="dim")
+        return text
+
+    def _get_content(self) -> RenderableType:
+        """Return the content for the currently selected tab."""
+        for tab in self._tabs:
+            if tab.id == self._selected:
+                if callable(tab.content):
+                    content_factory = cast(Callable[[], RenderableType], tab.content)
+                    return content_factory()
+                return tab.content
+        return Text("")

iac_code/ui/core/in_place_render.py

@@ -0,0 +1,129 @@
+"""In-place renderer for full-screen pickers and dialogs.
+
+Renders a Rich renderable at the cursor's current position in the main
+buffer (not the alternate screen), erasing the previous frame before
+drawing each new one. Same teardown pattern as
+``Renderer._quiet_stop_live`` — emits zero newlines past the bottom of
+the render so nothing leaks into scrollback.
+
+Why not the alternate screen / Rich ``Live(transient=True)``: both leak
+the rendered frames into the main buffer's scrollback on some terminals,
+which makes ``↑`` after a picker show every frame instead of pre-picker
+history.
+
+Why not bare ``console.print`` in a loop: that appends each frame below
+the previous one (no erase), and under ``RawInputCapture`` (raw mode,
+OPOST off) the kernel TTY no longer maps ``\\n`` → ``\\r\\n``, so each
+line stair-steps right of where the previous one ended.
+"""
+
+from __future__ import annotations
+
+from rich.console import Console, RenderableType
+
+
+class InPlaceRenderer:
+    """Erase-and-redraw renderer for picker / dialog event loops.
+
+    Each :meth:`render` call rewinds over the previous frame using
+    ``CR + erase-line + (UP + erase-line) × (h-1)``, then writes the new
+    content. :meth:`clear` runs the same erase to wipe the last frame on
+    exit. Safe under raw mode: bare ``\\n`` in Rich's output is
+    translated to ``\\r\\n`` so each line returns to column 0.
+
+    Optional ``cursor_to`` lets callers park the hardware cursor inside
+    the frame (e.g. inside a search box) after drawing — the renderer
+    walks the cursor back to the last row before the next erase, so the
+    erase math stays correct.
+    """
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+        self._last_height = 0
+        # Where the cursor currently sits within the last rendered frame
+        # (0-indexed from the top). After a plain :meth:`render` the
+        # cursor is on the bottom row; if ``cursor_to`` was passed, it
+        # may be parked higher up.
+        self._cursor_row = 0
+
+    @property
+    def last_height(self) -> int:
+        return self._last_height
+
+    def render(
+        self,
+        renderable: RenderableType,
+        cursor_to: tuple[int, int] | None = None,
+    ) -> None:
+        """Erase the previous frame (if any) and draw the new one.
+
+        Args:
+            renderable: Rich renderable to draw.
+            cursor_to: Optional ``(row, col)`` offset (both 0-indexed,
+                relative to the top-left of the rendered frame) where the
+                terminal cursor should land after drawing. Useful for
+                pickers that want the hardware cursor to sit inside their
+                search box rather than at the bottom of the frame.
+        """
+        with self._console.capture() as capture:
+            self._console.print(renderable)
+        text = capture.get().replace("\r\n", "\n").replace("\n", "\r\n")
+        lines = text.split("\r\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+
+        out = self._console.file
+        if self._last_height > 0:
+            self._erase_previous(out)
+        if lines:
+            out.write("\r\n".join(lines))
+        new_height = len(lines)
+
+        # Cursor is now on the last drawn row; place it elsewhere only if
+        # the caller asked for it.
+        self._cursor_row = max(0, new_height - 1)
+        if cursor_to is not None and new_height > 0:
+            target_row, target_col = cursor_to
+            target_row = max(0, min(target_row, new_height - 1))
+            target_col = max(0, target_col)
+            out.write("\r")
+            rows_up = (new_height - 1) - target_row
+            if rows_up > 0:
+                out.write(f"\x1b[{rows_up}A")
+            if target_col > 0:
+                out.write(f"\x1b[{target_col}C")
+            self._cursor_row = target_row
+
+        out.flush()
+        self._last_height = new_height
+
+    def clear(self) -> None:
+        """Erase the last rendered frame.
+
+        Idempotent — calling :meth:`clear` twice is a no-op.
+        """
+        if self._last_height <= 0:
+            return
+        out = self._console.file
+        try:
+            self._erase_previous(out)
+            out.flush()
+        except OSError:
+            pass
+        self._last_height = 0
+        self._cursor_row = 0
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _erase_previous(self, out) -> None:
+        """Walk the cursor back to the last row of the previous frame
+        (if it was parked higher by ``cursor_to``) and erase every row.
+        """
+        rows_down = (self._last_height - 1) - self._cursor_row
+        if rows_down > 0:
+            out.write(f"\x1b[{rows_down}B")
+        out.write("\r\x1b[2K")
+        for _ in range(self._last_height - 1):
+            out.write("\x1b[A\x1b[2K")