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

src/linters/nesting/violation_builder.py

@@ -0,0 +1,139 @@
+"""
+Purpose: Violation creation for nesting depth linter
+
+Scope: Builds Violation objects for nesting depth violations
+
+Overview: Provides violation building functionality for the nesting depth linter. Creates
+    violations for Python and TypeScript functions with excessive nesting, generates contextual
+    error messages with actual vs maximum depth, and provides actionable refactoring suggestions
+    (early returns, guard clauses, extract method). Handles syntax errors gracefully. Isolates
+    violation construction from analysis and checking logic.
+
+Dependencies: ast, BaseLintContext, Violation, Severity, NestingConfig, src.core.violation_builder
+
+Exports: NestingViolationBuilder
+
+Interfaces: create_nesting_violation, create_typescript_nesting_violation, create_syntax_error_violation
+
+Implementation: Formats messages with depth information, provides targeted refactoring suggestions,
+    extends BaseViolationBuilder for consistent violation construction
+"""
+
+import ast
+from typing import Any
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+from src.core.violation_builder import BaseViolationBuilder
+
+from .config import NestingConfig
+
+
+class NestingViolationBuilder(BaseViolationBuilder):
+    """Builds violations for nesting depth issues."""
+
+    def __init__(self, rule_id: str):
+        """Initialize violation builder.
+
+        Args:
+            rule_id: Rule identifier for violations
+        """
+        self.rule_id = rule_id
+
+    def create_syntax_error_violation(
+        self, error: SyntaxError, context: BaseLintContext
+    ) -> Violation:
+        """Create violation for syntax error.
+
+        Args:
+            error: SyntaxError exception
+            context: Lint context
+
+        Returns:
+            Syntax error violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=error.lineno or 0,
+            column=error.offset or 0,
+            message=f"Syntax error: {error.msg}",
+            severity=Severity.ERROR,
+            suggestion="Fix syntax errors before checking nesting depth",
+        )
+
+    def create_nesting_violation(
+        self,
+        func: ast.FunctionDef | ast.AsyncFunctionDef,
+        max_depth: int,
+        config: NestingConfig,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for excessive nesting in Python function.
+
+        Args:
+            func: Python function AST node
+            max_depth: Actual max nesting depth found
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            Nesting depth violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=func.lineno,
+            column=func.col_offset,
+            message=f"Function '{func.name}' has excessive nesting depth ({max_depth})",
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
+        )
+
+    def create_typescript_nesting_violation(
+        self,
+        func_info: tuple[Any, str],
+        max_depth: int,
+        config: NestingConfig,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for excessive nesting in TypeScript function.
+
+        Args:
+            func_info: Tuple of (func_node, func_name)
+            max_depth: Actual max nesting depth found
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            Nesting depth violation
+        """
+        func_node, func_name = func_info
+        line = func_node.start_point[0] + 1  # Convert to 1-indexed
+        column = func_node.start_point[1]
+
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=line,
+            column=column,
+            message=f"Function '{func_name}' has excessive nesting depth ({max_depth})",
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
+        )
+
+    def _generate_suggestion(self, actual_depth: int, max_depth: int) -> str:
+        """Generate refactoring suggestion based on depth.
+
+        Args:
+            actual_depth: Actual nesting depth found
+            max_depth: Maximum allowed depth
+
+        Returns:
+            Suggestion string with refactoring advice
+        """
+        return (
+            f"Maximum nesting depth of {actual_depth} exceeds limit of {max_depth}. "
+            "Consider extracting nested logic to separate functions, using early returns, "
+            "or applying guard clauses to reduce nesting."
+        )

src/linters/print_statements/__init__.py

@@ -0,0 +1,53 @@
+"""
+File: src/linters/print_statements/__init__.py
+
+Purpose: Print statements linter package exports and convenience functions
+
+Exports: PrintStatementRule class, PrintStatementConfig dataclass, lint() convenience function
+
+Depends: .linter for PrintStatementRule, .config for PrintStatementConfig
+
+Implements: lint(file_path, config) -> list[Violation] for simple linting operations
+
+Related: src/linters/magic_numbers/__init__.py, src/core/base.py
+
+Overview: Provides the public interface for the print statements linter package. Exports main
+    PrintStatementRule class for use by the orchestrator and PrintStatementConfig for configuration.
+    Includes lint() convenience function that provides a simple API for running the print statements
+    linter on a file without directly interacting with the orchestrator. This module serves as the
+    entry point for users of the print statements linter, hiding implementation details and exposing
+    only the essential components needed for linting operations.
+
+Usage: from src.linters.print_statements import PrintStatementRule, lint
+    violations = lint("path/to/file.py")
+
+Notes: Module-level exports with __all__ definition, convenience function wrapper
+"""
+
+from .config import PrintStatementConfig
+from .linter import PrintStatementRule
+
+__all__ = ["PrintStatementRule", "PrintStatementConfig", "lint"]
+
+
+def lint(file_path: str, config: dict | None = None) -> list:
+    """Convenience function for linting a file for print statements.
+
+    Args:
+        file_path: Path to the file to lint
+        config: Optional configuration dictionary
+
+    Returns:
+        List of violations found
+    """
+    from pathlib import Path
+
+    from src.orchestrator.core import FileLintContext
+
+    rule = PrintStatementRule()
+    context = FileLintContext(
+        path=Path(file_path),
+        lang="python",
+    )
+
+    return rule.check(context)

src/linters/print_statements/config.py

@@ -0,0 +1,83 @@
+"""
+File: src/linters/print_statements/config.py
+
+Purpose: Configuration schema for print statements linter
+
+Exports: PrintStatementConfig dataclass
+
+Depends: dataclasses, typing
+
+Implements: PrintStatementConfig(enabled, ignore, allow_in_scripts, console_methods),
+    from_dict class method for loading configuration from dictionary
+
+Related: src/linters/magic_numbers/config.py, src/core/types.py
+
+Overview: Defines configuration schema for print statements linter. Provides PrintStatementConfig
+    dataclass with enabled flag, ignore patterns list, allow_in_scripts setting (default True to
+    allow print in __main__ blocks), and console_methods set (default includes log, warn, error,
+    debug, info) for TypeScript/JavaScript console method detection. Supports per-file and
+    per-directory config overrides through from_dict class method. Integrates with orchestrator's
+    configuration system to allow users to customize detection via .thailint.yaml configuration.
+
+Usage: config = PrintStatementConfig.from_dict(yaml_config, language="python")
+
+Notes: Dataclass with defaults matching common use cases, language-specific override support
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class PrintStatementConfig:
+    """Configuration for print statements linter."""
+
+    enabled: bool = True
+    ignore: list[str] = field(default_factory=list)
+    allow_in_scripts: bool = True
+    console_methods: set[str] = field(
+        default_factory=lambda: {"log", "warn", "error", "debug", "info"}
+    )
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any], language: str | None = None
+    ) -> "PrintStatementConfig":
+        """Load configuration from dictionary with language-specific overrides.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (python, typescript, javascript)
+                for language-specific settings
+
+        Returns:
+            PrintStatementConfig instance with values from dictionary
+        """
+        # Get language-specific config if available
+        if language and language in config:
+            lang_config = config[language]
+            allow_in_scripts = lang_config.get(
+                "allow_in_scripts", config.get("allow_in_scripts", True)
+            )
+            console_methods = set(
+                lang_config.get(
+                    "console_methods",
+                    config.get("console_methods", ["log", "warn", "error", "debug", "info"]),
+                )
+            )
+        else:
+            allow_in_scripts = config.get("allow_in_scripts", True)
+            console_methods = set(
+                config.get("console_methods", ["log", "warn", "error", "debug", "info"])
+            )
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            ignore=ignore_patterns,
+            allow_in_scripts=allow_in_scripts,
+            console_methods=console_methods,
+        )

src/linters/print_statements/linter.py

@@ -0,0 +1,430 @@
+"""
+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
+
+Related: src/linters/magic_numbers/linter.py, src/core/base.py
+
+Overview: Implements print statements linter rule following BaseLintRule 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.
+
+Usage: rule = PrintStatementRule()
+    violations = rule.check(context)
+
+Notes: Composition pattern with helper classes, AST-based analysis for Python, tree-sitter for TS/JS
+"""
+
+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