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

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

src/linters/srp/linter.py

@@ -0,0 +1,234 @@
+"""
+Purpose: Main SRP linter rule implementation
+
+Scope: SRPRule class implementing BaseLintRule interface
+
+Overview: Implements Single Responsibility Principle linter rule following BaseLintRule interface.
+    Orchestrates configuration loading, class analysis, metrics evaluation, and violation building
+    through focused helper classes. Detects classes with too many methods, excessive lines of code,
+    or generic naming patterns. Supports configurable thresholds and ignore directives. Handles both
+    Python and TypeScript code analysis. Main rule class acts as coordinator for SRP checking workflow.
+
+Dependencies: BaseLintRule, BaseLintContext, Violation, ClassAnalyzer, MetricsEvaluator, ViolationBuilder
+
+Exports: SRPRule class
+
+Interfaces: SRPRule.check(context) -> list[Violation], properties for rule metadata
+
+Implementation: Composition pattern with helper classes, heuristic-based SRP analysis
+"""
+
+from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.linter_utils import load_linter_config
+from src.core.types import Violation
+from src.linter_config.ignore import IgnoreDirectiveParser
+
+from .class_analyzer import ClassAnalyzer
+from .config import SRPConfig
+from .metrics_evaluator import evaluate_metrics
+from .violation_builder import ViolationBuilder
+
+
+class SRPRule(MultiLanguageLintRule):
+    """Detects Single Responsibility Principle violations in classes."""
+
+    def __init__(self) -> None:
+        """Initialize the SRP rule."""
+        self._ignore_parser = IgnoreDirectiveParser()
+        self._class_analyzer = ClassAnalyzer()
+        self._violation_builder = ViolationBuilder()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "srp.violation"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Single Responsibility Principle"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Classes should have a single, well-defined responsibility"
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for SRP violations with custom ignore pattern handling.
+
+        Overrides parent to add file-level ignore pattern checking before dispatch.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        from src.core.linter_utils import has_file_content
+
+        if not has_file_content(context):
+            return []
+
+        config = self._load_config(context)
+        if not self._should_process_file(context, config):
+            return []
+
+        # Standard language dispatch
+        return self._dispatch_by_language(context, config)
+
+    def _should_process_file(self, context: BaseLintContext, config: SRPConfig) -> bool:
+        """Check if file should be processed.
+
+        Args:
+            context: Lint context
+            config: SRP configuration
+
+        Returns:
+            True if file should be processed
+        """
+        if not config.enabled:
+            return False
+        return not self._is_file_ignored(context, config)
+
+    def _dispatch_by_language(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+        """Dispatch to language-specific checker.
+
+        Args:
+            context: Lint context
+            config: SRP configuration
+
+        Returns:
+            List of violations found
+        """
+        if context.language == "python":
+            return self._check_python(context, config)
+
+        if context.language in ("typescript", "javascript"):
+            return self._check_typescript(context, config)
+
+        return []
+
+    def _load_config(self, context: BaseLintContext) -> SRPConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            SRPConfig instance
+        """
+        return load_linter_config(context, "srp", SRPConfig)
+
+    def _is_file_ignored(self, context: BaseLintContext, config: SRPConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: SRP configuration
+
+        Returns:
+            True if file should be ignored
+        """
+        if not config.ignore:
+            return False
+
+        file_path = str(context.file_path)
+        for pattern in config.ignore:
+            if pattern in file_path:
+                return True
+        return False
+
+    def _check_python(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+        """Check Python code for SRP violations.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of violations found
+        """
+        results = self._class_analyzer.analyze_python(context, config)
+        if results and isinstance(results[0], Violation):  # Syntax errors
+            return results  # type: ignore[return-value]
+
+        return self._build_violations_from_metrics(results, config, context)
+
+    def _build_violations_from_metrics(
+        self,
+        metrics_list: list,
+        config: SRPConfig,
+        context: BaseLintContext,
+    ) -> list[Violation]:
+        """Build violations from class metrics.
+
+        Args:
+            metrics_list: List of class metrics
+            config: SRP configuration
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for metrics in metrics_list:
+            if not isinstance(metrics, dict):
+                continue
+            violation = self._create_violation_if_needed(metrics, config, context)
+            if violation:
+                violations.append(violation)
+        return violations
+
+    def _create_violation_if_needed(
+        self,
+        metrics: dict,
+        config: SRPConfig,
+        context: BaseLintContext,
+    ) -> Violation | None:
+        """Create violation if metrics exceed thresholds.
+
+        Args:
+            metrics: Class metrics dictionary
+            config: SRP configuration
+            context: Lint context
+
+        Returns:
+            Violation or None if no issues or should be ignored
+        """
+        issues = evaluate_metrics(metrics, config)
+        if not issues:
+            return None
+
+        violation = self._violation_builder.build_violation(metrics, issues, self.rule_id, context)
+        if self._should_ignore(violation, context):
+            return None
+
+        return violation
+
+    def _check_typescript(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+        """Check TypeScript code for SRP violations.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of violations found
+        """
+        metrics_list = self._class_analyzer.analyze_typescript(context, config)
+        return self._build_violations_from_metrics(metrics_list, config, context)
+
+    def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if violation should be ignored based on inline directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context with file content
+
+        Returns:
+            True if violation should be ignored
+        """
+        if context.file_content is None:
+            return False
+
+        return self._ignore_parser.should_ignore_violation(violation, context.file_content)

src/linters/srp/metrics_evaluator.py

@@ -0,0 +1,47 @@
+"""
+Purpose: SRP metrics evaluation against configured thresholds
+
+Scope: Evaluates class metrics to determine SRP violations
+
+Overview: Provides metrics evaluation functionality for the SRP linter. Checks class metrics
+    (method count, lines of code, naming keywords) against configured thresholds. Collects
+    issues when metrics exceed limits. Isolates threshold evaluation logic from class analysis
+    and violation building to maintain single responsibility.
+
+Dependencies: SRPConfig, typing
+
+Exports: evaluate_metrics
+
+Interfaces: evaluate_metrics(metrics, config) -> list[str] (returns list of issue descriptions)
+
+Implementation: Compares numeric thresholds and keyword patterns, returns descriptive issue strings
+"""
+
+from typing import Any
+
+from .config import SRPConfig
+
+
+def evaluate_metrics(metrics: dict[str, Any], config: SRPConfig) -> list[str]:
+    """Evaluate class metrics and collect SRP issues.
+
+    Args:
+        metrics: Class metrics dictionary with method_count, loc, has_keyword
+        config: SRP configuration with thresholds
+
+    Returns:
+        List of issue descriptions (empty if no violations)
+    """
+    issues = []
+
+    # Check numeric thresholds
+    if metrics["method_count"] > config.max_methods:
+        issues.append(f"{metrics['method_count']} methods (max: {config.max_methods})")
+    if metrics["loc"] > config.max_loc:
+        issues.append(f"{metrics['loc']} lines (max: {config.max_loc})")
+
+    # Check keyword heuristic
+    if config.check_keywords and metrics["has_keyword"]:
+        issues.append("responsibility keyword in name")
+
+    return issues

src/linters/srp/python_analyzer.py

@@ -0,0 +1,72 @@
+"""
+Purpose: Python AST analyzer for detecting SRP violations in Python classes
+
+Scope: PythonSRPAnalyzer class for analyzing Python classes using AST
+
+Overview: Implements Python-specific SRP analysis using the ast module to parse and analyze
+    class definitions. Walks the AST to find all class definitions, then analyzes each class
+    for SRP violation indicators: method count, lines of code, and responsibility keywords.
+    Collects comprehensive metrics including class name, method count, LOC, keyword presence,
+    and location information (line, column). Integrates with heuristics module for metric
+    calculation. Returns structured metric dictionaries that the main linter uses to create
+    violations. Handles nested classes by analyzing all classes in the tree.
+
+Dependencies: ast module for Python AST parsing, typing for type hints, heuristics module
+
+Exports: PythonSRPAnalyzer class
+
+Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
+
+Implementation: AST walking pattern, metric collection, integration with heuristics module
+"""
+
+import ast
+from typing import Any
+
+from .config import SRPConfig
+from .heuristics import count_loc, count_methods, has_responsibility_keyword
+
+
+class PythonSRPAnalyzer:
+    """Analyzes Python classes for SRP violations."""
+
+    def find_all_classes(self, tree: ast.AST) -> list[ast.ClassDef]:
+        """Find all class definitions in AST.
+
+        Args:
+            tree: Root AST node to search
+
+        Returns:
+            List of all class definition nodes
+        """
+        classes = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                classes.append(node)
+        return classes
+
+    def analyze_class(
+        self, class_node: ast.ClassDef, source: str, config: SRPConfig
+    ) -> dict[str, Any]:
+        """Analyze a class for SRP metrics.
+
+        Args:
+            class_node: AST node representing a class definition
+            source: Full source code of the file
+            config: SRP configuration with thresholds and keywords
+
+        Returns:
+            Dictionary with class metrics (name, method_count, loc, etc.)
+        """
+        method_count = count_methods(class_node)
+        loc = count_loc(class_node, source)
+        has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
+
+        return {
+            "class_name": class_node.name,
+            "method_count": method_count,
+            "loc": loc,
+            "has_keyword": has_keyword,
+            "line": class_node.lineno,
+            "column": class_node.col_offset,
+        }

src/linters/srp/typescript_analyzer.py

@@ -0,0 +1,75 @@
+"""
+Purpose: TypeScript AST analyzer for detecting SRP violations in TypeScript classes
+
+Scope: TypeScriptSRPAnalyzer class for analyzing TypeScript classes using tree-sitter
+
+Overview: Implements TypeScript-specific SRP analysis using tree-sitter parser. Extends
+    TypeScriptBaseAnalyzer to reuse common tree-sitter initialization and traversal patterns.
+    Walks the AST to find all class declarations, analyzes each class for SRP violation
+    indicators using metrics calculator helper. Collects comprehensive metrics including
+    class name, method count, LOC, keyword presence, and location information. Delegates
+    metrics calculation to TypeScriptMetricsCalculator.
+
+Dependencies: TypeScriptBaseAnalyzer, TypeScriptMetricsCalculator, SRPConfig
+
+Exports: TypeScriptSRPAnalyzer class
+
+Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
+
+Implementation: Inherits tree-sitter parsing from base, composition with metrics calculator
+"""
+
+from typing import Any
+
+from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
+from .config import SRPConfig
+from .typescript_metrics_calculator import TypeScriptMetricsCalculator
+
+
+class TypeScriptSRPAnalyzer(TypeScriptBaseAnalyzer):
+    """Analyzes TypeScript classes for SRP violations."""
+
+    def __init__(self) -> None:
+        """Initialize analyzer with metrics calculator."""
+        super().__init__()
+        self.metrics_calculator = TypeScriptMetricsCalculator()
+
+    def find_all_classes(self, root_node: Any) -> list[Any]:
+        """Find all class declarations in TypeScript AST.
+
+        Args:
+            root_node: Root tree-sitter node to search
+
+        Returns:
+            List of all class declaration nodes
+        """
+        return self.walk_tree(root_node, "class_declaration")
+
+    def analyze_class(self, class_node: Any, source: str, config: SRPConfig) -> dict[str, Any]:
+        """Analyze a TypeScript class for SRP metrics.
+
+        Args:
+            class_node: Tree-sitter node representing a class declaration
+            source: Full source code of the file
+            config: SRP configuration with thresholds and keywords
+
+        Returns:
+            Dictionary with class metrics (name, method_count, loc, etc.)
+        """
+        class_name = self.extract_identifier_name(class_node)
+        if class_name == "anonymous":
+            class_name = "UnnamedClass"
+
+        method_count = self.metrics_calculator.count_methods(class_node)
+        loc = self.metrics_calculator.count_loc(class_node, source)
+        has_keyword = any(keyword in class_name for keyword in config.keywords)
+
+        return {
+            "class_name": class_name,
+            "method_count": method_count,
+            "loc": loc,
+            "has_keyword": has_keyword,
+            "line": class_node.start_point[0] + 1,
+            "column": class_node.start_point[1],
+        }

src/linters/srp/typescript_metrics_calculator.py

@@ -0,0 +1,90 @@
+"""
+Purpose: TypeScript class metrics calculation for SRP analysis
+
+Scope: Calculates method count and lines of code for TypeScript classes
+
+Overview: Provides metrics calculation functionality for TypeScript classes in SRP analysis. Counts
+    public methods in class bodies (excludes constructors), calculates lines of code from AST node
+    positions, and identifies class body nodes. Uses tree-sitter AST node types. Isolates metrics
+    calculation from class analysis and tree traversal logic.
+
+Dependencies: typing
+
+Exports: TypeScriptMetricsCalculator
+
+Interfaces: count_methods(class_node), count_loc(class_node, source)
+
+Implementation: Tree-sitter node type matching, AST position arithmetic
+"""
+
+from typing import Any
+
+
+class TypeScriptMetricsCalculator:
+    """Calculates metrics for TypeScript classes."""
+
+    def count_methods(self, class_node: Any) -> int:
+        """Count number of methods in a TypeScript class.
+
+        Args:
+            class_node: Class declaration tree-sitter node
+
+        Returns:
+            Number of public methods (excludes constructor)
+        """
+        class_body = self._get_class_body(class_node)
+        if not class_body:
+            return 0
+
+        method_count = 0
+        for child in class_body.children:
+            if self._is_countable_method(child):
+                method_count += 1
+
+        return method_count
+
+    def count_loc(self, class_node: Any, source: str) -> int:
+        """Count lines of code in a TypeScript class.
+
+        Args:
+            class_node: Class declaration tree-sitter node
+            source: Full source code string
+
+        Returns:
+            Number of lines in class definition
+        """
+        start_line = class_node.start_point[0]
+        end_line = class_node.end_point[0]
+        return end_line - start_line + 1
+
+    def _get_class_body(self, class_node: Any) -> Any:
+        """Get the class_body node from a class declaration.
+
+        Args:
+            class_node: Class declaration node
+
+        Returns:
+            Class body node or None
+        """
+        for child in class_node.children:
+            if child.type == "class_body":
+                return child
+        return None
+
+    def _is_countable_method(self, node: Any) -> bool:
+        """Check if node is a method that should be counted.
+
+        Args:
+            node: Tree-sitter node to check
+
+        Returns:
+            True if node is a countable method
+        """
+        if node.type != "method_definition":
+            return False
+
+        # Check if it's a constructor
+        return all(
+            not (child.type == "property_identifier" and child.text.decode() == "constructor")
+            for child in node.children
+        )