thailint 0.4.6__py3-none-any.whl → 0.7.0__py3-none-any.whl

src/linters/print_statements/linter.py

@@ -0,0 +1,428 @@
+"""
+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
+"""
+
+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.linter_config.ignore import IgnoreDirectiveParser
+
+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 = IgnoreDirectiveParser()
+        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)
+        for pattern in config.ignore:
+            if self._matches_pattern(file_path, pattern):
+                return True
+        return False
+
+    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 = self._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)
+
+    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 _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]:
+        """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 = self._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
+
+        if "// noqa" in line_text:
+            return True
+
+        return False

src/linters/print_statements/python_analyzer.py

@@ -0,0 +1,149 @@
+"""
+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
+
+Exports: PythonPrintStatementAnalyzer class
+
+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
+
+
+class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
+    """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 = {}
+        self._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.
+
+        Args:
+            tree: AST to traverse
+        """
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and self._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.
+
+        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 self._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__"