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

src/linter_config/loader.py

@@ -16,9 +16,9 @@ Overview: Loads linter configuration from .thailint.yaml or .thailint.json files
 Dependencies: PyYAML for YAML parsing with safe_load(), json (stdlib) for JSON parsing,
     pathlib for file path handling
 
-Exports: LinterConfigLoader class
+Exports: load_config function, get_defaults function, LinterConfigLoader class (compat)
 
-Interfaces: load(config_path: Path) -> dict[str, Any] for loading config files,
+Interfaces: load_config(config_path: Path) -> dict[str, Any] for loading config files,
     get_defaults() -> dict[str, Any] for default configuration structure
 
 Implementation: Extension-based format detection (.yaml/.yml vs .json), yaml.safe_load()
@@ -31,13 +31,51 @@ from typing import Any
 from src.core.config_parser import parse_config_file
 
 
+def get_defaults() -> dict[str, Any]:
+    """Get default configuration.
+
+    Returns:
+        Default configuration with empty rules and ignore lists.
+    """
+    return {
+        "rules": {},
+        "ignore": [],
+    }
+
+
+def load_config(config_path: Path) -> dict[str, Any]:
+    """Load configuration from file.
+
+    Args:
+        config_path: Path to YAML or JSON config file.
+
+    Returns:
+        Configuration dictionary.
+
+    Raises:
+        ConfigParseError: If file format is unsupported or parsing fails.
+    """
+    if not config_path.exists():
+        return get_defaults()
+
+    return parse_config_file(config_path)
+
+
+# Legacy class wrapper for backward compatibility
 class LinterConfigLoader:
     """Load linter configuration from YAML or JSON files.
 
     Supports loading from .thailint.yaml, .thailint.json, or custom paths.
     Provides sensible defaults when config files don't exist.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
     """
 
+    def __init__(self) -> None:
+        """Initialize the loader."""
+        pass  # No state needed
+
     def load(self, config_path: Path) -> dict[str, Any]:
         """Load configuration from file.
 
@@ -50,18 +88,13 @@ class LinterConfigLoader:
         Raises:
             ConfigParseError: If file format is unsupported or parsing fails.
         """
-        if not config_path.exists():
-            return self.get_defaults()
-
-        return parse_config_file(config_path)
+        return load_config(config_path)
 
-    def get_defaults(self) -> dict[str, Any]:
-        """Get default configuration.
+    @property
+    def defaults(self) -> dict[str, Any]:
+        """Default configuration.
 
         Returns:
             Default configuration with empty rules and ignore lists.
         """
-        return {
-            "rules": {},
-            "ignore": [],
-        }
+        return get_defaults()

src/linter_config/pattern_utils.py

@@ -0,0 +1,65 @@
+"""
+Purpose: Pattern matching utilities for file paths and content parsing
+
+Scope: Gitignore-style pattern matching and content parsing
+
+Overview: Provides utility functions for matching file paths against gitignore-style
+    patterns and extracting patterns from configuration files. Supports directory
+    patterns (trailing /), standard glob patterns via fnmatch, and comment filtering.
+
+Dependencies: fnmatch for glob pattern matching, pathlib for path operations
+
+Exports: matches_pattern, extract_patterns_from_content
+
+Interfaces: matches_pattern(path, pattern) -> bool, extract_patterns_from_content(content) -> list
+
+Implementation: fnmatch-based pattern matching with directory-aware logic
+"""
+
+import fnmatch
+from pathlib import Path
+
+
+def matches_pattern(path: str, pattern: str) -> bool:
+    """Check if path matches gitignore-style pattern.
+
+    Args:
+        path: File path to check.
+        pattern: Gitignore-style pattern.
+
+    Returns:
+        True if path matches pattern.
+    """
+    if pattern.endswith("/"):
+        return _matches_directory_pattern(path, pattern)
+    return fnmatch.fnmatch(path, pattern) or fnmatch.fnmatch(str(Path(path)), pattern)
+
+
+def _matches_directory_pattern(path: str, pattern: str) -> bool:
+    """Check if path matches a directory pattern (trailing /).
+
+    Args:
+        path: File path to check
+        pattern: Directory pattern ending with /
+
+    Returns:
+        True if path is within the directory
+    """
+    dir_pattern = pattern.rstrip("/")
+    path_parts = Path(path).parts
+    if dir_pattern in path_parts:
+        return True
+    return fnmatch.fnmatch(path, dir_pattern + "*")
+
+
+def extract_patterns_from_content(content: str) -> list[str]:
+    """Extract non-empty, non-comment patterns from content.
+
+    Args:
+        content: File content with patterns (one per line)
+
+    Returns:
+        List of valid patterns (non-empty, non-comment lines)
+    """
+    lines = [line.strip() for line in content.splitlines()]
+    return [line for line in lines if line and not line.startswith("#")]

src/linter_config/rule_matcher.py

@@ -0,0 +1,89 @@
+"""
+Purpose: Rule ID matching utilities for ignore directive processing
+
+Scope: Pattern matching between rule IDs and ignore patterns
+
+Overview: Provides functions for matching rule IDs against ignore patterns. Supports
+    exact matching, wildcard matching (*.suffix), and prefix matching (category matches
+    category.specific). All comparisons are case-insensitive to handle variations in
+    rule ID formatting.
+
+Dependencies: re for regex operations
+
+Exports: rule_matches, check_bracket_rules, check_space_separated_rules
+
+Interfaces: rule_matches(rule_id, pattern) -> bool for checking if rule matches pattern
+
+Implementation: String-based pattern matching with wildcard and prefix support
+"""
+
+import re
+
+
+def rule_matches(rule_id: str, pattern: str) -> bool:
+    """Check if rule ID matches pattern (supports wildcards and prefixes).
+
+    Args:
+        rule_id: Rule ID to check (e.g., "nesting.excessive-depth").
+        pattern: Pattern with optional wildcard (e.g., "nesting.*" or "nesting").
+
+    Returns:
+        True if rule matches pattern.
+    """
+    rule_id_lower = rule_id.lower()
+    pattern_lower = pattern.lower()
+
+    if pattern_lower.endswith("*"):
+        prefix = pattern_lower[:-1]
+        return rule_id_lower.startswith(prefix)
+
+    if rule_id_lower == pattern_lower:
+        return True
+
+    if rule_id_lower.startswith(pattern_lower + "."):
+        return True
+
+    return False
+
+
+def check_bracket_rules(rules_text: str, rule_id: str) -> bool:
+    """Check if bracketed rules match the rule ID.
+
+    Args:
+        rules_text: Comma-separated rule patterns from bracket syntax
+        rule_id: Rule ID to match against
+
+    Returns:
+        True if any pattern matches the rule ID
+    """
+    ignored_rules = [r.strip() for r in rules_text.split(",")]
+    return any(rule_matches(rule_id, r) for r in ignored_rules)
+
+
+def check_space_separated_rules(rules_text: str, rule_id: str) -> bool:
+    """Check if space-separated rules match the rule ID.
+
+    Args:
+        rules_text: Space or comma-separated rule patterns
+        rule_id: Rule ID to match against
+
+    Returns:
+        True if any pattern matches the rule ID
+    """
+    ignored_rules = [r.strip() for r in re.split(r"[,\s]+", rules_text) if r.strip()]
+    return any(rule_matches(rule_id, r) for r in ignored_rules)
+
+
+def rules_match_violation(ignored_rules: set[str], rule_id: str) -> bool:
+    """Check if any of the ignored rules match the violation rule ID.
+
+    Args:
+        ignored_rules: Set of rule patterns to check
+        rule_id: Rule ID of the violation
+
+    Returns:
+        True if any pattern matches (or if wildcard "*" is present)
+    """
+    if "*" in ignored_rules:
+        return True
+    return any(rule_matches(rule_id, pattern) for pattern in ignored_rules)

src/linters/collection_pipeline/__init__.py

@@ -0,0 +1,90 @@
+"""
+Purpose: Collection pipeline linter package initialization
+
+Scope: Exports for collection-pipeline linter module
+
+Overview: Initializes the collection-pipeline linter package and exposes the main rule class
+    for external use. Exports CollectionPipelineRule as the primary interface for the linter,
+    allowing the orchestrator to discover and instantiate the rule. Also exports configuration
+    and detector 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 collection-pipeline linter functionality within the thai-lint framework.
+
+Dependencies: CollectionPipelineRule, CollectionPipelineConfig, PipelinePatternDetector
+
+Exports: CollectionPipelineRule (primary), CollectionPipelineConfig, PipelinePatternDetector, lint
+
+Interfaces: Standard Python package initialization with __all__ for explicit exports
+
+Implementation: Simple re-export pattern for package interface, convenience lint function
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .config import DEFAULT_MIN_CONTINUES, CollectionPipelineConfig
+from .detector import PatternMatch, PipelinePatternDetector
+from .linter import CollectionPipelineRule
+
+__all__ = [
+    "CollectionPipelineRule",
+    "CollectionPipelineConfig",
+    "PipelinePatternDetector",
+    "PatternMatch",
+    "lint",
+]
+
+
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+    min_continues: int = DEFAULT_MIN_CONTINUES,
+) -> list:
+    """Lint a file or directory for collection pipeline violations.
+
+    Args:
+        path: Path to file or directory to lint
+        config: Configuration dict (optional, uses defaults if not provided)
+        min_continues: Minimum if/continue patterns to flag (default: 1)
+
+    Returns:
+        List of violations found
+
+    Example:
+        >>> from src.linters.collection_pipeline import lint
+        >>> violations = lint('src/my_module.py', min_continues=2)
+        >>> 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_pipeline_orchestrator(project_root, config, min_continues)
+    violations = _execute_pipeline_lint(orchestrator, path_obj)
+
+    return [v for v in violations if "collection-pipeline" in v.rule_id]
+
+
+def _setup_pipeline_orchestrator(
+    project_root: Path, config: dict[str, Any] | None, min_continues: int
+) -> Any:
+    """Set up orchestrator with collection-pipeline config."""
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config:
+        orchestrator.config["collection-pipeline"] = config
+    else:
+        orchestrator.config["collection-pipeline"] = {"min_continues": min_continues}
+
+    return orchestrator
+
+
+def _execute_pipeline_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/collection_pipeline/any_all_analyzer.py

@@ -0,0 +1,281 @@
+"""
+Purpose: Analyze any()/all() anti-patterns in for loops
+
+Scope: Extract and validate loops that return True/False and could use any()/all()
+
+Overview: Provides helper functions for analyzing loops that iterate and return boolean
+    values based on conditions. Detects patterns like 'for x in iter: if cond: return True;
+    return False' which can be refactored to 'return any(cond for x in iter)'. Also handles
+    the inverse all() pattern. Requires function context to analyze return statements.
+
+Dependencies: ast module for Python AST processing
+
+Exports: extract_any_pattern, extract_all_pattern, AnyAllMatch dataclass
+
+Interfaces: Functions for analyzing any/all patterns in AST function bodies
+
+Implementation: AST-based pattern matching for any/all pattern identification
+"""
+
+import ast
+from dataclasses import dataclass
+from typing import cast
+
+from . import ast_utils
+
+
+@dataclass
+class AnyAllMatch:
+    """Information about a detected any()/all() pattern."""
+
+    for_node: ast.For
+    """The for loop AST node."""
+
+    condition: ast.expr
+    """The condition expression inside the if statement."""
+
+    is_any: bool
+    """True for any() pattern, False for all() pattern."""
+
+
+def extract_any_pattern(func_body: list[ast.stmt], for_node: ast.For) -> AnyAllMatch | None:
+    """Extract any() pattern from a for loop in a function body.
+
+    Pattern: for x in iter: if cond: return True; return False
+
+    Args:
+        func_body: List of statements in the function body
+        for_node: The for loop AST node to analyze
+
+    Returns:
+        AnyAllMatch if pattern detected, None otherwise
+    """
+    # Check for/else - different semantics, skip
+    if for_node.orelse:
+        return None
+
+    # Check loop body has exactly one if statement with return True
+    if_return_true = _extract_if_return_true(for_node.body)
+    if if_return_true is None:
+        return None
+
+    # Find position of for loop in function body
+    for_index = _get_stmt_index(func_body, for_node)
+    if for_index is None:
+        return None
+
+    # Check next statement is return False
+    if not _is_next_stmt_return_false(func_body, for_index):
+        return None
+
+    return AnyAllMatch(
+        for_node=for_node,
+        condition=if_return_true.test,
+        is_any=True,
+    )
+
+
+def extract_all_pattern(func_body: list[ast.stmt], for_node: ast.For) -> AnyAllMatch | None:
+    """Extract all() pattern from a for loop in a function body.
+
+    Pattern: for x in iter: if not cond: return False; return True
+
+    Args:
+        func_body: List of statements in the function body
+        for_node: The for loop AST node to analyze
+
+    Returns:
+        AnyAllMatch if pattern detected, None otherwise
+    """
+    # Check for/else - different semantics, skip
+    if for_node.orelse:
+        return None
+
+    # Check loop body has exactly one if statement with return False
+    if_return_false = _extract_if_return_false(for_node.body)
+    if if_return_false is None:
+        return None
+
+    # Find position of for loop in function body
+    for_index = _get_stmt_index(func_body, for_node)
+    if for_index is None:
+        return None
+
+    # Check next statement is return True
+    if not _is_next_stmt_return_true(func_body, for_index):
+        return None
+
+    # Invert the condition for all() suggestion
+    condition = _invert_condition(if_return_false.test)
+
+    return AnyAllMatch(
+        for_node=for_node,
+        condition=condition,
+        is_any=False,
+    )
+
+
+def _is_simple_if_return(stmt: ast.stmt) -> ast.Return | None:
+    """Check if statement is simple if with single return and no else.
+
+    Args:
+        stmt: Statement to check
+
+    Returns:
+        The return statement if pattern matches, None otherwise
+    """
+    if not isinstance(stmt, ast.If):
+        return None
+    if stmt.orelse:
+        return None
+    if len(stmt.body) != 1:
+        return None
+    if not isinstance(stmt.body[0], ast.Return):
+        return None
+    return stmt.body[0]
+
+
+def _extract_if_return_true(body: list[ast.stmt]) -> ast.If | None:
+    """Extract if statement that only contains return True.
+
+    Args:
+        body: List of statements in for loop body
+
+    Returns:
+        The if statement if pattern matches, None otherwise
+    """
+    if len(body) != 1:
+        return None
+
+    stmt = body[0]
+    return_stmt = _is_simple_if_return(stmt)
+    if return_stmt is None:
+        return None
+
+    if not _is_literal_true(return_stmt.value):
+        return None
+
+    return cast(ast.If, stmt)
+
+
+def _extract_if_return_false(body: list[ast.stmt]) -> ast.If | None:
+    """Extract if statement that only contains return False.
+
+    Args:
+        body: List of statements in for loop body
+
+    Returns:
+        The if statement if pattern matches, None otherwise
+    """
+    if len(body) != 1:
+        return None
+
+    stmt = body[0]
+    return_stmt = _is_simple_if_return(stmt)
+    if return_stmt is None:
+        return None
+
+    if not _is_literal_false(return_stmt.value):
+        return None
+
+    return cast(ast.If, stmt)
+
+
+def _get_stmt_index(func_body: list[ast.stmt], target: ast.stmt) -> int | None:
+    """Find index of a statement in a function body.
+
+    Args:
+        func_body: List of statements in function body
+        target: Statement to find
+
+    Returns:
+        Index if found, None otherwise
+    """
+    for i, stmt in enumerate(func_body):
+        if stmt is target:
+            return i
+    return None
+
+
+def _is_next_stmt_return_false(func_body: list[ast.stmt], for_index: int) -> bool:
+    """Check if the next statement after for loop is return False.
+
+    Args:
+        func_body: List of statements in function body
+        for_index: Index of the for loop
+
+    Returns:
+        True if next statement is return False
+    """
+    stmt = ast_utils.get_next_return_stmt(func_body, for_index)
+    if stmt is None:
+        return False
+    return _is_literal_false(stmt.value)
+
+
+def _is_next_stmt_return_true(func_body: list[ast.stmt], for_index: int) -> bool:
+    """Check if the next statement after for loop is return True.
+
+    Args:
+        func_body: List of statements in function body
+        for_index: Index of the for loop
+
+    Returns:
+        True if next statement is return True
+    """
+    stmt = ast_utils.get_next_return_stmt(func_body, for_index)
+    if stmt is None:
+        return False
+    return _is_literal_true(stmt.value)
+
+
+def _is_literal_true(node: ast.expr | None) -> bool:
+    """Check if expression is literal True.
+
+    Args:
+        node: AST expression node
+
+    Returns:
+        True if node is literal True
+    """
+    if node is None:
+        return False
+    if isinstance(node, ast.Constant):
+        return node.value is True
+    return False
+
+
+def _is_literal_false(node: ast.expr | None) -> bool:
+    """Check if expression is literal False.
+
+    Args:
+        node: AST expression node
+
+    Returns:
+        True if node is literal False
+    """
+    if node is None:
+        return False
+    if isinstance(node, ast.Constant):
+        return node.value is False
+    return False
+
+
+def _invert_condition(node: ast.expr) -> ast.expr:
+    """Invert a boolean condition.
+
+    If condition is 'not x', returns 'x'.
+    Otherwise wraps in 'not (...)'.
+
+    Args:
+        node: AST expression to invert
+
+    Returns:
+        Inverted expression
+    """
+    # If already negated with 'not', unwrap it
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+        return node.operand
+
+    # Otherwise wrap in 'not'
+    return ast.UnaryOp(op=ast.Not(), operand=node)

src/linters/collection_pipeline/ast_utils.py

@@ -0,0 +1,40 @@
+"""
+Purpose: Shared AST utility functions for collection pipeline analyzers
+
+Scope: Common patterns for analyzing function bodies and return statements
+
+Overview: Provides reusable AST analysis helpers to reduce duplication across
+    any_all_analyzer, filter_map_analyzer, and other pattern detection modules.
+    Centralizes common patterns like finding return statements after for loops.
+
+Dependencies: ast module
+
+Exports: get_next_return_stmt
+
+Interfaces: get_next_return_stmt(func_body, index) -> ast.Return | None
+
+Implementation: Pure functions using Python ast module for AST node inspection
+"""
+
+import ast
+
+
+def get_next_return_stmt(func_body: list[ast.stmt], current_index: int) -> ast.Return | None:
+    """Get the next return statement after a given index, if it exists.
+
+    Args:
+        func_body: List of statements in function body
+        current_index: Index of the current statement (e.g., for loop)
+
+    Returns:
+        The Return statement if the next statement is a return, None otherwise
+    """
+    next_index = current_index + 1
+    if next_index >= len(func_body):
+        return None
+
+    stmt = func_body[next_index]
+    if not isinstance(stmt, ast.Return):
+        return None
+
+    return stmt