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

lintro/parsers/__init__.py

@@ -1,21 +1,81 @@
 """Parser modules for Lintro tools."""
 
-from lintro.parsers 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/actionlint/actionlint_parser.py

@@ -8,7 +8,7 @@ uniform tables and reports across styles.
 from __future__ import annotations
 
 import re
-from typing import Iterable
+from collections.abc import Iterable
 
 from lintro.parsers.actionlint.actionlint_issue import ActionlintIssue
 

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/darglint/__init__.py

@@ -0,0 +1 @@
+"""Parsing utilities and types for Darglint output."""

lintro/parsers/darglint/darglint_issue.py

@@ -1,8 +1,19 @@
+"""Typed structure representing a single Darglint issue."""
+
 from dataclasses import dataclass
 
 
 @dataclass
 class DarglintIssue:
+    """Simple container for Darglint findings.
+
+    Attributes:
+        file: File path where the issue occurred.
+        line: Line number of the issue.
+        code: Darglint error code.
+        message: Human-readable description of the issue.
+    """
+
     file: str
     line: int
     code: str

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

lintro/parsers/markdownlint/markdownlint_parser.py

@@ -0,0 +1,113 @@
+"""Parser for markdownlint-cli2 output."""
+
+import re
+
+from lintro.parsers.markdownlint.markdownlint_issue import MarkdownlintIssue
+
+
+def parse_markdownlint_output(output: str) -> list[MarkdownlintIssue]:
+    """Parse markdownlint-cli2 output into a list of MarkdownlintIssue objects.
+
+    Markdownlint-cli2 default formatter outputs lines like:
+    file:line:column MD###/rule-name Message [Context: "..."]
+    or
+    file:line MD###/rule-name Message [Context: "..."]
+
+    Example outputs:
+    dir/about.md:1:1 MD021/no-multiple-space-closed-atx Multiple spaces
+        inside hashes on closed atx style heading [Context: "#  About  #"]
+    dir/about.md:4 MD032/blanks-around-lists Lists should be surrounded
+        by blank lines [Context: "1. List"]
+    viewme.md:3:10 MD009/no-trailing-spaces Trailing spaces
+        [Expected: 0 or 2; Actual: 1]
+
+    Args:
+        output: The raw output from markdownlint-cli2
+
+    Returns:
+        List of MarkdownlintIssue objects
+    """
+    issues: list[MarkdownlintIssue] = []
+
+    # Skip empty output
+    if not output.strip():
+        return issues
+
+    lines: list[str] = output.splitlines()
+
+    # Pattern for markdownlint-cli2 default formatter:
+    # file:line[:column] [error] MD###/rule-name Message [Context: "..."]
+    # Column is optional, "error" keyword is optional, and Context is optional
+    # Also handles variations like: file:line MD### Message
+    # [Expected: ...; Actual: ...]
+    pattern: re.Pattern[str] = re.compile(
+        r"^([^:]+):(\d+)(?::(\d+))?\s+(?:error\s+)?(MD\d+)(?:/[^:\s]+)?(?::\s*)?"
+        r"(.+?)(?:\s+\[(?:Context|Expected|Actual):.*?\])?$",
+    )
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        # Skip empty lines
+        if not line.strip():
+            i += 1
+            continue
+
+        # Skip metadata lines (version, Finding, Linting, Summary)
+        stripped_line = line.strip()
+        if (
+            stripped_line.startswith("markdownlint-cli2")
+            or stripped_line.startswith("Finding:")
+            or stripped_line.startswith("Linting:")
+            or stripped_line.startswith("Summary:")
+        ):
+            i += 1
+            continue
+
+        # Try to match the pattern on the current line
+        match: re.Match[str] | None = pattern.match(stripped_line)
+        if match:
+            filename: str
+            line_num: str
+            column: str | None
+            code: str
+            message: str
+            filename, line_num, column, code, message = match.groups()
+
+            # Collect continuation lines (lines that start with whitespace)
+            # These are part of the multi-line message
+            i += 1
+            continuation_lines: list[str] = []
+            while i < len(lines):
+                next_line = lines[i]
+                # Continuation lines start with whitespace (indentation)
+                # Empty lines break the continuation
+                if not next_line.strip():
+                    break
+                if next_line[0].isspace():
+                    continuation_lines.append(next_line.strip())
+                    i += 1
+                else:
+                    # Next line doesn't start with whitespace, stop collecting
+                    break
+
+            # Combine main message with continuation lines
+            full_message = message.strip()
+            if continuation_lines:
+                full_message = " ".join([full_message] + continuation_lines)
+
+            issues.append(
+                MarkdownlintIssue(
+                    file=filename,
+                    line=int(line_num),
+                    column=int(column) if column else None,
+                    code=code,
+                    message=full_message,
+                ),
+            )
+        else:
+            # Line doesn't match pattern, skip it
+            i += 1
+
+    return issues

lintro/parsers/prettier/__init__.py

@@ -0,0 +1 @@
+"""Parsing utilities and types for Prettier output."""

lintro/parsers/prettier/prettier_issue.py

@@ -1,8 +1,20 @@
+"""Typed structure representing a single Prettier issue."""
+
 from dataclasses import dataclass
 
 
 @dataclass
 class PrettierIssue:
+    """Simple container for Prettier findings.
+
+    Attributes:
+        file: File path where the issue occurred.
+        line: Line number, if provided by Prettier.
+        code: Tool-specific code identifying the rule.
+        message: Human-readable description of the issue.
+        column: Column number, if provided by Prettier.
+    """
+
     file: str
     line: int | None
     code: str

lintro/parsers/prettier/prettier_parser.py

@@ -36,7 +36,7 @@ def parse_prettier_output(output: str) -> list[PrettierIssue]:
 
     lines = normalized_output.splitlines()
 
-    for i, line in enumerate(lines):
+    for _i, line in enumerate(lines):
         line = line.strip()
         if not line:
             continue

lintro/parsers/pytest/__init__.py

@@ -0,0 +1,21 @@
+"""Pytest parser module."""
+
+from lintro.parsers.pytest.pytest_issue import PytestIssue
+from lintro.parsers.pytest.pytest_parser import (
+    PytestSummary,
+    extract_pytest_summary,
+    parse_pytest_json_output,
+    parse_pytest_junit_xml,
+    parse_pytest_output,
+    parse_pytest_text_output,
+)
+
+__all__ = [
+    "PytestIssue",
+    "PytestSummary",
+    "extract_pytest_summary",
+    "parse_pytest_json_output",
+    "parse_pytest_junit_xml",
+    "parse_pytest_output",
+    "parse_pytest_text_output",
+]

lintro/parsers/pytest/pytest_issue.py

@@ -0,0 +1,28 @@
+"""Models for pytest issues."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PytestIssue:
+    """Represents a pytest test result (failure, error, or skip).
+
+    Attributes:
+        file: File path where the test issue occurred.
+        line: Line number where the issue occurred.
+        test_name: Name of the test.
+        message: Error message, failure description, or skip reason.
+        test_status: Status of the test (FAILED, ERROR, SKIPPED, etc.).
+        duration: Duration of the test in seconds.
+        node_id: Full node ID of the test.
+    """
+
+    file: str
+    line: int
+    test_name: str
+    message: str
+    test_status: str
+    duration: float | None = None
+    node_id: str | None = None