codeplain 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

tui/components.py

@@ -1,18 +1,32 @@
+import time
 from enum import Enum
+from typing import Optional
 
 from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.message import Message
 from textual.widgets import Button, Static
 
-from spinner import Spinner
-
 from .models import Substate
+from .spinner import Spinner
+
+
+class CustomFooter(Horizontal):
+    """A custom footer with keyboard shortcuts and render ID."""
+
+    def __init__(self, render_id: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.render_id = render_id
+
+    def compose(self):
+        yield Static("ctrl+c: quit  *  ctrl+l: toggle logs", classes="custom-footer-text")
+        if self.render_id:
+            yield Static(f"render id: {self.render_id}", classes="custom-footer-render-id")
 
 
 class ScriptOutputType(str, Enum):
-    UNIT_TEST_OUTPUT_TEXT = "Latest unit test script execution output: "
-    CONFORMANCE_TEST_OUTPUT_TEXT = "Latest conformance tests script execution output: "
-    TESTING_ENVIRONMENT_OUTPUT_TEXT = "Latest testing environment preparation script execution output: "
+    UNIT_TEST_OUTPUT_TEXT = "Unit tests output: "
+    CONFORMANCE_TEST_OUTPUT_TEXT = "Conformance tests output: "
+    TESTING_ENVIRONMENT_OUTPUT_TEXT = "Testing environment preparation execution output: "
 
     @staticmethod
     def get_max_label_width(active_types: list["ScriptOutputType"]) -> int:
@@ -28,17 +42,14 @@ class ScriptOutputType(str, Enum):
             return 0
         return max(len(script_type.value) for script_type in active_types)
 
-    def get_padded_label(self, active_types: list["ScriptOutputType"]) -> str:
-        """Get the label right-padded to align with other active labels.
-
-        Args:
-            active_types: List of ScriptOutputType enum members that are currently active
+    def get_padded_label(self) -> str:
+        """Get the label left-aligned (no padding).
 
         Returns:
-            Right-aligned label padded to match the longest active label
+            Label without padding (left-aligned)
         """
-        max_width = ScriptOutputType.get_max_label_width(active_types)
-        return self.value.rjust(max_width)
+        # Return label as-is without padding for left alignment
+        return self.value
 
 
 class TUIComponents(str, Enum):
@@ -57,6 +68,9 @@ class TUIComponents(str, Enum):
     FRID_PROGRESS_REFACTORING = "frid-progress-refactoring"
     FRID_PROGRESS_CONFORMANCE_TEST = "frid-progress-conformance-test"
 
+    # Test scripts container widgets
+    TEST_SCRIPTS_CONTAINER = "test-scripts-container"
+
     CONTENT_SWITCHER = "content-switcher"
     DASHBOARD_VIEW = "dashboard-view"
     LOG_VIEW = "log-view"
@@ -64,6 +78,47 @@ class TUIComponents(str, Enum):
     LOG_FILTER = "log-filter"
 
 
+class SubstateLine(Horizontal):
+    """A single substate row with an attached timer."""
+
+    def __init__(self, text: str, indent: str, **kwargs):
+        super().__init__(**kwargs)
+        self.text = text
+        self.indent = indent
+        self.start_time = time.monotonic()
+        self._line_widget: Static | None = None
+
+    def compose(self):
+        self._line_widget = Static(self._format_line(), classes="substate-line-text")
+        yield self._line_widget
+
+    def on_mount(self) -> None:
+        self._refresh_timer()
+        self.set_interval(1, self._refresh_timer)
+
+    def _format_timer(self) -> str:
+        elapsed = int(time.monotonic() - self.start_time)
+        if elapsed < 60:
+            return f"{elapsed}s"
+        minutes = elapsed // 60
+        seconds = elapsed % 60
+        if minutes < 60:
+            return f"{minutes}m {seconds}s"
+        hours = minutes // 60
+        return f"{hours}h {minutes % 60}m"
+
+    def _format_line(self) -> str:
+        timer = self._format_timer()
+        return f"{self.indent}  └ {self.text} [#888888]({timer})[/#888888]"
+
+    def _refresh_timer(self) -> None:
+        try:
+            if self._line_widget:
+                self._line_widget.update(self._format_line())
+        except Exception:
+            pass
+
+
 class ProgressItem(Vertical):
     """A vertical container for a status, description, and substates."""
 
@@ -160,7 +215,7 @@ class ProgressItem(Vertical):
 
         for substate in substates:
             # Render the current substate
-            substate_widget = Static(f"{indent}  └ {substate.text}", classes="substate")
+            substate_widget = SubstateLine(substate.text, indent, classes="substate-row")
             await container.mount(substate_widget)
 
             # Recursively render children if they exist
@@ -176,6 +231,111 @@ class ProgressItem(Vertical):
             pass
 
 
+class RenderingInfoBox(Vertical):
+    """Responsive container for module and functionality information."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.module_text = ""
+        self.functionality_text = ""
+        self.module_widget: Static | None = None
+        self.functionality_widget: Static | None = None
+
+    def update_module(self, text: str) -> None:
+        """Update the module name display."""
+        self.module_text = text
+        self._refresh_content()
+
+    def update_functionality(self, text: str) -> None:
+        """Update the functionality text display."""
+        self.functionality_text = text
+        self._refresh_content()
+
+    def _refresh_content(self) -> None:
+        """Refresh text inside the box."""
+        if self.module_widget is not None:
+            self.module_widget.update(self.module_text or "")
+        if self.functionality_widget is not None:
+            self.functionality_widget.update(self.functionality_text or "")
+
+    def on_mount(self) -> None:
+        """Initialize default labels on mount."""
+        self.module_text = "Module: "
+        self.functionality_text = "Functionality:"
+        self._refresh_content()
+
+    def compose(self):
+        self.module_widget = Static(self.module_text, classes="rendering-info-row")
+        self.functionality_widget = Static(self.functionality_text, classes="rendering-info-row")
+        yield Static("module status", classes="rendering-info-title")
+        with Vertical(classes="rendering-info-box"):
+            yield self.module_widget
+            yield self.functionality_widget
+
+
+class TestScriptsContainer(Vertical):
+    """Container with ASCII border for test script outputs."""
+
+    def __init__(
+        self,
+        show_unit_test: bool = True,
+        show_conformance_test: bool = True,
+        show_testing_env: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.show_unit_test = show_unit_test
+        self.show_conformance_test = show_conformance_test
+        self.show_testing_env = show_testing_env
+        self.unit_test_text = ScriptOutputType.UNIT_TEST_OUTPUT_TEXT.value
+        self.conformance_test_text = ScriptOutputType.CONFORMANCE_TEST_OUTPUT_TEXT.value
+        self.testing_env_text = ScriptOutputType.TESTING_ENVIRONMENT_OUTPUT_TEXT.value
+        self.unit_widget: Static | None = None
+        self.conformance_widget: Static | None = None
+        self.testing_widget: Static | None = None
+
+    def update_unit_test(self, text: str) -> None:
+        """Update unit test output and refresh."""
+        self.unit_test_text = text
+        self._refresh_content()
+
+    def update_conformance_test(self, text: str) -> None:
+        """Update conformance test output and refresh."""
+        self.conformance_test_text = text
+        self._refresh_content()
+
+    def update_testing_env(self, text: str) -> None:
+        """Update testing env output and refresh."""
+        self.testing_env_text = text
+        self._refresh_content()
+
+    def _refresh_content(self) -> None:
+        """Refresh the test script rows."""
+        if self.unit_widget is not None:
+            self.unit_widget.update(self.unit_test_text)
+            self.unit_widget.display = self.show_unit_test
+        if self.conformance_widget is not None:
+            self.conformance_widget.update(self.conformance_test_text)
+            self.conformance_widget.display = self.show_conformance_test
+        if self.testing_widget is not None:
+            self.testing_widget.update(self.testing_env_text)
+            self.testing_widget.display = self.show_testing_env
+
+    def on_mount(self) -> None:
+        """Initialize the box on mount."""
+        self._refresh_content()
+
+    def compose(self):
+        yield Static("testing status", classes="test-scripts-title")
+        with Vertical(classes="test-scripts-box"):
+            self.unit_widget = Static(self.unit_test_text, classes="test-script-row")
+            self.conformance_widget = Static(self.conformance_test_text, classes="test-script-row")
+            self.testing_widget = Static(self.testing_env_text, classes="test-script-row")
+            yield self.unit_widget
+            yield self.conformance_widget
+            yield self.testing_widget
+
+
 class FRIDProgress(Vertical):
     """A widget to display the status of subcomponent tasks."""
 
@@ -185,16 +345,24 @@ class FRIDProgress(Vertical):
     REFACTORING_TEXT = "Refactoring"
     CONFORMANCE_TEST_VALIDATION_TEXT = "Conformance tests"
 
-    RENDERING_MODULE_TEXT = "Rendering module: "
-    RENDERING_FUNCTIONALITY_TEXT = "Rendering functionality:"
+    RENDERING_MODULE_TEXT = "Module: "
+    RENDERING_FUNCTIONALITY_TEXT = "Functionality:"
 
-    def __init__(self, **kwargs):
+    def __init__(
+        self,
+        unittests_script: Optional[str],
+        conformance_tests_script: Optional[str],
+        **kwargs,
+    ):
         super().__init__(**kwargs)
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def update_fr_text(self, text: str) -> None:
         try:
-            widget = self.query_one(f"#{TUIComponents.FRID_PROGRESS_HEADER.value}", Static)
-            widget.update(text)
+            # Update the rendering info box instead
+            info_box = self.query_one(RenderingInfoBox)
+            info_box.update_functionality(text)
         except Exception:
             pass
 
@@ -209,45 +377,31 @@ class FRIDProgress(Vertical):
         self.border_title = "FRID Progress"
 
     def compose(self):
-        yield Static(self.RENDERING_MODULE_TEXT, id=TUIComponents.RENDER_MODULE_NAME_WIDGET.value)
-        yield Static(self.RENDERING_FUNCTIONALITY_TEXT, id=TUIComponents.FRID_PROGRESS_HEADER.value)
-        yield ProgressItem(
-            self.IMPLEMENTING_FUNCTIONALITY_TEXT,
-            id=TUIComponents.FRID_PROGRESS_RENDER_FR.value,
-        )
-        yield ProgressItem(
-            self.UNIT_TEST_VALIDATION_TEXT,
-            id=TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
-        )
-        yield ProgressItem(
-            self.REFACTORING_TEXT,
-            id=TUIComponents.FRID_PROGRESS_REFACTORING.value,
-        )
-        yield ProgressItem(
-            self.CONFORMANCE_TEST_VALIDATION_TEXT,
-            id=TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value,
-        )
-
-
-class ClickableArrow(Static):
-    """A clickable arrow widget for expanding/collapsing logs."""
-
-    def __init__(self, is_expanded: bool = False, **kwargs):
-        arrow = "▼" if is_expanded else "▶"
-        super().__init__(arrow, **kwargs)
-        self.classes = "log-arrow"
-
-    def on_click(self, event):
-        """Notify parent to toggle expansion."""
-        # Bubble up to parent CollapsibleLogEntry
-        event.stop()
-        parent = self.parent
-        if isinstance(parent, CollapsibleLogEntry):
-            parent.toggle_expansion()
-
-
-class CollapsibleLogEntry(Horizontal):
-    """A single collapsible log entry that can be clicked to expand/collapse."""
+        yield RenderingInfoBox()
+        yield Static("rendering status", classes="frid-state-machine-title")
+        with Vertical(classes="frid-state-machine-box"):
+            yield ProgressItem(
+                self.IMPLEMENTING_FUNCTIONALITY_TEXT,
+                id=TUIComponents.FRID_PROGRESS_RENDER_FR.value,
+            )
+            if self.unittests_script is not None:
+                yield ProgressItem(
+                    self.UNIT_TEST_VALIDATION_TEXT,
+                    id=TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
+                )
+            yield ProgressItem(
+                self.REFACTORING_TEXT,
+                id=TUIComponents.FRID_PROGRESS_REFACTORING.value,
+            )
+            if self.conformance_tests_script is not None:
+                yield ProgressItem(
+                    self.CONFORMANCE_TEST_VALIDATION_TEXT,
+                    id=TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value,
+                )
+
+
+class LogEntry(Vertical):
+    """A single log entry that can be expanded to show details."""
 
     def __init__(self, logger_name: str, level: str, message: str, timestamp: str = "", **kwargs):
         super().__init__(**kwargs)
@@ -259,36 +413,58 @@ class CollapsibleLogEntry(Horizontal):
         self.classes = f"log-entry log-{level.lower()}"
 
     def compose(self):
-        # Start with collapsed view - arrow and full message text side by side
-        yield ClickableArrow(id="arrow")
-        yield Static(self.message, classes="log-summary")
-
-    def toggle_expansion(self):
-        """Toggle the expansion state of this log entry."""
-        self.is_expanded = not self.is_expanded
-        self.call_later(self.refresh_display)
-
-    async def refresh_display(self):
-        """Update the display based on expanded state."""
-        # Remove all children
-        await self.remove_children()
-
-        if self.is_expanded:
-            # Expanded view: shows arrow, full message, and structured metadata
-            await self.mount(ClickableArrow(is_expanded=True))
-            expanded_text = f"{self.message}\n"
-            expanded_text += f"   Level: {self.level}\n"
-            expanded_text += f"   Location: {self.logger_name}\n"
-            expanded_text += f"   Time: {self.timestamp}"
-            await self.mount(Static(expanded_text, classes="log-expanded"))
-        else:
-            # Collapsed view: shows arrow and full message only
-            await self.mount(ClickableArrow(is_expanded=False))
-            await self.mount(Static(self.message, classes="log-summary"))
+        # Main row: just the message with a clickable indicator
+        with Horizontal(classes="log-main-row"):
+            # Expandable indicator
+            yield Static("▶", classes="log-expand-indicator")
+
+            time_part = self.timestamp.split()[-1] if self.timestamp else ""
+            time_prefix = f"[#888888][{time_part}][/#888888] " if time_part else ""
+            indent_spaces = len(f"[{time_part}] ") if time_part else 0
+
+            message_body = self.message
+            if any(
+                keyword in self.message.lower()
+                for keyword in ["completed", "success", "successfully", "passed", "done", "✓"]
+            ):
+                message_body = f"[green]✓[/green] {message_body}"
+
+            if indent_spaces and "\n" in message_body:
+                message_body = message_body.replace("\n", "\n" + " " * indent_spaces)
+
+            yield Static(f"{time_prefix}{message_body}", classes="log-col-message")
+
+        # Details row (hidden by default) - vertical layout
+        with Vertical(id=f"log-details-{id(self)}", classes="log-details-row"):
+            location = self.logger_name
+            if len(location) > 20:
+                location = location[:20] + "..."
+            yield Static(f"  [#888]level:[/#888] {self.level}", classes="log-details-text")
+            yield Static(f"  [#888]location:[/#888] {location}", classes="log-details-text")
+
+    def on_mount(self) -> None:
+        """Hide details on mount."""
+        try:
+            details = self.query_one(f"#log-details-{id(self)}")
+            details.display = False
+        except Exception:
+            pass
+
+    def on_click(self) -> None:
+        """Toggle details visibility on click."""
+        try:
+            details = self.query_one(f"#log-details-{id(self)}")
+            indicator = self.query_one(".log-expand-indicator", Static)
+
+            self.is_expanded = not self.is_expanded
+            details.display = self.is_expanded
+            indicator.update("▼" if self.is_expanded else "▶")
+        except Exception:
+            pass
 
 
 class StructuredLogView(VerticalScroll):
-    """A scrollable container for collapsible log entries."""
+    """A scrollable container for log entries displayed as a table."""
 
     # Log level hierarchy (lower number = lower priority)
     LOG_LEVELS = {
@@ -296,7 +472,6 @@ class StructuredLogView(VerticalScroll):
         "INFO": 1,
         "WARNING": 2,
         "ERROR": 3,
-        "CRITICAL": 4,
     }
 
     def __init__(self, **kwargs):
@@ -311,7 +486,17 @@ class StructuredLogView(VerticalScroll):
 
     async def add_log(self, logger_name: str, level: str, message: str, timestamp: str = ""):
         """Add a new log entry."""
-        entry = CollapsibleLogEntry(logger_name, level, message, timestamp)
+        # Check if this is a success message that should have spacing before it
+        is_success_message = any(
+            keyword in message.lower() for keyword in ["completed", "success", "successfully", "passed", "done", "✓"]
+        )
+
+        # Add empty line before success messages
+        if is_success_message:
+            spacer = Static("", classes="log-spacer")
+            await self.mount(spacer)
+
+        entry = LogEntry(logger_name, level, message, timestamp)
 
         # Only show if level is >= minimum level
         if not self._should_show_log(level):
@@ -326,7 +511,7 @@ class StructuredLogView(VerticalScroll):
         self.min_level = min_level
 
         # Update visibility of all existing log entries
-        for entry in self.query(CollapsibleLogEntry):
+        for entry in self.query(LogEntry):
             entry.display = self._should_show_log(entry.level)
 
 
@@ -341,17 +526,34 @@ class LogFilterChanged(Message):
 class LogLevelFilter(Horizontal):
     """Filter logs by minimum level with buttons."""
 
-    LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+    LEVELS = ["debug", "info", "warning", "error"]
+
+    # Make the widget focusable to receive keyboard events
+    can_focus = True
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.current_level = "DEBUG"
+        self.current_level = "INFO"
+        self.current_index = self.LEVELS.index(self.current_level.lower())
 
     def compose(self):
-        yield Static("Level: ", classes="filter-label")
-        for level in self.LEVELS:
-            variant = "primary" if level == self.current_level else "default"
-            yield Button(level, id=f"filter-{level.lower()}", variant=variant, classes="filter-button")  # type: ignore[arg-type]
+        yield Static("level: ", classes="filter-label")
+        with Horizontal(classes="filter-buttons-container"):
+            for level in self.LEVELS:
+                variant = "primary" if level.upper() == self.current_level else "default"
+                btn = Button(level.upper(), id=f"filter-{level.lower()}", variant=variant, classes="filter-button")  # type: ignore[arg-type]
+                btn.can_focus = False  # Prevent buttons from receiving focus
+                yield btn
+
+    def on_key(self, event):
+        """Handle tab key to cycle through levels."""
+        if event.key == "tab":
+            # Move to next level
+            self.current_index = (self.current_index + 1) % len(self.LEVELS)
+            new_level = self.LEVELS[self.current_index].upper()
+            self._update_level(new_level)
+            event.prevent_default()
+            event.stop()
 
     def on_button_pressed(self, event):
         """Handle level button press."""
@@ -359,14 +561,20 @@ class LogLevelFilter(Horizontal):
         button_id = event.button.id
         if button_id and button_id.startswith("filter-"):
             level = button_id.replace("filter-", "").upper()
-            self.current_level = level
+            self.current_index = self.LEVELS.index(level.lower())
+            self._update_level(level)
 
-            # Update button variants
-            for btn in self.query(Button):
-                if btn.id == f"filter-{level.lower()}":
-                    btn.variant = "primary"
-                else:
-                    btn.variant = "default"
+    def _update_level(self, level: str):
+        """Update the current level and button states."""
+        self.current_level = level
+
+        # Update button variants
+        for btn in self.query(Button):
+            if btn.id == f"filter-{level.lower()}":
+                btn.variant = "primary"
+            else:
+                btn.variant = "default"
+            btn.refresh()  # Force immediate visual update
 
-            # Notify parent to refresh log visibility
-            self.post_message(LogFilterChanged(level))
+        # Notify parent to refresh log visibility
+        self.post_message(LogFilterChanged(level))