lintro 0.13.2__py3-none-any.whl → 0.17.2__py3-none-any.whl

lintro/formatters/tools/pytest_formatter.py

@@ -0,0 +1,201 @@
+"""Formatter for pytest issues."""
+
+from lintro.formatters.core.table_descriptor import TableDescriptor
+from lintro.formatters.styles.csv import CsvStyle
+from lintro.formatters.styles.grid import GridStyle
+from lintro.formatters.styles.html import HtmlStyle
+from lintro.formatters.styles.json import JsonStyle
+from lintro.formatters.styles.markdown import MarkdownStyle
+from lintro.formatters.styles.plain import PlainStyle
+from lintro.parsers.pytest.pytest_issue import PytestIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+# Maximum message length before truncation (reasonable for terminal widths)
+MAX_MESSAGE_LENGTH: int = 100
+
+FORMAT_MAP = {
+    "plain": PlainStyle(),
+    "grid": GridStyle(),
+    "markdown": MarkdownStyle(),
+    "html": HtmlStyle(),
+    "json": JsonStyle(),
+    "csv": CsvStyle(),
+}
+
+
+class PytestFailuresTableDescriptor(TableDescriptor):
+    """Describe columns and rows for pytest failed/error issues."""
+
+    def get_columns(self) -> list[str]:
+        """Return ordered column headers for the pytest failures table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
+        return ["File", "Status", "Error"]
+
+    def get_rows(
+        self,
+        issues: list[PytestIssue],
+    ) -> list[list[str]]:
+        """Return rows for the pytest failures table.
+
+        Args:
+            issues: Parsed pytest issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
+        rows = []
+        for issue in issues:
+            # Only show failed/error tests
+            if issue.test_status not in ("FAILED", "ERROR"):
+                continue
+
+            message = str(issue.message) if issue.message is not None else ""
+            truncated_message = (
+                f"{message[:MAX_MESSAGE_LENGTH]}..."
+                if len(message) > MAX_MESSAGE_LENGTH + 3
+                else message
+            )
+
+            status_emoji = "❌ FAIL" if issue.test_status == "FAILED" else "⚠️ ERROR"
+
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    status_emoji,
+                    truncated_message,
+                ],
+            )
+        return rows
+
+
+class PytestSkippedTableDescriptor(TableDescriptor):
+    """Describe columns and rows for pytest skipped issues."""
+
+    def get_columns(self) -> list[str]:
+        """Return ordered column headers for the pytest skipped table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
+        return ["File", "Test", "Skip Reason"]
+
+    def get_rows(
+        self,
+        issues: list[PytestIssue],
+    ) -> list[list[str]]:
+        """Return rows for the pytest skipped table.
+
+        Args:
+            issues: Parsed pytest issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
+        rows = []
+        for issue in issues:
+            # Only show skipped tests
+            if issue.test_status != "SKIPPED":
+                continue
+
+            message = str(issue.message) if issue.message is not None else ""
+            truncated_message = (
+                f"{message[:MAX_MESSAGE_LENGTH]}..."
+                if len(message) > MAX_MESSAGE_LENGTH + 3
+                else message
+            )
+
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    issue.test_name or "Unknown",
+                    truncated_message,
+                ],
+            )
+        return rows
+
+
+def format_pytest_failures(
+    issues: list[PytestIssue],
+    format: str = "grid",
+) -> str:
+    """Format pytest failures and errors into a table.
+
+    Args:
+        issues: List of pytest issues to format.
+        format: Output format (plain, grid, markdown, html, json, csv).
+
+    Returns:
+        str: Formatted string with pytest failures table.
+    """
+    descriptor = PytestFailuresTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+
+    # Always return a table structure, even if empty
+    return formatter.format(
+        columns=columns,
+        rows=rows,
+    )
+
+
+def format_pytest_skipped(
+    issues: list[PytestIssue],
+    format: str = "grid",
+) -> str:
+    """Format pytest skipped tests into a table.
+
+    Args:
+        issues: List of pytest issues to format.
+        format: Output format (plain, grid, markdown, html, json, csv).
+
+    Returns:
+        str: Formatted string with pytest skipped tests table.
+    """
+    descriptor = PytestSkippedTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+
+    # Always return a table structure, even if empty
+    return formatter.format(
+        columns=columns,
+        rows=rows,
+    )
+
+
+def format_pytest_issues(
+    issues: list[PytestIssue],
+    format: str = "grid",
+) -> str:
+    """Format pytest issues into tables for failures and skipped tests.
+
+    Args:
+        issues: List of pytest issues to format.
+        format: Output format (plain, grid, markdown, html, json, csv).
+
+    Returns:
+        str: Formatted string with pytest issues tables.
+    """
+    output_parts = []
+
+    # Format failures table
+    failures_table = format_pytest_failures(issues, format)
+    if failures_table.strip():
+        output_parts.append("Test Failures:")
+        output_parts.append(failures_table)
+
+    # Format skipped tests table
+    skipped_table = format_pytest_skipped(issues, format)
+    if skipped_table.strip():
+        if output_parts:
+            output_parts.append("")  # Add blank line between tables
+        output_parts.append("Skipped Tests:")
+        output_parts.append(skipped_table)
+
+    return "\n".join(output_parts)

lintro/parsers/__init__.py

@@ -1,21 +1,81 @@
 """Parser modules for Lintro tools."""
 
-from . import (
-    actionlint,
-    bandit,
-    darglint,
-    hadolint,
-    prettier,
-    ruff,
-    yamllint,
-)
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # Type checking imports
+    from lintro.parsers import (
+        actionlint,
+        bandit,
+        darglint,
+        eslint,
+        hadolint,
+        markdownlint,
+        prettier,
+        pytest,
+        ruff,
+        yamllint,
+    )
 
 __all__ = [
     "actionlint",
     "bandit",
     "darglint",
+    "eslint",
     "hadolint",
+    "markdownlint",
     "prettier",
+    "pytest",
     "ruff",
     "yamllint",
 ]
+
+# Lazy-load parser submodules to avoid circular imports
+_SUBMODULES = {
+    "actionlint",
+    "bandit",
+    "darglint",
+    "eslint",
+    "hadolint",
+    "markdownlint",
+    "prettier",
+    "pytest",
+    "ruff",
+    "yamllint",
+}
+
+
+def __getattr__(name: str) -> object:
+    """Lazy-load parser submodules to avoid circular import issues.
+
+    This function is called when an attribute is accessed that doesn't exist
+    in the module. It allows accessing parser submodules without eagerly
+    importing them all at package initialization time.
+
+    Args:
+        name: The name of the attribute being accessed.
+
+    Returns:
+        The imported submodule.
+
+    Raises:
+        AttributeError: If the requested name is not a known submodule.
+    """
+    if name in _SUBMODULES:
+        module = import_module(f".{name}", __package__)
+        # Cache the module in this module's namespace for future access
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    """Return list of available attributes for this module.
+
+    Returns:
+        List of submodule names and other module attributes.
+    """
+    return list(__all__)

lintro/parsers/bandit/__init__.py

@@ -0,0 +1,6 @@
+"""Bandit parser module."""
+
+from lintro.parsers.bandit.bandit_issue import BanditIssue
+from lintro.parsers.bandit.bandit_parser import parse_bandit_output
+
+__all__ = ["BanditIssue", "parse_bandit_output"]

lintro/parsers/bandit/bandit_issue.py

@@ -0,0 +1,49 @@
+"""Bandit issue model for security vulnerabilities."""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class BanditIssue:
+    """Represents a security issue found by Bandit.
+
+    Attributes:
+        file: str: Path to the file containing the issue.
+        line: int: Line number where the issue was found.
+        col_offset: int: Column offset of the issue.
+        issue_severity: str: Severity level (LOW, MEDIUM, HIGH).
+        issue_confidence: str: Confidence level (LOW, MEDIUM, HIGH).
+        test_id: str: Bandit test ID (e.g., B602, B301).
+        test_name: str: Name of the test that found the issue.
+        issue_text: str: Description of the security issue.
+        more_info: str: URL with more information about the issue.
+        cwe: dict[str, Any] | None: CWE (Common Weakness Enumeration) information.
+        code: str: Code snippet containing the issue.
+        line_range: list[int]: Range of lines containing the issue.
+    """
+
+    file: str
+    line: int
+    col_offset: int
+    issue_severity: str
+    issue_confidence: str
+    test_id: str
+    test_name: str
+    issue_text: str
+    more_info: str
+    cwe: dict[str, Any] | None = None
+    code: str | None = None
+    line_range: list[int] | None = None
+
+    @property
+    def message(self) -> str:
+        """Get a human-readable message for the issue.
+
+        Returns:
+            str: Formatted issue message.
+        """
+        return (
+            f"[{self.test_id}:{self.test_name}] {self.issue_severity} severity, "
+            f"{self.issue_confidence} confidence: {self.issue_text}"
+        )

lintro/parsers/bandit/bandit_parser.py

@@ -0,0 +1,99 @@
+"""Bandit output parser for security issues."""
+
+from typing import Any
+
+from loguru import logger
+
+from lintro.parsers.bandit.bandit_issue import BanditIssue
+
+
+def parse_bandit_output(bandit_data: dict[str, Any]) -> list[BanditIssue]:
+    """Parse Bandit JSON output into BanditIssue objects.
+
+    Args:
+        bandit_data: dict[str, Any]: JSON data from Bandit output.
+
+    Returns:
+        list[BanditIssue]: List of parsed security issues.
+
+    Raises:
+        ValueError: If the bandit data structure is invalid.
+    """
+    if not isinstance(bandit_data, dict):
+        raise ValueError("Bandit data must be a dictionary")
+
+    results = bandit_data.get("results", [])
+    if not isinstance(results, list):
+        raise ValueError("Bandit results must be a list")
+
+    issues: list[BanditIssue] = []
+
+    for result in results:
+        if not isinstance(result, dict):
+            continue
+
+        try:
+            filename = result.get("filename", "")
+            line_number = result.get("line_number", 0)
+            col_offset = result.get("col_offset", 0)
+            issue_severity = result.get("issue_severity", "UNKNOWN")
+            issue_confidence = result.get("issue_confidence", "UNKNOWN")
+            test_id = result.get("test_id", "")
+            test_name = result.get("test_name", "")
+            issue_text = result.get("issue_text", "")
+            more_info = result.get("more_info", "")
+            cwe = result.get("issue_cwe")
+            code = result.get("code")
+            line_range = result.get("line_range")
+
+            # Validate critical fields; skip malformed entries
+            if not isinstance(filename, str):
+                logger.warning("Skipping issue with non-string filename")
+                continue
+            if not isinstance(line_number, int):
+                logger.warning("Skipping issue with non-integer line_number")
+                continue
+            if not isinstance(col_offset, int):
+                col_offset = 0
+
+            sev = (
+                str(issue_severity).upper() if issue_severity is not None else "UNKNOWN"
+            )
+            conf = (
+                str(issue_confidence).upper()
+                if issue_confidence is not None
+                else "UNKNOWN"
+            )
+
+            test_id = test_id if isinstance(test_id, str) else ""
+            test_name = test_name if isinstance(test_name, str) else ""
+            issue_text = issue_text if isinstance(issue_text, str) else ""
+            more_info = more_info if isinstance(more_info, str) else ""
+
+            # Normalize line_range to list[int] when provided
+            if isinstance(line_range, list):
+                line_range = [x for x in line_range if isinstance(x, int)] or None
+            else:
+                line_range = None
+
+            issue = BanditIssue(
+                file=filename,
+                line=line_number,
+                col_offset=col_offset,
+                issue_severity=sev,
+                issue_confidence=conf,
+                test_id=test_id,
+                test_name=test_name,
+                issue_text=issue_text,
+                more_info=more_info,
+                cwe=cwe if isinstance(cwe, dict) else None,
+                code=code if isinstance(code, str) else None,
+                line_range=line_range,
+            )
+            issues.append(issue)
+        except (KeyError, TypeError, ValueError) as e:
+            # Log warning but continue processing other issues
+            logger.warning(f"Failed to parse bandit issue: {e}")
+            continue
+
+    return issues

lintro/parsers/black/black_issue.py

@@ -16,7 +16,11 @@ class BlackIssue:
     Attributes:
         file: Path to the file with a formatting difference.
         message: Short human-readable description (e.g., "Would reformat file").
+        fixable: Whether this issue can be auto-fixed by Black. Defaults to True
+            for standard formatting issues. Set to False for line length violations
+            that Black cannot safely wrap.
     """
 
     file: str
     message: str
+    fixable: bool = True

lintro/parsers/eslint/__init__.py

@@ -0,0 +1,6 @@
+"""Parsing utilities and types for ESLint output."""
+
+from lintro.parsers.eslint.eslint_issue import EslintIssue
+from lintro.parsers.eslint.eslint_parser import parse_eslint_output
+
+__all__ = ["EslintIssue", "parse_eslint_output"]

lintro/parsers/eslint/eslint_issue.py

@@ -0,0 +1,26 @@
+"""Typed structure representing a single ESLint issue."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EslintIssue:
+    """Simple container for ESLint findings.
+
+    Attributes:
+        file: File path where the issue occurred.
+        line: Line number where the issue occurred.
+        column: Column number where the issue occurred.
+        code: Rule ID that triggered the issue (e.g., 'no-unused-vars').
+        message: Human-readable description of the issue.
+        severity: Severity level (1=warning, 2=error).
+        fixable: Whether this issue can be auto-fixed.
+    """
+
+    file: str
+    line: int
+    column: int
+    code: str
+    message: str
+    severity: int
+    fixable: bool = False

lintro/parsers/eslint/eslint_parser.py

@@ -0,0 +1,63 @@
+"""Parser for ESLint JSON output.
+
+Handles ESLint JSON format output from --format json flag.
+"""
+
+import json
+from typing import Any
+
+from lintro.parsers.eslint.eslint_issue import EslintIssue
+
+
+def parse_eslint_output(output: str) -> list[EslintIssue]:
+    """Parse ESLint JSON output into a list of EslintIssue objects.
+
+    Args:
+        output: The raw JSON output from ESLint.
+
+    Returns:
+        List of EslintIssue objects.
+    """
+    issues: list[EslintIssue] = []
+
+    if not output:
+        return issues
+
+    try:
+        # ESLint JSON format is an array of file results
+        # Each file result has: filePath, messages[], errorCount, warningCount
+        eslint_data: list[dict[str, Any]] = json.loads(output)
+    except json.JSONDecodeError:
+        # If output is not valid JSON, return empty list
+        return issues
+
+    for file_result in eslint_data:
+        file_path: str = file_result.get("filePath", "")
+        messages: list[dict[str, Any]] = file_result.get("messages", [])
+
+        for msg in messages:
+            # Extract issue details from ESLint message format
+            line: int = msg.get("line", 1)
+            column: int = msg.get("column", 1)
+            rule_id: str = msg.get("ruleId", "unknown")
+            message_text: str = msg.get("message", "")
+            severity: int = msg.get("severity", 2)  # Default to error (2)
+            fixable: bool = msg.get("fix") is not None  # Has fix object if fixable
+
+            # Skip messages without a ruleId (usually syntax errors)
+            if not rule_id:
+                continue
+
+            issues.append(
+                EslintIssue(
+                    file=file_path,
+                    line=line,
+                    column=column,
+                    code=rule_id,
+                    message=message_text,
+                    severity=severity,
+                    fixable=fixable,
+                ),
+            )
+
+    return issues

lintro/parsers/markdownlint/__init__.py

@@ -0,0 +1,6 @@
+"""Parser for markdownlint-cli2 output."""
+
+from lintro.parsers.markdownlint.markdownlint_issue import MarkdownlintIssue
+from lintro.parsers.markdownlint.markdownlint_parser import parse_markdownlint_output
+
+__all__ = ["MarkdownlintIssue", "parse_markdownlint_output"]

lintro/parsers/markdownlint/markdownlint_issue.py

@@ -0,0 +1,22 @@
+"""Markdownlint issue model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class MarkdownlintIssue:
+    """Represents an issue found by markdownlint-cli2.
+
+    Attributes:
+        file: File path where the issue was found
+        line: Line number where the issue occurs
+        code: Rule code that was violated (e.g., MD013, MD041)
+        message: Description of the issue
+        column: Column number where the issue occurs (if available)
+    """
+
+    file: str
+    line: int
+    code: str
+    message: str
+    column: int | None = None