thailint 0.15.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

src/linters/lbyl/violation_builder.py

@@ -0,0 +1,354 @@
+"""
+Purpose: Build Violation objects with EAFP suggestions for LBYL patterns
+
+Scope: Creates violations for detected LBYL anti-patterns with fix suggestions
+
+Overview: Provides module-level functions that create Violation objects for LBYL
+    anti-patterns detected in Python code. Each violation includes the rule ID, location,
+    descriptive message, and an EAFP suggestion showing how to refactor the code using
+    try/except. Supports dict key check, hasattr, isinstance, file exists, len check,
+    None check, string validator, and division zero-check patterns.
+
+Dependencies: src.core.types for Violation, src.core.base for BaseLintContext
+
+Exports: build_dict_key_violation, build_hasattr_violation, build_isinstance_violation,
+    build_file_exists_violation, build_len_check_violation, create_syntax_error_violation,
+    build_none_check_violation, build_string_validator_violation, build_division_check_violation
+
+Interfaces: Module functions for building LBYL violations
+
+Implementation: Factory functions for each violation type with descriptive suggestions
+
+Suppressions:
+    too-many-arguments, too-many-positional-arguments: build_string_validator_violation
+        requires 6 parameters (file_path, line, column, string_name, validator_method,
+        conversion_func) to create accurate violation messages and suggestions
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+
+
+def build_dict_key_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    dict_name: str,
+    key_expression: str,
+) -> Violation:
+    """Build a violation for dict key LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        dict_name: Name of the dict being checked
+        key_expression: Expression used as key
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {key_expression} in {dict_name}' followed by "
+        f"'{dict_name}[{key_expression}]'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'with suppress(KeyError): value = {dict_name}[{key_expression}]' "
+        f"or 'try: ... except KeyError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.dict-key-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_hasattr_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    object_name: str,
+    attribute_name: str,
+) -> Violation:
+    """Build a violation for hasattr LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        object_name: Name of the object being checked
+        attribute_name: Name of the attribute being checked
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if hasattr({object_name}, '{attribute_name}')' followed by "
+        f"'{object_name}.{attribute_name}'"
+    )
+
+    suggestion = f"Use EAFP: 'try: {object_name}.{attribute_name} except AttributeError: ...'"
+
+    return Violation(
+        rule_id="lbyl.hasattr-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_isinstance_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    object_name: str,
+    type_name: str,
+) -> Violation:
+    """Build a violation for isinstance LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        object_name: Name of the object being checked
+        type_name: Name of the type being checked against
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if isinstance({object_name}, {type_name})' before type-specific operation"
+    )
+
+    suggestion = (
+        "Consider EAFP: 'try: ... except (TypeError, AttributeError): ...' "
+        "instead of isinstance check"
+    )
+
+    return Violation(
+        rule_id="lbyl.isinstance-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def create_syntax_error_violation(error: SyntaxError, context: BaseLintContext) -> Violation:
+    """Create a violation for a syntax error.
+
+    Args:
+        error: The SyntaxError from parsing
+        context: Lint context with file information
+
+    Returns:
+        Violation indicating syntax error
+    """
+    file_path = str(context.file_path) if context.file_path else "unknown"
+    line = error.lineno or 1
+    column = error.offset or 0
+
+    return Violation(
+        rule_id="lbyl.syntax-error",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=f"Syntax error: {error.msg}",
+        suggestion="Fix the syntax error before running LBYL analysis",
+    )
+
+
+def build_file_exists_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    path_expression: str,
+    check_type: str,
+) -> Violation:
+    """Build a violation for file exists LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        path_expression: Expression representing the file path being checked
+        check_type: Type of check ("os.path.exists", "Path.exists", "exists")
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {check_type}({path_expression})' followed by "
+        f"file operation on '{path_expression}'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: with open({path_expression}) as f: ... except FileNotFoundError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.file-exists-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_len_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    collection_name: str,
+    index_expression: str,
+) -> Violation:
+    """Build a violation for len check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        collection_name: Name of the collection being checked
+        index_expression: Expression used as index
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if len({collection_name}) > {index_expression}' followed by "
+        f"'{collection_name}[...]'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: value = {collection_name}[{index_expression}] except IndexError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.len-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_none_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    variable_name: str,
+) -> Violation:
+    """Build a violation for None check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        variable_name: Name of the variable being checked for None
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {variable_name} is not None' followed by '{variable_name}.<method>()'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: {variable_name}.<method>() except AttributeError: ...' "
+        f"or check if None is a valid state to handle differently"
+    )
+
+    return Violation(
+        rule_id="lbyl.none-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_string_validator_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    file_path: str,
+    line: int,
+    column: int,
+    string_name: str,
+    validator_method: str,
+    conversion_func: str,
+) -> Violation:
+    """Build a violation for string validator LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        string_name: Name of the string being validated
+        validator_method: Validation method used (isnumeric, isdigit, etc.)
+        conversion_func: Conversion function used (int, float)
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {string_name}.{validator_method}()' followed by "
+        f"'{conversion_func}({string_name})'"
+    )
+
+    suggestion = f"Use EAFP: 'try: value = {conversion_func}({string_name}) except ValueError: ...'"
+
+    return Violation(
+        rule_id="lbyl.string-validator",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_division_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    divisor_name: str,
+    operation: str,
+) -> Violation:
+    """Build a violation for division zero-check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        divisor_name: Name of the divisor being checked for zero
+        operation: Division operation used (/, //, %, /=, //=, %=)
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {divisor_name} != 0' followed by "
+        f"'{operation}' operation with '{divisor_name}'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: result = ... {operation} {divisor_name} except ZeroDivisionError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.division-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )

src/linters/srp/heuristics.py

@@ -4,12 +4,13 @@ Purpose: SRP detection heuristics for analyzing code complexity and responsibili
 Scope: Helper functions for method counting, LOC calculation, and keyword detection
 
 Overview: Provides heuristic-based analysis functions for detecting Single Responsibility
-    Principle violations. Implements method counting that excludes property decorators and
-    special methods. Provides LOC calculation that filters out blank lines and comments.
-    Includes keyword detection for identifying generic class names that often indicate SRP
-    violations (Manager, Handler, etc.). Supports both Python AST and TypeScript tree-sitter
-    nodes. These heuristics enable practical SRP detection without requiring perfect semantic
-    analysis, focusing on measurable code metrics that correlate with responsibility scope.
+    Principle violations. Implements method counting that excludes property decorators,
+    private methods, and special methods. Provides LOC calculation that filters out blank
+    lines and comments. Includes keyword detection for identifying generic class names that
+    often indicate SRP violations (Manager, Handler, etc.). Supports both Python AST and
+    TypeScript tree-sitter nodes. These heuristics enable practical SRP detection without
+    requiring perfect semantic analysis, focusing on measurable code metrics that correlate
+    with responsibility scope.
 
 Dependencies: ast module for Python AST analysis, typing for type hints
 
@@ -24,23 +25,55 @@ import ast
 
 
 def count_methods(class_node: ast.ClassDef) -> int:
-    """Count methods in a class (excludes properties and special methods).
+    """Count public methods in a class (excludes properties and private methods).
+
+    Private methods are those starting with underscore (_), including dunder
+    methods (__init__, __str__, etc.). This focuses SRP analysis on the public
+    interface rather than implementation details.
 
     Args:
         class_node: AST node representing a class definition
 
     Returns:
-        Number of methods in the class
+        Number of public methods in the class
     """
-    methods = 0
     func_nodes = (
         n for n in class_node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
     )
-    for node in func_nodes:
-        # Don't count @property decorators as methods
-        if not has_property_decorator(node):
-            methods += 1
-    return methods
+    public_methods = [n for n in func_nodes if _is_countable_method(n)]
+    return len(public_methods)
+
+
+def _is_countable_method(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if a method should be counted (public and not a property).
+
+    Args:
+        node: Function AST node
+
+    Returns:
+        True if method should be counted
+    """
+    if has_property_decorator(node):
+        return False
+    if _is_private_method(node.name):
+        return False
+    return True
+
+
+def _is_private_method(method_name: str) -> bool:
+    """Check if method is private (starts with underscore).
+
+    This includes both single underscore (_helper) and dunder methods
+    (__init__, __str__). All underscore-prefixed methods are considered
+    implementation details.
+
+    Args:
+        method_name: Name of the method to check
+
+    Returns:
+        True if method is private, False otherwise
+    """
+    return method_name.startswith("_")
 
 
 def count_loc(class_node: ast.ClassDef, source: str) -> int:

src/linters/srp/typescript_metrics_calculator.py

@@ -4,9 +4,10 @@ Purpose: TypeScript class metrics calculation for SRP analysis
 Scope: Calculates method count and lines of code for TypeScript classes
 
 Overview: Provides metrics calculation functionality for TypeScript classes in SRP analysis. Counts
-    public methods in class bodies (excludes constructors), calculates lines of code from AST node
-    positions, and identifies class body nodes. Uses tree-sitter AST node types. Isolates metrics
-    calculation from class analysis and tree traversal logic.
+    public methods in class bodies (excludes constructors and private methods starting with _),
+    calculates lines of code from AST node positions, and identifies class body nodes. Uses
+    tree-sitter AST node types. Isolates metrics calculation from class analysis and tree
+    traversal logic.
 
 Dependencies: typing
 
@@ -72,22 +73,45 @@ def _get_class_body(class_node: Any) -> Any:
 
 
 def _is_countable_method(node: Any) -> bool:
-    """Check if node is a method that should be counted.
+    """Check if node is a public method that should be counted.
+
+    Excludes constructors and private methods (names starting with _).
 
     Args:
         node: Tree-sitter node to check
 
     Returns:
-        True if node is a countable method
+        True if node is a countable public method
     """
     if node.type != "method_definition":
         return False
 
-    # Check if it's a constructor
-    return all(
-        not (child.type == "property_identifier" and child.text.decode() == "constructor")
-        for child in node.children
-    )
+    method_name = _get_method_name(node)
+
+    # Don't count constructors
+    if method_name == "constructor":
+        return False
+
+    # Don't count private methods (underscore prefix convention)
+    if method_name and method_name.startswith("_"):
+        return False
+
+    return True
+
+
+def _get_method_name(node: Any) -> str | None:
+    """Extract method name from method_definition node.
+
+    Args:
+        node: Method definition tree-sitter node
+
+    Returns:
+        Method name or None if not found
+    """
+    for child in node.children:
+        if child.type == "property_identifier":
+            return child.text.decode()
+    return None
 
 
 # Legacy class wrapper for backward compatibility

src/linters/stringly_typed/ignore_checker.py

@@ -19,6 +19,7 @@ Implementation: Uses cached IgnoreDirectiveParser singleton, reads file content
     supports both stringly-typed.* and stringly-typed specific rule matching
 """
 
+from contextlib import suppress
 from pathlib import Path
 
 from src.core.types import Violation
@@ -73,7 +74,7 @@ class IgnoreChecker:
         Returns:
             File content or empty string if unreadable
         """
-        if file_path in self._file_content_cache:
+        with suppress(KeyError):
             return self._file_content_cache[file_path]
 
         content = self._read_file_content(file_path)
@@ -90,12 +91,9 @@ class IgnoreChecker:
             File content or empty string if unreadable
         """
         try:
-            path = Path(file_path)
-            if path.exists():
-                return path.read_text(encoding="utf-8")
+            return Path(file_path).read_text(encoding="utf-8")
         except (OSError, UnicodeDecodeError):
-            pass
-        return ""
+            return ""
 
     def clear_cache(self) -> None:
         """Clear file content cache."""

src/orchestrator/language_detector.py

@@ -17,12 +17,13 @@ Dependencies: pathlib for file path handling and content reading
 Exports: detect_language(file_path: Path) -> str function, EXTENSION_MAP constant
 
 Interfaces: detect_language(file_path: Path) -> str returns language identifier string
-    (python, javascript, typescript, java, go, unknown)
+    (python, javascript, typescript, java, go, rust, unknown)
 
 Implementation: Dictionary-based extension lookup for O(1) detection, first-line shebang
     parsing with substring matching, lazy file reading only when extension unknown
 """
 
+from contextlib import suppress
 from pathlib import Path
 
 # Extension to language mapping
@@ -34,6 +35,7 @@ EXTENSION_MAP = {
     ".jsx": "javascript",
     ".java": "java",
     ".go": "go",
+    ".rs": "rust",
 }
 
 
@@ -67,10 +69,10 @@ def detect_language(file_path: Path) -> str:
         file_path: Path to file to analyze.
 
     Returns:
-        Language identifier (python, javascript, typescript, java, go, unknown).
+        Language identifier (python, javascript, typescript, java, go, rust, unknown).
     """
     ext = file_path.suffix.lower()
-    if ext in EXTENSION_MAP:
+    with suppress(KeyError):
         return EXTENSION_MAP[ext]
 
     if file_path.exists() and file_path.stat().st_size > 0:

{thailint-0.15.0.dist-info → thailint-0.15.2.dist-info}/METADATA

@@ -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