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

lintro/formatters/tools/black_formatter.py

@@ -2,14 +2,12 @@
 
 from __future__ import annotations
 
-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.black.black_issue import BlackIssue
 from lintro.utils.path_utils import normalize_file_path_for_display
 
 FORMAT_MAP = {
@@ -22,11 +20,26 @@ FORMAT_MAP = {
 }
 
 
-class BlackTableDescriptor(TableDescriptor):
+class BlackTableDescriptor:
+    """Column layout for Black issues in tabular output."""
+
     def get_columns(self) -> list[str]:
+        """Return ordered column headers for Black output rows.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return ["File", "Message"]
 
-    def get_rows(self, issues: list[BlackIssue]) -> list[list[str]]:
+    def get_rows(self, issues: list) -> list[list[str]]:
+        """Return formatted rows for Black issues.
+
+        Args:
+            issues: Parsed Black issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file paths and messages.
+        """
         rows: list[list[str]] = []
         for issue in issues:
             rows.append(
@@ -38,7 +51,16 @@ class BlackTableDescriptor(TableDescriptor):
         return rows
 
 
-def format_black_issues(issues: list[BlackIssue], format: str = "grid") -> str:
+def format_black_issues(issues, format: str) -> str:
+    """Format Black issues according to the chosen style.
+
+    Args:
+        issues: Parsed Black issues.
+        format: Output style identifier.
+
+    Returns:
+        str: Rendered table string.
+    """
     descriptor = BlackTableDescriptor()
     formatter = FORMAT_MAP.get(format, GridStyle())
     columns = descriptor.get_columns()

lintro/formatters/tools/darglint_formatter.py

@@ -21,13 +21,28 @@ FORMAT_MAP = {
 
 
 class DarglintTableDescriptor(TableDescriptor):
+    """Describe columns and rows for Darglint issues."""
+
     def get_columns(self) -> list[str]:
+        """Return column headers for the Darglint issues table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return ["File", "Line", "Code", "Message"]
 
     def get_rows(
         self,
         issues: list[DarglintIssue],
     ) -> list[list[str]]:
+        """Return rows for the Darglint table.
+
+        Args:
+            issues: Parsed Darglint issues to format.
+
+        Returns:
+            list[list[str]]: Table rows with normalized path, line, code, message.
+        """
         rows = []
         for issue in issues:
             rows.append(
@@ -52,7 +67,7 @@ def format_darglint_issues(
         format: Output format (plain, grid, markdown, html, json, csv).
 
     Returns:
-        Formatted string representation of the issues.
+        str: Formatted string representation of the issues.
     """
     descriptor = DarglintTableDescriptor()
     columns = descriptor.get_columns()

lintro/formatters/tools/eslint_formatter.py

@@ -0,0 +1,108 @@
+"""Formatter for ESLint 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.eslint.eslint_issue import EslintIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+FORMAT_MAP = {
+    "plain": PlainStyle(),
+    "grid": GridStyle(),
+    "markdown": MarkdownStyle(),
+    "html": HtmlStyle(),
+    "json": JsonStyle(),
+    "csv": CsvStyle(),
+}
+
+
+class EslintTableDescriptor(TableDescriptor):
+    """Describe columns and rows for ESLint issues."""
+
+    def get_columns(self) -> list[str]:
+        """Return ordered column headers for the ESLint table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
+        return ["File", "Line", "Column", "Code", "Severity", "Message"]
+
+    def get_rows(
+        self,
+        issues: list[EslintIssue],
+    ) -> list[list[str]]:
+        """Return rows for the ESLint issues table.
+
+        Args:
+            issues: Parsed ESLint issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
+        rows = []
+        for issue in issues:
+            severity_str = "error" if issue.severity == 2 else "warning"
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    str(issue.line),
+                    str(issue.column),
+                    issue.code,
+                    severity_str,
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_eslint_issues(
+    issues: list[EslintIssue],
+    format: str = "grid",
+) -> str:
+    """Format ESLint issues with auto-fixable labeling.
+
+    Args:
+        issues: List of EslintIssue objects.
+        format: Output format identifier (e.g., "grid", "json").
+
+    Returns:
+        str: Formatted output string.
+
+    Notes:
+        ESLint issues can be auto-fixable if the fixable flag is True.
+        For non-JSON formats, issues are split into auto-fixable and
+        not auto-fixable sections.
+        JSON returns the combined table for compatibility.
+    """
+    descriptor = EslintTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+
+    if format == "json":
+        columns = descriptor.get_columns()
+        rows = descriptor.get_rows(issues)
+        return formatter.format(columns=columns, rows=rows, tool_name="eslint")
+
+    # Split issues by fixability
+    fixable_issues = [i for i in issues if i.fixable]
+    non_fixable_issues = [i for i in issues if not i.fixable]
+
+    sections: list[str] = []
+    if fixable_issues:
+        columns = descriptor.get_columns()
+        rows = descriptor.get_rows(fixable_issues)
+        table = formatter.format(columns=columns, rows=rows)
+        sections.append("Auto-fixable issues\n" + table)
+    if non_fixable_issues:
+        columns = descriptor.get_columns()
+        rows = descriptor.get_rows(non_fixable_issues)
+        table = formatter.format(columns=columns, rows=rows)
+        sections.append("Not auto-fixable issues\n" + table)
+
+    if not sections:
+        return "No issues found."
+
+    return "\n\n".join(sections)

lintro/formatters/tools/hadolint_formatter.py

@@ -19,6 +19,11 @@ class HadolintTableDescriptor(TableDescriptor):
     """Describe hadolint issue columns and row extraction."""
 
     def get_columns(self) -> list[str]:
+        """Return ordered column headers for the Hadolint table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return [
             "File",
             "Line",
@@ -32,6 +37,14 @@ class HadolintTableDescriptor(TableDescriptor):
         self,
         issues: list[HadolintIssue],
     ) -> list[list[Any]]:
+        """Return rows for the Hadolint issues table.
+
+        Args:
+            issues: Parsed Hadolint issues to render.
+
+        Returns:
+            list[list[Any]]: Table rows with normalized file path and fields.
+        """
         rows: list[list[Any]] = []
         for issue in issues:
             rows.append(

lintro/formatters/tools/markdownlint_formatter.py

@@ -0,0 +1,88 @@
+"""Formatter for Markdownlint 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.markdownlint.markdownlint_issue import MarkdownlintIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+
+class MarkdownlintTableDescriptor(TableDescriptor):
+    """Describe columns and rows for Markdownlint issues."""
+
+    def get_columns(self) -> list[str]:
+        """Return ordered column headers for the Markdownlint table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
+        return ["File", "Line", "Column", "Code", "Message"]
+
+    def get_rows(
+        self,
+        issues: list[MarkdownlintIssue],
+    ) -> list[list[str]]:
+        """Return rows for the Markdownlint issues table.
+
+        Args:
+            issues: Parsed Markdownlint issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
+        rows = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    str(issue.line),
+                    str(issue.column) if issue.column is not None else "-",
+                    issue.code,
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_markdownlint_issues(
+    issues: list[MarkdownlintIssue],
+    format: str = "grid",
+    *,
+    tool_name: str = "markdownlint",
+) -> str:
+    """Format Markdownlint issues to the given style.
+
+    Args:
+        issues: List of MarkdownlintIssue instances.
+        format: Output style identifier.
+        tool_name: Tool name for JSON metadata.
+
+    Returns:
+        str: Rendered string for the issues table.
+    """
+    descriptor = MarkdownlintTableDescriptor()
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+
+    if not rows:
+        return "No issues found."
+
+    style = (format or "grid").lower()
+    if style == "grid":
+        return GridStyle().format(columns=columns, rows=rows)
+    if style == "plain":
+        return PlainStyle().format(columns=columns, rows=rows)
+    if style == "markdown":
+        return MarkdownStyle().format(columns=columns, rows=rows)
+    if style == "html":
+        return HtmlStyle().format(columns=columns, rows=rows)
+    if style == "json":
+        return JsonStyle().format(columns=columns, rows=rows, tool_name=tool_name)
+    if style == "csv":
+        return CsvStyle().format(columns=columns, rows=rows)
+
+    return GridStyle().format(columns=columns, rows=rows)

lintro/formatters/tools/prettier_formatter.py

@@ -21,13 +21,28 @@ FORMAT_MAP = {
 
 
 class PrettierTableDescriptor(TableDescriptor):
+    """Describe columns and rows for Prettier issues."""
+
     def get_columns(self) -> list[str]:
+        """Return ordered column headers for the Prettier table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return ["File", "Line", "Column", "Code", "Message"]
 
     def get_rows(
         self,
         issues: list[PrettierIssue],
     ) -> list[list[str]]:
+        """Return rows for the Prettier issues table.
+
+        Args:
+            issues: Parsed Prettier issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
         rows = []
         for issue in issues:
             rows.append(

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/formatters/tools/ruff_formatter.py

@@ -21,13 +21,28 @@ FORMAT_MAP = {
 
 
 class RuffTableDescriptor(TableDescriptor):
+    """Describe columns and rows for Ruff issues."""
+
     def get_columns(self) -> list[str]:
+        """Return ordered column headers for the Ruff table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return ["File", "Line", "Column", "Code", "Message"]
 
     def get_rows(
         self,
         issues: list[RuffIssue | RuffFormatIssue],
     ) -> list[list[str]]:
+        """Return rows for the Ruff issues table.
+
+        Args:
+            issues: Parsed Ruff issues to render.
+
+        Returns:
+            list[list[str]]: Table rows with normalized file path and fields.
+        """
         rows = []
         for issue in issues:
             if isinstance(issue, RuffIssue):
@@ -69,7 +84,7 @@ def format_ruff_issues(
         format: Output format (plain, grid, markdown, html, json, csv).
 
     Returns:
-        Formatted string (one or two tables depending on format).
+        str: Formatted string (one or two tables depending on format).
     """
     descriptor = RuffTableDescriptor()
     formatter = FORMAT_MAP.get(format, GridStyle())
@@ -79,9 +94,11 @@ def format_ruff_issues(
     non_fixable_issues: list[RuffIssue] = []
 
     for issue in issues:
-        if isinstance(issue, RuffFormatIssue):
-            fixable_issues.append(issue)
-        elif isinstance(issue, RuffIssue) and issue.fixable:
+        if (
+            isinstance(issue, RuffFormatIssue)
+            or isinstance(issue, RuffIssue)
+            and issue.fixable
+        ):
             fixable_issues.append(issue)
         elif isinstance(issue, RuffIssue):
             non_fixable_issues.append(issue)
@@ -90,7 +107,11 @@ def format_ruff_issues(
     if format == "json":
         columns = descriptor.get_columns()
         rows = descriptor.get_rows(issues)
-        return formatter.format(columns=columns, rows=rows, tool_name="ruff")
+        return formatter.format(
+            columns=columns,
+            rows=rows,
+            tool_name="ruff",
+        )
 
     sections: list[str] = []
 

lintro/formatters/tools/yamllint_formatter.py

@@ -19,6 +19,11 @@ class YamllintTableDescriptor(TableDescriptor):
     """Describe yamllint issue columns and row extraction."""
 
     def get_columns(self) -> list[str]:
+        """Return ordered column headers for the Yamllint table.
+
+        Returns:
+            list[str]: Column names for the formatted table.
+        """
         return [
             "File",
             "Line",
@@ -32,6 +37,14 @@ class YamllintTableDescriptor(TableDescriptor):
         self,
         issues: list[YamllintIssue],
     ) -> list[list[Any]]:
+        """Return rows for the Yamllint issues table.
+
+        Args:
+            issues: Parsed Yamllint issues to render.
+
+        Returns:
+            list[list[Any]]: Table rows with normalized file path and fields.
+        """
         rows: list[list[Any]] = []
         for issue in issues:
             rows.append(
@@ -61,7 +74,7 @@ def format_yamllint_issues(
         tool_name: Tool name for JSON metadata.
 
     Returns:
-        Rendered string for the issues table.
+        str: Rendered string for the issues table.
     """
     descriptor = YamllintTableDescriptor()
     columns = descriptor.get_columns()

lintro/models/__init__.py

@@ -0,0 +1 @@
+"""Model package containing issue types and configuration structures."""

lintro/models/core/__init__.py

@@ -0,0 +1 @@
+"""Core data models used across tool integrations."""

lintro/models/core/tool_config.py

@@ -1,3 +1,5 @@
+"""Core model for tool configuration used by Lintro tools."""
+
 from dataclasses import dataclass, field
 
 from lintro.enums.tool_type import ToolType
@@ -5,15 +7,17 @@ from lintro.enums.tool_type import ToolType
 
 @dataclass
 class ToolConfig:
-    """Configuration for a core.
+    """Configuration container for a tool.
+
+    This dataclass defines the static configuration associated with a tool,
+    including its priority, file targeting, type flags, and default options.
 
     Attributes:
-        priority: int:
-            Priority level (higher number = higher priority when resolving conflicts)
-        conflicts_with: list[str]: List of tools this core conflicts with
-        file_patterns: list[str]: List of file patterns this core should be applied to
-        tool_type: ToolType: Type of core
-        options: dict[str, object]: Tool-specific configuration options
+        priority: int: Priority used when ordering tools.
+        conflicts_with: list[str]: Names of tools that conflict with this one.
+        file_patterns: list[str]: Glob patterns to select applicable files.
+        tool_type: ToolType: Bitmask describing tool capabilities.
+        options: dict[str, object]: Default tool options applied at runtime.
     """
 
     priority: int = 0