thailint 0.15.0__tar.gz → 0.15.2__tar.gz

{thailint-0.15.0 → thailint-0.15.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.15.0
+Version: 0.15.2
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
-Keywords: linter,ai,code-quality,static-analysis,file-placement,governance,multi-language,cli,docker,python,performance,typescript
+Keywords: linter,ai,code-quality,static-analysis,file-placement,governance,multi-language,cli,docker,python,performance,typescript,rust
 Author: Steve Jackson
 Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 4 - Beta
@@ -27,6 +27,7 @@ Requires-Dist: click (>=8.1.0,<9.0.0)
 Requires-Dist: pyprojroot (>=0.3.0,<0.4.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: tree-sitter (>=0.25.2,<0.26.0)
+Requires-Dist: tree-sitter-rust (>=0.23.2,<0.24.0)
 Requires-Dist: tree-sitter-typescript (>=0.23.2,<0.24.0)
 Project-URL: Documentation, https://thai-lint.readthedocs.io/
 Project-URL: Homepage, https://github.com/be-wise-be-kind/thai-lint
@@ -37,7 +38,7 @@ Description-Content-Type: text/markdown
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![PyPI](https://img.shields.io/pypi/v/thai-lint)](https://pypi.org/project/thai-lint/)
+[![PyPI](https://img.shields.io/pypi/v/thailint)](https://pypi.org/project/thailint/)
 [![Documentation](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/)
 
 **The AI Linter** - Catch the mistakes AI coding assistants keep making.
@@ -47,7 +48,7 @@ thailint detects anti-patterns that AI tools frequently introduce: duplicate cod
 ## Installation
 
 ```bash
-pip install thai-lint
+pip install thailint
 ```
 
 Or with Docker:
@@ -84,6 +85,7 @@ That's it. See violations, fix them, ship better code.
 | **Lazy Ignores** | Unjustified linting suppressions | `thailint lazy-ignores src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/lazy-ignores-linter/) |
 | **Print Statements** | Debug prints left in code | `thailint print-statements src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/print-statements-linter/) |
 | **Stringly Typed** | Strings that should be enums | `thailint stringly-typed src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/stringly-typed-linter/) |
+| **LBYL** | Look Before You Leap anti-patterns | `thailint lbyl src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/lbyl-linter/) |
 
 ## Configuration
 

{thailint-0.15.0 → thailint-0.15.2}/README.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![PyPI](https://img.shields.io/pypi/v/thai-lint)](https://pypi.org/project/thai-lint/)
+[![PyPI](https://img.shields.io/pypi/v/thailint)](https://pypi.org/project/thailint/)
 [![Documentation](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/)
 
 **The AI Linter** - Catch the mistakes AI coding assistants keep making.
@@ -12,7 +12,7 @@ thailint detects anti-patterns that AI tools frequently introduce: duplicate cod
 ## Installation
 
 ```bash
-pip install thai-lint
+pip install thailint
 ```
 
 Or with Docker:
@@ -49,6 +49,7 @@ That's it. See violations, fix them, ship better code.
 | **Lazy Ignores** | Unjustified linting suppressions | `thailint lazy-ignores src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/lazy-ignores-linter/) |
 | **Print Statements** | Debug prints left in code | `thailint print-statements src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/print-statements-linter/) |
 | **Stringly Typed** | Strings that should be enums | `thailint stringly-typed src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/stringly-typed-linter/) |
+| **LBYL** | Look Before You Leap anti-patterns | `thailint lbyl src/` | [Guide](https://thai-lint.readthedocs.io/en/latest/lbyl-linter/) |
 
 ## Configuration
 

{thailint-0.15.0 → thailint-0.15.2}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "thailint"
-version = "0.15.0"
+version = "0.15.2"
 description = "The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages"
 authors = ["Steve Jackson"]
 license = "MIT"
@@ -38,6 +38,7 @@ keywords = [
     "python",
     "performance",
     "typescript",
+    "rust",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -75,6 +76,7 @@ click = "^8.1.0"
 pyyaml = "^6.0"
 tree-sitter = "^0.25.2"
 tree-sitter-typescript = "^0.23.2"
+tree-sitter-rust = "^0.23.2"
 pyprojroot = "^0.3.0"
 
 [tool.poetry.group.dev.dependencies]

thailint-0.15.2/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)

thailint-0.15.2/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)

{thailint-0.15.0 → thailint-0.15.2}/src/cli/config.py

@@ -150,12 +150,14 @@ def config_get(ctx: click.Context, key: str) -> None:
 
 def _convert_value_type(value: str) -> bool | int | float | str:
     """Convert string value to appropriate type."""
+    from contextlib import suppress
+
     if value.lower() in ["true", "false"]:
         return value.lower() == "true"
-    if value.isdigit():
-        return int(value)
-    if value.replace(".", "", 1).isdigit() and value.count(".") == 1:
-        return float(value)
+    # Use EAFP pattern for numeric conversion
+    for converter in (int, float):
+        with suppress(ValueError):
+            return converter(value)
     return value
 
 

{thailint-0.15.0 → thailint-0.15.2}/src/cli/linters/code_patterns.py

@@ -1,17 +1,18 @@
 """
-Purpose: CLI commands for code pattern linters (print-statements, method-property, stateless-class, lazy-ignores)
+Purpose: CLI commands for code pattern linters (print-statements, method-property, stateless-class, lazy-ignores, lbyl)
 
 Scope: Commands that detect code patterns and anti-patterns in Python code
 
 Overview: Provides CLI commands for code pattern linting: print-statements detects print() and
     console.log calls that should use proper logging, method-property finds methods that should be
     @property decorators, stateless-class detects classes without state that should be module
-    functions, and lazy-ignores detects unjustified linting suppressions. Each command supports
-    standard options (config, format, recursive) and integrates with the orchestrator for execution.
+    functions, lazy-ignores detects unjustified linting suppressions, and lbyl detects Look Before
+    You Leap anti-patterns. Each command supports standard options (config, format, recursive) and
+    integrates with the orchestrator for execution.
 
 Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities
 
-Exports: print_statements command, method_property command, stateless_class command, lazy_ignores command
+Exports: print_statements, method_property, stateless_class, lazy_ignores, lbyl commands
 
 Interfaces: Click CLI commands registered to main CLI group
 
@@ -48,10 +49,10 @@ def _setup_print_statements_orchestrator(
 
 
 def _run_print_statements_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute print-statements lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if "print-statement" in v.rule_id]
 
 
@@ -62,7 +63,7 @@ def _execute_print_statements_lint(params: ExecuteParams) -> NoReturn:
         params.path_objs, params.config_file, params.verbose, params.project_root
     )
     print_statements_violations = _run_print_statements_lint(
-        orchestrator, params.path_objs, params.recursive
+        orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
     if params.verbose:
@@ -94,10 +95,10 @@ def _setup_method_property_orchestrator(
 
 
 def _run_method_property_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute method-property lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if "method-property" in v.rule_id]
 
 
@@ -108,7 +109,7 @@ def _execute_method_property_lint(params: ExecuteParams) -> NoReturn:
         params.path_objs, params.config_file, params.verbose, params.project_root
     )
     method_property_violations = _run_method_property_lint(
-        orchestrator, params.path_objs, params.recursive
+        orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
     if params.verbose:
@@ -141,10 +142,10 @@ def _setup_stateless_class_orchestrator(
 
 
 def _run_stateless_class_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute stateless-class lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if "stateless-class" in v.rule_id]
 
 
@@ -155,7 +156,7 @@ def _execute_stateless_class_lint(params: ExecuteParams) -> NoReturn:
         params.path_objs, params.config_file, params.verbose, params.project_root
     )
     stateless_class_violations = _run_stateless_class_lint(
-        orchestrator, params.path_objs, params.recursive
+        orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
     if params.verbose:
@@ -188,10 +189,10 @@ def _setup_lazy_ignores_orchestrator(
 
 
 def _run_lazy_ignores_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute lazy-ignores lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if v.rule_id.startswith("lazy-ignores")]
 
 
@@ -202,7 +203,7 @@ def _execute_lazy_ignores_lint(params: ExecuteParams) -> NoReturn:
         params.path_objs, params.config_file, params.verbose, params.project_root
     )
     lazy_ignores_violations = _run_lazy_ignores_lint(
-        orchestrator, params.path_objs, params.recursive
+        orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
     if params.verbose:
@@ -220,3 +221,50 @@ lazy_ignores = create_linter_command(
     "    corresponding entries in the file header's Suppressions section. Enforces a\n"
     "    header-based suppression model requiring human approval for all linting bypasses.",
 )
+
+
+# =============================================================================
+# LBYL Command
+# =============================================================================
+
+
+def _setup_lbyl_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for lbyl command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_lbyl_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute lbyl lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("lbyl")]
+
+
+def _execute_lbyl_lint(params: ExecuteParams) -> NoReturn:
+    """Execute lbyl lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_lbyl_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    lbyl_violations = _run_lbyl_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    if params.verbose:
+        logger.info(f"Found {len(lbyl_violations)} LBYL violation(s)")
+
+    format_violations(lbyl_violations, params.format)
+    sys.exit(1 if lbyl_violations else 0)
+
+
+lbyl = create_linter_command(
+    "lbyl",
+    _execute_lbyl_lint,
+    "Check for Look Before You Leap anti-patterns.",
+    "Detects LBYL (Look Before You Leap) anti-patterns in Python code that should\n"
+    "    be refactored to EAFP (Easier to Ask Forgiveness than Permission) style.\n"
+    "    Examples: 'if key in dict: dict[key]' should use try/except KeyError.",
+)