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

lintro/config/tool_config_generator.py

@@ -0,0 +1,403 @@
+"""Tool configuration generator for Lintro.
+
+This module provides CLI argument injection for enforced settings and
+default config generation for tools without native configs.
+
+The tiered configuration model:
+1. EXECUTION: What tools run and how
+2. ENFORCE: Cross-cutting settings injected via CLI flags
+3. DEFAULTS: Fallback config when no native config exists
+4. TOOLS: Per-tool enable/disable and config source
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from lintro.config.lintro_config import LintroConfig
+
+try:
+    import yaml
+except ImportError:
+    yaml = None  # type: ignore[assignment]
+
+
+# CLI flags for enforced settings: setting -> {tool: flag}
+ENFORCE_CLI_FLAGS: dict[str, dict[str, str]] = {
+    "line_length": {
+        "ruff": "--line-length",
+        "black": "--line-length",
+        "prettier": "--print-width",
+    },
+    "target_python": {
+        "ruff": "--target-version",
+        "black": "--target-version",
+    },
+}
+
+# Tool config format for defaults generation
+TOOL_CONFIG_FORMATS: dict[str, str] = {
+    "prettier": "json",
+    "yamllint": "yaml",
+    "markdownlint": "json",
+    "hadolint": "yaml",
+    "bandit": "yaml",
+}
+
+# Native config file patterns for checking if tool has native config
+NATIVE_CONFIG_PATTERNS: dict[str, list[str]] = {
+    "prettier": [
+        ".prettierrc",
+        ".prettierrc.json",
+        ".prettierrc.yaml",
+        ".prettierrc.yml",
+        ".prettierrc.js",
+        ".prettierrc.cjs",
+        ".prettierrc.toml",
+        "prettier.config.js",
+        "prettier.config.cjs",
+    ],
+    "markdownlint": [
+        ".markdownlint-cli2.jsonc",
+        ".markdownlint-cli2.yaml",
+        ".markdownlint-cli2.cjs",
+        ".markdownlint.jsonc",
+        ".markdownlint.json",
+        ".markdownlint.yaml",
+        ".markdownlint.yml",
+        ".markdownlint.cjs",
+    ],
+    "yamllint": [
+        ".yamllint",
+        ".yamllint.yaml",
+        ".yamllint.yml",
+    ],
+    "hadolint": [
+        ".hadolint.yaml",
+        ".hadolint.yml",
+    ],
+    "bandit": [
+        ".bandit",
+        ".bandit.yaml",
+        ".bandit.yml",
+        "bandit.yaml",
+        "bandit.yml",
+    ],
+}
+
+# Track temporary files for cleanup
+_temp_files: list[Path] = []
+
+
+def _cleanup_temp_files() -> None:
+    """Clean up temporary config files on exit."""
+    for temp_file in _temp_files:
+        try:
+            if temp_file.exists():
+                temp_file.unlink()
+                logger.debug(f"Cleaned up temp config: {temp_file}")
+        except Exception as e:
+            logger.debug(f"Failed to clean up {temp_file}: {e}")
+
+
+# Register cleanup on exit
+atexit.register(_cleanup_temp_files)
+
+
+def get_enforce_cli_args(
+    tool_name: str,
+    lintro_config: LintroConfig,
+) -> list[str]:
+    """Get CLI arguments for enforced settings.
+
+    These settings override native tool configs to ensure consistency
+    across different tools for shared concerns like line length.
+
+    Args:
+        tool_name: Name of the tool (e.g., "ruff", "prettier").
+        lintro_config: Lintro configuration.
+
+    Returns:
+        list[str]: CLI arguments to inject (e.g., ["--line-length", "88"]).
+    """
+    args: list[str] = []
+    tool_lower = tool_name.lower()
+    enforce = lintro_config.enforce
+
+    # Inject line_length if set
+    if enforce.line_length is not None:
+        flag = ENFORCE_CLI_FLAGS.get("line_length", {}).get(tool_lower)
+        if flag:
+            args.extend([flag, str(enforce.line_length)])
+            logger.debug(
+                f"Injecting enforce.line_length={enforce.line_length} "
+                f"to {tool_name} as {flag}",
+            )
+
+    # Inject target_python if set
+    if enforce.target_python is not None:
+        flag = ENFORCE_CLI_FLAGS.get("target_python", {}).get(tool_lower)
+        if flag:
+            args.extend([flag, enforce.target_python])
+            logger.debug(
+                f"Injecting enforce.target_python={enforce.target_python} "
+                f"to {tool_name} as {flag}",
+            )
+
+    return args
+
+
+def has_native_config(tool_name: str) -> bool:
+    """Check if a tool has a native config file in the project.
+
+    Searches for known native config file patterns starting from the
+    current working directory and moving upward to find the project root.
+
+    Args:
+        tool_name: Name of the tool (e.g., "prettier", "markdownlint").
+
+    Returns:
+        bool: True if a native config file exists.
+    """
+    tool_lower = tool_name.lower()
+    patterns = NATIVE_CONFIG_PATTERNS.get(tool_lower, [])
+
+    if not patterns:
+        return False
+
+    # Search from current directory upward
+    current = Path.cwd().resolve()
+
+    while True:
+        for pattern in patterns:
+            config_path = current / pattern
+            if config_path.exists():
+                logger.debug(
+                    f"Found native config for {tool_name}: {config_path}",
+                )
+                return True
+
+        # Move up one directory
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root
+            break
+        current = parent
+
+    return False
+
+
+def generate_defaults_config(
+    tool_name: str,
+    lintro_config: LintroConfig,
+) -> Path | None:
+    """Generate a temporary config file from defaults.
+
+    Only used when a tool has no native config file and defaults
+    are specified in the Lintro config.
+
+    Args:
+        tool_name: Name of the tool.
+        lintro_config: Lintro configuration.
+
+    Returns:
+        Path | None: Path to generated config file, or None if not needed.
+    """
+    tool_lower = tool_name.lower()
+
+    # Check if tool has native config - if so, don't generate defaults
+    if has_native_config(tool_lower):
+        logger.debug(
+            f"Tool {tool_name} has native config, skipping defaults generation",
+        )
+        return None
+
+    # Get defaults for this tool
+    defaults = lintro_config.get_tool_defaults(tool_lower)
+    if not defaults:
+        return None
+
+    # Get config format for this tool
+    config_format = TOOL_CONFIG_FORMATS.get(tool_lower, "json")
+
+    try:
+        return _write_defaults_config(
+            defaults=defaults,
+            tool_name=tool_lower,
+            config_format=config_format,
+        )
+    except Exception as e:
+        logger.error(f"Failed to generate defaults config for {tool_name}: {e}")
+        return None
+
+
+def _write_defaults_config(
+    defaults: dict[str, Any],
+    tool_name: str,
+    config_format: str,
+) -> Path:
+    """Write defaults configuration to a temporary file.
+
+    Args:
+        defaults: Default configuration dictionary.
+        tool_name: Name of the tool.
+        config_format: Output format (json, yaml).
+
+    Returns:
+        Path: Path to temporary config file.
+
+    Raises:
+        ImportError: If PyYAML is not installed and YAML format is requested.
+    """
+    suffix_map = {"json": ".json", "yaml": ".yaml"}
+    suffix = suffix_map.get(config_format, ".json")
+
+    temp_fd, temp_path_str = tempfile.mkstemp(
+        prefix=f"lintro-{tool_name}-defaults-",
+        suffix=suffix,
+    )
+    os.close(temp_fd)
+    temp_path = Path(temp_path_str)
+    _temp_files.append(temp_path)
+
+    if config_format == "yaml":
+        if yaml is None:
+            raise ImportError("PyYAML required for YAML output")
+        content = yaml.dump(defaults, default_flow_style=False)
+    else:
+        content = json.dumps(defaults, indent=2)
+
+    temp_path.write_text(content, encoding="utf-8")
+    logger.debug(f"Generated defaults config for {tool_name}: {temp_path}")
+
+    return temp_path
+
+
+def get_defaults_injection_args(
+    tool_name: str,
+    config_path: Path | None,
+) -> list[str]:
+    """Get CLI arguments to inject defaults config file into a tool.
+
+    Args:
+        tool_name: Name of the tool.
+        config_path: Path to defaults config file (or None).
+
+    Returns:
+        list[str]: CLI arguments to pass to the tool.
+    """
+    if config_path is None:
+        return []
+
+    tool_lower = tool_name.lower()
+    config_str = str(config_path)
+
+    # Tool-specific config flags
+    config_flags: dict[str, list[str]] = {
+        "prettier": ["--config", config_str],
+        "yamllint": ["-c", config_str],
+        "markdownlint": ["--config", config_str],
+        "hadolint": ["--config", config_str],
+        "bandit": ["-c", config_str],
+    }
+
+    return config_flags.get(tool_lower, [])
+
+
+def cleanup_temp_config(config_path: Path) -> None:
+    """Explicitly clean up a temporary config file.
+
+    Args:
+        config_path: Path to temporary config file.
+    """
+    try:
+        if config_path in _temp_files:
+            _temp_files.remove(config_path)
+        if config_path.exists():
+            config_path.unlink()
+            logger.debug(f"Cleaned up temp config: {config_path}")
+    except Exception as e:
+        logger.debug(f"Failed to clean up {config_path}: {e}")
+
+
+# =============================================================================
+# DEPRECATED: Legacy functions for backward compatibility
+# These will be removed in a future version.
+# =============================================================================
+
+
+def generate_tool_config(
+    tool_name: str,
+    lintro_config: LintroConfig,
+) -> Path | None:
+    """Generate a temporary configuration file for a tool.
+
+    DEPRECATED: This function is deprecated. Use get_enforce_cli_args() for
+    CLI flag injection and generate_defaults_config() for defaults.
+
+    Args:
+        tool_name: Name of the tool.
+        lintro_config: Lintro configuration.
+
+    Returns:
+        Path | None: Path to generated config file, or None.
+    """
+    logger.warning(
+        f"generate_tool_config() is deprecated for {tool_name}. "
+        "Use get_enforce_cli_args() instead.",
+    )
+    return generate_defaults_config(
+        tool_name=tool_name,
+        lintro_config=lintro_config,
+    )
+
+
+def get_config_injection_args(
+    tool_name: str,
+    config_path: Path | None,
+) -> list[str]:
+    """Get CLI arguments to inject config file into a tool.
+
+    DEPRECATED: Use get_defaults_injection_args() instead.
+
+    Args:
+        tool_name: Name of the tool.
+        config_path: Path to config file (or None).
+
+    Returns:
+        list[str]: CLI arguments to pass to the tool.
+    """
+    logger.warning(
+        f"get_config_injection_args() is deprecated for {tool_name}. "
+        "Use get_defaults_injection_args() instead.",
+    )
+    return get_defaults_injection_args(
+        tool_name=tool_name,
+        config_path=config_path,
+    )
+
+
+def get_no_auto_config_args(tool_name: str) -> list[str]:
+    """Get CLI arguments to disable auto-config discovery.
+
+    DEPRECATED: No longer needed with the tiered model.
+    Tools use their native configs by default.
+
+    Args:
+        tool_name: Name of the tool.
+
+    Returns:
+        list[str]: Empty list (no longer used).
+    """
+    logger.warning(
+        f"get_no_auto_config_args() is deprecated for {tool_name}. "
+        "No longer needed with the tiered config model.",
+    )
+    return []

lintro/enums/tool_name.py

@@ -12,7 +12,9 @@ class ToolName(StrEnum):
     """Supported tool identifiers in lower-case values."""
 
     DARGLINT = auto()
+    ESLINT = auto()
     HADOLINT = auto()
+    MARKDOWNLINT = auto()
     PRETTIER = auto()
     RUFF = auto()
     YAMLLINT = auto()

lintro/enums/tool_type.py

@@ -17,6 +17,7 @@ class ToolType(Flag):
         DOCUMENTATION = Tool that checks documentation
         SECURITY = Tool that checks for security issues
         INFRASTRUCTURE = Tool that checks infrastructure code
+        TEST_RUNNER = Tool that runs tests
     """
 
     LINTER = auto()
@@ -25,3 +26,4 @@ class ToolType(Flag):
     DOCUMENTATION = auto()
     SECURITY = auto()
     INFRASTRUCTURE = auto()
+    TEST_RUNNER = auto()

lintro/formatters/tools/__init__.py

@@ -12,10 +12,18 @@ from lintro.formatters.tools.darglint_formatter import (
     DarglintTableDescriptor,
     format_darglint_issues,
 )
+from lintro.formatters.tools.eslint_formatter import (
+    EslintTableDescriptor,
+    format_eslint_issues,
+)
 from lintro.formatters.tools.hadolint_formatter import (
     HadolintTableDescriptor,
     format_hadolint_issues,
 )
+from lintro.formatters.tools.markdownlint_formatter import (
+    MarkdownlintTableDescriptor,
+    format_markdownlint_issues,
+)
 from lintro.formatters.tools.prettier_formatter import (
     PrettierTableDescriptor,
     format_prettier_issues,
@@ -36,8 +44,12 @@ __all__ = [
     "format_bandit_issues",
     "DarglintTableDescriptor",
     "format_darglint_issues",
+    "EslintTableDescriptor",
+    "format_eslint_issues",
     "HadolintTableDescriptor",
     "format_hadolint_issues",
+    "MarkdownlintTableDescriptor",
+    "format_markdownlint_issues",
     "PrettierTableDescriptor",
     "format_prettier_issues",
     "RuffTableDescriptor",

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/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)