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

src/__init__.py

@@ -19,6 +19,7 @@ Exports: __version__, Linter (high-level API), cli (CLI entry point), load_confi
 Interfaces: Package version string, Linter class API, CLI command group, configuration functions
 """
 
+__version__: str
 try:
     from importlib.metadata import version
 

src/analyzers/__init__.py

@@ -9,15 +9,16 @@ Overview: Package containing base analyzer classes for different programming lan
     (TypeScriptBaseAnalyzer, etc.) that linter-specific analyzers extend. Centralizes
     language parsing infrastructure to improve maintainability and consistency.
 
-Dependencies: tree-sitter, language-specific tree-sitter bindings
+Dependencies: tree-sitter, language-specific tree-sitter bindings, ast module
 
-Exports: TypeScriptBaseAnalyzer
+Exports: TypeScriptBaseAnalyzer, build_parent_map
 
 Interfaces: Base analyzer classes with parse(), walk_tree(), and extract() methods
 
 Implementation: Composition-based design for linter analyzers to use base utilities
 """
 
+from .ast_utils import build_parent_map
 from .typescript_base import TypeScriptBaseAnalyzer
 
-__all__ = ["TypeScriptBaseAnalyzer"]
+__all__ = ["TypeScriptBaseAnalyzer", "build_parent_map"]

src/analyzers/ast_utils.py

@@ -0,0 +1,54 @@
+"""
+Purpose: Common Python AST utilities for linter analyzers
+
+Scope: Shared AST traversal utilities for Python code analysis
+
+Overview: Provides common AST utility functions used across multiple Python linters.
+    Centralizes shared patterns like parent map building to eliminate code duplication.
+    The build_parent_map function creates a dictionary mapping AST nodes to their parents,
+    enabling upward tree traversal for context detection.
+
+Dependencies: ast module for AST node types
+
+Exports: build_parent_map
+
+Interfaces: build_parent_map(tree: ast.AST) -> dict[ast.AST, ast.AST]
+
+Implementation: Recursive AST traversal with parent tracking
+"""
+
+import ast
+
+
+def build_parent_map(tree: ast.AST) -> dict[ast.AST, ast.AST]:
+    """Build a map of AST nodes to their parent nodes.
+
+    Enables upward tree traversal for context detection (e.g., finding if a node
+    is inside a particular block type).
+
+    Args:
+        tree: Root AST node to build map from
+
+    Returns:
+        Dictionary mapping each node to its parent node
+    """
+    parent_map: dict[ast.AST, ast.AST] = {}
+    _build_parent_map_recursive(tree, None, parent_map)
+    return parent_map
+
+
+def _build_parent_map_recursive(
+    node: ast.AST, parent: ast.AST | None, parent_map: dict[ast.AST, ast.AST]
+) -> None:
+    """Recursively build parent map.
+
+    Args:
+        node: Current AST node
+        parent: Parent of current node
+        parent_map: Dictionary to populate
+    """
+    if parent is not None:
+        parent_map[node] = parent
+
+    for child in ast.iter_child_nodes(node):
+        _build_parent_map_recursive(child, node, parent_map)

src/analyzers/rust_base.py

@@ -0,0 +1,155 @@
+"""
+Purpose: Base class for Rust AST analysis with tree-sitter parsing
+
+Scope: Common tree-sitter initialization, parsing, and traversal utilities for Rust
+
+Overview: Provides shared infrastructure for Rust code analysis using tree-sitter parser.
+    Implements common tree-sitter initialization with language setup and parser configuration.
+    Provides reusable parsing methods that convert Rust source to AST nodes. Includes
+    shared traversal utilities for walking AST trees recursively and finding nodes by type.
+    Delegates context-specific detection (test functions, async functions) to rust_context
+    module. Serves as foundation for specialized Rust analyzers (unwrap abuse, clone abuse).
+
+Dependencies: tree-sitter, tree-sitter-rust (optional), src.analyzers.rust_context
+
+Exports: RustBaseAnalyzer class with parsing and traversal utilities,
+    TREE_SITTER_RUST_AVAILABLE constant for runtime detection
+
+Interfaces: parse_rust(code), walk_tree(node, node_type), extract_node_text(node),
+    is_inside_test(node), is_async_function(node)
+
+Implementation: Tree-sitter parser singleton, recursive AST traversal, composition pattern
+    with rust_context helpers
+
+Suppressions:
+    - type:ignore[assignment]: Tree-sitter RUST_PARSER fallback when import fails
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+"""
+
+from typing import Any
+
+from src.analyzers import rust_context
+
+try:
+    import tree_sitter_rust as tsrust
+    from tree_sitter import Language, Node, Parser
+
+    RUST_LANGUAGE = Language(tsrust.language())
+    RUST_PARSER = Parser(RUST_LANGUAGE)
+    TREE_SITTER_RUST_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_RUST_AVAILABLE = False
+    RUST_PARSER = None  # type: ignore[assignment]
+    Node = Any  # type: ignore[assignment,misc]
+
+
+class RustBaseAnalyzer:
+    """Base analyzer for Rust code using tree-sitter."""
+
+    def __init__(self) -> None:
+        """Initialize Rust base analyzer."""
+        self.tree_sitter_available = TREE_SITTER_RUST_AVAILABLE
+
+    def parse_rust(self, code: str) -> Node | None:
+        """Parse Rust code to AST using tree-sitter.
+
+        Args:
+            code: Rust source code to parse
+
+        Returns:
+            Tree-sitter AST root node, or None if parsing fails or tree-sitter unavailable
+        """
+        if not TREE_SITTER_RUST_AVAILABLE or RUST_PARSER is None:
+            return None
+
+        tree = RUST_PARSER.parse(bytes(code, "utf8"))
+        return tree.root_node
+
+    def walk_tree(self, node: Node, node_type: str) -> list[Node]:
+        """Find all nodes of a specific type in the AST.
+
+        Recursively walks the tree and collects all nodes matching the given type.
+
+        Args:
+            node: Root tree-sitter node to search from
+            node_type: Tree-sitter node type to find (e.g., "function_item")
+
+        Returns:
+            List of all matching nodes
+        """
+        if not TREE_SITTER_RUST_AVAILABLE or node is None:
+            return []
+
+        nodes: list[Node] = []
+        self._walk_tree_recursive(node, node_type, nodes)
+        return nodes
+
+    def _walk_tree_recursive(self, node: Node, node_type: str, nodes: list[Node]) -> None:
+        """Recursively walk tree to find nodes of specific type.
+
+        Args:
+            node: Current tree-sitter node
+            node_type: Node type to find
+            nodes: List to accumulate matching nodes
+        """
+        if node.type == node_type:
+            nodes.append(node)
+
+        for child in node.children:
+            self._walk_tree_recursive(child, node_type, nodes)
+
+    def extract_node_text(self, node: Node) -> str:
+        """Extract text content from a tree-sitter node.
+
+        Args:
+            node: Tree-sitter node
+
+        Returns:
+            Decoded text content of the node
+        """
+        text = node.text
+        if text is None:
+            return ""
+        return text.decode()
+
+    def extract_identifier_name(self, node: Node) -> str:
+        """Extract identifier name from node children.
+
+        Common pattern for extracting names from function/struct declarations.
+
+        Args:
+            node: Node to extract identifier from
+
+        Returns:
+            Identifier name or "anonymous" fallback
+        """
+        for child in node.children:
+            if child.type == "identifier":
+                return self.extract_node_text(child)
+        return "anonymous"
+
+    def is_inside_test(self, node: Node) -> bool:
+        """Check if node is inside a test function or module.
+
+        Delegates to rust_context module for implementation.
+
+        Args:
+            node: Tree-sitter node to check
+
+        Returns:
+            True if the node is inside a test function or test module
+        """
+        return rust_context.is_inside_test(node)
+
+    def is_async_function(self, node: Node) -> bool:
+        """Check if a function_item is async.
+
+        Delegates to rust_context module for implementation.
+
+        Args:
+            node: Function item node to check
+
+        Returns:
+            True if the function is declared as async
+        """
+        return rust_context.is_async_function(node)

src/analyzers/rust_context.py

@@ -0,0 +1,141 @@
+"""
+Purpose: Rust-specific AST context detection utilities
+
+Scope: Helper functions for detecting test contexts and async functions in Rust code
+
+Overview: Provides standalone helper functions for analyzing Rust AST context information.
+    Includes functions for detecting if code is inside a test function or module by checking
+    for #[test] or #[cfg(test)] attributes on preceding siblings, and for detecting async
+    functions by checking for function_modifiers. These utilities are designed to be used
+    in composition with RustBaseAnalyzer for Rust-specific lint rules that need to understand
+    code context.
+
+Dependencies: tree-sitter (for Node type when available)
+
+Exports: is_inside_test, is_async_function, has_test_attribute, has_cfg_test_attribute
+
+Interfaces: All functions take tree-sitter Node objects and return bool
+
+Implementation: Sibling-based attribute lookup for Rust AST structure, iterative parent
+    traversal for context detection
+
+Suppressions:
+    - misc,assignment: Node type alias when tree-sitter optional dependency unavailable
+"""
+
+from typing import Any
+
+try:
+    from tree_sitter import Node
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+    Node = Any  # type: ignore[misc,assignment]
+
+
+def _get_node_text(node: Node) -> str:
+    """Get decoded text from a node.
+
+    Args:
+        node: Tree-sitter node
+
+    Returns:
+        Decoded text content
+    """
+    return node.text.decode() if node.text else ""
+
+
+def has_test_attribute(function_node: Node) -> bool:
+    """Check if a function has #[test] attribute as preceding sibling.
+
+    Args:
+        function_node: Function item node
+
+    Returns:
+        True if function has #[test] attribute
+    """
+    prev_sibling = function_node.prev_sibling
+    while prev_sibling is not None and prev_sibling.type == "attribute_item":
+        if "test" in _get_node_text(prev_sibling):
+            return True
+        prev_sibling = prev_sibling.prev_sibling
+    return False
+
+
+def has_cfg_test_attribute(mod_node: Node) -> bool:
+    """Check if a module has #[cfg(test)] attribute as preceding sibling.
+
+    Args:
+        mod_node: Module item node
+
+    Returns:
+        True if module has #[cfg(test)] attribute
+    """
+    prev_sibling = mod_node.prev_sibling
+    while prev_sibling is not None and prev_sibling.type == "attribute_item":
+        if "cfg(test)" in _get_node_text(prev_sibling):
+            return True
+        prev_sibling = prev_sibling.prev_sibling
+    return False
+
+
+def is_inside_test(node: Node) -> bool:
+    """Check if node is inside a test function or module.
+
+    Walks up the tree looking for #[test] or #[cfg(test)] attributes.
+
+    Args:
+        node: Tree-sitter node to check
+
+    Returns:
+        True if the node is inside a test function or test module
+    """
+    current: Node | None = node
+    while current is not None:
+        if _is_test_context(current):
+            return True
+        current = current.parent
+    return False
+
+
+def _is_test_context(node: Node) -> bool:
+    """Check if a node represents a test context.
+
+    Args:
+        node: Node to check
+
+    Returns:
+        True if node is a test function or test module
+    """
+    if node.type == "function_item":
+        return has_test_attribute(node)
+    if node.type == "mod_item":
+        return has_cfg_test_attribute(node)
+    return False
+
+
+def is_async_function(node: Node) -> bool:
+    """Check if a function_item is async.
+
+    Args:
+        node: Function item node to check
+
+    Returns:
+        True if the function is declared as async
+    """
+    return any(
+        child.type == "function_modifiers" and _has_async_modifier(child) for child in node.children
+    )
+
+
+def _has_async_modifier(modifiers_node: Node) -> bool:
+    """Check if function_modifiers node contains async keyword.
+
+    Args:
+        modifiers_node: The function_modifiers node
+
+    Returns:
+        True if async keyword is present
+    """
+    return any(modifier.type == "async" for modifier in modifiers_node.children)

src/analyzers/typescript_base.py

@@ -18,6 +18,10 @@ Exports: TypeScriptBaseAnalyzer class with parsing and traversal utilities
 Interfaces: parse_typescript(code), walk_tree(node, node_type), extract_node_text(node)
 
 Implementation: Tree-sitter parser singleton, recursive AST traversal, composition pattern
+
+Suppressions:
+    - type:ignore[assignment]: Tree-sitter TS_PARSER fallback when import fails
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
 from typing import Any

src/cli/__init__.py

@@ -0,0 +1,30 @@
+"""
+Purpose: CLI package entry point and public API for thai-lint command-line interface
+
+Scope: Re-export fully configured CLI with all commands registered
+
+Overview: Provides the public API for the modular CLI package by re-exporting the CLI group from
+    src.cli.main and triggering command registration by importing submodules. Importing from this
+    module (src.cli) gives access to the complete CLI with all commands. Maintains backward
+    compatibility with code that imports from src.cli while enabling modular organization.
+
+Dependencies: src.cli.main for CLI group, src.cli.config for config commands, src.cli.linters
+    for linter commands
+
+Exports: cli (main Click command group with all commands registered)
+
+Interfaces: Single import point for CLI access via 'from src.cli import cli'
+
+Implementation: Imports submodules to trigger command registration via Click decorators
+
+Suppressions:
+    - F401: Module re-exports required for public API interface
+"""
+
+# Import the CLI group from main module
+# Import config and linters to register their commands with the CLI group
+from src.cli import config as _config_module  # noqa: F401
+from src.cli import linters as _linters_module  # noqa: F401
+from src.cli.main import cli  # noqa: F401
+
+__all__ = ["cli"]

src/cli/__main__.py

@@ -0,0 +1,22 @@
+"""
+Purpose: Entry point for running thai-lint CLI as a module (python -m src.cli)
+
+Scope: Module execution support for direct CLI invocation
+
+Overview: Enables running the CLI via 'python -m src.cli' by invoking the main cli group.
+    This file is executed when the package is run as a module, providing an alternative
+    entry point to the installed 'thailint' command.
+
+Dependencies: src.cli for fully configured CLI
+
+Exports: None (execution entry point only)
+
+Interfaces: Command-line invocation via 'python -m src.cli [command] [args]'
+
+Implementation: Imports and invokes cli() from the package
+"""
+
+from src.cli import cli
+
+if __name__ == "__main__":
+    cli()