lintro 0.3.2__py3-none-any.whl

lintro/parsers/hadolint/hadolint_issue.py

@@ -0,0 +1,24 @@
+"""Hadolint issue model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class HadolintIssue:
+    """Represents an issue found by hadolint.
+
+    Attributes:
+        file: File path where the issue was found
+        line: Line number where the issue occurs
+        column: Column number where the issue occurs (if available)
+        level: Severity level (error, warning, info, style)
+        code: Rule code (e.g., DL3006, SC2086)
+        message: Description of the issue
+    """
+
+    file: str
+    line: int
+    column: int | None
+    level: str
+    code: str
+    message: str

lintro/parsers/hadolint/hadolint_parser.py

@@ -0,0 +1,65 @@
+"""Parser for hadolint output."""
+
+import re
+
+from lintro.parsers.hadolint.hadolint_issue import HadolintIssue
+
+
+def parse_hadolint_output(output: str) -> list[HadolintIssue]:
+    """Parse hadolint output into a list of HadolintIssue objects.
+
+    Hadolint outputs in the format:
+    filename:line code level: message
+
+    Example outputs:
+    Dockerfile:1 DL3006 error: Always tag the version of an image explicitly
+    Dockerfile:3 DL3009 warning: Delete the apt-get lists after installing
+        something
+    Dockerfile:5 DL3015 info: Avoid additional packages by specifying
+        `--no-install-recommends`
+
+    Args:
+        output: The raw output from hadolint
+
+    Returns:
+        List of HadolintIssue objects
+    """
+    issues: list[HadolintIssue] = []
+
+    # Skip empty output
+    if not output.strip():
+        return issues
+
+    # Pattern for hadolint output: filename:line code level: message
+    pattern: re.Pattern[str] = re.compile(
+        r"^(.+?):(\d+)\s+([A-Z]+\d+)\s+(error|warning|info|style):\s+(.+)$"
+    )
+
+    lines: list[str] = output.splitlines()
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        match: re.Match[str] | None = pattern.match(line)
+        if match:
+            file: str
+            line_num: str
+            code: str
+            level: str
+            message: str
+            file, line_num, code, level, message = match.groups()
+
+            issues.append(
+                HadolintIssue(
+                    file=file,
+                    line=int(line_num),
+                    column=None,  # hadolint doesn't provide column in this format
+                    level=level,
+                    code=code,
+                    message=message.strip(),
+                )
+            )
+
+    return issues

lintro/parsers/prettier/prettier_issue.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PrettierIssue:
+    file: str
+    line: int | None
+    code: str
+    message: str
+    column: int | None = None

lintro/parsers/prettier/prettier_parser.py

@@ -0,0 +1,60 @@
+"""Parser for prettier output.
+
+Handles typical Prettier CLI output for --check and --write modes,
+including ANSI-colored lines produced in CI environments.
+"""
+
+import re
+
+from lintro.parsers.prettier.prettier_issue import PrettierIssue
+
+
+def parse_prettier_output(output: str) -> list[PrettierIssue]:
+    """Parse prettier output into a list of PrettierIssue objects.
+
+    Args:
+        output: The raw output from prettier
+
+    Returns:
+        List of PrettierIssue objects
+    """
+    issues: list[PrettierIssue] = []
+
+    if not output:
+        return issues
+
+    # Prettier output format when issues are found:
+    # "Checking formatting..."
+    # "[warn] path/to/file.js"
+    # "[warn] Code style issues found in the above file. Run Prettier with --write \
+    # to fix."
+    # Normalize output by stripping ANSI escape sequences to make matching robust
+    # across different terminals and CI runners.
+    # Example: "[\x1b[33mwarn\x1b[39m] file.js" -> "[warn] file.js"
+    ansi_escape = re.compile(r"\x1b\[[0-9;]*m")
+    normalized_output = ansi_escape.sub("", output)
+
+    lines = normalized_output.splitlines()
+
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            continue
+
+        # Look for [warn] lines that contain file paths
+        if line.startswith("[warn]") and not line.endswith("fix."):
+            # Extract the file path from the [warn] line
+            file_path = line[6:].strip()  # Remove "[warn] " prefix
+            if file_path and not file_path.startswith("Code style issues"):
+                # Create a generic issue for the file
+                issues.append(
+                    PrettierIssue(
+                        file=file_path,
+                        line=1,  # Prettier doesn't provide specific line numbers
+                        code="FORMAT",
+                        message="Code style issues found",
+                        column=1,  # Prettier doesn't provide specific column numbers
+                    ),
+                )
+
+    return issues

lintro/parsers/ruff/__init__.py

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

lintro/parsers/ruff/ruff_issue.py

@@ -0,0 +1,43 @@
+"""Models for ruff issues."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RuffIssue:
+    """Represents a ruff linting issue.
+
+    Attributes:
+        file: File path where the issue was found.
+        line: Line number where the issue was found.
+        column: Column number where the issue was found.
+        code: Ruff error code (e.g., E401, F401).
+        message: Human-readable error message.
+        url: Optional URL to documentation for this error.
+        end_line: End line number for multi-line issues.
+        end_column: End column number for multi-line issues.
+        fixable: Whether this issue can be auto-fixed.
+        fix_applicability: Whether the fix is safe or unsafe (safe, unsafe, or None).
+    """
+
+    file: str
+    line: int
+    column: int
+    code: str
+    message: str
+    url: str | None = None
+    end_line: int | None = None
+    end_column: int | None = None
+    fixable: bool = False
+    fix_applicability: str | None = None
+
+
+@dataclass
+class RuffFormatIssue:
+    """Represents a ruff formatting issue.
+
+    Attributes:
+        file: File path that would be reformatted.
+    """
+
+    file: str

lintro/parsers/ruff/ruff_parser.py

@@ -0,0 +1,89 @@
+"""Parser for ruff output (lint and format).
+
+This module provides functions to parse both:
+- ruff check --output-format json (linting issues)
+- ruff format --check (plain text: files needing formatting)
+"""
+
+import json
+
+from lintro.parsers.ruff.ruff_issue import RuffIssue
+
+
+def parse_ruff_output(output: str) -> list[RuffIssue]:
+    """Parse ruff JSON output into a list of RuffIssue objects.
+
+    Args:
+        output: The raw JSON output from ruff
+
+    Returns:
+        List of RuffIssue objects
+    """
+    issues: list[RuffIssue] = []
+
+    if not output or output.strip() == "[]":
+        return issues
+
+    try:
+        # Ruff outputs JSON array of issue objects, but may have warnings
+        # after. Find the end of the JSON array by looking for the
+        # closing
+        # bracket
+        json_end = output.rfind("]")
+        if json_end == -1:
+            # No closing bracket found, try to parse the whole output
+            ruff_data = json.loads(output)
+        else:
+            # Extract just the JSON part (up to and including the closing bracket)
+            json_part = output[: json_end + 1]
+            ruff_data = json.loads(json_part)
+
+        for item in ruff_data:
+            # Extract fix applicability if available
+            fix_applicability = None
+            if item.get("fix"):
+                fix_applicability = item["fix"].get("applicability")
+
+            issues.append(
+                RuffIssue(
+                    file=item["filename"],
+                    line=item["location"]["row"],
+                    column=item["location"]["column"],
+                    code=item["code"],
+                    message=item["message"],
+                    url=item.get("url"),
+                    end_line=item["end_location"]["row"],
+                    end_column=item["end_location"]["column"],
+                    fixable=bool(item.get("fix")),
+                    fix_applicability=fix_applicability,
+                ),
+            )
+    except (json.JSONDecodeError, KeyError, TypeError):
+        # If JSON parsing fails, return empty list
+        # Could also log the error for debugging
+        pass
+
+    return issues
+
+
+def parse_ruff_format_check_output(output: str) -> list[str]:
+    """Parse the output of `ruff format --check` to get files needing formatting.
+
+    Args:
+        output: The raw output from `ruff format --check`
+
+    Returns:
+        List of file paths that would be reformatted
+    """
+    if not output:
+        return []
+    files = []
+    for line in output.splitlines():
+        line = line.strip()
+        # Ruff format --check output: 'Would reformat: path/to/file.py' or
+        # 'Would reformat path/to/file.py'
+        if line.startswith("Would reformat: "):
+            files.append(line[len("Would reformat: ") :])
+        elif line.startswith("Would reformat "):
+            files.append(line[len("Would reformat ") :])
+    return files

lintro/parsers/yamllint/yamllint_issue.py

@@ -0,0 +1,24 @@
+"""Yamllint issue model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class YamllintIssue:
+    """Represents an issue found by yamllint.
+
+    Attributes:
+        file: File path where the issue was found
+        line: Line number where the issue occurs
+        column: Column number where the issue occurs (if available)
+        level: Severity level (error, warning)
+        rule: Rule name that was violated (e.g., line-length, trailing-spaces)
+        message: Description of the issue
+    """
+
+    file: str
+    line: int
+    column: int | None
+    level: str
+    rule: str | None
+    message: str

lintro/parsers/yamllint/yamllint_parser.py

@@ -0,0 +1,68 @@
+"""Parser for yamllint output."""
+
+import re
+
+from lintro.parsers.yamllint.yamllint_issue import YamllintIssue
+
+
+def parse_yamllint_output(output: str) -> list[YamllintIssue]:
+    """Parse yamllint output into a list of YamllintIssue objects.
+
+    Yamllint outputs in parsable format as:
+    filename:line:column: [level] message (rule)
+
+    Example outputs:
+    test_samples/yaml_violations.yml:3:1: [warning] missing document start
+        "---" (document-start)
+    test_samples/yaml_violations.yml:6:32: [error] trailing spaces
+        (trailing-spaces)
+    test_samples/yaml_violations.yml:11:81: [error] line too long (149 > 80
+        characters) (line-length)
+
+    Args:
+        output: The raw output from yamllint
+
+    Returns:
+        List of YamllintIssue objects
+    """
+    issues: list[YamllintIssue] = []
+
+    # Skip empty output
+    if not output.strip():
+        return issues
+
+    lines: list[str] = output.splitlines()
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        # Pattern for yamllint parsable format: "filename:line:column: [level]
+        # message (rule)"
+        pattern: re.Pattern[str] = re.compile(
+            r"^([^:]+):(\d+):(\d+):\s*\[(error|warning)\]\s+(.+?)(?:\s+\(([^)]+)\))?$"
+        )
+
+        match: re.Match[str] | None = pattern.match(line)
+        if match:
+            filename: str
+            line_num: str
+            column: str
+            level: str
+            message: str
+            rule: str | None
+            filename, line_num, column, level, message, rule = match.groups()
+
+            issues.append(
+                YamllintIssue(
+                    file=filename,
+                    line=int(line_num),
+                    column=int(column) if column else None,
+                    level=level,
+                    rule=rule,
+                    message=message.strip(),
+                )
+            )
+
+    return issues

lintro/tools/__init__.py

@@ -0,0 +1,40 @@
+"""Tool implementations for Lintro."""
+
+from lintro.enums.tool_type import ToolType
+from lintro.models.core.tool import Tool
+from lintro.models.core.tool_config import ToolConfig
+from lintro.tools.core.tool_manager import ToolManager
+
+# Import core implementations after Tool class definition to avoid circular imports
+from lintro.tools.implementations.tool_darglint import DarglintTool
+from lintro.tools.implementations.tool_hadolint import HadolintTool
+from lintro.tools.implementations.tool_prettier import PrettierTool
+from lintro.tools.implementations.tool_ruff import RuffTool
+from lintro.tools.implementations.tool_yamllint import YamllintTool
+from lintro.tools.tool_enum import ToolEnum
+
+# Create global core manager instance
+tool_manager = ToolManager()
+
+# Register all available tools using ToolEnum
+AVAILABLE_TOOLS = {tool_enum: tool_enum.value for tool_enum in ToolEnum}
+
+
+for tool_enum, tool_class in AVAILABLE_TOOLS.items():
+    tool_manager.register_tool(tool_class)
+
+# Consolidated exports
+__all__ = [
+    "Tool",
+    "ToolConfig",
+    "ToolType",
+    "ToolManager",
+    "ToolEnum",
+    "tool_manager",
+    "AVAILABLE_TOOLS",
+    "DarglintTool",
+    "HadolintTool",
+    "PrettierTool",
+    "RuffTool",
+    "YamllintTool",
+]