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

lintro/config/config_loader.py

@@ -0,0 +1,420 @@
+"""Configuration loader for Lintro.
+
+Loads configuration from .lintro-config.yaml with fallback to
+[tool.lintro] in pyproject.toml for backward compatibility.
+
+Supports the new tiered configuration model:
+1. execution: What tools run and how
+2. enforce: Cross-cutting settings (replaces 'global')
+3. defaults: Fallback config when no native config exists
+4. tools: Per-tool enable/disable and config source
+"""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from lintro.config.lintro_config import (
+    EnforceConfig,
+    ExecutionConfig,
+    LintroConfig,
+    ToolConfig,
+)
+
+try:
+    import yaml
+except ImportError:
+    yaml = None  # type: ignore[assignment]
+
+# Default config file name
+LINTRO_CONFIG_FILENAME = ".lintro-config.yaml"
+LINTRO_CONFIG_FILENAMES = [
+    ".lintro-config.yaml",
+    ".lintro-config.yml",
+    "lintro-config.yaml",
+    "lintro-config.yml",
+]
+
+
+def _find_config_file(start_dir: Path | None = None) -> Path | None:
+    """Find .lintro-config.yaml by searching upward from start_dir.
+
+    Args:
+        start_dir: Directory to start searching from. Defaults to cwd.
+
+    Returns:
+        Path | None: Path to config file if found.
+    """
+    current = Path(start_dir) if start_dir else Path.cwd()
+    current = current.resolve()
+
+    while True:
+        for filename in LINTRO_CONFIG_FILENAMES:
+            config_path = current / filename
+            if config_path.exists():
+                return config_path
+
+        # Move up one directory
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root
+            break
+        current = parent
+
+    return None
+
+
+def _load_yaml_file(path: Path) -> dict[str, Any]:
+    """Load a YAML file.
+
+    Args:
+        path: Path to YAML file.
+
+    Returns:
+        dict[str, Any]: Parsed YAML content.
+
+    Raises:
+        ImportError: If PyYAML is not installed.
+    """
+    if yaml is None:
+        raise ImportError(
+            "PyYAML is required to load .lintro-config.yaml. "
+            "Install it with: pip install pyyaml",
+        )
+
+    with path.open(encoding="utf-8") as f:
+        content = yaml.safe_load(f)
+
+    return content if isinstance(content, dict) else {}
+
+
+def _load_pyproject_fallback() -> tuple[dict[str, Any], Path | None]:
+    """Load [tool.lintro] from pyproject.toml as fallback.
+
+    Searches upward from current directory for pyproject.toml, consistent
+    with _find_config_file's search behavior.
+
+    Returns:
+        tuple[dict[str, Any], Path | None]: Tuple of (config data, path to
+            pyproject.toml). Path is None if no pyproject.toml was found.
+    """
+    current = Path.cwd().resolve()
+
+    while True:
+        pyproject_path = current / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                with pyproject_path.open("rb") as f:
+                    data = tomllib.load(f)
+                return data.get("tool", {}).get("lintro", {}), pyproject_path
+            except (OSError, tomllib.TOMLDecodeError) as e:
+                logger.debug(f"Failed to load pyproject.toml: {e}")
+                return {}, None
+
+        # Move up one directory
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root
+            break
+        current = parent
+
+    return {}, None
+
+
+def _parse_enforce_config(data: dict[str, Any]) -> EnforceConfig:
+    """Parse enforce configuration section.
+
+    Args:
+        data: Raw 'enforce' or 'global' section from config.
+
+    Returns:
+        EnforceConfig: Parsed enforce configuration.
+    """
+    return EnforceConfig(
+        line_length=data.get("line_length"),
+        target_python=data.get("target_python"),
+    )
+
+
+def _parse_execution_config(data: dict[str, Any]) -> ExecutionConfig:
+    """Parse execution configuration section.
+
+    Args:
+        data: Raw 'execution' section from config.
+
+    Returns:
+        ExecutionConfig: Parsed execution configuration.
+    """
+    enabled_tools = data.get("enabled_tools", [])
+    if isinstance(enabled_tools, str):
+        enabled_tools = [enabled_tools]
+
+    tool_order = data.get("tool_order", "priority")
+
+    return ExecutionConfig(
+        enabled_tools=enabled_tools,
+        tool_order=tool_order,
+        fail_fast=data.get("fail_fast", False),
+        parallel=data.get("parallel", False),
+    )
+
+
+def _parse_tool_config(data: dict[str, Any]) -> ToolConfig:
+    """Parse a single tool configuration.
+
+    In the tiered model, tools only have enabled and optional config_source.
+
+    Args:
+        data: Raw tool configuration dict.
+
+    Returns:
+        ToolConfig: Parsed tool configuration.
+    """
+    enabled = data.get("enabled", True)
+    config_source = data.get("config_source")
+
+    return ToolConfig(
+        enabled=enabled,
+        config_source=config_source,
+    )
+
+
+def _parse_tools_config(data: dict[str, Any]) -> dict[str, ToolConfig]:
+    """Parse all tool configurations.
+
+    Args:
+        data: Raw 'tools' section from config.
+
+    Returns:
+        dict[str, ToolConfig]: Tool configurations keyed by tool name.
+    """
+    tools: dict[str, ToolConfig] = {}
+
+    for tool_name, tool_data in data.items():
+        if isinstance(tool_data, dict):
+            tools[tool_name.lower()] = _parse_tool_config(tool_data)
+        elif isinstance(tool_data, bool):
+            # Simple enabled/disabled flag
+            tools[tool_name.lower()] = ToolConfig(enabled=tool_data)
+
+    return tools
+
+
+def _parse_defaults(data: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    """Parse defaults configuration section.
+
+    Args:
+        data: Raw 'defaults' section from config.
+
+    Returns:
+        dict[str, dict[str, Any]]: Defaults configurations keyed by tool name.
+    """
+    defaults: dict[str, dict[str, Any]] = {}
+
+    for tool_name, tool_defaults in data.items():
+        if isinstance(tool_defaults, dict):
+            defaults[tool_name.lower()] = tool_defaults
+
+    return defaults
+
+
+def _convert_pyproject_to_config(data: dict[str, Any]) -> dict[str, Any]:
+    """Convert pyproject.toml [tool.lintro] format to .lintro-config.yaml format.
+
+    The pyproject format uses flat tool sections like [tool.lintro.ruff],
+    while .lintro-config.yaml uses nested tools: section.
+
+    Args:
+        data: Raw [tool.lintro] section from pyproject.toml.
+
+    Returns:
+        dict[str, Any]: Converted configuration in .lintro-config.yaml format.
+    """
+    result: dict[str, Any] = {
+        "enforce": {},
+        "execution": {},
+        "defaults": {},
+        "tools": {},
+    }
+
+    # Known tool names to separate from enforce settings
+    # Lazy import to avoid circular dependency
+    from lintro.tools.tool_enum import ToolEnum
+
+    # Derived from ToolEnum to stay synchronized with implementations
+    known_tools = {t.name.lower() for t in ToolEnum}
+    # Add common aliases for tools
+    tool_aliases = {"markdownlint-cli2": "markdownlint"}
+    known_tools.update(tool_aliases.keys())
+
+    # Known execution settings
+    execution_keys = {"enabled_tools", "tool_order", "fail_fast", "parallel"}
+
+    # Known enforce settings (formerly global)
+    enforce_keys = {"line_length", "target_python"}
+
+    for key, value in data.items():
+        key_lower = key.lower()
+
+        if key_lower in known_tools:
+            # Tool-specific config - normalize aliases to canonical names
+            canonical_name = tool_aliases.get(key_lower, key_lower)
+            result["tools"][canonical_name] = value
+        elif key in execution_keys or key.replace("-", "_") in execution_keys:
+            # Execution config
+            result["execution"][key.replace("-", "_")] = value
+        elif key in enforce_keys or key.replace("-", "_") in enforce_keys:
+            # Enforce config
+            result["enforce"][key.replace("-", "_")] = value
+        elif key == "post_checks":
+            # Skip post_checks (handled separately)
+            pass
+        elif key == "versions":
+            # Skip versions (handled separately)
+            pass
+        elif key == "defaults" and isinstance(value, dict):
+            # Defaults section
+            result["defaults"] = value
+
+    return result
+
+
+def load_config(
+    config_path: Path | str | None = None,
+    allow_pyproject_fallback: bool = True,
+) -> LintroConfig:
+    """Load Lintro configuration.
+
+    Priority:
+    1. Explicit config_path if provided
+    2. .lintro-config.yaml found by searching upward
+    3. [tool.lintro] in pyproject.toml (deprecated fallback)
+    4. Default empty configuration
+
+    Supports both new 'enforce' section and deprecated 'global' section.
+
+    Args:
+        config_path: Explicit path to config file. If None, searches for
+            .lintro-config.yaml.
+        allow_pyproject_fallback: Whether to fall back to pyproject.toml
+            if no .lintro-config.yaml is found.
+
+    Returns:
+        LintroConfig: Loaded configuration.
+    """
+    data: dict[str, Any] = {}
+    resolved_path: str | None = None
+
+    # Try explicit path first
+    if config_path:
+        path = Path(config_path)
+        if path.exists():
+            data = _load_yaml_file(path)
+            resolved_path = str(path.resolve())
+            logger.debug(f"Loaded config from explicit path: {resolved_path}")
+        else:
+            logger.warning(f"Config file not found: {config_path}")
+
+    # Try searching for .lintro-config.yaml
+    if not data:
+        found_path = _find_config_file()
+        if found_path:
+            data = _load_yaml_file(found_path)
+            resolved_path = str(found_path.resolve())
+            logger.debug(f"Loaded config from: {resolved_path}")
+
+    # Fall back to pyproject.toml
+    if not data and allow_pyproject_fallback:
+        pyproject_data, pyproject_path = _load_pyproject_fallback()
+        if pyproject_data:
+            data = _convert_pyproject_to_config(pyproject_data)
+            resolved_path = str(pyproject_path.resolve()) if pyproject_path else None
+            logger.debug(
+                "Using [tool.lintro] from pyproject.toml (deprecated). "
+                "Consider migrating to .lintro-config.yaml",
+            )
+
+    # Parse enforce config - support both 'enforce' and deprecated 'global'
+    enforce_data = data.get("enforce", {})
+    global_data = data.get("global", {})
+
+    # Always warn if 'global' section exists (it's deprecated)
+    if global_data:
+        if enforce_data:
+            # Both exist - warn that 'global' is ignored
+            logger.warning(
+                "The 'global' config section is deprecated and ignored "
+                "because 'enforce' is also present. Remove 'global' from your "
+                ".lintro-config.yaml",
+            )
+        else:
+            # Only 'global' exists - warn and use it
+            logger.warning(
+                "The 'global' config section is deprecated. "
+                "Please rename it to 'enforce' in your .lintro-config.yaml",
+            )
+            enforce_data = global_data
+
+    enforce_config = _parse_enforce_config(enforce_data)
+    execution_config = _parse_execution_config(data.get("execution", {}))
+    defaults = _parse_defaults(data.get("defaults", {}))
+    tools_config = _parse_tools_config(data.get("tools", {}))
+
+    return LintroConfig(
+        execution=execution_config,
+        enforce=enforce_config,
+        defaults=defaults,
+        tools=tools_config,
+        config_path=resolved_path,
+    )
+
+
+def get_default_config() -> LintroConfig:
+    """Get a default configuration with sensible defaults.
+
+    Returns:
+        LintroConfig: Default configuration.
+    """
+    return LintroConfig(
+        enforce=EnforceConfig(
+            line_length=88,
+            # target_python omitted - let tools infer from requires-python
+        ),
+        execution=ExecutionConfig(
+            tool_order="priority",
+        ),
+    )
+
+
+# Global singleton for loaded config
+_loaded_config: LintroConfig | None = None
+
+
+def get_config(reload: bool = False) -> LintroConfig:
+    """Get the loaded configuration singleton.
+
+    Args:
+        reload: Force reload from disk.
+
+    Returns:
+        LintroConfig: Loaded configuration.
+    """
+    global _loaded_config
+
+    if _loaded_config is None or reload:
+        _loaded_config = load_config()
+
+    return _loaded_config
+
+
+def clear_config_cache() -> None:
+    """Clear the configuration cache.
+
+    Useful for testing or when config file has changed.
+    """
+    global _loaded_config
+    _loaded_config = None

lintro/config/lintro_config.py

@@ -0,0 +1,189 @@
+"""Lintro configuration dataclasses.
+
+This module defines the configuration structure for .lintro-config.yaml.
+The configuration follows a 4-tier model:
+
+1. EXECUTION: What tools run and how (Lintro's core responsibility)
+2. ENFORCE: Cross-cutting settings injected via CLI flags (overrides native configs)
+3. DEFAULTS: Fallback config when no native config exists for a tool
+4. TOOLS: Per-tool enable/disable and config source
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class EnforceConfig:
+    """Cross-cutting settings enforced across all tools via CLI flags.
+
+    These settings override native tool configs to ensure consistency
+    across different tools for shared concerns.
+
+    Attributes:
+        line_length: Line length limit injected via CLI flags.
+            Injected as: --line-length (ruff, black), --print-width (prettier)
+        target_python: Python version target (e.g., "py313").
+            Injected as: --target-version (ruff, black)
+    """
+
+    line_length: int | None = None
+    target_python: str | None = None
+
+
+# Backward compatibility alias
+GlobalConfig = EnforceConfig
+
+
+@dataclass
+class ExecutionConfig:
+    """Execution control settings.
+
+    Attributes:
+        enabled_tools: List of tool names to run. If empty/None, all tools run.
+        tool_order: Execution order strategy. One of:
+            - "priority": Use default priority (formatters before linters)
+            - "alphabetical": Alphabetical order
+            - list[str]: Custom order as explicit list
+        fail_fast: Stop on first tool failure.
+        parallel: Run tools in parallel where possible (future).
+    """
+
+    enabled_tools: list[str] = field(default_factory=list)
+    tool_order: str | list[str] = "priority"
+    fail_fast: bool = False
+    parallel: bool = False
+
+
+@dataclass
+class ToolConfig:
+    """Configuration for a single tool.
+
+    In the tiered model, tools use their native configs by default.
+    Lintro only controls whether tools run and optionally specifies
+    an explicit config source path.
+
+    Attributes:
+        enabled: Whether the tool is enabled.
+        config_source: Optional explicit path to native config file.
+            If not set, tool uses its own config discovery.
+    """
+
+    enabled: bool = True
+    config_source: str | None = None
+
+
+@dataclass
+class LintroConfig:
+    """Main Lintro configuration container.
+
+    This is the root configuration object loaded from .lintro-config.yaml.
+    Follows the 4-tier model:
+
+    1. execution: What tools run and how
+    2. enforce: Cross-cutting settings that override native configs
+    3. defaults: Fallback config when no native config exists
+    4. tools: Per-tool enable/disable and config source
+
+    Attributes:
+        execution: Execution control settings.
+        enforce: Cross-cutting settings enforced via CLI flags.
+        defaults: Fallback configs for tools without native configs.
+        tools: Per-tool configuration, keyed by tool name.
+        config_path: Path to the config file (set by loader).
+    """
+
+    execution: ExecutionConfig = field(default_factory=ExecutionConfig)
+    enforce: EnforceConfig = field(default_factory=EnforceConfig)
+    defaults: dict[str, dict[str, Any]] = field(default_factory=dict)
+    tools: dict[str, ToolConfig] = field(default_factory=dict)
+    config_path: str | None = None
+
+    # Backward compatibility property
+    @property
+    def global_config(self) -> EnforceConfig:
+        """Get enforce config (deprecated alias for backward compatibility).
+
+        Returns:
+            EnforceConfig: The enforce configuration.
+        """
+        return self.enforce
+
+    def get_tool_config(self, tool_name: str) -> ToolConfig:
+        """Get configuration for a specific tool.
+
+        Args:
+            tool_name: Name of the tool (e.g., "ruff", "prettier").
+
+        Returns:
+            ToolConfig: Tool configuration. Returns default config if not
+                explicitly configured.
+        """
+        return self.tools.get(tool_name.lower(), ToolConfig())
+
+    def is_tool_enabled(self, tool_name: str) -> bool:
+        """Check if a tool is enabled.
+
+        A tool is enabled if:
+        1. execution.enabled_tools is empty (all tools enabled), OR
+        2. tool_name is in execution.enabled_tools, AND
+        3. The tool's config has enabled=True (default)
+
+        Args:
+            tool_name: Name of the tool.
+
+        Returns:
+            bool: True if tool should run.
+        """
+        tool_lower = tool_name.lower()
+
+        # Check execution.enabled_tools filter
+        if self.execution.enabled_tools:
+            enabled_lower = [t.lower() for t in self.execution.enabled_tools]
+            if tool_lower not in enabled_lower:
+                return False
+
+        # Check tool-specific enabled flag
+        tool_config = self.get_tool_config(tool_lower)
+        return tool_config.enabled
+
+    def get_tool_defaults(self, tool_name: str) -> dict[str, Any]:
+        """Get default configuration for a tool.
+
+        Used when the tool has no native config file.
+
+        Args:
+            tool_name: Name of the tool.
+
+        Returns:
+            dict[str, Any]: Default configuration or empty dict.
+        """
+        return self.defaults.get(tool_name.lower(), {})
+
+    def get_effective_line_length(self, tool_name: str) -> int | None:
+        """Get effective line length for a specific tool.
+
+        In the tiered model, this simply returns the enforce.line_length
+        value, which will be injected via CLI flags.
+
+        Args:
+            tool_name: Name of the tool (unused, kept for compatibility).
+
+        Returns:
+            int | None: Enforced line length or None.
+        """
+        return self.enforce.line_length
+
+    def get_effective_target_python(self, tool_name: str) -> str | None:
+        """Get effective Python target version for a specific tool.
+
+        In the tiered model, this simply returns the enforce.target_python
+        value, which will be injected via CLI flags.
+
+        Args:
+            tool_name: Name of the tool (unused, kept for compatibility).
+
+        Returns:
+            str | None: Enforced target version or None.
+        """
+        return self.enforce.target_python