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

src/linters/print_statements/python_analyzer.py

@@ -0,0 +1,155 @@
+"""
+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
+
+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.
+
+Usage: analyzer = PythonPrintStatementAnalyzer()
+    print_calls = analyzer.find_print_calls(ast.parse(code))
+
+Notes: AST walk pattern with parent tracking for context detection
+"""
+
+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__"

src/linters/print_statements/typescript_analyzer.py

@@ -0,0 +1,135 @@
+"""
+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
+
+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.
+
+Usage: analyzer = TypeScriptPrintStatementAnalyzer()
+    root = analyzer.parse_typescript(code)
+    calls = analyzer.find_console_calls(root, {"log", "warn", "error"})
+
+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
+
+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."""
+
+    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

src/linters/print_statements/violation_builder.py

@@ -0,0 +1,98 @@
+"""
+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
+
+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.
+
+Usage: builder = ViolationBuilder("print-statements.detected")
+    violation = builder.create_python_violation(node, line, file_path)
+
+Notes: Message templates suggest logging as alternative, consistent with other linter patterns
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.types import Violation
+
+
+class ViolationBuilder:
+    """Builds violations for print statement detections."""
+
+    def __init__(self, rule_id: str) -> None:
+        """Initialize the violation builder.
+
+        Args:
+            rule_id: The rule ID to use in violations
+        """
+        self.rule_id = rule_id
+
+    def create_python_violation(
+        self,
+        node: ast.Call,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a Python print() call.
+
+        Args:
+            node: The AST Call node containing the print statement
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the print statement
+        """
+        message = "print() statement should be replaced with proper logging"
+        suggestion = "Use logging.info(), logging.debug(), or similar instead of print()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=node.col_offset if hasattr(node, "col_offset") else 0,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def create_typescript_violation(
+        self,
+        method: str,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a TypeScript/JavaScript console.* call.
+
+        Args:
+            method: The console method name (log, warn, error, etc.)
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the console statement
+        """
+        message = f"console.{method}() should be replaced with proper logging"
+        suggestion = f"Use a logging library instead of console.{method}()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=0,  # Tree-sitter nodes don't provide easy column access
+            message=message,
+            suggestion=suggestion,
+        )

src/linters/srp/__init__.py

@@ -0,0 +1,99 @@
+"""
+Purpose: SRP linter package initialization
+
+Scope: Exports for Single Responsibility Principle linter module
+
+Overview: Initializes the SRP linter package and exposes the main rule class for external use.
+    Exports SRPRule as the primary interface for the SRP linter, allowing the orchestrator to
+    discover and instantiate the rule. Also exports configuration and analyzer classes for
+    advanced use cases. Provides a convenience lint() function for direct usage without
+    orchestrator setup. This module serves as the entry point for the SRP linter functionality
+    within the thai-lint framework, enabling detection of classes with too many responsibilities.
+
+Dependencies: SRPRule, SRPConfig, PythonSRPAnalyzer, TypeScriptSRPAnalyzer
+
+Exports: SRPRule (primary), SRPConfig, PythonSRPAnalyzer, TypeScriptSRPAnalyzer, lint
+
+Interfaces: Standard Python package initialization with __all__ for explicit exports, lint() convenience function
+
+Implementation: Simple re-export pattern for package interface, convenience function wraps orchestrator
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .config import DEFAULT_MAX_LOC_PER_CLASS, DEFAULT_MAX_METHODS_PER_CLASS, SRPConfig
+from .linter import SRPRule
+from .python_analyzer import PythonSRPAnalyzer
+from .typescript_analyzer import TypeScriptSRPAnalyzer
+
+__all__ = [
+    "SRPRule",
+    "SRPConfig",
+    "PythonSRPAnalyzer",
+    "TypeScriptSRPAnalyzer",
+    "lint",
+]
+
+
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS,
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS,
+) -> list:
+    """Lint a file or directory for SRP violations.
+
+    Args:
+        path: Path to file or directory to lint
+        config: Configuration dict (optional, uses defaults if not provided)
+        max_methods: Maximum allowed methods per class (default: 7)
+        max_loc: Maximum allowed lines of code per class (default: 200)
+
+    Returns:
+        List of violations found
+
+    Example:
+        >>> from src.linters.srp import lint
+        >>> violations = lint('src/my_module.py', max_methods=5)
+        >>> for v in violations:
+        ...     print(f"{v.file_path}:{v.line} - {v.message}")
+    """
+    path_obj = Path(path) if isinstance(path, str) else path
+    project_root = path_obj if path_obj.is_dir() else path_obj.parent
+
+    orchestrator = _setup_srp_orchestrator(project_root, config, max_methods, max_loc)
+    violations = _execute_srp_lint(orchestrator, path_obj)
+
+    return [v for v in violations if "srp" in v.rule_id]
+
+
+def _setup_srp_orchestrator(
+    project_root: Path,
+    config: dict[str, Any] | None,
+    max_methods: int,
+    max_loc: int,
+) -> Any:
+    """Set up orchestrator with SRP config."""
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config:
+        orchestrator.config["srp"] = config
+    else:
+        orchestrator.config["srp"] = {
+            "max_methods": max_methods,
+            "max_loc": max_loc,
+        }
+
+    return orchestrator
+
+
+def _execute_srp_lint(orchestrator: Any, path_obj: Path) -> list:
+    """Execute linting on file or directory."""
+    if path_obj.is_file():
+        return orchestrator.lint_file(path_obj)
+    if path_obj.is_dir():
+        return orchestrator.lint_directory(path_obj)
+    return []

src/linters/srp/class_analyzer.py

@@ -0,0 +1,113 @@
+"""
+Purpose: Class analysis coordination for SRP linter
+
+Scope: Coordinates Python and TypeScript class analysis
+
+Overview: Provides unified class analysis interface for the SRP linter. Delegates to language-
+    specific analyzers (PythonSRPAnalyzer, TypeScriptSRPAnalyzer) based on language type.
+    Handles syntax error gracefully and extracts class metrics for SRP evaluation. Isolates
+    language-specific analysis logic from rule checking and violation building.
+
+Dependencies: ast, PythonSRPAnalyzer, TypeScriptSRPAnalyzer, BaseLintContext, SRPConfig
+
+Exports: ClassAnalyzer
+
+Interfaces: analyze_python(context, config) -> list[dict], analyze_typescript(context, config) -> list[dict]
+
+Implementation: Delegates to language-specific analyzers, returns normalized metrics dicts
+"""
+
+import ast
+from typing import Any
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+
+from .config import SRPConfig
+from .python_analyzer import PythonSRPAnalyzer
+from .typescript_analyzer import TypeScriptSRPAnalyzer
+
+
+class ClassAnalyzer:
+    """Coordinates class analysis for Python and TypeScript."""
+
+    def analyze_python(
+        self, context: BaseLintContext, config: SRPConfig
+    ) -> list[dict[str, Any]] | list[Violation]:
+        """Analyze Python classes and return metrics or syntax errors.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of class metrics dicts, or list of syntax error violations
+        """
+        tree = self._parse_python_safely(context)
+        if isinstance(tree, list):  # Syntax error violations
+            return tree
+
+        analyzer = PythonSRPAnalyzer()
+        classes = analyzer.find_all_classes(tree)
+        return [
+            analyzer.analyze_class(class_node, context.file_content or "", config)
+            for class_node in classes
+        ]
+
+    def analyze_typescript(
+        self, context: BaseLintContext, config: SRPConfig
+    ) -> list[dict[str, Any]]:
+        """Analyze TypeScript classes and return metrics.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of class metrics dicts
+        """
+        analyzer = TypeScriptSRPAnalyzer()
+        root_node = analyzer.parse_typescript(context.file_content or "")
+        if not root_node:
+            return []
+
+        classes = analyzer.find_all_classes(root_node)
+        return [
+            analyzer.analyze_class(class_node, context.file_content or "", config)
+            for class_node in classes
+        ]
+
+    def _parse_python_safely(self, context: BaseLintContext) -> ast.AST | list[Violation]:
+        """Parse Python code and return AST or syntax error violations.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            AST if successful, list of syntax error violations otherwise
+        """
+        try:
+            return ast.parse(context.file_content or "")
+        except SyntaxError as exc:
+            return [self._create_syntax_error_violation(exc, context)]
+
+    def _create_syntax_error_violation(
+        self, exc: SyntaxError, context: BaseLintContext
+    ) -> Violation:
+        """Create syntax error violation.
+
+        Args:
+            exc: SyntaxError exception
+            context: Lint context
+
+        Returns:
+            Syntax error violation
+        """
+        return Violation(
+            rule_id="srp.syntax-error",
+            file_path=str(context.file_path or ""),
+            line=exc.lineno or 1,
+            column=exc.offset or 0,
+            message=f"Syntax error: {exc.msg}",
+            severity=Severity.ERROR,
+        )

src/linters/srp/config.py

@@ -0,0 +1,82 @@
+"""
+Purpose: Configuration schema for Single Responsibility Principle linter
+
+Scope: SRPConfig dataclass with max_methods, max_loc, and keyword settings
+
+Overview: Defines configuration schema for SRP linter. Provides SRPConfig dataclass with
+    max_methods field (default 7), max_loc field (default 200), and check_keywords flag
+    (default True) with configurable responsibility keywords. Supports per-file and
+    per-directory config overrides. Validates that thresholds are positive integers.
+    Integrates with the orchestrator's configuration system to allow users to customize
+    SRP thresholds via .thailint.yaml configuration files. Keywords list identifies
+    generic class names that often indicate SRP violations (Manager, Handler, etc.).
+
+Dependencies: dataclasses, typing
+
+Exports: SRPConfig dataclass
+
+Interfaces: SRPConfig(max_methods, max_loc, check_keywords, keywords), from_dict class method
+
+Implementation: Dataclass with validation and defaults, heuristic-based SRP detection thresholds
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default SRP threshold constants
+DEFAULT_MAX_METHODS_PER_CLASS = 7
+DEFAULT_MAX_LOC_PER_CLASS = 200
+
+
+@dataclass
+class SRPConfig:
+    """Configuration for SRP linter."""
+
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS  # Maximum methods per class
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS  # Maximum lines of code per class
+    enabled: bool = True
+    check_keywords: bool = True
+    keywords: list[str] = field(
+        default_factory=lambda: ["Manager", "Handler", "Processor", "Utility", "Helper"]
+    )
+    ignore: list[str] = field(default_factory=list)  # Path patterns to ignore
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.max_methods <= 0:
+            raise ValueError(f"max_methods must be positive, got {self.max_methods}")
+        if self.max_loc <= 0:
+            raise ValueError(f"max_loc must be positive, got {self.max_loc}")
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "SRPConfig":
+        """Load configuration from dictionary with language-specific overrides.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (python, typescript, javascript) for language-specific thresholds
+
+        Returns:
+            SRPConfig instance with values from dictionary
+        """
+        # Get language-specific config if available
+        if language and language in config:
+            lang_config = config[language]
+            max_methods = lang_config.get(
+                "max_methods", config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            )
+            max_loc = lang_config.get("max_loc", config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS))
+        else:
+            max_methods = config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            max_loc = config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS)
+
+        return cls(
+            max_methods=max_methods,
+            max_loc=max_loc,
+            enabled=config.get("enabled", True),
+            check_keywords=config.get("check_keywords", True),
+            keywords=config.get(
+                "keywords", ["Manager", "Handler", "Processor", "Utility", "Helper"]
+            ),
+            ignore=config.get("ignore", []),
+        )