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

src/linters/print_statements/violation_builder.py

@@ -0,0 +1,96 @@
+"""
+Purpose: Builds Violation objects for print statement detection
+
+Scope: Violation creation for print and console statement detections
+
+Overview: Provides ViolationBuilder class that creates Violation objects for print statement
+    detections. Generates descriptive messages suggesting the use of proper logging instead of
+    print/console statements. Constructs complete Violation instances with rule_id, file_path,
+    line number, column, message, and suggestions. Provides separate methods for Python print()
+    violations and TypeScript/JavaScript console.* violations with language-appropriate messages
+    and helpful remediation guidance.
+
+Dependencies: ast module for Python AST nodes, pathlib.Path for file paths,
+    src.core.types.Violation for violation structure
+
+Exports: ViolationBuilder class
+
+Interfaces: create_python_violation(node, line, file_path) -> Violation,
+    create_typescript_violation(method, line, file_path) -> Violation
+
+Implementation: Builder pattern with message templates suggesting logging as alternative
+    to print/console statements
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.types import Violation
+
+
+class ViolationBuilder:
+    """Builds violations for print statement detections."""
+
+    def __init__(self, rule_id: str) -> None:
+        """Initialize the violation builder.
+
+        Args:
+            rule_id: The rule ID to use in violations
+        """
+        self.rule_id = rule_id
+
+    def create_python_violation(
+        self,
+        node: ast.Call,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a Python print() call.
+
+        Args:
+            node: The AST Call node containing the print statement
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the print statement
+        """
+        message = "print() statement should be replaced with proper logging"
+        suggestion = "Use logging.info(), logging.debug(), or similar instead of print()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=node.col_offset if hasattr(node, "col_offset") else 0,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def create_typescript_violation(
+        self,
+        method: str,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a TypeScript/JavaScript console.* call.
+
+        Args:
+            method: The console method name (log, warn, error, etc.)
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the console statement
+        """
+        message = f"console.{method}() should be replaced with proper logging"
+        suggestion = f"Use a logging library instead of console.{method}()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=0,  # Tree-sitter nodes don't provide easy column access
+            message=message,
+            suggestion=suggestion,
+        )

src/linters/srp/__init__.py

@@ -22,7 +22,7 @@ Implementation: Simple re-export pattern for package interface, convenience func
 from pathlib import Path
 from typing import Any
 
-from .config import SRPConfig
+from .config import DEFAULT_MAX_LOC_PER_CLASS, DEFAULT_MAX_METHODS_PER_CLASS, SRPConfig
 from .linter import SRPRule
 from .python_analyzer import PythonSRPAnalyzer
 from .typescript_analyzer import TypeScriptSRPAnalyzer
@@ -39,8 +39,8 @@ __all__ = [
 def lint(
     path: Path | str,
     config: dict[str, Any] | None = None,
-    max_methods: int = 7,
-    max_loc: int = 200,
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS,
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS,
 ) -> list:
     """Lint a file or directory for SRP violations.
 

src/linters/srp/class_analyzer.py

@@ -31,6 +31,12 @@ from .typescript_analyzer import TypeScriptSRPAnalyzer
 class ClassAnalyzer:
     """Coordinates class analysis for Python and TypeScript."""
 
+    def __init__(self) -> None:
+        """Initialize the class analyzer with singleton analyzers."""
+        # Singleton analyzers for performance (avoid recreating per-file)
+        self._python_analyzer = PythonSRPAnalyzer()
+        self._typescript_analyzer = TypeScriptSRPAnalyzer()
+
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
     ) -> list[dict[str, Any]] | list[Violation]:
@@ -47,10 +53,9 @@ class ClassAnalyzer:
         if isinstance(tree, list):  # Syntax error violations
             return tree
 
-        analyzer = PythonSRPAnalyzer()
-        classes = analyzer.find_all_classes(tree)
+        classes = self._python_analyzer.find_all_classes(tree)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._python_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 
@@ -66,14 +71,13 @@ class ClassAnalyzer:
         Returns:
             List of class metrics dicts
         """
-        analyzer = TypeScriptSRPAnalyzer()
-        root_node = analyzer.parse_typescript(context.file_content or "")
+        root_node = self._typescript_analyzer.parse_typescript(context.file_content or "")
         if not root_node:
             return []
 
-        classes = analyzer.find_all_classes(root_node)
+        classes = self._typescript_analyzer.find_all_classes(root_node)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._typescript_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 

src/linters/srp/config.py

@@ -23,13 +23,17 @@ Implementation: Dataclass with validation and defaults, heuristic-based SRP dete
 from dataclasses import dataclass, field
 from typing import Any
 
+# Default SRP threshold constants
+DEFAULT_MAX_METHODS_PER_CLASS = 7
+DEFAULT_MAX_LOC_PER_CLASS = 200
+
 
 @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
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS  # Maximum methods per class
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS  # Maximum lines of code per class
     enabled: bool = True
     check_keywords: bool = True
     keywords: list[str] = field(
@@ -58,11 +62,13 @@ class SRPConfig:
         # 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))
+            max_methods = lang_config.get(
+                "max_methods", config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            )
+            max_loc = lang_config.get("max_loc", config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS))
         else:
-            max_methods = config.get("max_methods", 7)
-            max_loc = config.get("max_loc", 200)
+            max_methods = config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            max_loc = config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS)
 
         return cls(
             max_methods=max_methods,

src/linters/srp/heuristics.py

@@ -4,12 +4,13 @@ Purpose: SRP detection heuristics for analyzing code complexity and responsibili
 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.
+    Principle violations. Implements method counting that excludes property decorators,
+    private methods, 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
 
@@ -24,22 +25,55 @@ import ast
 
 
 def count_methods(class_node: ast.ClassDef) -> int:
-    """Count methods in a class (excludes properties and special methods).
+    """Count public methods in a class (excludes properties and private methods).
+
+    Private methods are those starting with underscore (_), including dunder
+    methods (__init__, __str__, etc.). This focuses SRP analysis on the public
+    interface rather than implementation details.
 
     Args:
         class_node: AST node representing a class definition
 
     Returns:
-        Number of methods in the class
+        Number of public methods in the class
+    """
+    func_nodes = (
+        n for n in class_node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+    )
+    public_methods = [n for n in func_nodes if _is_countable_method(n)]
+    return len(public_methods)
+
+
+def _is_countable_method(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if a method should be counted (public and not a property).
+
+    Args:
+        node: Function AST node
+
+    Returns:
+        True if method should be counted
+    """
+    if has_property_decorator(node):
+        return False
+    if _is_private_method(node.name):
+        return False
+    return True
+
+
+def _is_private_method(method_name: str) -> bool:
+    """Check if method is private (starts with underscore).
+
+    This includes both single underscore (_helper) and dunder methods
+    (__init__, __str__). All underscore-prefixed methods are considered
+    implementation details.
+
+    Args:
+        method_name: Name of the method to check
+
+    Returns:
+        True if method is private, False otherwise
     """
-    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
+    return method_name.startswith("_")
 
 
 def count_loc(class_node: ast.ClassDef, source: str) -> int:
@@ -56,8 +90,8 @@ def count_loc(class_node: ast.ClassDef, source: str) -> int:
     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("#")]
+    # Filter out blank lines and comments (using walrus operator to avoid double strip)
+    code_lines = [s for line in lines if (s := line.strip()) and not s.startswith("#")]
     return len(code_lines)
 
 
@@ -83,7 +117,7 @@ def has_property_decorator(func_node: ast.FunctionDef | ast.AsyncFunctionDef) ->
     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
+    return any(
+        isinstance(decorator, ast.Name) and decorator.id == "property"
+        for decorator in func_node.decorator_list
+    )

src/linters/srp/linter.py

@@ -16,12 +16,16 @@ Exports: SRPRule class
 Interfaces: SRPRule.check(context) -> list[Violation], properties for rule metadata
 
 Implementation: Composition pattern with helper classes, heuristic-based SRP analysis
+
+Suppressions:
+    - type:ignore[return-value]: Generic TypeScript analyzer return type variance
 """
 
-from src.core.base import BaseLintContext, BaseLintRule
-from src.core.linter_utils import has_file_content, load_linter_config
+from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.constants import Language
+from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .class_analyzer import ClassAnalyzer
 from .config import SRPConfig
@@ -29,12 +33,12 @@ from .metrics_evaluator import evaluate_metrics
 from .violation_builder import ViolationBuilder
 
 
-class SRPRule(BaseLintRule):
+class SRPRule(MultiLanguageLintRule):
     """Detects Single Responsibility Principle violations in classes."""
 
     def __init__(self) -> None:
         """Initialize the SRP rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._class_analyzer = ClassAnalyzer()
         self._violation_builder = ViolationBuilder()
 
@@ -54,7 +58,9 @@ class SRPRule(BaseLintRule):
         return "Classes should have a single, well-defined responsibility"
 
     def check(self, context: BaseLintContext) -> list[Violation]:
-        """Check for SRP violations.
+        """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
@@ -62,53 +68,60 @@ class SRPRule(BaseLintRule):
         Returns:
             List of violations found
         """
-        if not self._should_check_file(context):
+        from src.core.linter_utils import has_file_content
+
+        if not has_file_content(context):
             return []
 
-        config = load_linter_config(context, "srp", SRPConfig)
-        if not self._is_linter_enabled(context, config):
+        config = self._load_config(context)
+        if not self._should_process_file(context, config):
             return []
 
-        return self._check_by_language(context, config)
+        # Standard language dispatch
+        return self._dispatch_by_language(context, config)
 
-    def _should_check_file(self, context: BaseLintContext) -> bool:
-        """Check if file has content to analyze.
+    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 checked
+            True if file should be processed
         """
-        return has_file_content(context)
+        if not config.enabled:
+            return False
+        return not self._is_file_ignored(context, config)
 
-    def _is_linter_enabled(self, context: BaseLintContext, config: SRPConfig) -> bool:
-        """Check if linter is enabled and file is not ignored.
+    def _dispatch_by_language(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+        """Dispatch to language-specific checker.
 
         Args:
             context: Lint context
             config: SRP configuration
 
         Returns:
-            True if linter should run on this file
+            List of violations found
         """
-        return config.enabled and not self._is_file_ignored(context, config)
+        if context.language == Language.PYTHON:
+            return self._check_python(context, config)
 
-    def _check_by_language(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
-        """Dispatch to language-specific checker.
+        if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
+            return self._check_typescript(context, config)
+
+        return []
+
+    def _load_config(self, context: BaseLintContext) -> SRPConfig:
+        """Load configuration from context.
 
         Args:
             context: Lint context
-            config: SRP configuration
 
         Returns:
-            List of violations found
+            SRPConfig instance
         """
-        if context.language == "python":
-            return self._check_python(context, config)
-        if context.language in ("typescript", "javascript"):
-            return self._check_typescript(context, config)
-        return []
+        return load_linter_config(context, "srp", SRPConfig)
 
     def _is_file_ignored(self, context: BaseLintContext, config: SRPConfig) -> bool:
         """Check if file matches ignore patterns.
@@ -124,10 +137,7 @@ class SRPRule(BaseLintRule):
             return False
 
         file_path = str(context.file_path)
-        for pattern in config.ignore:
-            if pattern in file_path:
-                return True
-        return False
+        return any(pattern in file_path for pattern in config.ignore)
 
     def _check_python(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
         """Check Python code for SRP violations.
@@ -161,14 +171,12 @@ class SRPRule(BaseLintRule):
         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
+        valid_metrics = (m for m in metrics_list if isinstance(m, dict))
+        return [
+            violation
+            for metrics in valid_metrics
+            if (violation := self._create_violation_if_needed(metrics, config, context))
+        ]
 
     def _create_violation_if_needed(
         self,

src/linters/srp/python_analyzer.py

@@ -1,7 +1,7 @@
 """
 Purpose: Python AST analyzer for detecting SRP violations in Python classes
 
-Scope: PythonSRPAnalyzer class for analyzing Python classes using AST
+Scope: Functions 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
@@ -13,7 +13,7 @@ Overview: Implements Python-specific SRP analysis using the ast module to parse
 
 Dependencies: ast module for Python AST parsing, typing for type hints, heuristics module
 
-Exports: PythonSRPAnalyzer class
+Exports: find_all_classes function, analyze_class function, PythonSRPAnalyzer class (compat)
 
 Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
 
@@ -27,8 +27,58 @@ from .config import SRPConfig
 from .heuristics import count_loc, count_methods, has_responsibility_keyword
 
 
+def find_all_classes(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(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,
+    }
+
+
+# Legacy class wrapper for backward compatibility
 class PythonSRPAnalyzer:
-    """Analyzes Python classes for SRP violations."""
+    """Analyzes Python classes for SRP violations.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        pass  # No state needed
 
     def find_all_classes(self, tree: ast.AST) -> list[ast.ClassDef]:
         """Find all class definitions in AST.
@@ -39,11 +89,7 @@ class PythonSRPAnalyzer:
         Returns:
             List of all class definition nodes
         """
-        classes = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                classes.append(node)
-        return classes
+        return find_all_classes(tree)
 
     def analyze_class(
         self, class_node: ast.ClassDef, source: str, config: SRPConfig
@@ -58,15 +104,4 @@ class PythonSRPAnalyzer:
         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,
-        }
+        return analyze_class(class_node, source, config)