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

src/linters/print_statements/linter.py

@@ -1,28 +1,31 @@
 """
-File: src/linters/print_statements/linter.py
-
 Purpose: Main print statements linter rule implementation
 
-Exports: PrintStatementRule class
-
-Depends: BaseLintContext, MultiLanguageLintRule, PythonPrintStatementAnalyzer,
-    TypeScriptPrintStatementAnalyzer, ViolationBuilder, PrintStatementConfig, IgnoreDirectiveParser
-
-Implements: PrintStatementRule.check(context) -> list[Violation], properties for rule metadata
+Scope: Print and console statement detection for Python, TypeScript, and JavaScript files
 
-Related: src/linters/magic_numbers/linter.py, src/core/base.py
-
-Overview: Implements print statements linter rule following BaseLintRule interface. Orchestrates
+Overview: Implements print statements linter rule following MultiLanguageLintRule interface. Orchestrates
     configuration loading, Python AST analysis for print() calls, TypeScript tree-sitter analysis
     for console.* calls, and violation building through focused helper classes. Detects print and
     console statements that should be replaced with proper logging. Supports configurable
     allow_in_scripts option to permit print() in __main__ blocks and configurable console_methods
-    set for TypeScript/JavaScript. Handles ignore directives for suppressing specific violations.
+    set for TypeScript/JavaScript. Handles ignore directives for suppressing specific violations
+    through inline comments and configuration patterns.
+
+Dependencies: BaseLintContext and MultiLanguageLintRule from core, ast module, pathlib,
+    analyzer classes, config classes
 
-Usage: rule = PrintStatementRule()
-    violations = rule.check(context)
+Exports: PrintStatementRule class implementing MultiLanguageLintRule interface
 
-Notes: Composition pattern with helper classes, AST-based analysis for Python, tree-sitter for TS/JS
+Interfaces: check(context) -> list[Violation] for rule validation, standard rule properties
+    (rule_id, rule_name, description)
+
+Implementation: Composition pattern with helper classes (analyzers, violation builder),
+    AST-based analysis for Python, tree-sitter for TypeScript/JavaScript
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation creation with related fields
+    - srp: Rule class coordinates multiple language analyzers and violation building.
+        Method count exceeds limit due to dual-language support (Python + TypeScript).
 """
 
 import ast
@@ -31,7 +34,8 @@ from pathlib import Path
 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 src.core.violation_utils import get_violation_line, has_python_noqa, has_typescript_noqa
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import PrintStatementConfig
 from .python_analyzer import PythonPrintStatementAnalyzer
@@ -44,7 +48,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
 
     def __init__(self) -> None:
         """Initialize the print statements rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
 
     @property
@@ -122,10 +126,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             return False
 
         file_path = Path(context.file_path)
-        for pattern in config.ignore:
-            if self._matches_pattern(file_path, pattern):
-                return True
-        return False
+        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.
@@ -257,27 +258,16 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has generic ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_generic_ignore_directive(line_text)
 
-    def _get_violation_line(self, violation: Violation, context: BaseLintContext) -> str | None:
-        """Get the line text for a violation."""
-        if not context.file_content:
-            return None
-
-        lines = context.file_content.splitlines()
-        if violation.line <= 0 or violation.line > len(lines):
-            return None
-
-        return lines[violation.line - 1].lower()
-
     def _has_generic_ignore_directive(self, line_text: str) -> bool:
         """Check if line has generic ignore directive."""
         if self._has_generic_thailint_ignore(line_text):
             return True
-        return self._has_noqa_directive(line_text)
+        return has_python_noqa(line_text)
 
     def _has_generic_thailint_ignore(self, line_text: str) -> bool:
         """Check for generic thailint: ignore (no brackets)."""
@@ -286,10 +276,6 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
         return "[" not in after_ignore
 
-    def _has_noqa_directive(self, line_text: str) -> bool:
-        """Check for noqa-style comments."""
-        return "# noqa" in line_text
-
     def _check_typescript(
         self, context: BaseLintContext, config: PrintStatementConfig
     ) -> list[Violation]:
@@ -402,7 +388,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_typescript_ignore_directive(line_text)
@@ -424,7 +410,4 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             if "[" not in after_ignore:
                 return True
 
-        if "// noqa" in line_text:
-            return True
-
-        return False
+        return has_typescript_noqa(line_text)

src/linters/print_statements/python_analyzer.py

@@ -1,34 +1,107 @@
 """
-File: src/linters/print_statements/python_analyzer.py
-
 Purpose: Python AST analysis for finding print() call nodes
 
-Exports: PythonPrintStatementAnalyzer class
-
-Depends: ast module for AST parsing and node types
-
-Implements: PythonPrintStatementAnalyzer.find_print_calls(tree) -> list[tuple],
-    PythonPrintStatementAnalyzer.is_in_main_block(node) -> bool
-
-Related: src/linters/magic_numbers/python_analyzer.py
+Scope: Python print() statement detection and __main__ block context analysis
 
 Overview: Provides PythonPrintStatementAnalyzer class that traverses Python AST to find all
     print() function calls. Uses ast.walk() to traverse the syntax tree and collect
     Call nodes where the function is 'print'. Tracks parent nodes to detect if print calls
     are within __main__ blocks (if __name__ == "__main__":) for allow_in_scripts filtering.
     Returns structured data about each print call including the AST node, parent context,
-    and line number for violation reporting.
+    and line number for violation reporting. Handles both simple print() and builtins.print() calls.
 
-Usage: analyzer = PythonPrintStatementAnalyzer()
-    print_calls = analyzer.find_print_calls(ast.parse(code))
+Dependencies: ast module for AST parsing and node types, analyzers.ast_utils
 
-Notes: AST walk pattern with parent tracking for context detection
+Exports: PythonPrintStatementAnalyzer class, is_print_call function, is_main_if_block function
+
+Interfaces: find_print_calls(tree) -> list[tuple[Call, AST | None, int]], is_in_main_block(node) -> bool
+
+Implementation: AST walk pattern with parent map for context detection and __main__ block identification
 """
 
 import ast
 
+from src.analyzers.ast_utils import build_parent_map
+
+# --- Pure helper functions for print call detection ---
+
+
+def is_print_call(node: ast.Call) -> bool:
+    """Check if a Call node is calling print().
+
+    Args:
+        node: The Call node to check
+
+    Returns:
+        True if this is a print() call
+    """
+    return _is_simple_print(node) or _is_builtins_print(node)
+
+
+def _is_simple_print(node: ast.Call) -> bool:
+    """Check for simple print() call."""
+    return isinstance(node.func, ast.Name) and node.func.id == "print"
+
+
+def _is_builtins_print(node: ast.Call) -> bool:
+    """Check for builtins.print() call."""
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    if node.func.attr != "print":
+        return False
+    return isinstance(node.func.value, ast.Name) and node.func.value.id == "builtins"
+
+
+# --- Pure helper functions for __main__ block detection ---
+
+
+def is_main_if_block(node: ast.AST) -> bool:
+    """Check if node is an `if __name__ == "__main__":` statement.
+
+    Args:
+        node: AST node to check
+
+    Returns:
+        True if this is a __main__ if block
+    """
+    if not isinstance(node, ast.If):
+        return False
+    if not isinstance(node.test, ast.Compare):
+        return False
+    return _is_main_comparison(node.test)
+
+
+def _is_main_comparison(test: ast.Compare) -> bool:
+    """Check if comparison is __name__ == '__main__'."""
+    if not _is_name_identifier(test.left):
+        return False
+    if not _has_single_eq_operator(test):
+        return False
+    return _compares_to_main(test)
+
 
-class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
+def _is_name_identifier(node: ast.expr) -> bool:
+    """Check if node is the __name__ identifier."""
+    return isinstance(node, ast.Name) and node.id == "__name__"
+
+
+def _has_single_eq_operator(test: ast.Compare) -> bool:
+    """Check if comparison has single == operator."""
+    return len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq)
+
+
+def _compares_to_main(test: ast.Compare) -> bool:
+    """Check if comparison is to '__main__' string."""
+    if len(test.comparators) != 1:
+        return False
+    comparator = test.comparators[0]
+    return isinstance(comparator, ast.Constant) and comparator.value == "__main__"
+
+
+# --- Analyzer class with stateful parent tracking ---
+
+
+class PythonPrintStatementAnalyzer:
     """Analyzes Python AST to find print() calls."""
 
     def __init__(self) -> None:
@@ -46,24 +119,10 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
             List of tuples (node, parent, line_number)
         """
         self.print_calls = []
-        self.parent_map = {}
-        self._build_parent_map(tree)
+        self.parent_map = build_parent_map(tree)
         self._collect_print_calls(tree)
         return self.print_calls
 
-    def _build_parent_map(self, node: ast.AST, parent: ast.AST | None = None) -> None:
-        """Build a map of nodes to their parents.
-
-        Args:
-            node: Current AST node
-            parent: Parent of current node
-        """
-        if parent is not None:
-            self.parent_map[node] = parent
-
-        for child in ast.iter_child_nodes(node):
-            self._build_parent_map(child, node)
-
     def _collect_print_calls(self, tree: ast.AST) -> None:
         """Walk tree and collect all print() calls.
 
@@ -71,34 +130,11 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
             tree: AST to traverse
         """
         for node in ast.walk(tree):
-            if isinstance(node, ast.Call) and self._is_print_call(node):
+            if isinstance(node, ast.Call) and is_print_call(node):
                 parent = self.parent_map.get(node)
                 line_number = node.lineno if hasattr(node, "lineno") else 0
                 self.print_calls.append((node, parent, line_number))
 
-    def _is_print_call(self, node: ast.Call) -> bool:
-        """Check if a Call node is calling print().
-
-        Args:
-            node: The Call node to check
-
-        Returns:
-            True if this is a print() call
-        """
-        return self._is_simple_print(node) or self._is_builtins_print(node)
-
-    def _is_simple_print(self, node: ast.Call) -> bool:
-        """Check for simple print() call."""
-        return isinstance(node.func, ast.Name) and node.func.id == "print"
-
-    def _is_builtins_print(self, node: ast.Call) -> bool:
-        """Check for builtins.print() call."""
-        if not isinstance(node.func, ast.Attribute):
-            return False
-        if node.func.attr != "print":
-            return False
-        return isinstance(node.func.value, ast.Name) and node.func.value.id == "builtins"
-
     def is_in_main_block(self, node: ast.AST) -> bool:
         """Check if node is within `if __name__ == "__main__":` block.
 
@@ -111,45 +147,7 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
         current = node
         while current in self.parent_map:
             parent = self.parent_map[current]
-            if self._is_main_if_block(parent):
+            if is_main_if_block(parent):
                 return True
             current = parent
         return False
-
-    def _is_main_if_block(self, node: ast.AST) -> bool:
-        """Check if node is an `if __name__ == "__main__":` statement.
-
-        Args:
-            node: AST node to check
-
-        Returns:
-            True if this is a __main__ if block
-        """
-        if not isinstance(node, ast.If):
-            return False
-        if not isinstance(node.test, ast.Compare):
-            return False
-        return self._is_main_comparison(node.test)
-
-    def _is_main_comparison(self, test: ast.Compare) -> bool:
-        """Check if comparison is __name__ == '__main__'."""
-        if not self._is_name_identifier(test.left):
-            return False
-        if not self._has_single_eq_operator(test):
-            return False
-        return self._compares_to_main(test)
-
-    def _is_name_identifier(self, node: ast.expr) -> bool:
-        """Check if node is the __name__ identifier."""
-        return isinstance(node, ast.Name) and node.id == "__name__"
-
-    def _has_single_eq_operator(self, test: ast.Compare) -> bool:
-        """Check if comparison has single == operator."""
-        return len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq)
-
-    def _compares_to_main(self, test: ast.Compare) -> bool:
-        """Check if comparison is to '__main__' string."""
-        if len(test.comparators) != 1:
-            return False
-        comparator = test.comparators[0]
-        return isinstance(comparator, ast.Constant) and comparator.value == "__main__"

src/linters/print_statements/typescript_analyzer.py

@@ -1,46 +1,36 @@
 """
-File: src/linters/print_statements/typescript_analyzer.py
-
 Purpose: TypeScript/JavaScript console.* call detection using Tree-sitter AST analysis
 
-Exports: TypeScriptPrintStatementAnalyzer class
-
-Depends: TypeScriptBaseAnalyzer for tree-sitter parsing, tree-sitter Node type
-
-Implements: find_console_calls(root_node, methods) -> list[tuple]
-
-Related: src/linters/magic_numbers/typescript_analyzer.py, src/analyzers/typescript_base.py
+Scope: TypeScript and JavaScript console statement detection
 
 Overview: Analyzes TypeScript and JavaScript code to detect console.* method calls that should
     be replaced with proper logging. Uses Tree-sitter parser to traverse TypeScript/JavaScript
     AST and identify call expressions where the callee is console.log, console.warn, console.error,
     console.debug, or console.info (configurable). Returns structured data with the node, method
     name, and line number for each detected console call. Supports both TypeScript and JavaScript
-    files with shared detection logic.
+    files with shared detection logic. Handles member expression pattern matching to identify
+    console object method calls.
 
-Usage: analyzer = TypeScriptPrintStatementAnalyzer()
-    root = analyzer.parse_typescript(code)
-    calls = analyzer.find_console_calls(root, {"log", "warn", "error"})
+Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing infrastructure, tree-sitter Node type, logging module
+
+Exports: TypeScriptPrintStatementAnalyzer class
+
+Interfaces: find_console_calls(root_node, methods) -> list[tuple[Node, str, int]]
+
+Implementation: Tree-sitter node traversal with call_expression and member_expression pattern matching
 
-Notes: Tree-sitter node traversal with call_expression and member_expression pattern matching
 """
 
 import logging
-from typing import Any
 
-from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
 
 logger = logging.getLogger(__name__)
 
-# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
-try:
-    from tree_sitter import Node
-
-    TREE_SITTER_AVAILABLE = True
-except ImportError:
-    TREE_SITTER_AVAILABLE = False
-    Node = Any  # type: ignore
-
 
 class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
     """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""

src/linters/print_statements/violation_builder.py

@@ -1,27 +1,25 @@
 """
-File: src/linters/print_statements/violation_builder.py
-
 Purpose: Builds Violation objects for print statement detection
 
-Exports: ViolationBuilder class
-
-Depends: ast, pathlib.Path, src.core.types.Violation
-
-Implements: ViolationBuilder.create_python_violation(node, line, file_path) -> Violation,
-    ViolationBuilder.create_typescript_violation(method, line, file_path) -> Violation
-
-Related: src/linters/magic_numbers/violation_builder.py, src/core/types.py
+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.
+    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
 
-Usage: builder = ViolationBuilder("print-statements.detected")
-    violation = builder.create_python_violation(node, line, file_path)
+Interfaces: create_python_violation(node, line, file_path) -> Violation,
+    create_typescript_violation(method, line, file_path) -> Violation
 
-Notes: Message templates suggest logging as alternative, consistent with other linter patterns
+Implementation: Builder pattern with message templates suggesting logging as alternative
+    to print/console statements
 """
 
 import ast

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/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
+    )