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

lintro/tools/implementations/tool_ruff.py

@@ -1,6 +1,7 @@
 """Ruff Python linter and formatter integration."""
 
 import os
+import subprocess  # nosec B404 - used safely with shell disabled
 import tomllib
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -14,6 +15,11 @@ from lintro.parsers.ruff.ruff_parser import (
     parse_ruff_format_check_output,
     parse_ruff_output,
 )
+from lintro.tools.core.timeout_utils import (
+    create_timeout_result,
+    get_timeout_value,
+    run_subprocess_with_timeout,
+)
 from lintro.tools.core.tool_base import BaseTool
 from lintro.utils.tool_utils import walk_files_with_excludes
 
@@ -31,7 +37,7 @@ def _load_ruff_config() -> dict:
     """Load ruff configuration from pyproject.toml.
 
     Returns:
-        dict: Ruff configuration dictionary.
+        dict: Ruff configuration dictionary with flattened lint settings.
     """
     config: dict = {}
     pyproject_path = Path("pyproject.toml")
@@ -41,7 +47,20 @@ def _load_ruff_config() -> dict:
             with open(pyproject_path, "rb") as f:
                 pyproject_data = tomllib.load(f)
                 if "tool" in pyproject_data and "ruff" in pyproject_data["tool"]:
-                    config = pyproject_data["tool"]["ruff"]
+                    ruff_config = pyproject_data["tool"]["ruff"]
+                    # Copy top-level settings
+                    config = dict(ruff_config)
+                    # Flatten nested lint section to top level for easy access
+                    if "lint" in ruff_config:
+                        lint_config = ruff_config["lint"]
+                        if "select" in lint_config:
+                            config["select"] = lint_config["select"]
+                        if "ignore" in lint_config:
+                            config["ignore"] = lint_config["ignore"]
+                        if "extend-select" in lint_config:
+                            config["extend_select"] = lint_config["extend-select"]
+                        if "extend-ignore" in lint_config:
+                            config["extend_ignore"] = lint_config["extend-ignore"]
         except Exception as e:
             logger.warning(f"Failed to load ruff configuration: {e}")
 
@@ -54,12 +73,14 @@ def _load_lintro_ignore() -> list[str]:
     Returns:
         list[str]: List of ignore patterns.
     """
+    from lintro.utils.path_utils import find_lintro_ignore
+
     ignore_patterns: list[str] = []
-    lintro_ignore_path = Path(".lintro-ignore")
+    lintro_ignore_path = find_lintro_ignore()
 
-    if lintro_ignore_path.exists():
+    if lintro_ignore_path and lintro_ignore_path.exists():
         try:
-            with open(lintro_ignore_path, "r", encoding="utf-8") as f:
+            with open(lintro_ignore_path, encoding="utf-8") as f:
                 for line in f:
                     line = line.strip()
                     # Skip empty lines and comments
@@ -127,29 +148,40 @@ class RuffTool(BaseTool):
     def __post_init__(self) -> None:
         """Initialize the tool with default configuration."""
         super().__post_init__()
-        # Load ruff configuration from pyproject.toml
-        ruff_config = _load_ruff_config()
-
-        # Load .lintro-ignore patterns
-        lintro_ignore_patterns = _load_lintro_ignore()
-
-        # Update exclude patterns from configuration and .lintro-ignore
-        if "exclude" in ruff_config:
-            self.exclude_patterns.extend(ruff_config["exclude"])
-        if lintro_ignore_patterns:
-            self.exclude_patterns.extend(lintro_ignore_patterns)
-
-        # Update other options from configuration
-        if "line_length" in ruff_config:
-            self.options["line_length"] = ruff_config["line_length"]
-        if "target_version" in ruff_config:
-            self.options["target_version"] = ruff_config["target_version"]
-        if "select" in ruff_config:
-            self.options["select"] = ruff_config["select"]
-        if "ignore" in ruff_config:
-            self.options["ignore"] = ruff_config["ignore"]
-        if "unsafe_fixes" in ruff_config:
-            self.options["unsafe_fixes"] = ruff_config["unsafe_fixes"]
+
+        # Skip config loading in test mode to allow tests to set specific options
+        # without interference from pyproject.toml settings
+        if os.environ.get(RUFF_TEST_MODE_ENV) != RUFF_TEST_MODE_VALUE:
+            # Load ruff configuration from pyproject.toml
+            ruff_config = _load_ruff_config()
+
+            # Load .lintro-ignore patterns
+            lintro_ignore_patterns = _load_lintro_ignore()
+
+            # Update exclude patterns from configuration and .lintro-ignore
+            if "exclude" in ruff_config:
+                self.exclude_patterns.extend(ruff_config["exclude"])
+            if lintro_ignore_patterns:
+                self.exclude_patterns.extend(lintro_ignore_patterns)
+
+            # Update other options from configuration
+            if "line_length" in ruff_config:
+                self.options["line_length"] = ruff_config["line_length"]
+            if "target_version" in ruff_config:
+                self.options["target_version"] = ruff_config["target_version"]
+            if "select" in ruff_config:
+                self.options["select"] = ruff_config["select"]
+            if "ignore" in ruff_config:
+                self.options["ignore"] = ruff_config["ignore"]
+            if "unsafe_fixes" in ruff_config:
+                self.options["unsafe_fixes"] = ruff_config["unsafe_fixes"]
+
+        # Allow environment variable override for unsafe fixes
+        # Useful for development and CI environments
+        # This must come after config loading to override config values
+        env_unsafe_fixes = os.environ.get("RUFF_UNSAFE_FIXES", "").lower()
+        if env_unsafe_fixes in ("true", "1", "yes", "on"):
+            self.options["unsafe_fixes"] = True
 
     def set_options(
         self,
@@ -187,14 +219,26 @@ class RuffTool(BaseTool):
         Raises:
             ValueError: If an option value is invalid.
         """
-        if select is not None and not isinstance(select, list):
-            raise ValueError("select must be a list of rule codes")
-        if ignore is not None and not isinstance(ignore, list):
-            raise ValueError("ignore must be a list of rule codes")
-        if extend_select is not None and not isinstance(extend_select, list):
-            raise ValueError("extend_select must be a list of rule codes")
-        if extend_ignore is not None and not isinstance(extend_ignore, list):
-            raise ValueError("extend_ignore must be a list of rule codes")
+        if select is not None:
+            if isinstance(select, str):
+                select = [select]
+            elif not isinstance(select, list):
+                raise ValueError("select must be a string or list of rule codes")
+        if ignore is not None:
+            if isinstance(ignore, str):
+                ignore = [ignore]
+            elif not isinstance(ignore, list):
+                raise ValueError("ignore must be a string or list of rule codes")
+        if extend_select is not None:
+            if isinstance(extend_select, str):
+                extend_select = [extend_select]
+            elif not isinstance(extend_select, list):
+                raise ValueError("extend_select must be a string or list of rule codes")
+        if extend_ignore is not None:
+            if isinstance(extend_ignore, str):
+                extend_ignore = [extend_ignore]
+            elif not isinstance(extend_ignore, list):
+                raise ValueError("extend_ignore must be a string or list of rule codes")
         if line_length is not None:
             if not isinstance(line_length, int):
                 raise ValueError("line_length must be an integer")
@@ -247,8 +291,16 @@ class RuffTool(BaseTool):
         """
         cmd: list[str] = self._get_executable_command(tool_name="ruff") + ["check"]
 
-        # Add --isolated if in test mode
-        if os.environ.get(RUFF_TEST_MODE_ENV) == RUFF_TEST_MODE_VALUE:
+        # Get enforced settings to avoid duplicate CLI args
+        enforced = self._get_enforced_settings()
+
+        # Add Lintro config injection args (--line-length, --target-version)
+        # from enforce tier. This takes precedence over native config and options
+        config_args = self._build_config_args()
+        if config_args:
+            cmd.extend(config_args)
+        # Add --isolated if in test mode (fallback when no Lintro config)
+        elif os.environ.get(RUFF_TEST_MODE_ENV) == RUFF_TEST_MODE_VALUE:
             cmd.append("--isolated")
 
         # Add configuration options
@@ -271,11 +323,15 @@ class RuffTool(BaseTool):
             cmd.extend(["--ignore", ",".join(sorted(ignored_rules))])
         if extend_selected_rules:
             cmd.extend(["--extend-select", ",".join(extend_selected_rules)])
-        if self.options.get("extend_ignore"):
-            cmd.extend(["--extend-ignore", ",".join(self.options["extend_ignore"])])
-        if self.options.get("line_length"):
+        extend_ignored_rules = list(self.options.get("extend_ignore") or [])
+        if extend_ignored_rules:
+            cmd.extend(["--extend-ignore", ",".join(extend_ignored_rules)])
+        # Only add line_length/target_version from options if not enforced.
+        # Note: enforced uses Lintro's generic names (line_length, target_python)
+        # while options use tool-specific names (line_length, target_version).
+        if self.options.get("line_length") and "line_length" not in enforced:
             cmd.extend(["--line-length", str(self.options["line_length"])])
-        if self.options.get("target_version"):
+        if self.options.get("target_version") and "target_python" not in enforced:
             cmd.extend(["--target-version", self.options["target_version"]])
 
         # Fix options
@@ -315,11 +371,16 @@ class RuffTool(BaseTool):
         if check_only:
             cmd.append("--check")
 
-        # Add configuration options
-        if self.options.get("line_length"):
-            cmd.extend(["--line-length", str(self.options["line_length"])])
-        if self.options.get("target_version"):
-            cmd.extend(["--target-version", self.options["target_version"]])
+        # Add Lintro config injection args (--isolated, --config)
+        config_args = self._build_config_args()
+        if config_args:
+            cmd.extend(config_args)
+        else:
+            # Fallback to options-based configuration
+            if self.options.get("line_length"):
+                cmd.extend(["--line-length", str(self.options["line_length"])])
+            if self.options.get("target_version"):
+                cmd.extend(["--target-version", self.options["target_version"]])
 
         # Add files
         cmd.extend(files)
@@ -338,6 +399,11 @@ class RuffTool(BaseTool):
         Returns:
             ToolResult: ToolResult instance.
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
         if not paths:
             return ToolResult(
@@ -373,16 +439,31 @@ class RuffTool(BaseTool):
             os.path.relpath(f, cwd) if cwd else f for f in python_files
         ]
 
-        timeout: int = self.options.get("timeout", RUFF_DEFAULT_TIMEOUT)
+        timeout: int = get_timeout_value(self, RUFF_DEFAULT_TIMEOUT)
         # Lint check
         cmd: list[str] = self._build_check_command(files=rel_files, fix=False)
         success_lint: bool
         output_lint: str
-        success_lint, output_lint = self._run_subprocess(
-            cmd=cmd,
-            timeout=timeout,
-            cwd=cwd,
-        )
+        try:
+            success_lint, output_lint = run_subprocess_with_timeout(
+                tool=self,
+                cmd=cmd,
+                timeout=timeout,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            timeout_result = create_timeout_result(
+                tool=self,
+                timeout=timeout,
+                cmd=cmd,
+            )
+            return ToolResult(
+                name=self.name,
+                success=timeout_result["success"],
+                output=timeout_result["output"],
+                issues_count=timeout_result["issues_count"],
+                issues=timeout_result["issues"],
+            )
         lint_issues = parse_ruff_output(output=output_lint)
         lint_issues_count: int = len(lint_issues)
 
@@ -397,11 +478,26 @@ class RuffTool(BaseTool):
             )
             success_format: bool
             output_format: str
-            success_format, output_format = self._run_subprocess(
-                cmd=format_cmd,
-                timeout=timeout,
-                cwd=cwd,
-            )
+            try:
+                success_format, output_format = self._run_subprocess(
+                    cmd=format_cmd,
+                    timeout=timeout,
+                    cwd=cwd,
+                )
+            except subprocess.TimeoutExpired:
+                timeout_msg = (
+                    f"Ruff execution timed out ({timeout}s limit exceeded).\n\n"
+                    "This may indicate:\n"
+                    "  - Large codebase taking too long to process\n"
+                    "  - Need to increase timeout via --tool-options ruff:timeout=N"
+                )
+                return ToolResult(
+                    name=self.name,
+                    success=False,
+                    output=timeout_msg,
+                    issues_count=1,  # Count timeout as execution failure
+                    issues=lint_issues,  # Include any lint issues found before timeout
+                )
             format_files = parse_ruff_format_check_output(output=output_format)
             # Normalize files to absolute paths to keep behavior consistent with
             # direct CLI calls and stabilize tests that compare exact paths.
@@ -445,6 +541,11 @@ class RuffTool(BaseTool):
         Returns:
             ToolResult: ToolResult instance.
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
         if not paths:
             return ToolResult(
@@ -471,7 +572,7 @@ class RuffTool(BaseTool):
             )
 
         logger.debug(f"Files to fix: {python_files}")
-        timeout: int = self.options.get("timeout", RUFF_DEFAULT_TIMEOUT)
+        timeout: int = get_timeout_value(self, RUFF_DEFAULT_TIMEOUT)
         all_outputs: list[str] = []
         overall_success: bool = True
 
@@ -482,10 +583,28 @@ class RuffTool(BaseTool):
         cmd_check: list[str] = self._build_check_command(files=python_files, fix=False)
         success_check: bool
         output_check: str
-        success_check, output_check = self._run_subprocess(
-            cmd=cmd_check,
-            timeout=timeout,
-        )
+        try:
+            success_check, output_check = run_subprocess_with_timeout(
+                tool=self,
+                cmd=cmd_check,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            timeout_result = create_timeout_result(
+                tool=self,
+                timeout=timeout,
+                cmd=cmd_check,
+            )
+            return ToolResult(
+                name=self.name,
+                success=timeout_result["success"],
+                output=timeout_result["output"],
+                issues_count=timeout_result["issues_count"],
+                issues=timeout_result["issues"],
+                initial_issues_count=0,
+                fixed_issues_count=0,
+                remaining_issues_count=1,
+            )
         initial_issues = parse_ruff_output(output=output_check)
         initial_count: int = len(initial_issues)
 
@@ -499,10 +618,29 @@ class RuffTool(BaseTool):
             )
             success_format_check: bool
             output_format_check: str
-            success_format_check, output_format_check = self._run_subprocess(
-                cmd=format_cmd_check,
-                timeout=timeout,
-            )
+            try:
+                success_format_check, output_format_check = self._run_subprocess(
+                    cmd=format_cmd_check,
+                    timeout=timeout,
+                )
+            except subprocess.TimeoutExpired:
+                timeout_msg = (
+                    f"Ruff execution timed out ({timeout}s limit exceeded).\n\n"
+                    "This may indicate:\n"
+                    "  - Large codebase taking too long to process\n"
+                    "  - Need to increase timeout via --tool-options ruff:timeout=N"
+                )
+                return ToolResult(
+                    name=self.name,
+                    success=False,
+                    output=timeout_msg,
+                    issues_count=1,  # Count timeout as execution failure
+                    # Include any lint issues found before timeout
+                    issues=initial_issues,
+                    initial_issues_count=initial_count,
+                    fixed_issues_count=0,
+                    remaining_issues_count=1,
+                )
             format_files = parse_ruff_format_check_output(output=output_format_check)
             initial_format_count = len(format_files)
 
@@ -512,11 +650,29 @@ class RuffTool(BaseTool):
         # Optionally run ruff check --fix (lint fixes)
         remaining_issues = []
         remaining_count = 0
+        success: bool = True  # Default to True when lint_fix is disabled
         if self.options.get("lint_fix", True):
             cmd: list[str] = self._build_check_command(files=python_files, fix=True)
-            success: bool
             output: str
-            success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
+            try:
+                success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
+            except subprocess.TimeoutExpired:
+                timeout_msg = (
+                    f"Ruff execution timed out ({timeout}s limit exceeded).\n\n"
+                    "This may indicate:\n"
+                    "  - Large codebase taking too long to process\n"
+                    "  - Need to increase timeout via --tool-options ruff:timeout=N"
+                )
+                return ToolResult(
+                    name=self.name,
+                    success=False,
+                    output=timeout_msg,
+                    issues_count=1,  # Count timeout as execution failure
+                    issues=initial_issues,  # Include initial issues found
+                    initial_issues_count=total_initial_count,
+                    fixed_issues_count=0,
+                    remaining_issues_count=1,
+                )
             remaining_issues = parse_ruff_output(output=output)
             remaining_count = len(remaining_issues)
 
@@ -547,11 +703,18 @@ class RuffTool(BaseTool):
                 # Only run if not already run with unsafe fixes
                 success_unsafe: bool
                 output_unsafe: str
-                success_unsafe, output_unsafe = self._run_subprocess(
-                    cmd=cmd_unsafe,
-                    timeout=timeout,
-                )
-                remaining_unsafe = parse_ruff_output(output=output_unsafe)
+                try:
+                    success_unsafe, output_unsafe = self._run_subprocess(
+                        cmd=cmd_unsafe,
+                        timeout=timeout,
+                    )
+                except subprocess.TimeoutExpired:
+                    # If unsafe check times out, just continue with current results
+                    # Don't fail the entire operation for this optional check
+                    logger.debug("Unsafe fixes check timed out, skipping")
+                    remaining_unsafe = remaining_issues
+                else:
+                    remaining_unsafe = parse_ruff_output(output=output_unsafe)
                 if len(remaining_unsafe) < remaining_count:
                     all_outputs.append(
                         "Some remaining issues could be fixed by enabling unsafe "
@@ -593,10 +756,28 @@ class RuffTool(BaseTool):
             )
             format_success: bool
             format_output: str
-            format_success, format_output = self._run_subprocess(
-                cmd=format_cmd,
-                timeout=timeout,
-            )
+            try:
+                format_success, format_output = self._run_subprocess(
+                    cmd=format_cmd,
+                    timeout=timeout,
+                )
+            except subprocess.TimeoutExpired:
+                timeout_msg = (
+                    f"Ruff execution timed out ({timeout}s limit exceeded).\n\n"
+                    "This may indicate:\n"
+                    "  - Large codebase taking too long to process\n"
+                    "  - Need to increase timeout via --tool-options ruff:timeout=N"
+                )
+                return ToolResult(
+                    name=self.name,
+                    success=False,
+                    output=timeout_msg,
+                    issues_count=1,  # Count timeout as execution failure
+                    issues=remaining_issues,  # Include any issues found before timeout
+                    initial_issues_count=total_initial_count,
+                    fixed_issues_count=fixed_lint_count,
+                    remaining_issues_count=1,
+                )
             # Formatting fixes are counted separately from lint fixes
             if initial_format_count > 0:
                 fixed_count = fixed_lint_count + initial_format_count
@@ -621,10 +802,23 @@ class RuffTool(BaseTool):
 
         # Success should be based on whether there are remaining issues after fixing
         # If there are no initial issues, success should be True
-        if total_initial_count == 0:
-            overall_success = True
-        else:
-            overall_success = remaining_count == 0
+        overall_success = True if total_initial_count == 0 else remaining_count == 0
+
+        # Convert initial format files to RuffFormatIssue objects (these were fixed)
+        # and combine with remaining issues so formatter can split them by fixability
+        fixed_format_issues: list[RuffFormatIssue] = []
+        if format_files:
+            # Normalize files to absolute paths to keep behavior consistent
+            cwd: str | None = self.get_cwd(paths=python_files)
+            for file_path in format_files:
+                if cwd and not os.path.isabs(file_path):
+                    absolute_path = os.path.abspath(os.path.join(cwd, file_path))
+                    fixed_format_issues.append(RuffFormatIssue(file=absolute_path))
+                else:
+                    fixed_format_issues.append(RuffFormatIssue(file=file_path))
+
+        # Combine fixed format issues with remaining lint issues
+        all_issues = fixed_format_issues + remaining_issues
 
         return ToolResult(
             name=self.name,
@@ -632,8 +826,8 @@ class RuffTool(BaseTool):
             output=final_output,
             # For fix operations, issues_count represents remaining for summaries
             issues_count=remaining_count,
-            # Display remaining issues only to align tables with summary counts
-            issues=remaining_issues,
+            # Display both fixed format issues and remaining lint issues
+            issues=all_issues,
             initial_issues_count=total_initial_count,
             fixed_issues_count=fixed_count,
             remaining_issues_count=remaining_count,