thailint 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/linters/nesting/violation_builder.py

@@ -0,0 +1,139 @@
+"""
+Purpose: Violation creation for nesting depth linter
+
+Scope: Builds Violation objects for nesting depth violations
+
+Overview: Provides violation building functionality for the nesting depth linter. Creates
+    violations for Python and TypeScript functions with excessive nesting, generates contextual
+    error messages with actual vs maximum depth, and provides actionable refactoring suggestions
+    (early returns, guard clauses, extract method). Handles syntax errors gracefully. Isolates
+    violation construction from analysis and checking logic.
+
+Dependencies: ast, BaseLintContext, Violation, Severity, NestingConfig, src.core.violation_builder
+
+Exports: NestingViolationBuilder
+
+Interfaces: create_nesting_violation, create_typescript_nesting_violation, create_syntax_error_violation
+
+Implementation: Formats messages with depth information, provides targeted refactoring suggestions,
+    extends BaseViolationBuilder for consistent violation construction
+"""
+
+import ast
+from typing import Any
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+from src.core.violation_builder import BaseViolationBuilder
+
+from .config import NestingConfig
+
+
+class NestingViolationBuilder(BaseViolationBuilder):
+    """Builds violations for nesting depth issues."""
+
+    def __init__(self, rule_id: str):
+        """Initialize violation builder.
+
+        Args:
+            rule_id: Rule identifier for violations
+        """
+        self.rule_id = rule_id
+
+    def create_syntax_error_violation(
+        self, error: SyntaxError, context: BaseLintContext
+    ) -> Violation:
+        """Create violation for syntax error.
+
+        Args:
+            error: SyntaxError exception
+            context: Lint context
+
+        Returns:
+            Syntax error violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=error.lineno or 0,
+            column=error.offset or 0,
+            message=f"Syntax error: {error.msg}",
+            severity=Severity.ERROR,
+            suggestion="Fix syntax errors before checking nesting depth",
+        )
+
+    def create_nesting_violation(
+        self,
+        func: ast.FunctionDef | ast.AsyncFunctionDef,
+        max_depth: int,
+        config: NestingConfig,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for excessive nesting in Python function.
+
+        Args:
+            func: Python function AST node
+            max_depth: Actual max nesting depth found
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            Nesting depth violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=func.lineno,
+            column=func.col_offset,
+            message=f"Function '{func.name}' has excessive nesting depth ({max_depth})",
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
+        )
+
+    def create_typescript_nesting_violation(
+        self,
+        func_info: tuple[Any, str],
+        max_depth: int,
+        config: NestingConfig,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for excessive nesting in TypeScript function.
+
+        Args:
+            func_info: Tuple of (func_node, func_name)
+            max_depth: Actual max nesting depth found
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            Nesting depth violation
+        """
+        func_node, func_name = func_info
+        line = func_node.start_point[0] + 1  # Convert to 1-indexed
+        column = func_node.start_point[1]
+
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=line,
+            column=column,
+            message=f"Function '{func_name}' has excessive nesting depth ({max_depth})",
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
+        )
+
+    def _generate_suggestion(self, actual_depth: int, max_depth: int) -> str:
+        """Generate refactoring suggestion based on depth.
+
+        Args:
+            actual_depth: Actual nesting depth found
+            max_depth: Maximum allowed depth
+
+        Returns:
+            Suggestion string with refactoring advice
+        """
+        return (
+            f"Maximum nesting depth of {actual_depth} exceeds limit of {max_depth}. "
+            "Consider extracting nested logic to separate functions, using early returns, "
+            "or applying guard clauses to reduce nesting."
+        )

src/linters/srp/__init__.py

@@ -0,0 +1,99 @@
+"""
+Purpose: SRP linter package initialization
+
+Scope: Exports for Single Responsibility Principle linter module
+
+Overview: Initializes the SRP linter package and exposes the main rule class for external use.
+    Exports SRPRule as the primary interface for the SRP linter, allowing the orchestrator to
+    discover and instantiate the rule. Also exports configuration and analyzer classes for
+    advanced use cases. Provides a convenience lint() function for direct usage without
+    orchestrator setup. This module serves as the entry point for the SRP linter functionality
+    within the thai-lint framework, enabling detection of classes with too many responsibilities.
+
+Dependencies: SRPRule, SRPConfig, PythonSRPAnalyzer, TypeScriptSRPAnalyzer
+
+Exports: SRPRule (primary), SRPConfig, PythonSRPAnalyzer, TypeScriptSRPAnalyzer, lint
+
+Interfaces: Standard Python package initialization with __all__ for explicit exports, lint() convenience function
+
+Implementation: Simple re-export pattern for package interface, convenience function wraps orchestrator
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .config import SRPConfig
+from .linter import SRPRule
+from .python_analyzer import PythonSRPAnalyzer
+from .typescript_analyzer import TypeScriptSRPAnalyzer
+
+__all__ = [
+    "SRPRule",
+    "SRPConfig",
+    "PythonSRPAnalyzer",
+    "TypeScriptSRPAnalyzer",
+    "lint",
+]
+
+
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+    max_methods: int = 7,
+    max_loc: int = 200,
+) -> list:
+    """Lint a file or directory for SRP violations.
+
+    Args:
+        path: Path to file or directory to lint
+        config: Configuration dict (optional, uses defaults if not provided)
+        max_methods: Maximum allowed methods per class (default: 7)
+        max_loc: Maximum allowed lines of code per class (default: 200)
+
+    Returns:
+        List of violations found
+
+    Example:
+        >>> from src.linters.srp import lint
+        >>> violations = lint('src/my_module.py', max_methods=5)
+        >>> for v in violations:
+        ...     print(f"{v.file_path}:{v.line} - {v.message}")
+    """
+    path_obj = Path(path) if isinstance(path, str) else path
+    project_root = path_obj if path_obj.is_dir() else path_obj.parent
+
+    orchestrator = _setup_srp_orchestrator(project_root, config, max_methods, max_loc)
+    violations = _execute_srp_lint(orchestrator, path_obj)
+
+    return [v for v in violations if "srp" in v.rule_id]
+
+
+def _setup_srp_orchestrator(
+    project_root: Path,
+    config: dict[str, Any] | None,
+    max_methods: int,
+    max_loc: int,
+) -> Any:
+    """Set up orchestrator with SRP config."""
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config:
+        orchestrator.config["srp"] = config
+    else:
+        orchestrator.config["srp"] = {
+            "max_methods": max_methods,
+            "max_loc": max_loc,
+        }
+
+    return orchestrator
+
+
+def _execute_srp_lint(orchestrator: Any, path_obj: Path) -> list:
+    """Execute linting on file or directory."""
+    if path_obj.is_file():
+        return orchestrator.lint_file(path_obj)
+    if path_obj.is_dir():
+        return orchestrator.lint_directory(path_obj)
+    return []

src/linters/srp/class_analyzer.py

@@ -0,0 +1,113 @@
+"""
+Purpose: Class analysis coordination for SRP linter
+
+Scope: Coordinates Python and TypeScript class analysis
+
+Overview: Provides unified class analysis interface for the SRP linter. Delegates to language-
+    specific analyzers (PythonSRPAnalyzer, TypeScriptSRPAnalyzer) based on language type.
+    Handles syntax error gracefully and extracts class metrics for SRP evaluation. Isolates
+    language-specific analysis logic from rule checking and violation building.
+
+Dependencies: ast, PythonSRPAnalyzer, TypeScriptSRPAnalyzer, BaseLintContext, SRPConfig
+
+Exports: ClassAnalyzer
+
+Interfaces: analyze_python(context, config) -> list[dict], analyze_typescript(context, config) -> list[dict]
+
+Implementation: Delegates to language-specific analyzers, returns normalized metrics dicts
+"""
+
+import ast
+from typing import Any
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+
+from .config import SRPConfig
+from .python_analyzer import PythonSRPAnalyzer
+from .typescript_analyzer import TypeScriptSRPAnalyzer
+
+
+class ClassAnalyzer:
+    """Coordinates class analysis for Python and TypeScript."""
+
+    def analyze_python(
+        self, context: BaseLintContext, config: SRPConfig
+    ) -> list[dict[str, Any]] | list[Violation]:
+        """Analyze Python classes and return metrics or syntax errors.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of class metrics dicts, or list of syntax error violations
+        """
+        tree = self._parse_python_safely(context)
+        if isinstance(tree, list):  # Syntax error violations
+            return tree
+
+        analyzer = PythonSRPAnalyzer()
+        classes = analyzer.find_all_classes(tree)
+        return [
+            analyzer.analyze_class(class_node, context.file_content or "", config)
+            for class_node in classes
+        ]
+
+    def analyze_typescript(
+        self, context: BaseLintContext, config: SRPConfig
+    ) -> list[dict[str, Any]]:
+        """Analyze TypeScript classes and return metrics.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of class metrics dicts
+        """
+        analyzer = TypeScriptSRPAnalyzer()
+        root_node = analyzer.parse_typescript(context.file_content or "")
+        if not root_node:
+            return []
+
+        classes = analyzer.find_all_classes(root_node)
+        return [
+            analyzer.analyze_class(class_node, context.file_content or "", config)
+            for class_node in classes
+        ]
+
+    def _parse_python_safely(self, context: BaseLintContext) -> ast.AST | list[Violation]:
+        """Parse Python code and return AST or syntax error violations.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            AST if successful, list of syntax error violations otherwise
+        """
+        try:
+            return ast.parse(context.file_content or "")
+        except SyntaxError as exc:
+            return [self._create_syntax_error_violation(exc, context)]
+
+    def _create_syntax_error_violation(
+        self, exc: SyntaxError, context: BaseLintContext
+    ) -> Violation:
+        """Create syntax error violation.
+
+        Args:
+            exc: SyntaxError exception
+            context: Lint context
+
+        Returns:
+            Syntax error violation
+        """
+        return Violation(
+            rule_id="srp.syntax-error",
+            file_path=str(context.file_path or ""),
+            line=exc.lineno or 1,
+            column=exc.offset or 0,
+            message=f"Syntax error: {exc.msg}",
+            severity=Severity.ERROR,
+        )

src/linters/srp/config.py

@@ -0,0 +1,76 @@
+"""
+Purpose: Configuration schema for Single Responsibility Principle linter
+
+Scope: SRPConfig dataclass with max_methods, max_loc, and keyword settings
+
+Overview: Defines configuration schema for SRP linter. Provides SRPConfig dataclass with
+    max_methods field (default 7), max_loc field (default 200), and check_keywords flag
+    (default True) with configurable responsibility keywords. Supports per-file and
+    per-directory config overrides. Validates that thresholds are positive integers.
+    Integrates with the orchestrator's configuration system to allow users to customize
+    SRP thresholds via .thailint.yaml configuration files. Keywords list identifies
+    generic class names that often indicate SRP violations (Manager, Handler, etc.).
+
+Dependencies: dataclasses, typing
+
+Exports: SRPConfig dataclass
+
+Interfaces: SRPConfig(max_methods, max_loc, check_keywords, keywords), from_dict class method
+
+Implementation: Dataclass with validation and defaults, heuristic-based SRP detection thresholds
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class SRPConfig:
+    """Configuration for SRP linter."""
+
+    max_methods: int = 7  # Maximum methods per class
+    max_loc: int = 200  # Maximum lines of code per class
+    enabled: bool = True
+    check_keywords: bool = True
+    keywords: list[str] = field(
+        default_factory=lambda: ["Manager", "Handler", "Processor", "Utility", "Helper"]
+    )
+    ignore: list[str] = field(default_factory=list)  # Path patterns to ignore
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.max_methods <= 0:
+            raise ValueError(f"max_methods must be positive, got {self.max_methods}")
+        if self.max_loc <= 0:
+            raise ValueError(f"max_loc must be positive, got {self.max_loc}")
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "SRPConfig":
+        """Load configuration from dictionary with language-specific overrides.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (python, typescript, javascript) for language-specific thresholds
+
+        Returns:
+            SRPConfig instance with values from dictionary
+        """
+        # Get language-specific config if available
+        if language and language in config:
+            lang_config = config[language]
+            max_methods = lang_config.get("max_methods", config.get("max_methods", 7))
+            max_loc = lang_config.get("max_loc", config.get("max_loc", 200))
+        else:
+            max_methods = config.get("max_methods", 7)
+            max_loc = config.get("max_loc", 200)
+
+        return cls(
+            max_methods=max_methods,
+            max_loc=max_loc,
+            enabled=config.get("enabled", True),
+            check_keywords=config.get("check_keywords", True),
+            keywords=config.get(
+                "keywords", ["Manager", "Handler", "Processor", "Utility", "Helper"]
+            ),
+            ignore=config.get("ignore", []),
+        )

src/linters/srp/heuristics.py

@@ -0,0 +1,89 @@
+"""
+Purpose: SRP detection heuristics for analyzing code complexity and responsibility
+
+Scope: Helper functions for method counting, LOC calculation, and keyword detection
+
+Overview: Provides heuristic-based analysis functions for detecting Single Responsibility
+    Principle violations. Implements method counting that excludes property decorators and
+    special methods. Provides LOC calculation that filters out blank lines and comments.
+    Includes keyword detection for identifying generic class names that often indicate SRP
+    violations (Manager, Handler, etc.). Supports both Python AST and TypeScript tree-sitter
+    nodes. These heuristics enable practical SRP detection without requiring perfect semantic
+    analysis, focusing on measurable code metrics that correlate with responsibility scope.
+
+Dependencies: ast module for Python AST analysis, typing for type hints
+
+Exports: count_methods, count_loc, has_responsibility_keyword, has_property_decorator
+
+Interfaces: Functions accepting AST nodes and returning metrics (int, bool)
+
+Implementation: AST walking with filtering logic, heuristic-based thresholds
+"""
+
+import ast
+
+
+def count_methods(class_node: ast.ClassDef) -> int:
+    """Count methods in a class (excludes properties and special methods).
+
+    Args:
+        class_node: AST node representing a class definition
+
+    Returns:
+        Number of methods in the class
+    """
+    methods = 0
+    for node in class_node.body:
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        # Don't count @property decorators as methods
+        if not has_property_decorator(node):
+            methods += 1
+    return methods
+
+
+def count_loc(class_node: ast.ClassDef, source: str) -> int:
+    """Count lines of code in a class (excludes blank lines and comments).
+
+    Args:
+        class_node: AST node representing a class definition
+        source: Full source code of the file
+
+    Returns:
+        Number of code lines in the class
+    """
+    start_line = class_node.lineno
+    end_line = class_node.end_lineno or start_line
+    lines = source.split("\n")[start_line - 1 : end_line]
+
+    # Filter out blank lines and comments
+    code_lines = [line for line in lines if line.strip() and not line.strip().startswith("#")]
+    return len(code_lines)
+
+
+def has_responsibility_keyword(class_name: str, keywords: list[str]) -> bool:
+    """Check if class name contains responsibility keywords.
+
+    Args:
+        class_name: Name of the class to check
+        keywords: List of keywords indicating potential SRP violations
+
+    Returns:
+        True if class name contains any responsibility keyword
+    """
+    return any(keyword in class_name for keyword in keywords)
+
+
+def has_property_decorator(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if function has @property decorator.
+
+    Args:
+        func_node: AST node representing a function definition
+
+    Returns:
+        True if function has @property decorator
+    """
+    for decorator in func_node.decorator_list:
+        if isinstance(decorator, ast.Name) and decorator.id == "property":
+            return True
+    return False