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

src/linters/srp/typescript_metrics_calculator.py

@@ -4,13 +4,14 @@ 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.
+    public methods in class bodies (excludes constructors and private methods starting with _),
+    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
+Exports: count_methods function, count_loc function, TypeScriptMetricsCalculator class (compat)
 
 Interfaces: count_methods(class_node), count_loc(class_node, source)
 
@@ -20,8 +21,110 @@ Implementation: Tree-sitter node type matching, AST position arithmetic
 from typing import Any
 
 
+def count_methods(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 = _get_class_body(class_node)
+    if not class_body:
+        return 0
+
+    method_count = 0
+    for child in class_body.children:
+        if _is_countable_method(child):
+            method_count += 1
+
+    return method_count
+
+
+def count_loc(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(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(node: Any) -> bool:
+    """Check if node is a public method that should be counted.
+
+    Excludes constructors and private methods (names starting with _).
+
+    Args:
+        node: Tree-sitter node to check
+
+    Returns:
+        True if node is a countable public method
+    """
+    if node.type != "method_definition":
+        return False
+
+    method_name = _get_method_name(node)
+
+    # Don't count constructors
+    if method_name == "constructor":
+        return False
+
+    # Don't count private methods (underscore prefix convention)
+    if method_name and method_name.startswith("_"):
+        return False
+
+    return True
+
+
+def _get_method_name(node: Any) -> str | None:
+    """Extract method name from method_definition node.
+
+    Args:
+        node: Method definition tree-sitter node
+
+    Returns:
+        Method name or None if not found
+    """
+    for child in node.children:
+        if child.type == "property_identifier":
+            return child.text.decode()
+    return None
+
+
+# Legacy class wrapper for backward compatibility
 class TypeScriptMetricsCalculator:
-    """Calculates metrics for TypeScript classes."""
+    """Calculates metrics for TypeScript classes.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the metrics calculator."""
+        pass  # No state needed
 
     def count_methods(self, class_node: Any) -> int:
         """Count number of methods in a TypeScript class.
@@ -32,16 +135,7 @@ class TypeScriptMetricsCalculator:
         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
+        return count_methods(class_node)
 
     def count_loc(self, class_node: Any, source: str) -> int:
         """Count lines of code in a TypeScript class.
@@ -53,38 +147,4 @@ class TypeScriptMetricsCalculator:
         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
-        )
+        return count_loc(class_node, source)

src/linters/stateless_class/__init__.py

@@ -0,0 +1,25 @@
+"""
+Purpose: Stateless class linter package for detecting classes without state
+
+Scope: Python classes that should be refactored to module-level functions
+
+Overview: Package for detecting Python classes that have no constructor (__init__
+    or __new__) and no instance state (self.attr assignments), indicating they should
+    be refactored to module-level functions. Identifies a common anti-pattern in
+    AI-generated code where classes are used as namespaces rather than for object-
+    oriented encapsulation.
+
+Dependencies: Python AST module, base linter framework
+
+Exports: StatelessClassRule - main rule for detecting stateless classes
+
+Interfaces: StatelessClassRule.check(context) -> list[Violation]
+
+Implementation: AST-based analysis checking for constructor methods and instance
+    attribute assignments while excluding legitimate patterns (ABC, Protocol, decorators)
+"""
+
+from .linter import StatelessClassRule
+from .python_analyzer import ClassInfo, StatelessClassAnalyzer
+
+__all__ = ["StatelessClassRule", "StatelessClassAnalyzer", "ClassInfo"]

src/linters/stateless_class/config.py

@@ -0,0 +1,58 @@
+"""
+Purpose: Configuration schema for stateless-class linter
+
+Scope: Stateless class linter configuration for Python files
+
+Overview: Defines configuration schema for stateless-class linter. Provides
+    StatelessClassConfig dataclass with enabled flag, min_methods threshold (default 2)
+    for determining minimum methods required to flag a class as stateless, and ignore
+    patterns list for excluding specific files or directories. Supports per-file and
+    per-directory config overrides through from_dict class method. Integrates with
+    orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: StatelessClassConfig dataclass
+
+Interfaces: from_dict(config, language) -> StatelessClassConfig for configuration loading
+
+Implementation: Dataclass with defaults matching stateless class detection conventions
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class StatelessClassConfig:
+    """Configuration for stateless-class linter."""
+
+    enabled: bool = True
+    min_methods: int = 2
+    ignore: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "StatelessClassConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            StatelessClassConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            min_methods=config.get("min_methods", 2),
+            ignore=ignore_patterns,
+        )

src/linters/stateless_class/linter.py

@@ -0,0 +1,349 @@
+"""
+Purpose: Main stateless class linter rule implementation
+
+Scope: StatelessClassRule class implementing BaseLintRule interface
+
+Overview: Implements stateless class linter rule following BaseLintRule interface.
+    Detects Python classes that have no constructor (__init__ or __new__), no instance
+    state (self.attr assignments), and 2+ methods - indicating they should be refactored
+    to module-level functions. Delegates AST analysis to StatelessClassAnalyzer. Supports
+    configuration via .thailint.yaml and comprehensive 5-level ignore system including
+    project-level patterns, linter-specific ignore patterns, file-level directives,
+    line-level directives, and block-level directives.
+
+Dependencies: BaseLintRule, BaseLintContext, Violation, StatelessClassAnalyzer,
+    IgnoreDirectiveParser, StatelessClassConfig
+
+Exports: StatelessClassRule class
+
+Interfaces: StatelessClassRule.check(context) -> list[Violation]
+
+Implementation: Composition pattern delegating analysis to specialized analyzer with
+    config loading and comprehensive ignore checking
+
+Suppressions:
+    - B101: Type narrowing assertion after _should_analyze guard (can't fail)
+    - srp,dry: Rule class coordinates analyzer, config, and ignore checking. Method count
+        exceeds limit due to comprehensive 5-level ignore system support.
+"""
+
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, IgnoreDirective, Language
+from src.core.types import Severity, Violation
+from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.rule_matcher import rule_matches
+
+from .config import StatelessClassConfig
+from .python_analyzer import ClassInfo, StatelessClassAnalyzer
+
+
+class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
+    """Detects stateless classes that should be module-level functions."""
+
+    def __init__(self) -> None:
+        """Initialize the rule with analyzer and ignore parser."""
+        self._ignore_parser = get_ignore_parser()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "stateless-class.violation"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Stateless Class Detection"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Classes without state should be refactored to module-level functions"
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for stateless class violations.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        if not self._should_analyze(context):
+            return []
+
+        config = self._load_config(context)
+        if not config.enabled or self._should_skip_file(context, config):
+            return []
+
+        # _should_analyze ensures file_content is set
+        assert context.file_content is not None  # nosec B101
+
+        analyzer = StatelessClassAnalyzer(min_methods=config.min_methods)
+        stateless_classes = analyzer.analyze(context.file_content)
+
+        return self._filter_ignored_violations(stateless_classes, context)
+
+    def _should_skip_file(self, context: BaseLintContext, config: StatelessClassConfig) -> bool:
+        """Check if file should be skipped due to ignore patterns or directives.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be skipped
+        """
+        return self._is_file_ignored(context, config) or self._has_file_level_ignore(context)
+
+    def _should_analyze(self, context: BaseLintContext) -> bool:
+        """Check if context should be analyzed.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if should analyze
+        """
+        return context.language == Language.PYTHON and context.file_content is not None
+
+    def _load_config(self, context: BaseLintContext) -> StatelessClassConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            StatelessClassConfig instance
+        """
+        if not hasattr(context, "config") or context.config is None:
+            return StatelessClassConfig()
+
+        config_dict = context.config
+        if not isinstance(config_dict, dict):
+            return StatelessClassConfig()
+
+        # Check for stateless-class specific config
+        linter_config = config_dict.get("stateless-class", config_dict)
+        return StatelessClassConfig.from_dict(linter_config)
+
+    def _is_file_ignored(self, context: BaseLintContext, config: StatelessClassConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be ignored
+        """
+        if not config.ignore:
+            return False
+
+        if not context.file_path:
+            return False
+
+        file_path = Path(context.file_path)
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
+
+    def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Check if file path matches a glob pattern.
+
+        Args:
+            file_path: Path to check
+            pattern: Glob pattern
+
+        Returns:
+            True if path matches pattern
+        """
+        if file_path.match(pattern):
+            return True
+        if pattern in str(file_path):
+            return True
+        return False
+
+    def _has_file_level_ignore(self, context: BaseLintContext) -> bool:
+        """Check if file has file-level ignore directive.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if file should be ignored at file level
+        """
+        if not context.file_content:
+            return False
+
+        # Check first lines for ignore-file directive
+        lines = context.file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._is_file_ignore_directive(line) for line in lines)
+
+    def _is_file_ignore_directive(self, line: str) -> bool:
+        """Check if line is a file-level ignore directive.
+
+        Args:
+            line: Line to check
+
+        Returns:
+            True if line has file-level ignore for this rule
+        """
+        line_lower = line.lower()
+        if "thailint: ignore-file" not in line_lower:
+            return False
+
+        # Check for general ignore-file (no rule specified)
+        if "ignore-file[" not in line_lower:
+            return True
+
+        # Check for rule-specific ignore
+        return self._matches_rule_ignore(line_lower, "ignore-file")
+
+    def _matches_rule_ignore(self, line: str, directive: str) -> bool:
+        """Check if line matches rule-specific ignore.
+
+        Args:
+            line: Line to check (lowercase)
+            directive: Directive name (ignore-file or ignore)
+
+        Returns:
+            True if ignore applies to this rule
+        """
+        import re
+
+        pattern = rf"{directive}\[([^\]]+)\]"
+        match = re.search(pattern, line)
+        if not match:
+            return False
+
+        rules = [r.strip().lower() for r in match.group(1).split(",")]
+        return any(self._rule_matches(r) for r in rules)
+
+    def _rule_matches(self, rule_pattern: str) -> bool:
+        """Check if rule pattern matches this rule.
+
+        Args:
+            rule_pattern: Rule pattern to check
+
+        Returns:
+            True if pattern matches this rule
+        """
+        return rule_matches(self.rule_id, rule_pattern)
+
+    def _filter_ignored_violations(
+        self, classes: list[ClassInfo], context: BaseLintContext
+    ) -> list[Violation]:
+        """Filter out violations that should be ignored.
+
+        Args:
+            classes: List of stateless classes found
+            context: Lint context
+
+        Returns:
+            List of violations after filtering ignored ones
+        """
+        violations = []
+        for info in classes:
+            violation = self._create_violation(info, context)
+            if not self._should_ignore_violation(violation, info, context):
+                violations.append(violation)
+        return violations
+
+    def _should_ignore_violation(
+        self, violation: Violation, info: ClassInfo, context: BaseLintContext
+    ) -> bool:
+        """Check if violation should be ignored.
+
+        Args:
+            violation: Violation to check
+            info: Class info
+            context: Lint context
+
+        Returns:
+            True if violation should be ignored
+        """
+        if not context.file_content:
+            return False
+
+        # Check using IgnoreDirectiveParser for comprehensive ignore checking
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content):
+            return True
+
+        # Also check inline ignore on class line
+        return self._has_inline_ignore(info.line, context)
+
+    def _has_inline_ignore(self, line_num: int, context: BaseLintContext) -> bool:
+        """Check for inline ignore directive on class line.
+
+        Args:
+            line_num: Line number to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line = self._get_line_text(line_num, context)
+        if not line:
+            return False
+
+        return self._is_ignore_directive(line.lower())
+
+    def _get_line_text(self, line_num: int, context: BaseLintContext) -> str | None:
+        """Get text of a specific line.
+
+        Args:
+            line_num: Line number (1-indexed)
+            context: Lint context
+
+        Returns:
+            Line text or None if invalid
+        """
+        if not context.file_content:
+            return None
+
+        lines = context.file_content.splitlines()
+        if line_num <= 0 or line_num > len(lines):
+            return None
+
+        return lines[line_num - 1]
+
+    def _is_ignore_directive(self, line: str) -> bool:
+        """Check if line contains ignore directive for this rule.
+
+        Args:
+            line: Line text (lowercase)
+
+        Returns:
+            True if line has applicable ignore directive
+        """
+        if "thailint:" not in line or "ignore" not in line:
+            return False
+
+        # General ignore (no rule specified)
+        if "ignore[" not in line:
+            return True
+
+        # Rule-specific ignore
+        return self._matches_rule_ignore(line, IgnoreDirective.IGNORE)
+
+    def _create_violation(self, info: ClassInfo, context: BaseLintContext) -> Violation:
+        """Create violation from class info.
+
+        Args:
+            info: Detected stateless class info
+            context: Lint context
+
+        Returns:
+            Violation instance
+        """
+        message = (
+            f"Class '{info.name}' has no state and should be refactored to module-level functions"
+        )
+        return Violation(
+            rule_id=self.rule_id,
+            message=message,
+            file_path=str(context.file_path),
+            line=info.line,
+            column=info.column,
+            severity=Severity.ERROR,
+        )