roadmap-cli 0.1.1__py3-none-any.whl

roadmap/common/formatters/tables/issue_table.py

@@ -0,0 +1,276 @@
+"""Issue table formatting and display."""
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from rich.text import Text
+
+from roadmap.common.console import get_console
+from roadmap.common.formatters.base_table_formatter import BaseTableFormatter
+from roadmap.common.formatters.tables.column_factory import create_issue_columns
+from roadmap.common.models import TableData
+from roadmap.common.status_style_manager import StatusStyleManager
+from roadmap.core.domain import Issue, Priority
+
+if TYPE_CHECKING:
+    pass
+
+
+def _get_console():
+    """Get a fresh console instance for test compatibility."""
+    return get_console()
+
+
+class IssueTableFormatter(BaseTableFormatter[Issue]):
+    """Formats issues for display in rich tables."""
+
+    def __init__(self):
+        """Initialize issue formatter with headers and columns."""
+        self.show_github_ids = False
+        self.columns_config = [
+            {"name": "ID", "style": "cyan", "width": 8},
+            {"name": "Title", "style": "white", "width": 25, "no_wrap": True},
+            {"name": "Headline", "style": "white", "width": 30},
+            {"name": "Priority", "style": "yellow", "width": 10},
+            {"name": "Status", "style": "green", "width": 12},
+            {"name": "Progress", "style": "blue", "width": 10},
+            {"name": "Assignee", "style": "magenta", "width": 12},
+            {"name": "Estimate", "style": "green", "width": 10},
+            {"name": "Milestone", "style": "blue", "width": 15},
+        ]
+        # Add GitHub ID column if needed (will be shown if flag is set)
+        self.github_id_column = {"name": "GitHub #", "style": "cyan", "width": 10}
+
+    def create_table(self) -> Any:
+        """Create a rich table with issue columns."""
+        from rich.table import Table
+
+        table = Table(show_header=True, header_style="bold magenta")
+        for col in self.columns_config:
+            table.add_column(
+                col["name"],
+                style=col["style"],
+                width=col["width"],
+                no_wrap=col.get("no_wrap", False),
+            )
+        # Add GitHub ID column if showing them
+        if self.show_github_ids:
+            table.add_column(
+                self.github_id_column["name"],
+                style=self.github_id_column["style"],
+                width=self.github_id_column["width"],
+            )
+        return table
+
+    def add_row(self, table: Any, item: Issue) -> None:
+        """Add a single issue row to the table.
+
+        Args:
+            table: Rich Table object
+            item: Issue object to add
+        """
+        priority_style = {
+            Priority.CRITICAL: "bold red",
+            Priority.HIGH: "red",
+            Priority.MEDIUM: "yellow",
+            Priority.LOW: "dim",
+        }.get(item.priority, "white")
+
+        # Build row cells
+        comment_count = 0
+        if hasattr(item, "comments") and item.comments:
+            try:
+                comment_count = len(item.comments)
+            except TypeError:
+                # Handle Mock objects or other non-sequence types
+                comment_count = 0
+
+        comment_display = f"💬 {comment_count}" if comment_count > 0 else "-"
+
+        cells = [
+            item.id,
+            item.title,
+            Text(item.headline or "", style="white"),
+            Text(item.priority.value, style=priority_style),
+            Text(item.status.value, style=StatusStyleManager.get_style(item.status)),
+            Text(
+                item.progress_display,
+                style="blue" if item.progress_percentage else "dim",
+            ),
+            Text(
+                item.assignee or "Unassigned",
+                style="magenta" if item.assignee else "dim",
+            ),
+            Text(
+                item.estimated_time_display,
+                style="green" if item.estimated_hours else "dim",
+            ),
+            Text(item.milestone_name, style="dim" if item.is_backlog else "blue"),
+            Text(comment_display, style="cyan" if comment_count > 0 else "dim"),
+        ]
+
+        # Add GitHub ID if showing them
+        if self.show_github_ids:
+            github_id_text = (
+                f"#{item.github_issue}" if item.github_issue else Text("-", style="dim")
+            )
+            cells.append(github_id_text)
+
+        table.add_row(*cells)
+
+    def display_items(self, items: list[Issue], filter_description: str) -> None:
+        """Display issues in a formatted table.
+
+        Args:
+            items: List of Issue objects
+            filter_description: Description of filter applied
+        """
+        if not items:
+            _get_console().print(
+                f"📋 No {filter_description} issues found.", style="yellow"
+            )
+            _get_console().print(
+                "Create one with: roadmap issue create 'Issue title'", style="dim"
+            )
+            return
+
+        # Display header with filter info
+        header_text = f"📋 {len(items)} {filter_description} issue{'s' if len(items) != 1 else ''}"
+        _get_console().print(header_text, style="bold cyan")
+        _get_console().print()
+
+        # Rich table display
+        table = self.create_table()
+        for item in items:
+            self.add_row(table, item)
+
+        _get_console().print(table)
+
+    def get_filter_description(self, items: list[Issue]) -> str:
+        """Get human-readable description of filtered issues.
+
+        Args:
+            items: List of issues being displayed
+
+        Returns:
+            Description string (e.g., "5 open issues")
+        """
+        count = len(items)
+        return f"📋 {count} issue{'s' if count != 1 else ''}"
+
+    def items_to_table_data(
+        self, items: list[Issue], title: str = "Issues", description: str = ""
+    ) -> TableData:
+        """Convert Issue list to TableData for structured output.
+
+        Args:
+            items: List of Issue objects.
+            title: Optional table title.
+            description: Optional filter description.
+
+        Returns:
+            TableData object ready for rendering in any format.
+        """
+        columns = create_issue_columns()
+
+        rows = []
+        for item in items:
+            comment_count = 0
+            if hasattr(item, "comments") and item.comments:
+                try:
+                    comment_count = len(item.comments)
+                except TypeError:
+                    # Handle Mock objects or other non-sequence types
+                    comment_count = 0
+
+            comment_display = f"💬 {comment_count}" if comment_count > 0 else ""
+
+            rows.append(
+                [
+                    item.id,
+                    item.title,
+                    item.priority.value,
+                    item.status.value,
+                    item.progress_display,
+                    item.assignee or "Unassigned",
+                    item.estimated_time_display,
+                    item.milestone_name,
+                    comment_display,
+                ]
+            )
+
+        return TableData(
+            columns=columns,
+            rows=rows,
+            title=title,
+            headline=description,
+            total_count=len(items),
+            returned_count=len(items),
+        )
+
+    # Backward compatibility methods (for existing code that uses static methods)
+    @classmethod
+    def create_issue_table(cls):
+        """Create a rich table with issue columns (backward compatible)."""
+        return cls().create_table()
+
+    @classmethod
+    def add_issue_row(cls, table, issue: Issue) -> None:
+        """Add a single issue row to the table (backward compatible)."""
+        cls().add_row(table, issue)
+
+    @classmethod
+    def display_issues(cls, issues: list[Issue], filter_description: str) -> None:
+        """Display issues in a formatted table (backward compatible)."""
+        cls().display_items(issues, filter_description)
+
+    @staticmethod
+    def issues_to_table_data(
+        issues: Sequence[Issue],
+        title: str = "Issues",
+        description: str = "",
+        show_github_ids: bool = False,
+    ) -> TableData:
+        """Convert Issue list to TableData for structured output (backward compatible)."""
+        formatter = IssueTableFormatter()
+        formatter.show_github_ids = show_github_ids
+        return formatter.items_to_table_data(list(issues), title, description)
+
+    @staticmethod
+    def display_workload_summary(
+        assignee_name: str, total_hours: float, status_breakdown: dict
+    ) -> None:
+        """Display workload summary for an assignee."""
+        if total_hours == 0:
+            return
+
+        # Format total time display
+        if total_hours < 1:
+            total_display = f"{total_hours * 60:.0f}m"
+        elif total_hours <= 24:
+            total_display = f"{total_hours:.1f}h"
+        else:
+            total_display = f"{total_hours / 8:.1f}d"
+
+        _get_console().print()
+        _get_console().print(
+            f"Total estimated time for {assignee_name}: {total_display}",
+            style="bold blue",
+        )
+
+        # Show status breakdown
+        _get_console().print("Workload breakdown:", style="bold")
+        for status, data in status_breakdown.items():
+            if data["count"] > 0:
+                if data["hours"] > 0:
+                    if data["hours"] < 1:
+                        time_display = f"{data['hours'] * 60:.0f}m"
+                    elif data["hours"] <= 24:
+                        time_display = f"{data['hours']:.1f}h"
+                    else:
+                        time_display = f"{data['hours'] / 8:.1f}d"
+                    _get_console().print(
+                        f"  {status}: {data['count']} issues ({time_display})"
+                    )
+                else:
+                    _get_console().print(f"  {status}: {data['count']} issues")

roadmap/common/formatters/tables/milestone_table.py

@@ -0,0 +1,247 @@
+"""Milestone table formatting and display."""
+
+from typing import TYPE_CHECKING, Any
+
+from rich.text import Text
+
+from roadmap.common.console import get_console
+from roadmap.common.formatters.base_table_formatter import BaseTableFormatter
+from roadmap.common.models import ColumnDef, ColumnType, TableData
+
+if TYPE_CHECKING:
+    pass
+
+
+def _get_console():
+    """Get a fresh console instance for test compatibility."""
+    return get_console()
+
+
+class MilestoneTableFormatter(BaseTableFormatter):
+    """Formats milestones for display and structured output."""
+
+    def __init__(self):
+        """Initialize milestone formatter with headers and columns."""
+        super().__init__()
+        self.columns_config = [
+            {"name": "Milestone", "style": "cyan", "width": 20},
+            {"name": "Headline", "style": "white", "width": 30},
+            {"name": "Status", "style": "green", "width": 10},
+            {"name": "Due Date", "style": "yellow", "width": 12},
+            {"name": "Progress", "style": "blue", "width": 12},
+            {"name": "Estimate", "style": "green", "width": 12},
+        ]
+
+    def create_table(self) -> Any:
+        """Create a rich table with milestone columns."""
+        from rich.table import Table
+
+        table = Table(show_header=True, header_style="bold magenta")
+        for col in self.columns_config:
+            table.add_column(col["name"], style=col["style"], width=col["width"])
+        return table
+
+    def add_row(self, table: Any, item, estimate: str = "") -> None:
+        """Add a single milestone row to the table.
+
+        Args:
+            table: Rich Table object
+            item: Milestone object to add
+            estimate: Estimated time string for this milestone
+        """
+        progress = ""
+        if hasattr(item, "calculated_progress") and item.calculated_progress:
+            progress = f"{item.calculated_progress:.0f}%"
+
+        due_date_str = ""
+        if hasattr(item, "due_date") and item.due_date:
+            due_date_str = item.due_date.strftime("%Y-%m-%d")
+
+        status_value = (
+            item.status.value if hasattr(item.status, "value") else str(item.status)
+        )
+
+        table.add_row(
+            Text(item.name, style="cyan"),
+            Text(item.headline or "", style="white"),
+            Text(status_value, style="green"),
+            Text(due_date_str, style="yellow"),
+            Text(progress, style="blue"),
+            Text(estimate or "", style="green"),
+        )
+
+    def get_filter_description(self, items: list) -> str:
+        """Get human-readable description of filtered milestones.
+
+        Args:
+            items: List of milestones being displayed
+
+        Returns:
+            Description string (e.g., "5 open milestones")
+        """
+        count = len(items)
+        return f"🏁 {count} milestone{'s' if count != 1 else ''}"
+
+    def display_items(self, items: list, filter_description: str = "all") -> None:
+        """Display milestones in a formatted table.
+
+        Args:
+            items: List of milestone objects
+            filter_description: Description of filter applied
+        """
+        if not items:
+            _get_console().print(
+                f"🏁 No {filter_description} milestones found.", style="yellow"
+            )
+            _get_console().print(
+                "Create one with: roadmap milestone create 'Milestone name'",
+                style="dim",
+            )
+            return
+
+        # Display header with filter info
+        header_text = f"🏁 {len(items)} {filter_description} milestone{'s' if len(items) != 1 else ''}"
+        _get_console().print(header_text, style="bold cyan")
+        _get_console().print()
+
+        # Rich table display
+        table = self.create_table()
+        for item in items:
+            self.add_row(table, item)
+
+        _get_console().print(table)
+
+    def items_to_table_data(
+        self,
+        items: list,
+        title: str = "Milestones",
+        description: str = "",
+        estimates: dict | None = None,
+    ) -> TableData:
+        """Convert Milestone list to TableData for structured output.
+
+        Args:
+            items: List of Milestone objects.
+            title: Optional table title.
+            description: Optional filter description.
+            estimates: Optional dict mapping milestone names to estimate strings.
+
+        Returns:
+            TableData object ready for rendering in any format.
+        """
+        if estimates is None:
+            estimates = {}
+
+        # Create base milestone columns (ID, Name, Status, Progress, Owner)
+        # then customize for this table's specific needs
+        columns = [
+            ColumnDef(
+                name="name",
+                display_name="Milestone",
+                type=ColumnType.STRING,
+                width=20,
+                display_style="cyan",
+                sortable=True,
+                filterable=True,
+            ),
+            ColumnDef(
+                name="description",
+                display_name="Description",
+                type=ColumnType.STRING,
+                width=30,
+                display_style="white",
+                sortable=True,
+                filterable=True,
+            ),
+            ColumnDef(
+                name="status",
+                display_name="Status",
+                type=ColumnType.ENUM,
+                width=10,
+                display_style="green",
+                enum_values=["open", "closed"],
+                sortable=True,
+                filterable=True,
+            ),
+            ColumnDef(
+                name="due_date",
+                display_name="Due Date",
+                type=ColumnType.DATE,
+                width=12,
+                display_style="yellow",
+                sortable=True,
+                filterable=True,
+            ),
+            ColumnDef(
+                name="progress",
+                display_name="Progress",
+                type=ColumnType.STRING,
+                width=12,
+                display_style="blue",
+                sortable=False,
+                filterable=False,
+            ),
+            ColumnDef(
+                name="estimate",
+                display_name="Estimate",
+                type=ColumnType.STRING,
+                width=12,
+                display_style="green",
+                sortable=False,
+                filterable=False,
+            ),
+        ]
+
+        rows = []
+        for milestone in items:
+            progress = ""
+            if (
+                hasattr(milestone, "calculated_progress")
+                and milestone.calculated_progress
+            ):
+                progress = f"{milestone.calculated_progress:.0f}%"
+
+            due_date_str = ""
+            if hasattr(milestone, "due_date") and milestone.due_date:
+                due_date_str = milestone.due_date.strftime("%Y-%m-%d")
+
+            # Handle status - could be string or enum
+            status_value = milestone.status
+            if hasattr(milestone.status, "value"):
+                status_value = milestone.status.value
+
+            # Get estimate for this milestone
+            estimate_str = estimates.get(milestone.name, "-")
+
+            rows.append(
+                [
+                    milestone.name,
+                    milestone.content or "",
+                    status_value,
+                    due_date_str,
+                    progress,
+                    estimate_str,
+                ]
+            )
+
+        return TableData(
+            columns=columns,
+            rows=rows,
+            title=title,
+            headline=description,
+            total_count=len(items),
+            returned_count=len(items),
+        )
+
+    # Backward compatibility methods (for existing code that uses static methods)
+    @staticmethod
+    def milestones_to_table_data(
+        milestones: list,
+        title: str = "Milestones",
+        description: str = "",
+        estimates: dict | None = None,
+    ) -> TableData:
+        """Convert Milestone list to TableData for structured output (backward compatible)."""
+        return MilestoneTableFormatter().items_to_table_data(
+            milestones, title, description, estimates
+        )