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

src/linters/magic_numbers/typescript_analyzer.py

@@ -0,0 +1,218 @@
+"""
+Purpose: TypeScript/JavaScript magic number detection using Tree-sitter AST analysis
+
+Scope: Tree-sitter based numeric literal detection for TypeScript and JavaScript code
+
+Overview: Analyzes TypeScript and JavaScript code to detect numeric literals that should be
+    extracted to named constants. Uses Tree-sitter parser to traverse TypeScript AST and
+    identify numeric literal nodes with their line numbers and values. Detects acceptable
+    contexts such as enum definitions and UPPERCASE constant declarations to avoid false
+    positives. Supports both TypeScript and JavaScript files with shared detection logic.
+    Handles TypeScript-specific syntax including enums, const assertions, readonly properties,
+    arrow functions, async functions, and class methods.
+
+Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing, tree-sitter Node type
+
+Exports: TypeScriptMagicNumberAnalyzer class with find_numeric_literals and context detection
+
+Interfaces: find_numeric_literals(root_node) -> list[tuple], is_enum_context(node),
+    is_constant_definition(node)
+
+Implementation: Tree-sitter node traversal with visitor pattern, context-aware filtering
+    for acceptable numeric literal locations
+"""
+
+from typing import Any
+
+from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
+# 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 TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore[srp]
+    """Analyzes TypeScript/JavaScript code for magic numbers using Tree-sitter.
+
+    Note: Method count (11) exceeds SRP limit (8) because refactoring for A-grade
+    complexity requires extracting helper methods. Class maintains single responsibility
+    of TypeScript magic number detection - all methods support this core purpose.
+    """
+
+    def find_numeric_literals(self, root_node: Node) -> list[tuple[Node, float | int, int]]:
+        """Find all numeric literal nodes in TypeScript/JavaScript AST.
+
+        Args:
+            root_node: Root tree-sitter node to search from
+
+        Returns:
+            List of (node, value, line_number) tuples for each numeric literal
+        """
+        if not TREE_SITTER_AVAILABLE or root_node is None:
+            return []
+
+        literals: list[tuple[Node, float | int, int]] = []
+        self._collect_numeric_literals(root_node, literals)
+        return literals
+
+    def _collect_numeric_literals(
+        self, node: Node, literals: list[tuple[Node, float | int, int]]
+    ) -> None:
+        """Recursively collect numeric literals from AST.
+
+        Args:
+            node: Current tree-sitter node
+            literals: List to accumulate found literals
+        """
+        if node.type == "number":
+            value = self._extract_numeric_value(node)
+            if value is not None:
+                line_number = node.start_point[0] + 1
+                literals.append((node, value, line_number))
+
+        for child in node.children:
+            self._collect_numeric_literals(child, literals)
+
+    def _extract_numeric_value(self, node: Node) -> float | int | None:
+        """Extract numeric value from number node.
+
+        Args:
+            node: Tree-sitter number node
+
+        Returns:
+            Numeric value (int or float) or None if parsing fails
+        """
+        text = self.extract_node_text(node)
+        try:
+            # Try int first
+            if "." not in text and "e" not in text.lower():
+                return int(text, 0)  # Handles hex, octal, binary
+            # Otherwise float
+            return float(text)
+        except (ValueError, TypeError):
+            return None
+
+    def is_enum_context(self, node: Node) -> bool:
+        """Check if numeric literal is in enum definition.
+
+        Args:
+            node: Numeric literal node
+
+        Returns:
+            True if node is within enum_declaration
+        """
+        if not TREE_SITTER_AVAILABLE:
+            return False
+
+        current = node.parent
+        while current is not None:
+            if current.type == "enum_declaration":
+                return True
+            current = current.parent
+        return False
+
+    def is_constant_definition(self, node: Node, source_code: str) -> bool:
+        """Check if numeric literal is in UPPERCASE constant definition.
+
+        Args:
+            node: Numeric literal node
+            source_code: Full source code to extract variable names
+
+        Returns:
+            True if assigned to UPPERCASE constant variable
+        """
+        if not TREE_SITTER_AVAILABLE:
+            return False
+
+        # Find the declaration parent
+        parent = self._find_declaration_parent(node)
+        if parent is None:
+            return False
+
+        # Check if identifier is UPPERCASE constant
+        return self._has_uppercase_identifier(parent)
+
+    def _find_declaration_parent(self, node: Node) -> Node | None:
+        """Find the declaration parent node.
+
+        Args:
+            node: Starting node
+
+        Returns:
+            Declaration parent or None
+        """
+        parent = node.parent
+        if self._is_declaration_type(parent):
+            return parent
+
+        # Try grandparent for nested cases
+        if parent is not None:
+            grandparent = parent.parent
+            if self._is_declaration_type(grandparent):
+                return grandparent
+
+        return None
+
+    def _is_declaration_type(self, node: Node | None) -> bool:
+        """Check if node is a declaration type."""
+        if node is None:
+            return False
+        return node.type in ("variable_declarator", "lexical_declaration", "pair")
+
+    def _has_uppercase_identifier(self, parent_node: Node) -> bool:
+        """Check if declaration has UPPERCASE identifier.
+
+        Args:
+            parent_node: Declaration parent node
+
+        Returns:
+            True if identifier is UPPERCASE
+        """
+        identifier_node = self._find_identifier_in_declaration(parent_node)
+        if identifier_node is None:
+            return False
+
+        identifier_text = self.extract_node_text(identifier_node)
+        return self._is_uppercase_constant(identifier_text)
+
+    def _find_identifier_in_declaration(self, node: Node) -> Node | None:
+        """Find identifier node in variable declaration.
+
+        Args:
+            node: Variable declarator or lexical declaration node
+
+        Returns:
+            Identifier node or None
+        """
+        # Walk children looking for identifier
+        for child in node.children:
+            if child.type in ("identifier", "property_identifier"):
+                return child
+            # Recursively check children
+            result = self._find_identifier_in_declaration(child)
+            if result is not None:
+                return result
+        return None
+
+    def _is_uppercase_constant(self, name: str) -> bool:
+        """Check if identifier is UPPERCASE constant style.
+
+        Args:
+            name: Identifier name
+
+        Returns:
+            True if name is UPPERCASE with optional underscores
+        """
+        if not name:
+            return False
+        # Must be at least one letter and all letters must be uppercase
+        # Allow underscores and numbers
+        letters_only = "".join(c for c in name if c.isalpha())
+        if not letters_only:
+            return False
+        return letters_only.isupper()

src/linters/magic_numbers/violation_builder.py

@@ -0,0 +1,98 @@
+"""
+Purpose: Builds Violation objects for magic number detection
+
+Scope: Violation message construction for magic numbers linter
+
+Overview: Provides ViolationBuilder class that creates Violation objects for magic number detections.
+    Generates helpful, descriptive messages suggesting constant extraction for numeric literals.
+    Constructs complete Violation instances with rule_id, file_path, line number, column, message,
+    and suggestions. Formats messages to mention the specific numeric value and encourage using
+    named constants for better code maintainability and readability. Provides consistent violation
+    structure across all magic number detections.
+
+Dependencies: src.core.types for Violation dataclass, pathlib for Path handling, ast for node types
+
+Exports: ViolationBuilder class
+
+Interfaces: ViolationBuilder.create_violation(node, value, line, file_path) -> Violation,
+    builds complete Violation object with all required fields
+
+Implementation: Message template with value interpolation, structured violation construction
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.types import Violation
+
+
+class ViolationBuilder:
+    """Builds violations for magic number 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_violation(
+        self,
+        node: ast.Constant,
+        value: int | float,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a magic number.
+
+        Args:
+            node: The AST node containing the magic number
+            value: The numeric value
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the magic number
+        """
+        message = f"Magic number {value} should be a named constant"
+
+        suggestion = f"Extract {value} to a named constant (e.g., CONSTANT_NAME = {value})"
+
+        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,
+        value: int | float,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a TypeScript magic number.
+
+        Args:
+            value: The numeric value
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the magic number
+        """
+        message = f"Magic number {value} should be a named constant"
+
+        suggestion = f"Extract {value} to a named constant (e.g., const CONSTANT_NAME = {value})"
+
+        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 have easy column access
+            message=message,
+            suggestion=suggestion,
+        )

src/linters/nesting/__init__.py

@@ -22,7 +22,7 @@ Implementation: Simple re-export pattern for package interface, convenience func
 from pathlib import Path
 from typing import Any
 
-from .config import NestingConfig
+from .config import DEFAULT_MAX_NESTING_DEPTH, NestingConfig
 from .linter import NestingDepthRule
 from .python_analyzer import PythonNestingAnalyzer
 from .typescript_analyzer import TypeScriptNestingAnalyzer
@@ -36,7 +36,11 @@ __all__ = [
 ]
 
 
-def lint(path: Path | str, config: dict[str, Any] | None = None, max_depth: int = 4) -> list:
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+    max_depth: int = DEFAULT_MAX_NESTING_DEPTH,
+) -> list:
     """Lint a file or directory for nesting depth violations.
 
     Args:

src/linters/nesting/config.py

@@ -21,12 +21,15 @@ Implementation: Dataclass with validation and defaults, matches reference implem
 from dataclasses import dataclass
 from typing import Any
 
+# Default nesting threshold constant
+DEFAULT_MAX_NESTING_DEPTH = 4
+
 
 @dataclass
 class NestingConfig:
     """Configuration for nesting depth linter."""
 
-    max_nesting_depth: int = 4  # Default from reference implementation
+    max_nesting_depth: int = DEFAULT_MAX_NESTING_DEPTH  # Default from reference implementation
     enabled: bool = True
 
     def __post_init__(self) -> None:
@@ -49,10 +52,10 @@ class NestingConfig:
         if language and language in config:
             lang_config = config[language]
             max_nesting_depth = lang_config.get(
-                "max_nesting_depth", config.get("max_nesting_depth", 4)
+                "max_nesting_depth", config.get("max_nesting_depth", DEFAULT_MAX_NESTING_DEPTH)
             )
         else:
-            max_nesting_depth = config.get("max_nesting_depth", 4)
+            max_nesting_depth = config.get("max_nesting_depth", DEFAULT_MAX_NESTING_DEPTH)
 
         return cls(
             max_nesting_depth=max_nesting_depth,

src/linters/nesting/linter.py

@@ -21,8 +21,8 @@ Implementation: Composition pattern with helper classes, AST-based analysis with
 import ast
 from typing import Any
 
-from src.core.base import BaseLintContext, BaseLintRule
-from src.core.linter_utils import has_file_content, load_linter_config
+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
 
@@ -32,7 +32,7 @@ from .typescript_analyzer import TypeScriptNestingAnalyzer
 from .violation_builder import NestingViolationBuilder
 
 
-class NestingDepthRule(BaseLintRule):
+class NestingDepthRule(MultiLanguageLintRule):
     """Detects excessive nesting depth in functions."""
 
     def __init__(self) -> None:
@@ -55,27 +55,16 @@ class NestingDepthRule(BaseLintRule):
         """Description of what this rule checks."""
         return "Functions should not have excessive nesting depth for better readability"
 
-    def check(self, context: BaseLintContext) -> list[Violation]:
-        """Check for excessive nesting depth violations.
+    def _load_config(self, context: BaseLintContext) -> NestingConfig:
+        """Load configuration from context.
 
         Args:
-            context: Lint context with file information
+            context: Lint context
 
         Returns:
-            List of violations found
+            NestingConfig instance
         """
-        if not has_file_content(context):
-            return []
-
-        config = load_linter_config(context, "nesting", NestingConfig)
-        if not config.enabled:
-            return []
-
-        if context.language == "python":
-            return self._check_python(context, config)
-        if context.language in ("typescript", "javascript"):
-            return self._check_typescript(context, config)
-        return []
+        return load_linter_config(context, "nesting", NestingConfig)
 
     def _process_python_functions(
         self, functions: list, analyzer: Any, config: NestingConfig, context: BaseLintContext

src/linters/nesting/typescript_analyzer.py

@@ -22,6 +22,7 @@ from typing import Any
 
 from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
+# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
 try:
     from tree_sitter import Node
 

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