!squash more

Author: tony

src/libtmux/snapshot.py

@@ -4,7 +4,9 @@
 
 import dataclasses
 import datetime
+import json
 import typing as t
+from abc import ABC, abstractmethod
 
 from typing_extensions import Self
 
@@ -16,6 +18,147 @@
     from libtmux.pane import Pane
 
 
+class SnapshotOutputAdapter(ABC):
+    """Base class for snapshot output adapters.
+
+    This class defines the interface for converting a PaneSnapshot
+    into different output formats.
+    """
+
+    @abstractmethod
+    def format(self, snapshot: PaneSnapshot) -> str:
+        """Format the snapshot for output.
+
+        Parameters
+        ----------
+        snapshot : PaneSnapshot
+            The snapshot to format
+
+        Returns
+        -------
+        str
+            The formatted output
+        """
+
+
+class TerminalOutputAdapter(SnapshotOutputAdapter):
+    """Format snapshot for terminal output with ANSI colors."""
+
+    def format(self, snapshot: PaneSnapshot) -> str:
+        """Format snapshot with ANSI colors for terminal display.
+
+        Parameters
+        ----------
+        snapshot : PaneSnapshot
+            The snapshot to format
+
+        Returns
+        -------
+        str
+            ANSI-colored terminal output
+        """
+        header = (
+            f"\033[1;34m=== Pane Snapshot ===\033[0m\n"
+            f"\033[1;36mPane:\033[0m {snapshot.pane_id}\n"
+            f"\033[1;36mWindow:\033[0m {snapshot.window_id}\n"
+            f"\033[1;36mSession:\033[0m {snapshot.session_id}\n"
+            f"\033[1;36mServer:\033[0m {snapshot.server_name}\n"
+            f"\033[1;36mTimestamp:\033[0m {snapshot.timestamp.isoformat()}\n"
+            f"\033[1;33m=== Content ===\033[0m\n"
+        )
+        return header + snapshot.content_str
+
+
+class CLIOutputAdapter(SnapshotOutputAdapter):
+    """Format snapshot for plain text CLI output."""
+
+    def format(self, snapshot: PaneSnapshot) -> str:
+        """Format snapshot as plain text.
+
+        Parameters
+        ----------
+        snapshot : PaneSnapshot
+            The snapshot to format
+
+        Returns
+        -------
+        str
+            Plain text output suitable for CLI
+        """
+        header = (
+            f"=== Pane Snapshot ===\n"
+            f"Pane: {snapshot.pane_id}\n"
+            f"Window: {snapshot.window_id}\n"
+            f"Session: {snapshot.session_id}\n"
+            f"Server: {snapshot.server_name}\n"
+            f"Timestamp: {snapshot.timestamp.isoformat()}\n"
+            f"=== Content ===\n"
+        )
+        return header + snapshot.content_str
+
+
+class PytestDiffAdapter(SnapshotOutputAdapter):
+    """Format snapshot for pytest assertion diffs."""
+
+    def format(self, snapshot: PaneSnapshot) -> str:
+        """Format snapshot for optimal pytest diff output.
+
+        Parameters
+        ----------
+        snapshot : PaneSnapshot
+            The snapshot to format
+
+        Returns
+        -------
+        str
+            Pytest-friendly diff output
+        """
+        lines = [
+            "PaneSnapshot(",
+            f"    pane_id={snapshot.pane_id!r},",
+            f"    window_id={snapshot.window_id!r},",
+            f"    session_id={snapshot.session_id!r},",
+            f"    server_name={snapshot.server_name!r},",
+            f"    timestamp={snapshot.timestamp.isoformat()!r},",
+            "    content=[",
+            *(f"        {line!r}," for line in snapshot.content),
+            "    ],",
+            "    metadata={",
+            *(f"        {k!r}: {v!r}," for k, v in sorted(snapshot.metadata.items())),
+            "    },",
+            ")",
+        ]
+        return "\n".join(lines)
+
+
+class SyrupySnapshotAdapter(SnapshotOutputAdapter):
+    """Format snapshot for syrupy snapshot testing."""
+
+    def format(self, snapshot: PaneSnapshot) -> str:
+        """Format snapshot for syrupy compatibility.
+
+        Parameters
+        ----------
+        snapshot : PaneSnapshot
+            The snapshot to format
+
+        Returns
+        -------
+        str
+            JSON-serialized snapshot data
+        """
+        data = {
+            "pane_id": snapshot.pane_id,
+            "window_id": snapshot.window_id,
+            "session_id": snapshot.session_id,
+            "server_name": snapshot.server_name,
+            "timestamp": snapshot.timestamp.isoformat(),
+            "content": snapshot.content,
+            "metadata": snapshot.metadata,
+        }
+        return json.dumps(data, indent=2, sort_keys=True)
+
+
 @dataclasses.dataclass(frozen=True)
 class PaneSnapshot:
     """A frozen snapshot of a pane's state at a point in time.
@@ -92,6 +235,25 @@ def from_pane(
             metadata=metadata,
         )
 
+    def format(self, adapter: SnapshotOutputAdapter | None = None) -> str:
+        """Format the snapshot using the specified adapter.
+
+        If no adapter is provided, uses the default string representation.
+
+        Parameters
+        ----------
+        adapter : SnapshotOutputAdapter | None
+            The adapter to use for formatting
+
+        Returns
+        -------
+        str
+            The formatted output
+        """
+        if adapter is None:
+            return str(self)
+        return adapter.format(self)
+
     def __str__(self) -> str:
         """Return a string representation of the snapshot.
 

tests/test_snapshot.py

@@ -3,11 +3,19 @@
 from __future__ import annotations
 
 import datetime
+import json
 import shutil
 import time
 import typing as t
 
-from libtmux.snapshot import PaneRecording, PaneSnapshot
+from libtmux.snapshot import (
+    CLIOutputAdapter,
+    PaneRecording,
+    PaneSnapshot,
+    PytestDiffAdapter,
+    SyrupySnapshotAdapter,
+    TerminalOutputAdapter,
+)
 
 if t.TYPE_CHECKING:
     from libtmux.session import Session
@@ -105,3 +113,121 @@ def test_pane_recording(session: Session) -> None:
 
     assert len(recording.get_snapshots_between(start_time, end_time)) == 3
     assert len(recording.get_snapshots_between(mid_time, end_time)) == 2
+
+
+def test_snapshot_output_adapters(session: Session) -> None:
+    """Test the various output adapters for PaneSnapshot."""
+    env = shutil.which("env")
+    assert env is not None, "Cannot find usable `env` in PATH."
+
+    session.new_window(
+        attach=True,
+        window_name="adapter_test",
+        window_shell=f"{env} PS1='$ ' sh",
+    )
+    pane = session.active_window.active_pane
+    assert pane is not None
+
+    # Create a snapshot with some content
+    pane.send_keys("echo 'Test Content'")
+    time.sleep(0.1)
+    snapshot = pane.snapshot()
+
+    # Test Terminal Output
+    terminal_output = snapshot.format(TerminalOutputAdapter())
+    assert "\033[1;34m=== Pane Snapshot ===\033[0m" in terminal_output
+    assert "\033[1;36mPane:\033[0m" in terminal_output
+    assert "Test Content" in terminal_output
+
+    # Test CLI Output
+    cli_output = snapshot.format(CLIOutputAdapter())
+    assert "=== Pane Snapshot ===" in cli_output
+    assert "Pane: " in cli_output
+    assert "\033" not in cli_output  # No ANSI codes
+    assert "Test Content" in cli_output
+
+    # Test Pytest Diff Output
+    pytest_output = snapshot.format(PytestDiffAdapter())
+    assert "PaneSnapshot(" in pytest_output
+    assert "    pane_id=" in pytest_output
+    assert "    content=[" in pytest_output
+    assert "    metadata={" in pytest_output
+    assert "'Test Content'" in pytest_output
+
+    # Test Syrupy Output
+    syrupy_output = snapshot.format(SyrupySnapshotAdapter())
+    data = json.loads(syrupy_output)
+    assert isinstance(data, dict)
+    assert "pane_id" in data
+    assert "content" in data
+    assert "metadata" in data
+    assert "Test Content" in str(data["content"])
+
+    # Test default format (no adapter)
+    default_output = snapshot.format()
+    assert default_output == str(snapshot)
+
+
+def test_pane_snapshot_convenience_method(session: Session) -> None:
+    """Test the Pane.snapshot() convenience method."""
+    env = shutil.which("env")
+    assert env is not None, "Cannot find usable `env` in PATH."
+
+    session.new_window(
+        attach=True,
+        window_name="snapshot_convenience_test",
+        window_shell=f"{env} PS1='$ ' sh",
+    )
+    pane = session.active_window.active_pane
+    assert pane is not None
+
+    # Take snapshot using convenience method
+    snapshot = pane.snapshot()
+    assert snapshot.content == ["$"]
+    assert snapshot.pane_id == pane.pane_id
+    assert snapshot.window_id == pane.window.window_id
+    assert snapshot.session_id == pane.session.session_id
+    assert snapshot.server_name == pane.server.socket_name
+
+    # Test with start/end parameters
+    pane.send_keys("echo 'Line 1'")
+    time.sleep(0.1)
+    pane.send_keys("echo 'Line 2'")
+    time.sleep(0.1)
+    pane.send_keys("echo 'Line 3'")
+    time.sleep(0.1)
+
+    snapshot_partial = pane.snapshot(start=1, end=2)
+    assert len(snapshot_partial.content) == 2
+    assert "Line 1" in snapshot_partial.content_str
+    assert "Line 2" in snapshot_partial.content_str
+    assert "Line 3" not in snapshot_partial.content_str
+
+
+def test_pane_record_convenience_method(session: Session) -> None:
+    """Test the Pane.record() convenience method."""
+    env = shutil.which("env")
+    assert env is not None, "Cannot find usable `env` in PATH."
+
+    session.new_window(
+        attach=True,
+        window_name="record_convenience_test",
+        window_shell=f"{env} PS1='$ ' sh",
+    )
+    pane = session.active_window.active_pane
+    assert pane is not None
+
+    # Create recording using convenience method
+    recording = pane.record()
+    assert isinstance(recording, PaneRecording)
+    assert len(recording) == 0
+
+    # Add snapshots to recording
+    recording.add_snapshot(pane)
+    pane.send_keys("echo 'Test'")
+    time.sleep(0.1)
+    recording.add_snapshot(pane)
+
+    assert len(recording) == 2
+    assert recording[0].content == ["$"]
+    assert "Test" in recording[1].content_str