thailint 0.5.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/orchestrator/core.py

@@ -10,34 +10,170 @@ Overview: Provides the main entry point for linting operations by coordinating e
     appropriate file information and language metadata, executes applicable rules against contexts,
     and collects violations across all processed files. Supports recursive and non-recursive
     directory traversal, respects .thailintignore patterns at repository level, and provides
-    configurable linting through .thailint.yaml configuration files. Serves as the primary
-    interface between the linter framework and user-facing CLI/library APIs.
+    configurable linting through .thailint.yaml configuration files. Includes parallel processing
+    support for improved performance on multi-core systems. Serves as the primary interface between
+    the linter framework and user-facing CLI/library APIs.
 
 Dependencies: pathlib for file operations, BaseLintRule and BaseLintContext from core.base,
     Violation from core.types, RuleRegistry from core.registry, LinterConfigLoader from
     linter_config.loader, IgnoreDirectiveParser from linter_config.ignore, detect_language
-    from language_detector
+    from language_detector, concurrent.futures for parallel processing
 
 Exports: Orchestrator class, FileLintContext implementation class
 
 Interfaces: Orchestrator(project_root: Path | None), lint_file(file_path: Path) -> list[Violation],
-    lint_directory(dir_path: Path, recursive: bool) -> list[Violation]
+    lint_directory(dir_path: Path, recursive: bool) -> list[Violation],
+    lint_files_parallel(file_paths, max_workers) -> list[Violation]
 
 Implementation: Directory glob pattern matching for traversal (** for recursive, * for shallow),
     ignore pattern checking before file processing, dynamic context creation per file,
-    rule filtering by applicability, violation collection and aggregation across files
+    rule filtering by applicability, violation collection and aggregation across files,
+    ProcessPoolExecutor for parallel file processing
+
+Suppressions:
+    - srp: Orchestrator class coordinates multiple subsystems by design (registry, config, ignore,
+        language detection). Splitting would fragment the core linting workflow.
 """
 
+from __future__ import annotations
+
+import logging
+import multiprocessing
+import os
+from concurrent.futures import Future, ProcessPoolExecutor, as_completed
 from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.registry import RuleRegistry
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 from src.linter_config.loader import LinterConfigLoader
 
 from .language_detector import detect_language
 
+logger = logging.getLogger(__name__)
+
+# Default max workers for parallel processing (capped to avoid resource contention)
+DEFAULT_MAX_WORKERS = 8
+
+# Hardcoded exclusions for files/directories that should never be linted
+# These are always skipped regardless of configuration to improve performance
+_HARDCODED_EXCLUDE_EXTENSIONS: frozenset[str] = frozenset(
+    {
+        ".pyc",
+        ".pyo",
+        ".pyd",  # Python bytecode
+        ".so",
+        ".dll",
+        ".dylib",  # Compiled libraries
+        ".class",  # Java bytecode
+        ".o",
+        ".obj",  # Object files
+    }
+)
+_HARDCODED_EXCLUDE_DIRS: frozenset[str] = frozenset(
+    {
+        "__pycache__",
+        "node_modules",
+        ".git",
+        ".svn",
+        ".hg",
+        ".venv",
+        "venv",
+        ".tox",
+        ".eggs",
+        "*.egg-info",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".ruff_cache",
+        "dist",
+        "build",
+        "htmlcov",
+    }
+)
+
+
+def _is_hardcoded_excluded(file_path: Path) -> bool:
+    """Check if file should be excluded based on hardcoded patterns.
+
+    Args:
+        file_path: Path to check
+
+    Returns:
+        True if file should be skipped (compiled file, cache directory, etc.)
+    """
+    # Check file extension
+    if file_path.suffix in _HARDCODED_EXCLUDE_EXTENSIONS:
+        return True
+
+    # Check if any parent directory is in the exclude list
+    for part in file_path.parts:
+        if part in _HARDCODED_EXCLUDE_DIRS:
+            return True
+        # Handle wildcard patterns like *.egg-info
+        if part.endswith(".egg-info"):
+            return True
+
+    return False
+
+
+def _should_include_dir(dirname: str) -> bool:
+    """Check if directory should be traversed (not excluded)."""
+    return dirname not in _HARDCODED_EXCLUDE_DIRS and not dirname.endswith(".egg-info")
+
+
+def _collect_files_from_walk(root: str, filenames: list[str]) -> list[Path]:
+    """Collect non-excluded files from a single directory."""
+    root_path = Path(root)
+    return [root_path / f for f in filenames if Path(f).suffix not in _HARDCODED_EXCLUDE_EXTENSIONS]
+
+
+def _collect_files_fast(dir_path: Path, recursive: bool = True) -> list[Path]:
+    """Collect files, skipping excluded directories entirely.
+
+    Uses os.walk() instead of glob to avoid traversing into excluded
+    directories like .venv, node_modules, __pycache__, etc.
+
+    Args:
+        dir_path: Directory to collect files from.
+        recursive: Whether to traverse subdirectories.
+
+    Returns:
+        List of file paths, excluding hardcoded exclusions.
+    """
+    files: list[Path] = []
+    for root, dirs, filenames in os.walk(dir_path):
+        dirs[:] = [d for d in dirs if _should_include_dir(d)]
+        files.extend(_collect_files_from_walk(root, filenames))
+        if not recursive:
+            break
+    return files
+
+
+def _lint_file_worker(args: tuple[Path, Path, dict]) -> list[dict]:
+    """Worker function for parallel file linting.
+
+    This function runs in a separate process and creates its own Orchestrator
+    instance to lint a single file. Results are returned as dicts to avoid
+    pickling issues with Violation dataclass.
+
+    Args:
+        args: Tuple of (file_path, project_root, config)
+
+    Returns:
+        List of violation dicts (serializable for cross-process transfer)
+    """
+    file_path, project_root, config = args
+    try:
+        # Create isolated orchestrator for this worker process
+        orchestrator = Orchestrator(project_root=project_root, config=config)
+        violations = orchestrator.lint_file(file_path)
+        # Convert to dicts for pickling
+        return [v.to_dict() for v in violations]
+    except Exception:
+        logger.exception("Worker error processing file: %s", file_path)
+        return []
+
 
 class FileLintContext(BaseLintContext):
     """Concrete implementation of lint context for file analysis."""
@@ -56,6 +192,7 @@ class FileLintContext(BaseLintContext):
         self._path = path
         self._language = lang
         self._content = content
+        self._lines: list[str] | None = None  # Cached line split
         self.metadata = metadata or {}
 
     @property
@@ -81,12 +218,31 @@ class FileLintContext(BaseLintContext):
         """Get programming language of file."""
         return self._language
 
+    @property
+    def file_lines(self) -> list[str]:
+        """Get file content as list of lines (cached).
+
+        Returns:
+            List of lines from file content, empty list if no content.
+        """
+        if self._lines is None:
+            content = self.file_content
+            self._lines = content.split("\n") if content else []
+        return self._lines
 
-class Orchestrator:
+
+class Orchestrator:  # thailint: ignore[srp]
     """Main linter orchestrator coordinating rule execution.
 
     Integrates rule registry, configuration loading, ignore patterns, and language
     detection to provide comprehensive linting of files and directories.
+
+    SRP Exception: Method count (12) exceeds guideline (8) because this is the
+    central orchestration point. Methods are organized into logical groups:
+    - Core linting: lint_file, lint_files, lint_directory
+    - Parallel linting: lint_files_parallel, lint_directory_parallel
+    - Helper methods: _execute_rules, _safe_check_rule, _ensure_rules_discovered, etc.
+    All methods support the single responsibility of coordinating lint operations.
     """
 
     def __init__(self, project_root: Path | None = None, config: dict | None = None):
@@ -99,7 +255,7 @@ class Orchestrator:
         self.project_root = project_root or Path.cwd()
         self.registry = RuleRegistry()
         self.config_loader = LinterConfigLoader()
-        self.ignore_parser = IgnoreDirectiveParser(self.project_root)
+        self.ignore_parser = get_ignore_parser(self.project_root)
 
         # Performance optimization: Defer rule discovery until first file is linted
         # This eliminates ~0.077s overhead for commands that don't need rules (--help, config, etc.)
@@ -125,6 +281,10 @@ class Orchestrator:
         Returns:
             List of violations found in the file.
         """
+        # Fast path: skip compiled files and common excluded directories
+        if _is_hardcoded_excluded(file_path):
+            return []
+
         if self.ignore_parser.is_ignored(file_path):
             return []
 
@@ -182,8 +342,8 @@ class Orchestrator:
         except ValueError:
             # Re-raise configuration validation errors (these are user-facing)
             raise
-        except Exception:  # nosec B112
-            # Skip rules that fail (defensive programming)
+        except Exception:
+            logger.exception("Rule %s failed on %s", rule.rule_id, context.file_path)
             return []
 
     def lint_directory(self, dir_path: Path, recursive: bool = True) -> list[Violation]:
@@ -197,11 +357,11 @@ class Orchestrator:
             List of all violations found across all files.
         """
         violations = []
-        pattern = "**/*" if recursive else "*"
+        # Use fast file collection that skips excluded directories entirely
+        file_paths = _collect_files_fast(dir_path, recursive)
 
-        for file_path in dir_path.glob(pattern):
-            if file_path.is_file():
-                violations.extend(self.lint_file(file_path))
+        for file_path in file_paths:
+            violations.extend(self.lint_file(file_path))
 
         # Call finalize() on all rules after processing all files
         for rule in self.registry.list_all():
@@ -209,6 +369,84 @@ class Orchestrator:
 
         return violations
 
+    def lint_files_parallel(
+        self, file_paths: list[Path], max_workers: int | None = None
+    ) -> list[Violation]:
+        """Lint multiple files in parallel using process pool.
+
+        Uses ProcessPoolExecutor to distribute file linting across multiple
+        CPU cores. Each worker process creates its own Orchestrator instance.
+
+        Args:
+            file_paths: List of file paths to lint.
+            max_workers: Maximum worker processes. Defaults to min(DEFAULT_MAX_WORKERS, cpu_count).
+
+        Returns:
+            List of violations found across all files.
+        """
+        if not file_paths:
+            return []
+
+        effective_workers = max_workers or min(DEFAULT_MAX_WORKERS, multiprocessing.cpu_count())
+
+        # For small file counts, sequential is faster due to process overhead
+        if len(file_paths) < effective_workers * 2:
+            return self.lint_files(file_paths)
+
+        violations = self._execute_parallel_linting(file_paths, effective_workers)
+        violations.extend(self._finalize_rules())
+        return violations
+
+    def _execute_parallel_linting(
+        self, file_paths: list[Path], max_workers: int
+    ) -> list[Violation]:
+        """Execute parallel linting using process pool."""
+        work_items = [(fp, self.project_root, self.config) for fp in file_paths]
+
+        with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(_lint_file_worker, item) for item in work_items]
+            return self._collect_parallel_results(futures)
+
+    def _collect_parallel_results(self, futures: list[Future[list[dict]]]) -> list[Violation]:
+        """Collect results from parallel futures."""
+        violations: list[Violation] = []
+        for future in as_completed(futures):
+            violations.extend(self._extract_violations_from_future(future))
+        return violations
+
+    def _extract_violations_from_future(self, future: Future[list[dict]]) -> list[Violation]:
+        """Extract violations from a completed future, handling errors."""
+        try:
+            return [Violation.from_dict(d) for d in future.result()]
+        except Exception:
+            logger.exception("Error extracting violations from worker future")
+            return []
+
+    def _finalize_rules(self) -> list[Violation]:
+        """Call finalize() on all rules for cross-file analysis."""
+        self._ensure_rules_discovered()
+        violations: list[Violation] = []
+        for rule in self.registry.list_all():
+            violations.extend(rule.finalize())
+        return violations
+
+    def lint_directory_parallel(
+        self, dir_path: Path, recursive: bool = True, max_workers: int | None = None
+    ) -> list[Violation]:
+        """Lint all files in a directory using parallel processing.
+
+        Args:
+            dir_path: Path to directory to lint.
+            recursive: Whether to traverse subdirectories recursively.
+            max_workers: Maximum worker processes. Defaults to min(DEFAULT_MAX_WORKERS, cpu_count).
+
+        Returns:
+            List of all violations found across all files.
+        """
+        # Use fast file collection that skips excluded directories entirely
+        file_paths = _collect_files_fast(dir_path, recursive)
+        return self.lint_files_parallel(file_paths, max_workers=max_workers)
+
     def _ensure_rules_discovered(self) -> None:
         """Ensure rules have been discovered and registered (lazy initialization)."""
         if not self._rules_discovered:

src/orchestrator/language_detector.py

@@ -17,12 +17,13 @@ Dependencies: pathlib for file path handling and content reading
 Exports: detect_language(file_path: Path) -> str function, EXTENSION_MAP constant
 
 Interfaces: detect_language(file_path: Path) -> str returns language identifier string
-    (python, javascript, typescript, java, go, unknown)
+    (python, javascript, typescript, java, go, rust, unknown)
 
 Implementation: Dictionary-based extension lookup for O(1) detection, first-line shebang
     parsing with substring matching, lazy file reading only when extension unknown
 """
 
+from contextlib import suppress
 from pathlib import Path
 
 # Extension to language mapping
@@ -34,6 +35,7 @@ EXTENSION_MAP = {
     ".jsx": "javascript",
     ".java": "java",
     ".go": "go",
+    ".rs": "rust",
 }
 
 
@@ -67,10 +69,10 @@ def detect_language(file_path: Path) -> str:
         file_path: Path to file to analyze.
 
     Returns:
-        Language identifier (python, javascript, typescript, java, go, unknown).
+        Language identifier (python, javascript, typescript, java, go, rust, unknown).
     """
     ext = file_path.suffix.lower()
-    if ext in EXTENSION_MAP:
+    with suppress(KeyError):
         return EXTENSION_MAP[ext]
 
     if file_path.exists() and file_path.stat().st_size > 0:

src/templates/thailint_config_template.yaml

@@ -132,6 +132,202 @@ print-statements:
   #   - "scripts/**"
   #   - "**/debug.py"
 
+# ============================================================================
+# STRINGLY-TYPED LINTER
+# ============================================================================
+# Detects "stringly typed" code patterns where strings are used instead of
+# proper enums - e.g., if env == "production": ... repeated across files
+#
+stringly-typed:
+  enabled: true
+
+  # Minimum occurrences across files to flag a violation
+  # Default: 2
+  min_occurrences: 2
+
+  # Minimum unique string values to suggest creating an enum
+  # Default: 2
+  min_values_for_enum: 2
+
+  # Maximum unique string values to suggest an enum (above this, probably not enum-worthy)
+  # Default: 6
+  max_values_for_enum: 6
+
+  # Whether to require cross-file occurrences to flag violations
+  # Default: true
+  require_cross_file: true
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: String value sets that are acceptable (won't be flagged)
+  # -------------------------------------------------------------------------
+  # allowed_string_sets:
+  #   - ["debug", "info", "warning", "error"]  # Log levels
+  #   - ["ASC", "DESC"]                         # Sort directions
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Variable names to exclude from analysis
+  # -------------------------------------------------------------------------
+  # exclude_variables:
+  #   - log_level
+  #   - severity
+
+# ============================================================================
+# FILE HEADER LINTER
+# ============================================================================
+# Validates that files have proper documentation headers
+#
+file-header:
+  enabled: true
+
+  # Enforce atemporal language (no "currently", "now", dates)
+  # Default: true
+  enforce_atemporal: true
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Override required fields by language
+  # -------------------------------------------------------------------------
+  # required_fields:
+  #   python: [Purpose, Scope, Overview, Dependencies, Exports, Interfaces, Implementation]
+  #   typescript: [Purpose, Scope, Overview, Dependencies, Exports, Props/Interfaces, State/Behavior]
+  #   bash: [Purpose, Scope, Overview, Dependencies, Exports, Usage, Environment]
+  #   markdown: [purpose, scope, overview, audience, status]
+  #   css: [Purpose, Scope, Overview, Dependencies, Exports, Interfaces, Environment]
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore:
+  #   - "test/**"
+  #   - "**/migrations/**"
+  #   - "**/__init__.py"
+
+# ============================================================================
+# METHOD PROPERTY LINTER
+# ============================================================================
+# Detects methods that should be @property (no args, simple return)
+#
+method-property:
+  enabled: true
+
+  # Maximum statements in method body to suggest @property
+  # Default: 3
+  max_body_statements: 3
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Methods to ignore (exact names)
+  # -------------------------------------------------------------------------
+  # ignore_methods:
+  #   - "__str__"
+  #   - "__repr__"
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Additional action verb prefixes to exclude
+  # -------------------------------------------------------------------------
+  # exclude_prefixes:
+  #   - "fetch_"
+  #   - "load_"
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore:
+  #   - "tests/**"
+
+# ============================================================================
+# STATELESS CLASS LINTER
+# ============================================================================
+# Detects classes with no instance state (should be modules or functions)
+#
+stateless-class:
+  enabled: true
+
+  # Minimum methods to flag a stateless class
+  # Default: 2
+  min_methods: 2
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore:
+  #   - "tests/**"
+
+# ============================================================================
+# COLLECTION PIPELINE LINTER
+# ============================================================================
+# Detects "embedded loop filtering" anti-pattern (if/continue in loops)
+# Suggests using filter(), list comprehensions, or generator expressions
+#
+pipeline:
+  enabled: true
+
+  # Minimum if/continue patterns in a loop to flag
+  # Default: 1
+  min_continues: 1
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore:
+  #   - "tests/**"
+
+# ============================================================================
+# LAZY IGNORES LINTER
+# ============================================================================
+# Detects unjustified linting suppressions (noqa, type: ignore, etc.)
+# without proper documentation in file headers
+#
+lazy-ignores:
+  enabled: true
+
+  # Pattern-specific toggles
+  check_noqa: true
+  check_type_ignore: true
+  check_pylint_disable: true
+  check_nosec: true
+  check_ts_ignore: true
+  check_eslint_disable: true
+  check_thailint_ignore: true
+  check_test_skips: true
+
+  # Check for orphaned suppressions (documented but not used)
+  check_orphaned: true
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore_patterns:
+  #   - "tests/**"
+
+# ============================================================================
+# PERFORMANCE LINTER
+# ============================================================================
+# Detects performance anti-patterns in loops that cause O(n²) behavior
+#
+performance:
+  enabled: true
+
+  # String concatenation in loops (O(n²) pattern)
+  # Detects: result += str in for/while loops
+  # Suggests: Use "".join() or list append + join
+  string-concat-loop:
+    enabled: true
+    # Report each += separately, or one violation per loop
+    # Default: false (one per loop)
+    report_each_concat: false
+
+  # Regex compilation in loops
+  # Detects: re.match(), re.search(), re.sub() etc. in loops
+  # Suggests: Use re.compile() outside loop
+  regex-in-loop:
+    enabled: true
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: File patterns to ignore
+  # -------------------------------------------------------------------------
+  # ignore:
+  #   - "tests/**"
+  #   - "scripts/**"
+
 # ============================================================================
 # GLOBAL SETTINGS
 # ============================================================================

src/utils/project_root.py

@@ -15,6 +15,9 @@ Exports: is_project_root(), get_project_root()
 Interfaces: Path-based functions for checking and finding project roots
 
 Implementation: pyprojroot delegation with manual fallback for test environments
+
+Suppressions:
+    - type:ignore[arg-type]: pyprojroot external library typing issue with Path conversion
 """
 
 from pathlib import Path