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

src/linters/srp/linter.py

@@ -0,0 +1,225 @@
+"""
+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, BaseLintRule
+from src.core.linter_utils import has_file_content, 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(BaseLintRule):
+    """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.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        if not self._should_check_file(context):
+            return []
+
+        config = load_linter_config(context, "srp", SRPConfig)
+        if not self._is_linter_enabled(context, config):
+            return []
+
+        return self._check_by_language(context, config)
+
+    def _should_check_file(self, context: BaseLintContext) -> bool:
+        """Check if file has content to analyze.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if file should be checked
+        """
+        return has_file_content(context)
+
+    def _is_linter_enabled(self, context: BaseLintContext, config: SRPConfig) -> bool:
+        """Check if linter is enabled and file is not ignored.
+
+        Args:
+            context: Lint context
+            config: SRP configuration
+
+        Returns:
+            True if linter should run on this file
+        """
+        return config.enabled and not self._is_file_ignored(context, config)
+
+    def _check_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 _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
+        )

src/linters/srp/violation_builder.py

@@ -0,0 +1,117 @@
+"""
+Purpose: Violation creation with suggestions for SRP linter
+
+Scope: Builds Violation objects with contextual messages and refactoring suggestions
+
+Overview: Provides violation building functionality for the SRP linter. Creates violations
+    from class metrics and issue descriptions, generates contextual error messages, and
+    provides actionable refactoring suggestions based on issue types (methods, lines, keywords).
+    Isolates violation construction and suggestion generation from metrics evaluation and
+    class analysis to maintain single responsibility.
+
+Dependencies: BaseLintContext, Violation, Severity, typing, src.core.violation_builder
+
+Exports: ViolationBuilder
+
+Interfaces: build_violation(metrics, issues, rule_id, context) -> Violation
+
+Implementation: Formats messages from metrics, generates targeted suggestions per issue type,
+    extends BaseViolationBuilder for consistent violation construction
+"""
+
+from typing import Any
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+from src.core.violation_builder import BaseViolationBuilder, ViolationInfo
+
+
+class ViolationBuilder(BaseViolationBuilder):
+    """Builds SRP violations with messages and suggestions."""
+
+    def build_violation(
+        self,
+        metrics: dict[str, Any],
+        issues: list[str],
+        rule_id: str,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Build violation from metrics and issues.
+
+        Args:
+            metrics: Class metrics dictionary
+            issues: List of issue descriptions
+            rule_id: Rule identifier
+            context: Lint context
+
+        Returns:
+            Violation with message and suggestion
+        """
+        message = f"Class '{metrics['class_name']}' may violate SRP: {', '.join(issues)}"
+        suggestion = self._generate_suggestion(issues)
+
+        info = ViolationInfo(
+            rule_id=rule_id,
+            file_path=str(context.file_path or ""),
+            line=metrics["line"],
+            column=metrics["column"],
+            message=message,
+            severity=Severity.ERROR,
+            suggestion=suggestion,
+        )
+        return self.build(info)
+
+    def _generate_suggestion(self, issues: list[str]) -> str:
+        """Generate refactoring suggestion based on issues.
+
+        Args:
+            issues: List of issue descriptions
+
+        Returns:
+            Suggestion string with refactoring advice
+        """
+        suggestions = [
+            self._suggest_for_methods(issues),
+            self._suggest_for_lines(issues),
+            self._suggest_for_keywords(issues),
+        ]
+        return ". ".join(filter(None, suggestions))
+
+    def _suggest_for_methods(self, issues: list[str]) -> str:
+        """Suggest fix for too many methods.
+
+        Args:
+            issues: List of issue descriptions
+
+        Returns:
+            Suggestion string or empty string
+        """
+        if any("methods" in issue for issue in issues):
+            return "Consider extracting related methods into separate classes"
+        return ""
+
+    def _suggest_for_lines(self, issues: list[str]) -> str:
+        """Suggest fix for too many lines.
+
+        Args:
+            issues: List of issue descriptions
+
+        Returns:
+            Suggestion string or empty string
+        """
+        if any("lines" in issue for issue in issues):
+            return "Consider breaking the class into smaller, focused classes"
+        return ""
+
+    def _suggest_for_keywords(self, issues: list[str]) -> str:
+        """Suggest fix for responsibility keywords.
+
+        Args:
+            issues: List of issue descriptions
+
+        Returns:
+            Suggestion string or empty string
+        """
+        if any("keyword" in issue for issue in issues):
+            return "Avoid generic names like Manager, Handler, Processor"
+        return ""