shrinkray 26.1.1.0__tar.gz → 26.2.4.0__tar.gz

{shrinkray-26.1.1.0/src/shrinkray.egg-info → shrinkray-26.2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.1.1.0
+Version: 26.2.4.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.1.1.0 → shrinkray-26.2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "26.1.1.0"
+version = "26.2.4.0"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}

{shrinkray-26.1.1.0 → shrinkray-26.2.4.0}/src/shrinkray/tui.py

@@ -13,7 +13,6 @@ from difflib import unified_diff
 from typing import Literal, Protocol, cast
 
 import humanize
-from rich.markup import escape as escape_markup
 from rich.text import Text
 from textual import work
 from textual.app import App, ComposeResult
@@ -46,6 +45,7 @@ from shrinkray.subprocess.protocol import (
 
 ThemeMode = Literal["auto", "dark", "light"]
 
+
 # Custom themes with true white/black backgrounds
 SHRINKRAY_LIGHT_THEME = Theme(
     name="shrinkray-light",
@@ -505,20 +505,20 @@ class ContentPreview(Static):
         # Fallback based on common terminal height
         return 30
 
-    def render(self) -> str:
+    def render(self) -> Text:
         if not self.preview_content:
-            return "Loading..."
+            return Text("Loading...")
 
         available_lines = self._get_available_lines()
 
         if self.hex_mode:
-            return f"[Hex mode]\n{self.preview_content}"
+            return Text(f"[Hex mode]\n{self.preview_content}")
 
         lines = self.preview_content.split("\n")
 
         # For small files that fit, show full content
         if len(lines) <= available_lines:
-            return self.preview_content
+            return Text(self.preview_content)
 
         # For larger files, show diff if we have previous displayed content
         if (
@@ -530,10 +530,10 @@ class ContentPreview(Static):
             diff = list(unified_diff(prev_lines, curr_lines, lineterm=""))
             if diff:
                 # Show as much diff as fits
-                return "\n".join(diff[:available_lines])
+                return Text("\n".join(diff[:available_lines]))
 
         # No diff available, show truncated content
-        return (
+        return Text(
             "\n".join(lines[:available_lines])
             + f"\n\n... ({len(lines) - available_lines} more lines)"
         )
@@ -591,39 +591,46 @@ class OutputPreview(Static):
             pass
         return 30
 
-    def render(self) -> str:
+    def render(self) -> Text:
         # Header line - use return_code to determine if test is running
         # (return_code is None means still running, has value means completed)
         if self.active_test_id is not None and self.last_return_code is None:
-            header = f"[green]Test #{self.active_test_id} running...[/green]"
+            header_text = f"Test #{self.active_test_id} running..."
+            header_style = "green"
         elif self.active_test_id is not None:
-            header = f"[dim]Test #{self.active_test_id} exited with code {self.last_return_code}[/dim]"
+            header_text = (
+                f"Test #{self.active_test_id} exited with code {self.last_return_code}"
+            )
+            header_style = "dim"
         elif self._has_seen_output or self.output_content:
             # Have seen output before - show without header
-            header = ""
+            header_text = ""
+            header_style = ""
         else:
-            header = "[dim]No test output yet...[/dim]"
+            header_text = "No test output yet..."
+            header_style = "dim"
 
         if not self.output_content:
-            return header
+            return Text(header_text, style=header_style)
 
         available_lines = self._get_available_lines()
-        # Escape the output content to prevent Rich markup interpretation
-        # (test output may contain characters like ^ that have special meaning)
-        escaped_content = escape_markup(self.output_content)
-        lines = escaped_content.split("\n")
-
-        # Build prefix (header + newline, or empty if no header)
-        prefix = f"{header}\n" if header else ""
+        lines = self.output_content.split("\n")
 
         # Show tail of output (most recent lines)
-        if len(lines) <= available_lines:
-            return f"{prefix}{escaped_content}"
+        if len(lines) > available_lines:
+            truncated_lines = lines[-(available_lines):]
+            skipped = len(lines) - available_lines
+            content = f"... ({skipped} earlier lines)\n" + "\n".join(truncated_lines)
+        else:
+            content = self.output_content
 
-        # Truncate from the beginning
-        truncated_lines = lines[-(available_lines):]
-        skipped = len(lines) - available_lines
-        return f"{prefix}... ({skipped} earlier lines)\n" + "\n".join(truncated_lines)
+        # Build result with styled header and unstyled content
+        result = Text()
+        if header_text:
+            result.append(header_text, style=header_style)
+            result.append("\n")
+        result.append(content)
+        return result
 
 
 class HelpScreen(ModalScreen[None]):
@@ -734,21 +741,20 @@ class ExpandedBoxModal(ModalScreen[None]):
         self._content_widget_id = content_widget_id
         self._file_path = file_path
 
-    def _read_file(self, file_path: str) -> str:
+    def _read_file(self, file_path: str) -> Text:
         """Read file content, decoding as text if possible."""
         if not os.path.isfile(file_path):
-            return "[dim]File not found[/dim]"
+            return Text("File not found", style="dim")
         try:
             with open(file_path, "rb") as f:
                 raw_content = f.read()
             # Try to decode as text, fall back to hex display if binary
             encoding, text = try_decode(raw_content)
             if encoding is not None:
-                # Escape Rich markup to prevent interpretation of [ ] etc
-                return escape_markup(text)
-            return "[Binary content - hex display]\n\n" + raw_content.hex()
+                return Text(text)
+            return Text("Binary content - hex display\n\n" + raw_content.hex())
         except OSError:
-            return "[red]Error reading file[/red]"
+            return Text("Error reading file", style="red")
 
     def compose(self) -> ComposeResult:
         with Vertical():
@@ -781,16 +787,16 @@ class ExpandedBoxModal(ModalScreen[None]):
             return "Statistics not available"
         return stats_displays[0].render()
 
-    def _get_file_content(self, app: "ShrinkRayApp") -> str:
+    def _get_file_content(self, app: "ShrinkRayApp") -> str | Text:
         """Get content from file or preview widget."""
         if self._file_path:
             return self._read_file(self._file_path)
         content_previews = list(app.query("#content-preview").results(ContentPreview))
         if not content_previews:
             return "Content preview not available"
-        return content_previews[0].preview_content
+        return Text(content_previews[0].preview_content)
 
-    def _get_output_content(self, app: "ShrinkRayApp") -> str:
+    def _get_output_content(self, app: "ShrinkRayApp") -> str | Text:
         """Get output content from the output preview widget."""
         output_previews = list(app.query("#output-preview").results(OutputPreview))
         if not output_previews:
@@ -811,21 +817,29 @@ class ExpandedBoxModal(ModalScreen[None]):
         )
         has_seen_output = output_preview._has_seen_output
 
-        # Build header - return_code is None means test is still running
+        # Build header with styling
         if test_id is not None and return_code is None:
-            header = f"[green]Test #{test_id} running...[/green]\n\n"
+            header_text = f"Test #{test_id} running..."
+            header_style = "green"
         elif test_id is not None:
-            header = f"[dim]Test #{test_id} exited with code {return_code}[/dim]\n\n"
+            header_text = f"Test #{test_id} exited with code {return_code}"
+            header_style = "dim"
         else:
-            header = ""
+            header_text = ""
+            header_style = ""
 
         if raw_content:
-            return header + raw_content
+            result = Text()
+            if header_text:
+                result.append(header_text, style=header_style)
+                result.append("\n\n")
+            result.append(raw_content)
+            return result
         elif has_seen_output or test_id is not None:
             # We've seen output before - show header only (no "No test output" message)
-            return header.rstrip("\n") if header else ""
+            return Text(header_text, style=header_style)
         else:
-            return "[dim]No test output yet...[/dim]"
+            return Text("No test output yet...", style="dim")
 
     def on_mount(self) -> None:
         """Populate content from the source widget."""
@@ -1447,13 +1461,13 @@ class HistoryExplorerModal(ModalScreen[None]):
         if os.path.isfile(output_path):
             output_content = self._read_file(output_path)
         else:
-            output_content = "[dim]No output captured[/dim]"
+            output_content = Text("No output captured", style="dim")
         self.query_one(f"#{output_preview_id}", Static).update(output_content)
 
-    def _read_file(self, file_path: str) -> str:
+    def _read_file(self, file_path: str) -> Text:
         """Read file content, decoding as text if possible."""
         if not os.path.isfile(file_path):
-            return "[dim]File not found[/dim]"
+            return Text("File not found", style="dim")
         try:
             with open(file_path, "rb") as f:
                 raw_content = f.read()
@@ -1465,18 +1479,17 @@ class HistoryExplorerModal(ModalScreen[None]):
             # Try to decode as text
             encoding, text = try_decode(raw_content)
             if encoding is not None:
-                # Escape Rich markup to prevent interpretation of [ ] etc
-                text = escape_markup(text)
+                result = Text(text)
                 if truncated:
-                    text += "\n\n[dim]... (truncated)[/dim]"
-                return text
+                    result.append("\n\n... (truncated)", style="dim")
+                return result
             # Binary content - hex display
-            hex_display = "[Binary content - hex display]\n\n" + raw_content.hex()
+            result = Text("Binary content - hex display\n\n" + raw_content.hex())
             if truncated:
-                hex_display += "\n\n[dim]... (truncated)[/dim]"
-            return hex_display
+                result.append("\n\n... (truncated)", style="dim")
+            return result
         except OSError:
-            return "[red]Error reading file[/red]"
+            return Text("Error reading file", style="red")
 
     def action_restart_from_here(self) -> None:
         """Restart reduction from the currently selected history point."""

{shrinkray-26.1.1.0 → shrinkray-26.2.4.0/src/shrinkray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.1.1.0
+Version: 26.2.4.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.1.1.0 → shrinkray-26.2.4.0}/tests/test_tui.py

@@ -9,6 +9,7 @@ from collections.abc import AsyncGenerator
 from unittest.mock import AsyncMock, MagicMock, Mock, PropertyMock, patch
 
 import pytest
+from rich.text import Text
 from textual.app import App
 from textual.widgets import DataTable, Label, ListView, Static, TabbedContent
 
@@ -715,6 +716,40 @@ def test_output_preview_get_available_lines_app_zero_height():
         assert lines == 30
 
 
+def test_output_preview_render_returns_text():
+    """Test that OutputPreview.render() returns a Text object, not a markup string.
+
+    Returning a Text object ensures Textual never parses user content as markup.
+    Previously, render() returned a markup string and used Rich's escape() which
+    failed on patterns like [key=; causing MarkupError.
+
+    This fixes the crash from: shrinkray --parallelism 60 interest2.sh bf_simple_yk.c
+    """
+    widget = OutputPreview()
+    # Content that would crash if parsed as markup
+    widget.output_content = "some output\n[key=;value"
+    widget.active_test_id = 1
+
+    rendered = widget.render()
+    assert isinstance(rendered, Text)
+    assert "[key=;value" in rendered
+
+
+def test_content_preview_render_returns_text():
+    """Test that ContentPreview.render() returns a Text object, not a markup string.
+
+    Returning a Text object ensures Textual never parses user content as markup.
+    Previously, render() returned raw strings that would crash on patterns like
+    [Key=; when Textual parsed them as markup.
+    """
+    widget = ContentPreview()
+    widget.update_content("[Key=;value", False)
+
+    rendered = widget.render()
+    assert isinstance(rendered, Text)
+    assert "[Key=;value" in rendered
+
+
 # === ShrinkRayApp with fake client tests ===
 
 
@@ -1303,21 +1338,22 @@ def test_expanded_modal_read_file_success(tmp_path):
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
-    assert content == "Hello World"
+    assert isinstance(content, Text)
+    assert content.plain == "Hello World"
 
 
-def test_expanded_modal_read_file_escapes_markup(tmp_path):
-    """Test _read_file escapes Rich markup characters like [."""
+def test_expanded_modal_read_file_preserves_brackets(tmp_path):
+    """Test _read_file preserves bracket characters in file content."""
     test_file = tmp_path / "test.txt"
     # Content with brackets that could be interpreted as Rich markup
     test_file.write_text("expected [bold] and [red]text[/red]")
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
-    # Opening brackets should be escaped to prevent Rich interpretation
-    # Rich's escape() converts [ to \[ when followed by tag-like content
-    assert "[bold]" not in content or "\\[bold]" in content
-    assert "[red]" not in content or "\\[red]" in content
+    # Returns a Text object so brackets are preserved literally
+    assert isinstance(content, Text)
+    assert "[bold]" in content.plain
+    assert "[red]text[/red]" in content.plain
 
 
 def test_expanded_modal_read_file_binary(tmp_path):
@@ -1328,26 +1364,29 @@ def test_expanded_modal_read_file_binary(tmp_path):
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
+    assert isinstance(content, Text)
     assert "Binary content" in content
     assert "80818283" in content
 
 
 def test_expanded_modal_read_file_missing(tmp_path):
-    """Test _read_file returns error message for missing file."""
+    """Test _read_file returns styled message for missing file."""
     modal = ExpandedBoxModal("Test", "content-container")
     result = modal._read_file(str(tmp_path / "nonexistent.txt"))
-    assert "[dim]File not found[/dim]" in result
+    assert isinstance(result, Text)
+    assert "File not found" in result
 
 
 def test_expanded_modal_read_file_oserror(tmp_path):
-    """Test _read_file returns error message on OSError."""
+    """Test _read_file returns styled message on OSError."""
     modal = ExpandedBoxModal("Test", "content-container")
     # Create a file that exists but can't be read
     test_file = tmp_path / "unreadable.txt"
     test_file.write_text("content")
     with patch("builtins.open", side_effect=OSError("Permission denied")):
         result = modal._read_file(str(test_file))
-    assert "[red]Error reading file[/red]" in result
+    assert isinstance(result, Text)
+    assert "Error reading file" in result
 
 
 # === ExpandedBoxModal integration tests ===
@@ -5367,6 +5406,55 @@ def test_expanded_modal_output_with_empty_content_and_header():
     asyncio.run(run())
 
 
+def test_expanded_modal_output_content_without_test_id():
+    """Test output modal with content but no test ID (no header)."""
+
+    async def run():
+        fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("test")
+            temp_file = f.name
+
+        try:
+            app = ShrinkRayApp(
+                file_path=temp_file,
+                test=["true"],
+                exit_on_completion=False,
+                client=fake_client,
+            )
+
+            async with app.run_test() as pilot:
+                await pilot.pause()
+
+                # Set output preview with content but no test ID
+                output_preview = app.query_one("#output-preview", OutputPreview)
+                output_preview.active_test_id = None
+                output_preview._has_seen_output = True
+                output_preview.output_content = "some raw output"
+                output_preview._pending_content = "some raw output"
+                output_preview._pending_test_id = None
+
+                # Create modal for output-container
+                modal = ExpandedBoxModal("Output", "output-container", None)
+                await app.push_screen(modal)
+                await pilot.pause()
+
+                # Should show content without header
+                content = modal.query_one("#expanded-content", Static)
+                content_str = get_static_content(content)
+                assert "some raw output" in content_str
+                assert "Test #" not in content_str
+
+                await pilot.press("escape")
+                await pilot.press("q")
+        finally:
+            if os.path.exists(temp_file):
+                os.unlink(temp_file)
+
+    asyncio.run(run())
+
+
 # === Action method tests ===
 
 
@@ -6125,11 +6213,12 @@ def test_history_modal_read_file_success(tmp_path):
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(test_file))
 
-    assert content == "Hello World\nLine 2"
+    assert isinstance(content, Text)
+    assert content.plain == "Hello World\nLine 2"
 
 
-def test_history_modal_read_file_escapes_markup(tmp_path):
-    """Test _read_file escapes Rich markup characters like [."""
+def test_history_modal_read_file_preserves_brackets(tmp_path):
+    """Test _read_file preserves bracket characters in file content."""
     test_file = tmp_path / "test.txt"
     # Content with brackets that look like Rich markup tags
     test_file.write_text("error: [bold]text[/bold] failed")
@@ -6137,9 +6226,9 @@ def test_history_modal_read_file_escapes_markup(tmp_path):
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(test_file))
 
-    # Opening brackets should be escaped to prevent Rich interpretation
-    assert "[bold]" not in content or "\\[bold]" in content
-    # The original text should not be corrupted
+    # Returns a Text object so brackets are preserved literally
+    assert isinstance(content, Text)
+    assert "[bold]" in content.plain
     assert "error:" in content
     assert "failed" in content
 
@@ -6153,15 +6242,17 @@ def test_history_modal_read_file_binary(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should fall back to hex display
+    assert isinstance(content, Text)
     assert "Binary content" in content
 
 
 def test_history_modal_read_file_missing(tmp_path):
-    """Test _read_file returns error message for missing file."""
+    """Test _read_file returns styled message for missing file."""
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(tmp_path / "nonexistent.txt"))
 
-    assert "[dim]File not found[/dim]" in content
+    assert isinstance(content, Text)
+    assert "File not found" in content
 
 
 def test_history_modal_read_file_truncated_text(tmp_path):
@@ -6174,9 +6265,10 @@ def test_history_modal_read_file_truncated_text(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should be truncated
-    assert "[dim]... (truncated)[/dim]" in content
-    # Content should be limited
-    assert len(content) < 60000
+    assert isinstance(content, Text)
+    assert "truncated" in content
+    # Content should be limited (50000 chars + truncation message)
+    assert len(content.plain) < 60000
 
 
 def test_history_modal_read_file_truncated_binary(tmp_path):
@@ -6189,8 +6281,9 @@ def test_history_modal_read_file_truncated_binary(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should be truncated and shown as binary
-    assert "[Binary content" in content
-    assert "[dim]... (truncated)[/dim]" in content
+    assert isinstance(content, Text)
+    assert "Binary content" in content
+    assert "truncated" in content
 
 
 def test_history_modal_read_file_oserror(tmp_path):
@@ -6204,7 +6297,8 @@ def test_history_modal_read_file_oserror(tmp_path):
     with patch("builtins.open", side_effect=OSError("Permission denied")):
         content = modal._read_file(str(test_file))
 
-    assert "[red]Error reading file[/red]" in content
+    assert isinstance(content, Text)
+    assert "Error reading file" in content
 
 
 def test_history_modal_on_list_view_highlighted_no_entries(tmp_path):