thailint 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

src/cli.py

@@ -1895,5 +1895,247 @@ def _execute_method_property_lint(  # pylint: disable=too-many-arguments,too-man
     sys.exit(1 if method_property_violations else 0)
 
 
+# =============================================================================
+# Stateless Class Linter Command
+# =============================================================================
+
+
+def _setup_stateless_class_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for stateless-class command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_stateless_class_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute stateless-class lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "stateless-class" in v.rule_id]
+
+
+@cli.command("stateless-class")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def stateless_class(
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check for stateless classes that should be module functions.
+
+    Detects Python classes that have no constructor (__init__), no instance
+    state, and 2+ methods - indicating they should be refactored to module-level
+    functions instead of using a class as a namespace.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint stateless-class
+
+        \b
+        # Check specific directory
+        thai-lint stateless-class src/
+
+        \b
+        # Check single file
+        thai-lint stateless-class src/utils.py
+
+        \b
+        # Check multiple files
+        thai-lint stateless-class src/utils.py src/helpers.py
+
+        \b
+        # Get JSON output
+        thai-lint stateless-class --format json .
+
+        \b
+        # Get SARIF output for CI/CD integration
+        thai-lint stateless-class --format sarif src/
+
+        \b
+        # Use custom config file
+        thai-lint stateless-class --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_stateless_class_lint(
+            path_objs, config_file, format, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_stateless_class_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose, project_root=None
+):
+    """Execute stateless-class lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_stateless_class_orchestrator(
+        path_objs, config_file, verbose, project_root
+    )
+    stateless_class_violations = _run_stateless_class_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(stateless_class_violations)} stateless-class violation(s)")
+
+    format_violations(stateless_class_violations, format)
+    sys.exit(1 if stateless_class_violations else 0)
+
+
+# Collection Pipeline command helper functions
+
+
+def _setup_pipeline_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for pipeline command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _apply_pipeline_config_override(orchestrator, min_continues: int | None, verbose: bool):
+    """Apply min_continues override to orchestrator config."""
+    if min_continues is None:
+        return
+
+    if "collection_pipeline" not in orchestrator.config:
+        orchestrator.config["collection_pipeline"] = {}
+
+    orchestrator.config["collection_pipeline"]["min_continues"] = min_continues
+    if verbose:
+        logger.debug(f"Overriding min_continues to {min_continues}")
+
+
+def _run_pipeline_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute collection-pipeline lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "collection-pipeline" in v.rule_id]
+
+
+@cli.command("pipeline")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--min-continues", type=int, help="Override min continue guards to flag (default: 1)")
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def pipeline(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    min_continues: int | None,
+    recursive: bool,
+):
+    """Check for collection pipeline anti-patterns in code.
+
+    Detects for loops with embedded if/continue filtering patterns that could
+    be refactored to use collection pipelines (generator expressions, filter()).
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all Python files recursively)
+        thai-lint pipeline
+
+        \b
+        # Check specific directory
+        thai-lint pipeline src/
+
+        \b
+        # Check single file
+        thai-lint pipeline src/app.py
+
+        \b
+        # Only flag loops with 2+ continue guards
+        thai-lint pipeline --min-continues 2 src/
+
+        \b
+        # Get JSON output
+        thai-lint pipeline --format json .
+
+        \b
+        # Get SARIF output for CI/CD integration
+        thai-lint pipeline --format sarif src/
+
+        \b
+        # Use custom config file
+        thai-lint pipeline --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_pipeline_lint(
+            path_objs, config_file, format, min_continues, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_pipeline_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, min_continues, recursive, verbose, project_root=None
+):
+    """Execute collection-pipeline lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_pipeline_orchestrator(path_objs, config_file, verbose, project_root)
+    _apply_pipeline_config_override(orchestrator, min_continues, verbose)
+    pipeline_violations = _run_pipeline_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(pipeline_violations)} collection-pipeline violation(s)")
+
+    format_violations(pipeline_violations, format)
+    sys.exit(1 if pipeline_violations else 0)
+
+
 if __name__ == "__main__":
     cli()

src/config.py

@@ -103,9 +103,8 @@ def _load_from_explicit_path(config_path: Path) -> dict[str, Any]:
 
 def _load_from_default_locations() -> dict[str, Any]:
     """Load config from default locations."""
-    for location in CONFIG_LOCATIONS:
-        if not location.exists():
-            continue
+    existing_locations = (loc for loc in CONFIG_LOCATIONS if loc.exists())
+    for location in existing_locations:
         loaded_config = _try_load_from_location(location)
         if loaded_config:
             return loaded_config

src/core/base.py

@@ -151,6 +151,10 @@ class MultiLanguageLintRule(BaseLintRule):
     - _load_config(context) for configuration loading
     """
 
+    def __init__(self) -> None:
+        """Initialize the multi-language lint rule."""
+        pass  # Base class for multi-language linters
+
     def check(self, context: BaseLintContext) -> list[Violation]:
         """Check for violations with automatic language dispatch.
 

src/core/rule_discovery.py

@@ -10,7 +10,7 @@ Overview: Provides automatic rule discovery functionality for the linter framewo
 
 Dependencies: importlib, inspect, pkgutil, BaseLintRule
 
-Exports: RuleDiscovery
+Exports: discover_from_package function, RuleDiscovery class (compat)
 
 Interfaces: discover_from_package(package_path) -> list[BaseLintRule]
 
@@ -20,113 +20,172 @@ Implementation: Package traversal with pkgutil, class introspection with inspect
 import importlib
 import inspect
 import pkgutil
+from types import ModuleType
 from typing import Any
 
 from .base import BaseLintRule
 
 
-class RuleDiscovery:
-    """Discovers linting rules from Python packages."""
+def discover_from_package(package_path: str) -> list[BaseLintRule]:
+    """Discover rules from a package and its modules.
 
-    def discover_from_package(self, package_path: str) -> list[BaseLintRule]:
-        """Discover rules from a package and its modules.
+    Args:
+        package_path: Python package path (e.g., 'src.linters')
 
-        Args:
-            package_path: Python package path (e.g., 'src.linters')
+    Returns:
+        List of discovered rule instances
+    """
+    try:
+        package = importlib.import_module(package_path)
+    except ImportError:
+        return []
 
-        Returns:
-            List of discovered rule instances
-        """
-        try:
-            package = importlib.import_module(package_path)
-        except ImportError:
-            return []
+    if not hasattr(package, "__path__"):
+        return _discover_from_module(package_path)
 
-        if not hasattr(package, "__path__"):
-            return self._discover_from_module(package_path)
+    return _discover_from_package_modules(package_path, package)
 
-        return self._discover_from_package_modules(package_path, package)
 
-    def _discover_from_package_modules(self, package_path: str, package: Any) -> list[BaseLintRule]:
-        """Discover rules from all modules in a package.
+def _discover_from_package_modules(package_path: str, package: Any) -> list[BaseLintRule]:
+    """Discover rules from all modules in a package.
 
-        Args:
-            package_path: Package path
-            package: Imported package object
+    Args:
+        package_path: Package path
+        package: Imported package object
 
-        Returns:
-            List of discovered rules
-        """
-        rules = []
-        for _, module_name, _ in pkgutil.iter_modules(package.__path__):
-            full_module_name = f"{package_path}.{module_name}"
-            module_rules = self._try_discover_from_module(full_module_name)
-            rules.extend(module_rules)
-        return rules
+    Returns:
+        List of discovered rules
+    """
+    rules = []
+    for _, module_name, _ in pkgutil.iter_modules(package.__path__):
+        full_module_name = f"{package_path}.{module_name}"
+        module_rules = _try_discover_from_module(full_module_name)
+        rules.extend(module_rules)
+    return rules
 
-    def _try_discover_from_module(self, module_name: str) -> list[BaseLintRule]:
-        """Try to discover rules from a module, return empty list on error.
 
-        Args:
-            module_name: Full module name
+def _try_discover_from_module(module_name: str) -> list[BaseLintRule]:
+    """Try to discover rules from a module, return empty list on error.
 
-        Returns:
-            List of discovered rules (empty on error)
-        """
-        try:
-            return self._discover_from_module(module_name)
-        except (ImportError, AttributeError):
-            return []
+    Args:
+        module_name: Full module name
 
-    def _discover_from_module(self, module_path: str) -> list[BaseLintRule]:
-        """Discover rules from a specific module.
+    Returns:
+        List of discovered rules (empty on error)
+    """
+    try:
+        return _discover_from_module(module_name)
+    except (ImportError, AttributeError):
+        return []
 
-        Args:
-            module_path: Full module path to search
 
-        Returns:
-            List of discovered rule instances
-        """
-        try:
-            module = importlib.import_module(module_path)
-        except (ImportError, AttributeError):
-            return []
-
-        rules = []
-        for _name, obj in inspect.getmembers(module):
-            if not self._is_rule_class(obj):
-                continue
-            rule_instance = self._try_instantiate_rule(obj)
-            if rule_instance:
-                rules.append(rule_instance)
-        return rules
-
-    def _try_instantiate_rule(self, rule_class: type[BaseLintRule]) -> BaseLintRule | None:
-        """Try to instantiate a rule class.
+def _discover_from_module(module_path: str) -> list[BaseLintRule]:
+    """Discover rules from a specific module.
 
-        Args:
-            rule_class: Rule class to instantiate
+    Args:
+        module_path: Full module path to search
 
-        Returns:
-            Rule instance or None on error
-        """
-        try:
-            return rule_class()
-        except (TypeError, AttributeError):
-            return None
+    Returns:
+        List of discovered rule instances
+    """
+    module = _try_import_module(module_path)
+    if module is None:
+        return []
+    return _extract_rules_from_module(module)
+
+
+def _try_import_module(module_path: str) -> ModuleType | None:
+    """Try to import a module, returning None on failure.
+
+    Args:
+        module_path: Full module path to import
+
+    Returns:
+        Module object or None if import fails
+    """
+    try:
+        return importlib.import_module(module_path)
+    except (ImportError, AttributeError):
+        return None
 
-    def _is_rule_class(self, obj: Any) -> bool:
-        """Check if an object is a valid rule class.
+
+def _extract_rules_from_module(module: ModuleType) -> list[BaseLintRule]:
+    """Extract rule instances from a module.
+
+    Args:
+        module: Imported module to scan
+
+    Returns:
+        List of discovered rule instances
+    """
+    rule_classes = [obj for _name, obj in inspect.getmembers(module) if _is_rule_class(obj)]
+    return _instantiate_rules(rule_classes)
+
+
+def _instantiate_rules(rule_classes: list[type[BaseLintRule]]) -> list[BaseLintRule]:
+    """Instantiate a list of rule classes.
+
+    Args:
+        rule_classes: List of rule classes to instantiate
+
+    Returns:
+        List of successfully instantiated rules
+    """
+    instances = (_try_instantiate_rule(cls) for cls in rule_classes)
+    return [inst for inst in instances if inst is not None]
+
+
+def _try_instantiate_rule(rule_class: type[BaseLintRule]) -> BaseLintRule | None:
+    """Try to instantiate a rule class.
+
+    Args:
+        rule_class: Rule class to instantiate
+
+    Returns:
+        Rule instance or None on error
+    """
+    try:
+        return rule_class()
+    except (TypeError, AttributeError):
+        return None
+
+
+def _is_rule_class(obj: Any) -> bool:
+    """Check if an object is a valid rule class.
+
+    Args:
+        obj: Object to check
+
+    Returns:
+        True if obj is a concrete BaseLintRule subclass
+    """
+    return (
+        inspect.isclass(obj)
+        and issubclass(obj, BaseLintRule)
+        and obj is not BaseLintRule
+        and not inspect.isabstract(obj)
+    )
+
+
+# Legacy class wrapper for backward compatibility
+class RuleDiscovery:
+    """Discovers linting rules from Python packages.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the discovery service."""
+        pass  # No state needed
+
+    def discover_from_package(self, package_path: str) -> list[BaseLintRule]:
+        """Discover rules from a package and its modules.
 
         Args:
-            obj: Object to check
+            package_path: Python package path (e.g., 'src.linters')
 
         Returns:
-            True if obj is a concrete BaseLintRule subclass
+            List of discovered rule instances
         """
-        return (
-            inspect.isclass(obj)
-            and issubclass(obj, BaseLintRule)
-            and obj is not BaseLintRule
-            and not inspect.isabstract(obj)
-        )
+        return discover_from_package(package_path)

src/core/violation_builder.py

@@ -13,13 +13,14 @@ Overview: Provides base classes and data structures for violation creation acros
 
 Dependencies: dataclasses, src.core.types (Violation, Severity)
 
-Exports: ViolationInfo dataclass, BaseViolationBuilder class
+Exports: ViolationInfo dataclass, build_violation function, build_violation_from_params function,
+    BaseViolationBuilder class (compat)
 
 Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
-    BaseViolationBuilder.build(info: ViolationInfo) -> Violation
+    build_violation(info: ViolationInfo) -> Violation
 
-Implementation: Uses dataclass for type-safe violation info, base class provides build()
-    method that constructs Violation objects with proper defaults
+Implementation: Uses dataclass for type-safe violation info, functions provide build logic
+    that constructs Violation objects with proper defaults
 """
 
 from dataclasses import dataclass
@@ -50,14 +51,82 @@ class ViolationInfo:
     suggestion: str | None = None
 
 
+def build_violation(info: ViolationInfo) -> Violation:
+    """Build a Violation from ViolationInfo.
+
+    Args:
+        info: ViolationInfo containing all violation details
+
+    Returns:
+        Violation object with all fields populated
+    """
+    return Violation(
+        rule_id=info.rule_id,
+        file_path=info.file_path,
+        line=info.line,
+        column=info.column,
+        message=info.message,
+        severity=info.severity,
+        suggestion=info.suggestion,
+    )
+
+
+def build_violation_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    rule_id: str,
+    file_path: str,
+    line: int,
+    message: str,
+    column: int = 1,
+    severity: Severity = Severity.ERROR,
+    suggestion: str | None = None,
+) -> Violation:
+    """Build a Violation directly from parameters.
+
+    Note: Pylint too-many-arguments disabled. This convenience function mirrors the
+    ViolationInfo dataclass fields (7 parameters, 3 with defaults). The alternative
+    would require every caller to create ViolationInfo objects manually, reducing
+    readability.
+
+    Args:
+        rule_id: Identifier for the rule that was violated
+        file_path: Path to the file containing the violation
+        line: Line number where violation occurs (1-indexed)
+        message: Description of the violation
+        column: Column number where violation occurs (0-indexed, default=1)
+        severity: Severity level of the violation (default=ERROR)
+        suggestion: Optional suggestion for fixing the violation
+
+    Returns:
+        Violation object with all fields populated
+    """
+    info = ViolationInfo(
+        rule_id=rule_id,
+        file_path=file_path,
+        line=line,
+        message=message,
+        column=column,
+        severity=severity,
+        suggestion=suggestion,
+    )
+    return build_violation(info)
+
+
+# Legacy class wrapper for backward compatibility
 class BaseViolationBuilder:
     """Base class for building violations with consistent structure.
 
     Provides common build() method for creating Violation objects from ViolationInfo.
     Linter-specific builders extend this class to add their domain-specific violation
     creation methods while inheriting the common construction logic.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
     """
 
+    def __init__(self) -> None:
+        """Initialize the builder."""
+        pass  # No state needed
+
     def build(self, info: ViolationInfo) -> Violation:
         """Build a Violation from ViolationInfo.
 
@@ -67,15 +136,7 @@ class BaseViolationBuilder:
         Returns:
             Violation object with all fields populated
         """
-        return Violation(
-            rule_id=info.rule_id,
-            file_path=info.file_path,
-            line=info.line,
-            column=info.column,
-            message=info.message,
-            severity=info.severity,
-            suggestion=info.suggestion,
-        )
+        return build_violation(info)
 
     def build_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
@@ -110,7 +171,7 @@ class BaseViolationBuilder:
         Returns:
             Violation object with all fields populated
         """
-        info = ViolationInfo(
+        return build_violation_from_params(
             rule_id=rule_id,
             file_path=file_path,
             line=line,
@@ -119,4 +180,3 @@ class BaseViolationBuilder:
             severity=severity,
             suggestion=suggestion,
         )
-        return self.build(info)