lintro 0.3.2__py3-none-any.whl

lintro/enums/hadolint_enums.py

@@ -0,0 +1,46 @@
+"""Hadolint enums for formats and failure thresholds."""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class HadolintFormat(StrEnum):
+    TTY = auto()
+    JSON = auto()
+    CHECKSTYLE = auto()
+    CODECLIMATE = auto()
+    GITLAB_CODECLIMATE = auto()
+    GNU = auto()
+    CODACY = auto()
+    SONARQUBE = auto()
+    SARIF = auto()
+
+
+class HadolintFailureThreshold(StrEnum):
+    ERROR = auto()
+    WARNING = auto()
+    INFO = auto()
+    STYLE = auto()
+    IGNORE = auto()
+    NONE = auto()
+
+
+def normalize_hadolint_format(value: str | HadolintFormat) -> HadolintFormat:
+    if isinstance(value, HadolintFormat):
+        return value
+    try:
+        return HadolintFormat[value.upper()]
+    except Exception:
+        return HadolintFormat.TTY
+
+
+def normalize_hadolint_threshold(
+    value: str | HadolintFailureThreshold,
+) -> HadolintFailureThreshold:
+    if isinstance(value, HadolintFailureThreshold):
+        return value
+    try:
+        return HadolintFailureThreshold[value.upper()]
+    except Exception:
+        return HadolintFailureThreshold.INFO

lintro/enums/output_format.py

@@ -0,0 +1,40 @@
+"""Output format enum definitions.
+
+This module defines the supported output formats for displaying results.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class OutputFormat(StrEnum):
+    """Supported output formats for rendering results.
+
+    Values are lower-case string identifiers to align with CLI choices.
+    """
+
+    PLAIN = auto()
+    GRID = auto()
+    MARKDOWN = auto()
+    HTML = auto()
+    JSON = auto()
+    CSV = auto()
+
+
+def normalize_output_format(value: str | OutputFormat) -> OutputFormat:
+    """Normalize a raw value to an OutputFormat enum.
+
+    Args:
+        value: str or OutputFormat to normalize.
+
+    Returns:
+        OutputFormat: Normalized enum value.
+    """
+    if isinstance(value, OutputFormat):
+        return value
+    try:
+        return OutputFormat[value.upper()]
+    except Exception:
+        # Fallback to GRID if invalid; callers may override upstream.
+        return OutputFormat.GRID

lintro/enums/tool_name.py

@@ -0,0 +1,36 @@
+"""Canonical tool name definitions.
+
+Provides a stable set of identifiers for tools used across the codebase.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class ToolName(StrEnum):
+    """Supported tool identifiers in lower-case values."""
+
+    DARGLINT = auto()
+    HADOLINT = auto()
+    PRETTIER = auto()
+    RUFF = auto()
+    YAMLLINT = auto()
+
+
+def normalize_tool_name(value: str | ToolName) -> ToolName:
+    """Normalize a raw name to ToolName.
+
+    Args:
+        value: Tool name as str or ToolName.
+
+    Returns:
+        ToolName: Normalized enum member.
+    """
+    if isinstance(value, ToolName):
+        return value
+    try:
+        return ToolName[value.upper()]
+    except Exception:
+        # Conservative default if unknown
+        return ToolName.RUFF

lintro/enums/tool_type.py

@@ -0,0 +1,27 @@
+"""Tool type definitions."""
+
+from enum import Flag, auto
+
+
+class ToolType(Flag):
+    """Tool type definitions.
+
+    This enum defines the different types of tools that can be used in Lintro.
+    Tools can be of multiple types (e.g., a core can be both a linter and a formatter),
+    which is why this is a Flag enum rather than a regular Enum.
+
+    Attributes:
+        LINTER = Tool that checks code for issues
+        FORMATTER = Tool that formats code
+        TYPE_CHECKER = Tool that checks types
+        DOCUMENTATION = Tool that checks documentation
+        SECURITY = Tool that checks for security issues
+        INFRASTRUCTURE = Tool that checks infrastructure code
+    """
+
+    LINTER = auto()
+    FORMATTER = auto()
+    TYPE_CHECKER = auto()
+    DOCUMENTATION = auto()
+    SECURITY = auto()
+    INFRASTRUCTURE = auto()

lintro/enums/yamllint_format.py

@@ -0,0 +1,22 @@
+"""Yamllint format enum."""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class YamllintFormat(StrEnum):
+    PARSABLE = auto()
+    STANDARD = auto()
+    COLORED = auto()
+    GITHUB = auto()
+    AUTO = auto()
+
+
+def normalize_yamllint_format(value: str | YamllintFormat) -> YamllintFormat:
+    if isinstance(value, YamllintFormat):
+        return value
+    try:
+        return YamllintFormat[value.upper()]
+    except Exception:
+        return YamllintFormat.PARSABLE

lintro/exceptions/errors.py

@@ -0,0 +1,15 @@
+"""Custom exception types for Lintro."""
+
+from __future__ import annotations
+
+
+class LintroError(Exception):
+    """Base exception for all Lintro-related errors."""
+
+
+class InvalidToolConfigError(LintroError):
+    """Raised when a tool's configuration is invalid."""
+
+
+class InvalidToolOptionError(LintroError):
+    """Raised when invalid options are provided to a tool."""

lintro/formatters/core/output_style.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class OutputStyle(ABC):
+    @abstractmethod
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows.
+
+        Args:
+            columns: List of column header names.
+            rows: List of rows, where each row is a list of values.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        pass

lintro/formatters/core/table_descriptor.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class TableDescriptor(ABC):
+    @abstractmethod
+    def get_columns(self) -> list[str]:
+        """Return the list of column names in order."""
+        pass
+
+    @abstractmethod
+    def get_rows(
+        self,
+        issues: list[Any],
+    ) -> list[list[Any]]:
+        """Return the values for each column for a list of issues.
+
+        Args:
+            issues: List of issue objects to extract data from.
+
+        Returns:
+            list[list]: Nested list representing table rows and columns.
+        """
+        pass

lintro/formatters/styles/__init__.py

@@ -0,0 +1,17 @@
+"""Output format styles for lintro."""
+
+from .csv import CsvStyle
+from .grid import GridStyle
+from .html import HtmlStyle
+from .json import JsonStyle
+from .markdown import MarkdownStyle
+from .plain import PlainStyle
+
+__all__ = [
+    "PlainStyle",
+    "GridStyle",
+    "MarkdownStyle",
+    "HtmlStyle",
+    "JsonStyle",
+    "CsvStyle",
+]

lintro/formatters/styles/csv.py

@@ -0,0 +1,41 @@
+import csv
+import io
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+
+class CsvStyle(OutputStyle):
+    """Output format that renders data as CSV."""
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows as CSV.
+
+        Args:
+            columns: List of column header names.
+            rows: List of row values (each row is a list of cell values).
+
+        Returns:
+            Formatted data as CSV string.
+        """
+        if not rows:
+            return ""
+
+        # Create a string buffer to write CSV data
+        output = io.StringIO()
+        writer = csv.writer(output)
+
+        # Write header
+        writer.writerow(columns)
+
+        # Write rows
+        for row in rows:
+            # Ensure row has same number of elements as columns
+            padded_row = row + [""] * (len(columns) - len(row))
+            writer.writerow(padded_row)
+
+        return output.getvalue()

lintro/formatters/styles/grid.py

@@ -0,0 +1,91 @@
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+# Try to import tabulate
+try:
+    from tabulate import tabulate
+
+    TABULATE_AVAILABLE = True
+except ImportError:
+    TABULATE_AVAILABLE = False
+
+
+class GridStyle(OutputStyle):
+    """Output format that renders data as a formatted grid table.
+
+    This style creates a nicely formatted table with proper column alignment
+    and borders, similar to what you might see in a terminal or console.
+    """
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows as a grid.
+
+        Args:
+            columns: List of column header names.
+            rows: List of row values (each row is a list of cell values).
+
+        Returns:
+            Formatted data as grid table string.
+        """
+        if not rows:
+            return ""
+
+        # Use tabulate if available
+        if TABULATE_AVAILABLE:
+            # Provide sane defaults for alignment and column widths to avoid
+            # terminal wrapping that misaligns the grid. We keep most columns
+            # left-aligned, numeric columns right-aligned, and cap wide
+            # columns like File/Message.
+            colalign_map = {
+                "Line": "right",
+                "Column": "right",
+                "Fixable": "center",
+            }
+            colalign = [colalign_map.get(col, "left") for col in columns]
+
+            # Cap very wide columns so tabulate wraps within cells, preserving
+            # alignment instead of letting the terminal wrap mid-grid.
+            width_map: dict[str, int] = {
+                "File": 48,
+                "Message": 64,
+                "Code": 12,
+                "Line": 8,
+                "Column": 8,
+                "Fixable": 8,
+            }
+            maxcolwidths = [width_map.get(col) for col in columns]
+
+            return tabulate(
+                tabular_data=rows,
+                headers=columns,
+                tablefmt="grid",
+                stralign="left",
+                numalign="right",
+                colalign=colalign,
+                maxcolwidths=maxcolwidths,
+                disable_numparse=True,
+            )
+
+        # Fallback to simple format when tabulate is not available
+        if not columns:
+            return ""
+
+        # Build the header
+        header = " | ".join(columns)
+        separator = "-" * len(header)
+
+        # Build the rows
+        formatted_rows = []
+        for row in rows:
+            # Ensure row has same number of elements as columns
+            padded_row = row + [""] * (len(columns) - len(row))
+            formatted_rows.append(" | ".join(str(cell) for cell in padded_row))
+
+        # Combine all parts
+        result = [header, separator] + formatted_rows
+        return "\n".join(result)

lintro/formatters/styles/html.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+
+class HtmlStyle(OutputStyle):
+    """Output format that renders data as HTML table."""
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows as HTML.
+
+        Args:
+            columns: List of column header names.
+            rows: List of row values (each row is a list of cell values).
+
+        Returns:
+            Formatted data as HTML table string.
+        """
+        if not rows:
+            return "<p>No issues found.</p>"
+
+        # Build the header
+        header_cells = "".join(f"<th>{col}</th>" for col in columns)
+        header = f"<tr>{header_cells}</tr>"
+
+        # Build the rows
+        formatted_rows = []
+        for row in rows:
+            # Ensure row has same number of elements as columns
+            padded_row = row + [""] * (len(columns) - len(row))
+            # Escape HTML characters in cell values
+            escaped_cells = [
+                str(cell)
+                .replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                for cell in padded_row
+            ]
+            row_cells = "".join(f"<td>{cell}</td>" for cell in escaped_cells)
+            formatted_rows.append(f"<tr>{row_cells}</tr>")
+
+        # Combine all parts
+        table_content = header + "".join(formatted_rows)
+        return f"<table>{table_content}</table>"

lintro/formatters/styles/json.py

@@ -0,0 +1,61 @@
+import json
+from datetime import datetime
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+
+class JsonStyle(OutputStyle):
+    """Output format that renders data as structured JSON."""
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+        tool_name: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> str:
+        """Format a table given columns and rows as structured JSON.
+
+        Args:
+            columns: List of column names.
+            rows: List of row values (each row is a list of cell values).
+            tool_name: Name of the tool that generated the data.
+            metadata: Tool-specific metadata.
+            **kwargs: Additional metadata.
+
+        Returns:
+            Formatted data as structured JSON string.
+        """
+        # Convert column names to standardized format
+        normalized_columns = [col.lower().replace(" ", "_") for col in columns]
+
+        # Convert rows to list of dictionaries with proper data types
+        issues = []
+        for row in rows:
+            issue_dict = {}
+            for i, value in enumerate(row):
+                if i < len(normalized_columns):
+                    issue_dict[normalized_columns[i]] = value
+            issues.append(issue_dict)
+
+        # Create the final JSON structure
+        result = {
+            "tool": tool_name,
+            "timestamp": datetime.now().isoformat(),
+            "total_issues": len(issues),
+            "issues": issues,
+        }
+
+        # Add metadata if provided
+        if metadata:
+            result["metadata"] = metadata
+
+        # Add any additional kwargs as metadata
+        if kwargs:
+            if "metadata" not in result:
+                result["metadata"] = {}
+            result["metadata"].update(kwargs)
+
+        return json.dumps(result, indent=2, ensure_ascii=False)

lintro/formatters/styles/markdown.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+
+class MarkdownStyle(OutputStyle):
+    """Output format that renders data as markdown table."""
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows as markdown.
+
+        Args:
+            columns: List of column header names.
+            rows: List of row values (each row is a list of cell values).
+
+        Returns:
+            Formatted data as markdown table string.
+        """
+        if not rows:
+            return "No issues found."
+
+        # Build the header
+        header = "| " + " | ".join(columns) + " |"
+        separator = "| " + " | ".join("---" for _ in columns) + " |"
+
+        # Build the rows
+        formatted_rows = []
+        for row in rows:
+            # Ensure row has same number of elements as columns
+            padded_row = row + [""] * (len(columns) - len(row))
+            # Escape pipe characters in cell values
+            escaped_cells = [str(cell).replace("|", "\\|") for cell in padded_row]
+            formatted_rows.append("| " + " | ".join(escaped_cells) + " |")
+
+        # Combine all parts
+        result = [header, separator] + formatted_rows
+        return "\n".join(result)

lintro/formatters/styles/plain.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from lintro.formatters.core.output_style import OutputStyle
+
+
+class PlainStyle(OutputStyle):
+    """Output format that renders data as plain text."""
+
+    def format(
+        self,
+        columns: list[str],
+        rows: list[list[Any]],
+    ) -> str:
+        """Format a table given columns and rows as plain text.
+
+        Args:
+            columns: List of column header names.
+            rows: List of row values (each row is a list of cell values).
+
+        Returns:
+            Formatted data as plain text string.
+        """
+        if not rows:
+            return "No issues found."
+
+        # Build the header
+        header = " | ".join(columns)
+        separator = "-" * len(header)
+
+        # Build the rows
+        formatted_rows = []
+        for row in rows:
+            # Ensure row has same number of elements as columns
+            padded_row = row + [""] * (len(columns) - len(row))
+            formatted_rows.append(" | ".join(str(cell) for cell in padded_row))
+
+        # Combine all parts
+        result = [header, separator] + formatted_rows
+        return "\n".join(result)

lintro/formatters/tools/__init__.py

@@ -0,0 +1,35 @@
+"""Tool-specific table formatters package exports."""
+
+from lintro.formatters.tools.darglint_formatter import (
+    DarglintTableDescriptor,
+    format_darglint_issues,
+)
+from lintro.formatters.tools.hadolint_formatter import (
+    HadolintTableDescriptor,
+    format_hadolint_issues,
+)
+from lintro.formatters.tools.prettier_formatter import (
+    PrettierTableDescriptor,
+    format_prettier_issues,
+)
+from lintro.formatters.tools.ruff_formatter import (
+    RuffTableDescriptor,
+    format_ruff_issues,
+)
+from lintro.formatters.tools.yamllint_formatter import (
+    YamllintTableDescriptor,
+    format_yamllint_issues,
+)
+
+__all__ = [
+    "DarglintTableDescriptor",
+    "format_darglint_issues",
+    "HadolintTableDescriptor",
+    "format_hadolint_issues",
+    "PrettierTableDescriptor",
+    "format_prettier_issues",
+    "RuffTableDescriptor",
+    "format_ruff_issues",
+    "YamllintTableDescriptor",
+    "format_yamllint_issues",
+]