lintro 0.3.2__py3-none-any.whl

lintro/formatters/tools/darglint_formatter.py

@@ -0,0 +1,72 @@
+"""Formatter for darglint 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.darglint.darglint_issue import DarglintIssue
+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 DarglintTableDescriptor(TableDescriptor):
+    def get_columns(self) -> list[str]:
+        return ["File", "Line", "Code", "Message"]
+
+    def get_rows(
+        self,
+        issues: list[DarglintIssue],
+    ) -> list[list[str]]:
+        rows = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    str(issue.line),
+                    issue.code,
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_darglint_issues(
+    issues: list[DarglintIssue],
+    format: str = "grid",
+) -> str:
+    """Format a list of Darglint issues using the specified format.
+
+    Args:
+        issues: List of Darglint issues to format.
+        format: Output format (plain, grid, markdown, html, json, csv).
+
+    Returns:
+        Formatted string representation of the issues.
+    """
+    descriptor = DarglintTableDescriptor()
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+
+    formatter = FORMAT_MAP.get(format, GridStyle())
+
+    # For JSON format, pass tool name
+    if format == "json":
+        formatted_table = formatter.format(
+            columns=columns, rows=rows, tool_name="darglint"
+        )
+    else:
+        # For other formats, use standard formatting
+        formatted_table = formatter.format(columns=columns, rows=rows)
+
+    return formatted_table

lintro/formatters/tools/hadolint_formatter.py

@@ -0,0 +1,84 @@
+"""Hadolint table formatting utilities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+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.hadolint.hadolint_issue import HadolintIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+
+class HadolintTableDescriptor(TableDescriptor):
+    """Describe hadolint issue columns and row extraction."""
+
+    def get_columns(self) -> list[str]:
+        return [
+            "File",
+            "Line",
+            "Column",
+            "Level",
+            "Code",
+            "Message",
+        ]
+
+    def get_rows(
+        self,
+        issues: list[HadolintIssue],
+    ) -> list[list[Any]]:
+        rows: list[list[Any]] = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    issue.line,
+                    issue.column if getattr(issue, "column", None) is not None else "",
+                    issue.level,
+                    issue.code,
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_hadolint_issues(
+    issues: list[HadolintIssue],
+    format: str = "grid",
+) -> str:
+    """Format hadolint issues to the given style.
+
+    Args:
+        issues: List of HadolintIssue instances.
+        format: Output style identifier.
+
+    Returns:
+        Rendered string for the issues table.
+    """
+    descriptor = HadolintTableDescriptor()
+    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="hadolint")
+    if style == "csv":
+        return CsvStyle().format(columns=columns, rows=rows)
+
+    return GridStyle().format(columns=columns, rows=rows)

lintro/formatters/tools/prettier_formatter.py

@@ -0,0 +1,76 @@
+"""Formatter for Prettier 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.prettier.prettier_issue import PrettierIssue
+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 PrettierTableDescriptor(TableDescriptor):
+    def get_columns(self) -> list[str]:
+        return ["File", "Line", "Column", "Code", "Message"]
+
+    def get_rows(
+        self,
+        issues: list[PrettierIssue],
+    ) -> list[list[str]]:
+        rows = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    str(issue.line) if issue.line is not None else "-",
+                    str(issue.column) if issue.column is not None else "-",
+                    issue.code,
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_prettier_issues(
+    issues: list[PrettierIssue],
+    format: str = "grid",
+) -> str:
+    """Format Prettier issues with auto-fixable labeling.
+
+    Args:
+        issues: List of PrettierIssue objects.
+        format: Output format identifier (e.g., "grid", "json").
+
+    Returns:
+        str: Formatted output string.
+
+    Notes:
+        All Prettier issues are auto-fixable by running `lintro format`.
+        For non-JSON formats, a single section is labeled as auto-fixable.
+        JSON returns the combined table for compatibility.
+    """
+    descriptor = PrettierTableDescriptor()
+    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="prettier")
+
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+    table = formatter.format(columns=columns, rows=rows)
+    if not rows:
+        return table
+    return "Auto-fixable issues\n" + table

lintro/formatters/tools/ruff_formatter.py

@@ -0,0 +1,116 @@
+"""Formatter for ruff 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.ruff.ruff_issue import RuffFormatIssue, RuffIssue
+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 RuffTableDescriptor(TableDescriptor):
+    def get_columns(self) -> list[str]:
+        return ["File", "Line", "Column", "Code", "Message"]
+
+    def get_rows(
+        self,
+        issues: list[RuffIssue | RuffFormatIssue],
+    ) -> list[list[str]]:
+        rows = []
+        for issue in issues:
+            if isinstance(issue, RuffIssue):
+                # Linting issue
+                rows.append(
+                    [
+                        normalize_file_path_for_display(issue.file),
+                        str(issue.line),
+                        str(issue.column),
+                        issue.code,
+                        issue.message,
+                    ],
+                )
+            elif isinstance(issue, RuffFormatIssue):
+                # From Lintro's perspective, fmt applies both lint fixes and
+                # formatting, so formatting entries are auto-fixable by fmt.
+                rows.append(
+                    [
+                        normalize_file_path_for_display(issue.file),
+                        "-",
+                        "-",
+                        "FORMAT",
+                        "Would reformat file",
+                    ],
+                )
+        return rows
+
+
+def format_ruff_issues(
+    issues: list[RuffIssue | RuffFormatIssue],
+    format: str = "grid",
+) -> str:
+    """Format Ruff issues, split into auto-fixable and not auto-fixable tables.
+
+    For JSON format, return a single combined table (backwards compatible).
+
+    Args:
+        issues: List of Ruff issues to format.
+        format: Output format (plain, grid, markdown, html, json, csv).
+
+    Returns:
+        Formatted string (one or two tables depending on format).
+    """
+    descriptor = RuffTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+
+    # Partition issues
+    fixable_issues: list[RuffIssue | RuffFormatIssue] = []
+    non_fixable_issues: list[RuffIssue] = []
+
+    for issue in issues:
+        if isinstance(issue, RuffFormatIssue):
+            fixable_issues.append(issue)
+        elif isinstance(issue, RuffIssue) and issue.fixable:
+            fixable_issues.append(issue)
+        elif isinstance(issue, RuffIssue):
+            non_fixable_issues.append(issue)
+
+    # JSON: keep a single table for compatibility
+    if format == "json":
+        columns = descriptor.get_columns()
+        rows = descriptor.get_rows(issues)
+        return formatter.format(columns=columns, rows=rows, tool_name="ruff")
+
+    sections: list[str] = []
+
+    # Auto-fixable section
+    if fixable_issues:
+        columns_f = descriptor.get_columns()
+        rows_f = descriptor.get_rows(fixable_issues)
+        table_f = formatter.format(columns=columns_f, rows=rows_f)
+        sections.append("Auto-fixable issues\n" + table_f)
+
+    # Not auto-fixable section
+    if non_fixable_issues:
+        columns_u = descriptor.get_columns()
+        rows_u = descriptor.get_rows(non_fixable_issues)
+        table_u = formatter.format(columns=columns_u, rows=rows_u)
+        sections.append("Not auto-fixable issues\n" + table_u)
+
+    # If neither, return empty table structure
+    if not sections:
+        columns = descriptor.get_columns()
+        return formatter.format(columns=columns, rows=[])
+
+    return "\n\n".join(sections)

lintro/formatters/tools/yamllint_formatter.py

@@ -0,0 +1,87 @@
+"""Yamllint table formatting utilities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+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.yamllint.yamllint_issue import YamllintIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+
+class YamllintTableDescriptor(TableDescriptor):
+    """Describe yamllint issue columns and row extraction."""
+
+    def get_columns(self) -> list[str]:
+        return [
+            "File",
+            "Line",
+            "Column",
+            "Level",
+            "Rule",
+            "Message",
+        ]
+
+    def get_rows(
+        self,
+        issues: list[YamllintIssue],
+    ) -> list[list[Any]]:
+        rows: list[list[Any]] = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    issue.line,
+                    issue.column if getattr(issue, "column", None) is not None else "",
+                    issue.level,
+                    issue.rule or "",
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_yamllint_issues(
+    issues: list[YamllintIssue],
+    format: str = "grid",
+    *,
+    tool_name: str = "yamllint",
+) -> str:
+    """Format yamllint issues to the given style.
+
+    Args:
+        issues: List of YamllintIssue instances.
+        format: Output style identifier.
+        tool_name: Tool name for JSON metadata.
+
+    Returns:
+        Rendered string for the issues table.
+    """
+    descriptor = YamllintTableDescriptor()
+    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/models/core/tool.py

@@ -0,0 +1,104 @@
+"""Tool-related models for Lintro."""
+
+from abc import abstractmethod
+from typing import Protocol, runtime_checkable
+
+from lintro.models.core.tool_config import ToolConfig
+from lintro.models.core.tool_result import ToolResult
+
+
+@runtime_checkable
+class Tool(Protocol):
+    """Protocol for all linting and formatting tools.
+
+    This protocol defines the interface that all tools must implement.
+    Tools can be implemented as classes that inherit from this protocol.
+
+    Attributes:
+        name: Tool name
+        description: Tool description
+        can_fix: Whether the core can fix issues
+        config: Tool configuration
+    """
+
+    name: str
+    description: str
+    can_fix: bool
+    config: ToolConfig
+
+    def set_options(
+        self,
+        **kwargs,
+    ) -> None:
+        """Set core options.
+
+        Args:
+            **kwargs: Tool-specific options
+        """
+        ...
+
+    @abstractmethod
+    def check(
+        self,
+        paths: list[str],
+    ) -> ToolResult:
+        """Check files for issues.
+
+        Args:
+            paths: List of file paths to check.
+
+        Returns:
+            Result of the check operation.
+
+        Raises:
+            FileNotFoundError: If the core executable is not found
+            subprocess.TimeoutExpired: If the core execution times out
+            subprocess.CalledProcessError: If the core execution fails
+        """
+        ...
+
+    @abstractmethod
+    def fix(
+        self,
+        paths: list[str],
+    ) -> ToolResult:
+        """Fix issues in files.
+
+        Args:
+            paths: List of file paths to fix.
+
+        Returns:
+            Result of the fix operation.
+
+        Raises:
+            FileNotFoundError: If the core executable is not found
+            subprocess.TimeoutExpired: If the core execution times out
+            subprocess.CalledProcessError: If the core execution fails
+            NotImplementedError: If the core does not support fixing issues
+        """
+        ...
+
+    @staticmethod
+    def to_result(
+        name: str,
+        success: bool,
+        output: str,
+        issues_count: int,
+    ) -> ToolResult:
+        """Convert core operation result to a ToolResult.
+
+        Args:
+            name: Tool name
+            success: Whether the operation was successful
+            output: Output from the core
+            issues_count: Number of issues found or fixed
+
+        Returns:
+            Result object
+        """
+        return ToolResult(
+            name=name,
+            success=success,
+            output=output,
+            issues_count=issues_count,
+        )

lintro/models/core/tool_config.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+
+from lintro.enums.tool_type import ToolType
+
+
+@dataclass
+class ToolConfig:
+    """Configuration for a core.
+
+    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 = 0
+    conflicts_with: list[str] = field(default_factory=list)
+    file_patterns: list[str] = field(default_factory=list)
+    tool_type: ToolType = ToolType.LINTER
+    options: dict[str, object] = field(default_factory=dict)

lintro/models/core/tool_result.py

@@ -0,0 +1,39 @@
+"""Models for core tool execution results.
+
+This module defines the canonical result object returned by all tools. It
+supports both check and fix flows and includes standardized fields to report
+fixed vs remaining counts for fix-capable tools.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ToolResult:
+    """Result of running a tool.
+
+    For check operations:
+        - ``issues_count`` represents the number of issues found.
+
+    For fix/format operations:
+        - ``initial_issues_count`` is the number of issues detected before fixes
+        - ``fixed_issues_count`` is the number of issues the tool auto-fixed
+        - ``remaining_issues_count`` is the number of issues still remaining
+        - ``issues_count`` should mirror ``remaining_issues_count`` for
+          backward compatibility in format-mode summaries
+
+    The ``issues`` field can contain parsed issue objects (tool-specific) to
+    support unified table formatting.
+    """
+
+    name: str
+    success: bool
+    output: str | None = None
+    issues_count: int = 0
+    formatted_output: str | None = None
+    issues: list[object] | None = None
+
+    # Optional standardized counts for fix-capable tools
+    initial_issues_count: int | None = None
+    fixed_issues_count: int | None = None
+    remaining_issues_count: int | None = None

lintro/parsers/darglint/darglint_issue.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class DarglintIssue:
+    file: str
+    line: int
+    code: str
+    message: str

lintro/parsers/darglint/darglint_parser.py

@@ -0,0 +1,62 @@
+"""Parser for darglint output."""
+
+import re
+
+from lintro.parsers.darglint.darglint_issue import DarglintIssue
+
+
+def parse_darglint_output(output: str) -> list[DarglintIssue]:
+    """Parse darglint output into a list of DarglintIssue objects.
+
+    Args:
+        output: The raw output from darglint
+
+    Returns:
+        List of DarglintIssue objects
+    """
+    issues: list[DarglintIssue] = []
+    # Patterns:
+    # 1. filename:function:line: CODE message
+    # 2. filename:line: CODE message (for module-level errors)
+    # Accept both "CODE message" and "CODE: message" variants from darglint
+    pattern: re.Pattern[str] = re.compile(r"^(.*?):(.*?):(\d+): (D[A-Z]*\d+):? (.*)$")
+    alt_pattern: re.Pattern[str] = re.compile(r"^(.*?):(\d+): (D[A-Z]*\d+):? (.*)$")
+    lines: list[str] = output.splitlines()
+    i: int = 0
+    while i < len(lines):
+        line: str = lines[i]
+        match: re.Match[str] | None = pattern.match(line)
+        if match:
+            file: str
+            obj: str
+            line_num: str
+            code: str
+            message: str
+            file, obj, line_num, code, message = match.groups()
+        else:
+            match = alt_pattern.match(line)
+            if match:
+                file, line_num, code, message = match.groups()
+            else:
+                i += 1
+                continue
+        # Capture all subsequent indented or colon-prefixed lines as part of the message
+        message_lines: list[str] = [message]
+        j: int = i + 1
+        while j < len(lines) and (
+            lines[j].strip().startswith(":") or lines[j].startswith("    ")
+        ):
+            # Remove leading colon and whitespace
+            message_lines.append(lines[j].strip().lstrip(": "))
+            j += 1
+        full_message: str = " ".join(message_lines)
+        issues.append(
+            DarglintIssue(
+                file=file,
+                line=int(line_num),
+                code=code,
+                message=full_message,
+            )
+        )
+        i = j
+    return issues

lintro/parsers/hadolint/__init__.py

@@ -0,0 +1 @@
+"""Hadolint parser module."""