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

src/linters/print_statements/linter.py

@@ -0,0 +1,413 @@
+"""
+Purpose: Main print statements linter rule implementation
+
+Scope: Print and console statement detection for Python, TypeScript, and JavaScript files
+
+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
+    through inline comments and configuration patterns.
+
+Dependencies: BaseLintContext and MultiLanguageLintRule from core, ast module, pathlib,
+    analyzer classes, config classes
+
+Exports: PrintStatementRule class implementing MultiLanguageLintRule interface
+
+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
+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.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
+from .typescript_analyzer import TypeScriptPrintStatementAnalyzer
+from .violation_builder import ViolationBuilder
+
+
+class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
+    """Detects print/console statements that should be replaced with proper logging."""
+
+    def __init__(self) -> None:
+        """Initialize the print statements rule."""
+        self._ignore_parser = get_ignore_parser()
+        self._violation_builder = ViolationBuilder(self.rule_id)
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "print-statements.detected"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Print Statements"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Print/console statements should be replaced with proper logging"
+
+    def _load_config(self, context: BaseLintContext) -> PrintStatementConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            PrintStatementConfig instance
+        """
+        test_config = self._try_load_test_config(context)
+        if test_config is not None:
+            return test_config
+
+        prod_config = self._try_load_production_config(context)
+        if prod_config is not None:
+            return prod_config
+
+        return PrintStatementConfig()
+
+    def _try_load_test_config(self, context: BaseLintContext) -> PrintStatementConfig | None:
+        """Try to load test-style configuration."""
+        if not hasattr(context, "config"):
+            return None
+        config_attr = context.config
+        if config_attr is None or not isinstance(config_attr, dict):
+            return None
+        return PrintStatementConfig.from_dict(config_attr, context.language)
+
+    def _try_load_production_config(self, context: BaseLintContext) -> PrintStatementConfig | None:
+        """Try to load production configuration."""
+        if not hasattr(context, "metadata") or not isinstance(context.metadata, dict):
+            return None
+
+        metadata = context.metadata
+
+        if "print_statements" in metadata:
+            return load_linter_config(context, "print_statements", PrintStatementConfig)
+
+        if "print-statements" in metadata:
+            return load_linter_config(context, "print-statements", PrintStatementConfig)
+
+        return None
+
+    def _is_file_ignored(self, context: BaseLintContext, config: PrintStatementConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: Print statements 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 _check_python(
+        self, context: BaseLintContext, config: PrintStatementConfig
+    ) -> list[Violation]:
+        """Check Python code for print() violations.
+
+        Args:
+            context: Lint context with Python file information
+            config: Print statements configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        if self._is_file_ignored(context, config):
+            return []
+
+        tree = self._parse_python_code(context.file_content)
+        if tree is None:
+            return []
+
+        analyzer = PythonPrintStatementAnalyzer()
+        print_calls = analyzer.find_print_calls(tree)
+        return self._collect_python_violations(print_calls, context, config, analyzer)
+
+    def _parse_python_code(self, code: str | None) -> ast.AST | None:
+        """Parse Python code into AST."""
+        try:
+            return ast.parse(code or "")
+        except SyntaxError:
+            return None
+
+    def _collect_python_violations(
+        self,
+        print_calls: list,
+        context: BaseLintContext,
+        config: PrintStatementConfig,
+        analyzer: PythonPrintStatementAnalyzer,
+    ) -> list[Violation]:
+        """Collect violations from Python print() calls.
+
+        Args:
+            print_calls: List of (node, parent, line_number) tuples
+            context: Lint context
+            config: Configuration
+            analyzer: Python analyzer instance
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for node, _parent, line_number in print_calls:
+            violation = self._try_create_python_violation(
+                node, line_number, context, config, analyzer
+            )
+            if violation is not None:
+                violations.append(violation)
+        return violations
+
+    def _try_create_python_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        node: ast.Call,
+        line_number: int,
+        context: BaseLintContext,
+        config: PrintStatementConfig,
+        analyzer: PythonPrintStatementAnalyzer,
+    ) -> Violation | None:
+        """Try to create a violation for a Python print() call.
+
+        Args:
+            node: AST Call node
+            line_number: Line number
+            context: Lint context
+            config: Configuration
+            analyzer: Python analyzer
+
+        Returns:
+            Violation or None if should not flag
+        """
+        # Check if in __main__ block and allow_in_scripts is enabled
+        if config.allow_in_scripts and analyzer.is_in_main_block(node):
+            return None
+
+        violation = self._violation_builder.create_python_violation(
+            node, line_number, context.file_path
+        )
+
+        if self._should_ignore(violation, context):
+            return None
+
+        return violation
+
+    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 self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
+            return True
+        return self._check_generic_ignore(violation, context)
+
+    def _check_generic_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for generic ignore directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has generic ignore directive
+        """
+        line_text = get_violation_line(violation, context)
+        if line_text is None:
+            return False
+        return self._has_generic_ignore_directive(line_text)
+
+    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 has_python_noqa(line_text)
+
+    def _has_generic_thailint_ignore(self, line_text: str) -> bool:
+        """Check for generic thailint: ignore (no brackets)."""
+        if "# thailint: ignore" not in line_text:
+            return False
+        after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
+        return "[" not in after_ignore
+
+    def _check_typescript(
+        self, context: BaseLintContext, config: PrintStatementConfig
+    ) -> list[Violation]:
+        """Check TypeScript/JavaScript code for console.* violations.
+
+        Args:
+            context: Lint context with TypeScript/JavaScript file information
+            config: Print statements configuration
+
+        Returns:
+            List of violations found in TypeScript/JavaScript code
+        """
+        if self._is_file_ignored(context, config):
+            return []
+
+        analyzer = TypeScriptPrintStatementAnalyzer()
+        root_node = analyzer.parse_typescript(context.file_content or "")
+        if root_node is None:
+            return []
+
+        console_calls = analyzer.find_console_calls(root_node, config.console_methods)
+        return self._collect_typescript_violations(console_calls, context)
+
+    def _collect_typescript_violations(
+        self,
+        console_calls: list,
+        context: BaseLintContext,
+    ) -> list[Violation]:
+        """Collect violations from TypeScript console.* calls.
+
+        Args:
+            console_calls: List of (node, method_name, line_number) tuples
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for _node, method_name, line_number in console_calls:
+            violation = self._try_create_typescript_violation(method_name, line_number, context)
+            if violation is not None:
+                violations.append(violation)
+        return violations
+
+    def _try_create_typescript_violation(
+        self,
+        method_name: str,
+        line_number: int,
+        context: BaseLintContext,
+    ) -> Violation | None:
+        """Try to create a violation for a TypeScript console.* call.
+
+        Args:
+            method_name: Console method name (log, warn, etc.)
+            line_number: Line number
+            context: Lint context
+
+        Returns:
+            Violation or None if should not flag
+        """
+        # Check if test file (skip test files)
+        if self._is_test_file(context.file_path):
+            return None
+
+        violation = self._violation_builder.create_typescript_violation(
+            method_name, line_number, context.file_path
+        )
+
+        if self._should_ignore_typescript(violation, context):
+            return None
+
+        return violation
+
+    def _is_test_file(self, file_path: object) -> bool:
+        """Check if file is a test file.
+
+        Args:
+            file_path: Path to check
+
+        Returns:
+            True if test file
+        """
+        path_str = str(file_path)
+        return any(
+            pattern in path_str
+            for pattern in [".test.", ".spec.", "test_", "_test.", "/tests/", "/test/"]
+        )
+
+    def _should_ignore_typescript(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if TypeScript violation should be ignored.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if should ignore
+        """
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
+            return True
+        return self._check_typescript_ignore(violation, context)
+
+    def _check_typescript_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for TypeScript-style ignore directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line_text = get_violation_line(violation, context)
+        if line_text is None:
+            return False
+        return self._has_typescript_ignore_directive(line_text)
+
+    def _has_typescript_ignore_directive(self, line_text: str) -> bool:
+        """Check if line has TypeScript-style ignore directive.
+
+        Args:
+            line_text: Line text to check
+
+        Returns:
+            True if has ignore directive
+        """
+        if "// thailint: ignore[print-statements]" in line_text:
+            return True
+
+        if "// thailint: ignore" in line_text:
+            after_ignore = line_text.split("// thailint: ignore")[1].split("//")[0]
+            if "[" not in after_ignore:
+                return True
+
+        return has_typescript_noqa(line_text)

src/linters/print_statements/python_analyzer.py

@@ -0,0 +1,153 @@
+"""
+Purpose: Python AST analysis for finding print() call nodes
+
+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. Handles both simple print() and builtins.print() calls.
+
+Dependencies: ast module for AST parsing and node types, analyzers.ast_utils
+
+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)
+
+
+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:
+        """Initialize the analyzer."""
+        self.print_calls: list[tuple[ast.Call, ast.AST | None, int]] = []
+        self.parent_map: dict[ast.AST, ast.AST] = {}
+
+    def find_print_calls(self, tree: ast.AST) -> list[tuple[ast.Call, ast.AST | None, int]]:
+        """Find all print() calls in the AST.
+
+        Args:
+            tree: The AST to analyze
+
+        Returns:
+            List of tuples (node, parent, line_number)
+        """
+        self.print_calls = []
+        self.parent_map = build_parent_map(tree)
+        self._collect_print_calls(tree)
+        return self.print_calls
+
+    def _collect_print_calls(self, tree: ast.AST) -> None:
+        """Walk tree and collect all print() calls.
+
+        Args:
+            tree: AST to traverse
+        """
+        for node in ast.walk(tree):
+            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_in_main_block(self, node: ast.AST) -> bool:
+        """Check if node is within `if __name__ == "__main__":` block.
+
+        Args:
+            node: AST node to check
+
+        Returns:
+            True if node is inside a __main__ block
+        """
+        current = node
+        while current in self.parent_map:
+            parent = self.parent_map[current]
+            if is_main_if_block(parent):
+                return True
+            current = parent
+        return False

src/linters/print_statements/typescript_analyzer.py

@@ -0,0 +1,125 @@
+"""
+Purpose: TypeScript/JavaScript console.* call detection using Tree-sitter AST analysis
+
+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. Handles member expression pattern matching to identify
+    console object method calls.
+
+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
+
+"""
+
+import logging
+
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
+    """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""
+
+    def find_console_calls(self, root_node: Node, methods: set[str]) -> list[tuple[Node, str, int]]:
+        """Find all console.* calls matching the specified methods.
+
+        Args:
+            root_node: Root tree-sitter node to search from
+            methods: Set of console method names to detect (e.g., {"log", "warn"})
+
+        Returns:
+            List of (node, method_name, line_number) tuples for each console call
+        """
+        logger.debug(
+            "find_console_calls: TREE_SITTER_AVAILABLE=%s, root_node=%s",
+            TREE_SITTER_AVAILABLE,
+            root_node is not None,
+        )
+        if not TREE_SITTER_AVAILABLE or root_node is None:
+            logger.debug("Early return: tree-sitter not available or root_node is None")
+            return []
+
+        calls: list[tuple[Node, str, int]] = []
+        self._collect_console_calls(root_node, methods, calls)
+        logger.debug("find_console_calls: found %d calls", len(calls))
+        return calls
+
+    def _collect_console_calls(
+        self, node: Node, methods: set[str], calls: list[tuple[Node, str, int]]
+    ) -> None:
+        """Recursively collect console.* calls from AST.
+
+        Args:
+            node: Current tree-sitter node
+            methods: Set of console method names to detect
+            calls: List to accumulate found calls
+        """
+        if node.type == "call_expression":
+            method_name = self._extract_console_method(node, methods)
+            if method_name is not None:
+                line_number = node.start_point[0] + 1
+                calls.append((node, method_name, line_number))
+
+        for child in node.children:
+            self._collect_console_calls(child, methods, calls)
+
+    def _extract_console_method(self, node: Node, methods: set[str]) -> str | None:
+        """Extract console method name if this is a console.* call.
+
+        Args:
+            node: Tree-sitter call_expression node
+            methods: Set of console method names to detect
+
+        Returns:
+            Method name if this is a matching console call, None otherwise
+        """
+        func_node = self.find_child_by_type(node, "member_expression")
+        if func_node is None:
+            return None
+        if not self._is_console_object(func_node):
+            return None
+        return self._get_matching_method(func_node, methods)
+
+    def _is_console_object(self, func_node: Node) -> bool:
+        """Check if the member expression is on 'console' object."""
+        object_node = self._find_object_node(func_node)
+        if object_node is None:
+            return False
+        return self.extract_node_text(object_node) == "console"
+
+    def _get_matching_method(self, func_node: Node, methods: set[str]) -> str | None:
+        """Get method name if it matches the configured methods."""
+        method_node = self.find_child_by_type(func_node, "property_identifier")
+        if method_node is None:
+            return None
+        method_name = self.extract_node_text(method_node)
+        return method_name if method_name in methods else None
+
+    def _find_object_node(self, member_expr: Node) -> Node | None:
+        """Find the object node in a member expression.
+
+        Args:
+            member_expr: Tree-sitter member_expression node
+
+        Returns:
+            Object node (identifier) or None
+        """
+        for child in member_expr.children:
+            if child.type == "identifier":
+                return child
+        return None