thailint 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

src/linters/collection_pipeline/filter_map_analyzer.py

@@ -0,0 +1,402 @@
+"""
+Purpose: Analyze filter-map and takewhile anti-patterns in for loops
+
+Scope: Extract and validate loops that build lists with transform/filter or takewhile
+
+Overview: Provides helper functions for analyzing loops that initialize an empty list,
+    iterate with a transform and conditional append, then return the list. Detects
+    patterns like 'result=[]; for x: y=f(x); if y: result.append(y); return result'
+    which can be refactored to list comprehensions with walrus operator. Also handles
+    takewhile patterns with break statements.
+
+Dependencies: ast module for Python AST processing
+
+Exports: extract_filter_map_pattern, extract_takewhile_pattern, FilterMapMatch, TakewhileMatch
+
+Interfaces: Functions for analyzing filter-map/takewhile patterns in AST function bodies
+
+Implementation: AST-based pattern matching for filter-map/takewhile pattern identification
+"""
+
+import ast
+from dataclasses import dataclass
+
+from . import ast_utils
+
+
+@dataclass
+class FilterMapMatch:
+    """Information about a detected filter-map pattern."""
+
+    for_node: ast.For
+    """The for loop AST node."""
+
+    result_var: str
+    """Name of the result list variable."""
+
+    transform_var: str
+    """Name of the variable holding transform result."""
+
+    transform_expr: str
+    """The transform expression as string."""
+
+
+@dataclass
+class TakewhileMatch:
+    """Information about a detected takewhile pattern."""
+
+    for_node: ast.For
+    """The for loop AST node."""
+
+    result_var: str
+    """Name of the result list variable."""
+
+    condition: ast.expr
+    """The condition expression (inverted from break condition)."""
+
+
+def extract_filter_map_pattern(
+    func_body: list[ast.stmt], for_node: ast.For
+) -> FilterMapMatch | None:
+    """Extract filter-map pattern from a for loop in a function body.
+
+    Pattern: result=[]; for x: y=f(x); if y: result.append(y); return result
+
+    Args:
+        func_body: List of statements in the function body
+        for_node: The for loop AST node to analyze
+
+    Returns:
+        FilterMapMatch if pattern detected, None otherwise
+    """
+    # Find the for loop position
+    for_index = _get_stmt_index(func_body, for_node)
+    if for_index is None:
+        return None
+
+    # Find result list initialization before the loop
+    result_init = _find_result_init_before(func_body, for_index)
+    if result_init is None:
+        return None
+
+    result_var, _ = result_init
+
+    # Check loop body has: assign, if, append pattern
+    loop_pattern = _extract_assign_if_append(for_node.body, result_var)
+    if loop_pattern is None:
+        return None
+
+    transform_var, transform_expr = loop_pattern
+
+    # Check return result after loop
+    if not _is_return_var_after(func_body, for_index, result_var):
+        return None
+
+    return FilterMapMatch(
+        for_node=for_node,
+        result_var=result_var,
+        transform_var=transform_var,
+        transform_expr=transform_expr,
+    )
+
+
+def extract_takewhile_pattern(
+    func_body: list[ast.stmt], for_node: ast.For
+) -> TakewhileMatch | None:
+    """Extract takewhile pattern from a for loop in a function body.
+
+    Pattern: result=[]; for x: if not cond: break; result.append(x); return result
+
+    Args:
+        func_body: List of statements in the function body
+        for_node: The for loop AST node to analyze
+
+    Returns:
+        TakewhileMatch if pattern detected, None otherwise
+    """
+    # Find the for loop position
+    for_index = _get_stmt_index(func_body, for_node)
+    if for_index is None:
+        return None
+
+    # Find result list initialization before the loop
+    result_init = _find_result_init_before(func_body, for_index)
+    if result_init is None:
+        return None
+
+    result_var, _ = result_init
+
+    # Check loop body has: if break, append pattern
+    loop_pattern = _extract_if_break_append(for_node.body, result_var)
+    if loop_pattern is None:
+        return None
+
+    condition = loop_pattern
+
+    # Check return result after loop
+    if not _is_return_var_after(func_body, for_index, result_var):
+        return None
+
+    return TakewhileMatch(
+        for_node=for_node,
+        result_var=result_var,
+        condition=condition,
+    )
+
+
+def _get_stmt_index(func_body: list[ast.stmt], target: ast.stmt) -> int | None:
+    """Find index of a statement in a function body."""
+    for i, stmt in enumerate(func_body):
+        if stmt is target:
+            return i
+    return None
+
+
+def _get_assign_empty_list_var(stmt: ast.Assign) -> str | None:
+    """Get variable name from simple assignment to empty list."""
+    if len(stmt.targets) != 1:
+        return None
+    if not isinstance(stmt.targets[0], ast.Name):
+        return None
+    if not _is_empty_list(stmt.value):
+        return None
+    return stmt.targets[0].id
+
+
+def _get_annassign_empty_list_var(stmt: ast.AnnAssign) -> str | None:
+    """Get variable name from annotated assignment to empty list."""
+    if not isinstance(stmt.target, ast.Name):
+        return None
+    if stmt.value is None:
+        return None
+    if not _is_empty_list(stmt.value):
+        return None
+    return stmt.target.id
+
+
+def _get_empty_list_var(stmt: ast.stmt) -> str | None:
+    """Get variable name if statement is empty list initialization.
+
+    Handles both: result = [] and result: list[T] = []
+
+    Args:
+        stmt: Statement to check
+
+    Returns:
+        Variable name if empty list init, None otherwise
+    """
+    if isinstance(stmt, ast.Assign):
+        return _get_assign_empty_list_var(stmt)
+    if isinstance(stmt, ast.AnnAssign):
+        return _get_annassign_empty_list_var(stmt)
+    return None
+
+
+def _find_result_init_before(func_body: list[ast.stmt], for_index: int) -> tuple[str, int] | None:
+    """Find empty list initialization before the for loop.
+
+    Searches backwards from for_index to find: result = [] or result: list[T] = []
+
+    Args:
+        func_body: List of statements in function body
+        for_index: Index of the for loop
+
+    Returns:
+        Tuple of (variable_name, init_index) if found, None otherwise
+    """
+    for i in range(for_index - 1, -1, -1):
+        var_name = _get_empty_list_var(func_body[i])
+        if var_name is not None:
+            return (var_name, i)
+    return None
+
+
+def _is_empty_list(node: ast.expr) -> bool:
+    """Check if expression is an empty list literal."""
+    return isinstance(node, ast.List) and len(node.elts) == 0
+
+
+def _extract_simple_assignment(stmt: ast.stmt) -> tuple[str, str] | None:
+    """Extract variable and expression from a simple assignment.
+
+    Args:
+        stmt: Statement to check
+
+    Returns:
+        Tuple of (var_name, expr_string) if simple assignment, None otherwise
+    """
+    if not isinstance(stmt, ast.Assign):
+        return None
+    if len(stmt.targets) != 1:
+        return None
+    if not isinstance(stmt.targets[0], ast.Name):
+        return None
+    return (stmt.targets[0].id, ast.unparse(stmt.value))
+
+
+def _is_conditional_append(
+    if_stmt: ast.If, condition_var: str, result_var: str, appended_var: str
+) -> bool:
+    """Check if statement is: if condition_var: result.append(appended_var).
+
+    Args:
+        if_stmt: The if statement to check
+        condition_var: Expected condition variable name
+        result_var: Expected result list name
+        appended_var: Expected appended variable name
+
+    Returns:
+        True if pattern matches
+    """
+    if if_stmt.orelse:
+        return False
+    if not isinstance(if_stmt.test, ast.Name):
+        return False
+    if if_stmt.test.id != condition_var:
+        return False
+    if len(if_stmt.body) != 1:
+        return False
+    return _is_append_call(if_stmt.body[0], result_var, appended_var)
+
+
+def _extract_assign_if_append(body: list[ast.stmt], result_var: str) -> tuple[str, str] | None:
+    """Extract assign, if, append pattern from loop body.
+
+    Pattern: y = f(x); if y: result.append(y)
+
+    Args:
+        body: List of statements in for loop body
+        result_var: Name of the result list variable
+
+    Returns:
+        Tuple of (transform_var, transform_expr) if pattern matches, None otherwise
+    """
+    if len(body) != 2:
+        return None
+
+    # First statement should be assignment
+    assignment = _extract_simple_assignment(body[0])
+    if assignment is None:
+        return None
+
+    transform_var, transform_expr = assignment
+
+    # Second statement should be: if transform_var: result.append(transform_var)
+    if not isinstance(body[1], ast.If):
+        return None
+
+    if not _is_conditional_append(body[1], transform_var, result_var, transform_var):
+        return None
+
+    return (transform_var, transform_expr)
+
+
+def _is_simple_if_break(stmt: ast.stmt) -> ast.If | None:
+    """Check if statement is simple 'if cond: break' with no else.
+
+    Args:
+        stmt: Statement to check
+
+    Returns:
+        The if 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.Break):
+        return None
+    return stmt
+
+
+def _extract_if_break_append(body: list[ast.stmt], result_var: str) -> ast.expr | None:
+    """Extract if break, append pattern from loop body.
+
+    Pattern: if not cond: break; result.append(x)
+
+    Args:
+        body: List of statements in for loop body
+        result_var: Name of the result list variable
+
+    Returns:
+        The condition (inverted for takewhile) if pattern matches, None otherwise
+    """
+    if len(body) != 2:
+        return None
+
+    if_stmt = _is_simple_if_break(body[0])
+    if if_stmt is None:
+        return None
+
+    if not isinstance(body[1], ast.Expr):
+        return None
+
+    return _invert_condition(if_stmt.test)
+
+
+def _get_method_call_info(stmt: ast.stmt) -> tuple[str, str, list[ast.expr]] | None:
+    """Extract method call info from statement: obj.method(args).
+
+    Args:
+        stmt: Statement to check
+
+    Returns:
+        Tuple of (object_name, method_name, args) if method call, None otherwise
+    """
+    if not isinstance(stmt, ast.Expr):
+        return None
+    if not isinstance(stmt.value, ast.Call):
+        return None
+    call = stmt.value
+    if not isinstance(call.func, ast.Attribute):
+        return None
+    if not isinstance(call.func.value, ast.Name):
+        return None
+    return (call.func.value.id, call.func.attr, call.args)
+
+
+def _is_single_name_arg(args: list[ast.expr], expected_name: str) -> bool:
+    """Check if args list is single Name with expected id."""
+    if len(args) != 1:
+        return False
+    if not isinstance(args[0], ast.Name):
+        return False
+    return args[0].id == expected_name
+
+
+def _is_append_call(stmt: ast.stmt, result_var: str, appended_var: str) -> bool:
+    """Check if statement is result.append(appended_var)."""
+    info = _get_method_call_info(stmt)
+    if info is None:
+        return False
+    obj_name, method_name, args = info
+    if obj_name != result_var or method_name != "append":
+        return False
+    return _is_single_name_arg(args, appended_var)
+
+
+def _is_return_var_after(func_body: list[ast.stmt], for_index: int, var_name: str) -> bool:
+    """Check if the next statement after for loop is return var_name."""
+    stmt = ast_utils.get_next_return_stmt(func_body, for_index)
+    if stmt is None:
+        return False
+
+    if stmt.value is None:
+        return False
+    if not isinstance(stmt.value, ast.Name):
+        return False
+
+    return stmt.value.id == var_name
+
+
+def _invert_condition(node: ast.expr) -> ast.expr:
+    """Invert a boolean condition.
+
+    If condition is 'not x', returns 'x'.
+    Otherwise wraps in 'not (...)'.
+    """
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+        return node.operand
+    return ast.UnaryOp(op=ast.Not(), operand=node)

src/linters/collection_pipeline/linter.py

@@ -21,13 +21,19 @@ Interfaces: CollectionPipelineRule.check(context) -> list[Violation], rule metad
 
 Implementation: Uses PipelinePatternDetector for AST analysis, composition pattern with
     config loading and comprehensive ignore checking via IgnoreDirectiveParser
+
+Suppressions:
+    - srp,dry: Rule class coordinates detector, config, and comprehensive ignore system.
+        Method count exceeds limit due to 5-level ignore pattern support.
 """
 
 from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, IgnoreDirective, Language
 from src.core.types import Severity, Violation
 from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.rule_matcher import rule_matches
 
 from .config import CollectionPipelineConfig
 from .detector import PatternMatch, PipelinePatternDetector
@@ -91,7 +97,7 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if should analyze
         """
-        return context.language == "python" and context.file_content is not None
+        return context.language == Language.PYTHON and context.file_content is not None
 
     def _get_config_dict(self, context: BaseLintContext) -> dict | None:
         """Get configuration dictionary from context.
@@ -144,10 +150,7 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return False
 
         file_path = Path(context.file_path)
-        for pattern in config.ignore:
-            if self._matches_pattern(file_path, pattern):
-                return True
-        return False
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
 
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
         """Check if file path matches a glob pattern.
@@ -177,12 +180,9 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
         if not context.file_content:
             return False
 
-        # Check first 10 lines for ignore-file directive
-        lines = context.file_content.splitlines()[:10]
-        for line in lines:
-            if self._is_file_ignore_directive(line):
-                return True
-        return False
+        # Check first lines for ignore-file directive
+        lines = context.file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._is_file_ignore_directive(line) for line in lines)
 
     def _is_file_ignore_directive(self, line: str) -> bool:
         """Check if line is a file-level ignore directive.
@@ -233,23 +233,7 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if pattern matches this rule
         """
-        rule_id_lower = self.rule_id.lower()
-        pattern_lower = rule_pattern.lower()
-
-        # Exact match
-        if rule_id_lower == pattern_lower:
-            return True
-
-        # Prefix match: collection-pipeline matches collection-pipeline.embedded-filter
-        if rule_id_lower.startswith(pattern_lower + "."):
-            return True
-
-        # Wildcard match: collection-pipeline.* matches collection-pipeline.embedded-filter
-        if pattern_lower.endswith("*"):
-            prefix = pattern_lower[:-1]
-            return rule_id_lower.startswith(prefix)
-
-        return False
+        return rule_matches(self.rule_id, rule_pattern)
 
     def _analyze_python(
         self, context: BaseLintContext, config: CollectionPipelineConfig
@@ -284,12 +268,11 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             List of violations after filtering
         """
-        violations: list[Violation] = []
-        for match in matches:
-            violation = self._process_match(match, config, context)
-            if violation:
-                violations.append(violation)
-        return violations
+        return [
+            violation
+            for match in matches
+            if (violation := self._process_match(match, config, context))
+        ]
 
     def _process_match(
         self,
@@ -391,7 +374,7 @@ class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return True
 
         # Rule-specific ignore
-        return self._matches_rule_ignore(line, "ignore")
+        return self._matches_rule_ignore(line, IgnoreDirective.IGNORE)
 
     def _create_violation(self, match: PatternMatch, context: BaseLintContext) -> Violation:
         """Create a Violation from a PatternMatch.

src/linters/collection_pipeline/suggestion_builder.py

@@ -10,7 +10,8 @@ Overview: Provides helper functions for generating refactoring suggestions when
 
 Dependencies: ast module for Python AST processing
 
-Exports: build_suggestion, invert_condition, get_target_name
+Exports: build_suggestion, invert_condition, get_target_name, build_any_suggestion,
+    build_all_suggestion, build_filter_map_suggestion, build_takewhile_suggestion
 
 Interfaces: Functions for suggestion generation and condition transformation
 
@@ -61,3 +62,69 @@ def build_suggestion(loop_var: str, iterable: str, conditions: list[str]) -> str
     """
     combined = " and ".join(conditions)
     return f"for {loop_var} in ({loop_var} for {loop_var} in {iterable} if {combined}):"
+
+
+def build_any_suggestion(loop_var: str, iterable: str, condition: str) -> str:
+    """Generate any() refactoring suggestion.
+
+    Args:
+        loop_var: Name of the loop variable
+        iterable: Source representation of the iterable
+        condition: The filter condition
+
+    Returns:
+        Code suggestion for refactoring to any()
+    """
+    return f"return any({condition} for {loop_var} in {iterable})"
+
+
+def build_all_suggestion(loop_var: str, iterable: str, condition: str) -> str:
+    """Generate all() refactoring suggestion.
+
+    Args:
+        loop_var: Name of the loop variable
+        iterable: Source representation of the iterable
+        condition: The filter condition (already inverted to positive form)
+
+    Returns:
+        Code suggestion for refactoring to all()
+    """
+    return f"return all({condition} for {loop_var} in {iterable})"
+
+
+def build_filter_map_suggestion(
+    loop_var: str,
+    iterable: str,
+    transform_var: str,
+    transform_expr: str,
+    use_walrus: bool = True,
+) -> str:
+    """Generate filter-map list comprehension suggestion.
+
+    Args:
+        loop_var: Name of the loop variable
+        iterable: Source representation of the iterable
+        transform_var: Name of the transform result variable
+        transform_expr: The transform expression
+        use_walrus: Whether to use walrus operator (Python 3.8+)
+
+    Returns:
+        Code suggestion for refactoring to list comprehension
+    """
+    if use_walrus:
+        return f"return [{transform_var} for {loop_var} in {iterable} if ({transform_var} := {transform_expr})]"
+    return f"return [{transform_expr} for {loop_var} in {iterable} if {transform_expr}]"
+
+
+def build_takewhile_suggestion(loop_var: str, iterable: str, condition: str) -> str:
+    """Generate takewhile() refactoring suggestion.
+
+    Args:
+        loop_var: Name of the loop variable
+        iterable: Source representation of the iterable
+        condition: The condition for takewhile (positive form)
+
+    Returns:
+        Code suggestion for refactoring to takewhile()
+    """
+    return f"return list(takewhile(lambda {loop_var}: {condition}, {iterable}))"

src/linters/dry/base_token_analyzer.py

@@ -9,28 +9,35 @@ Overview: Provides shared infrastructure for token-based duplicate code detectio
     for TypeScript). Eliminates duplication between PythonDuplicateAnalyzer and TypeScriptDuplicateAnalyzer
     by extracting shared analyze() method pattern and CodeBlock creation logic.
 
-Dependencies: TokenHasher, CodeBlock, DRYConfig, pathlib.Path
+Dependencies: token_hasher module functions, CodeBlock, DRYConfig, pathlib.Path
 
 Exports: BaseTokenAnalyzer class
 
 Interfaces: BaseTokenAnalyzer.analyze(file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]
 
 Implementation: Template method pattern with extension point for language-specific block filtering
+
+Suppressions:
+    - stateless-class: BaseTokenAnalyzer is an intentional template method base class.
+        Subclasses (PythonDuplicateAnalyzer, TypeScriptDuplicateAnalyzer) override
+        _should_include_block for language-specific filtering. Statelessness is by design
+        since state was moved to module-level functions in token_hasher.
 """
 
 from pathlib import Path
 
+from . import token_hasher
 from .cache import CodeBlock
 from .config import DRYConfig
-from .token_hasher import TokenHasher
 
 
-class BaseTokenAnalyzer:
-    """Base analyzer for token-based duplicate detection."""
+class BaseTokenAnalyzer:  # thailint: ignore[stateless-class] - Template method base class for inheritance
+    """Base analyzer for token-based duplicate detection.
 
-    def __init__(self) -> None:
-        """Initialize analyzer with token hasher."""
-        self._hasher = TokenHasher()
+    This is intentionally a base class for polymorphism. Subclasses
+    (PythonDuplicateAnalyzer, TypeScriptDuplicateAnalyzer) override
+    _should_include_block for language-specific filtering.
+    """
 
     def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
         """Analyze file for duplicate code blocks.
@@ -43,8 +50,8 @@ class BaseTokenAnalyzer:
         Returns:
             List of CodeBlock instances with hash values
         """
-        lines = self._hasher.tokenize(content)
-        windows = self._hasher.rolling_hash(lines, config.min_duplicate_lines)
+        lines = token_hasher.tokenize(content)
+        windows = token_hasher.rolling_hash(lines, config.min_duplicate_lines)
 
         blocks = []
         for hash_val, start_line, end_line, snippet in windows:

src/linters/dry/block_filter.py

@@ -16,6 +16,9 @@ Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGrou
 Interfaces: BaseBlockFilter.should_filter(code_block, file_content) -> bool
 
 Implementation: Strategy pattern with filter registry for extensibility
+
+Suppressions:
+    - type:ignore[operator]: Tree-sitter Node comparison operations (optional dependency)
 """
 
 import ast
@@ -115,10 +118,10 @@ class KeywordArgumentFilter(BaseBlockFilter):
             return False
 
         # Find if any Call node contains the block
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Call) and self._check_multiline_containment(node, block):
-                return True
-        return False
+        return any(
+            isinstance(node, ast.Call) and self._check_multiline_containment(node, block)
+            for node in ast.walk(tree)
+        )
 
     @staticmethod
     def _check_multiline_containment(node: ast.Call, block: CodeBlock) -> bool:

src/linters/dry/cache.py

@@ -20,6 +20,9 @@ Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
 
 Implementation: SQLite with three tables (files, code_blocks, constants), indexed for performance,
     storage_mode determines :memory: vs tempfile location, ACID transactions for reliability
+
+Suppressions:
+    - consider-using-with: Tempfile managed by class lifecycle, not context manager
 """
 
 from __future__ import annotations
@@ -30,6 +33,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from src.core.constants import StorageMode
+
 from .cache_query import CacheQueryService
 
 if TYPE_CHECKING:
@@ -62,9 +67,9 @@ class DRYCache:
         self._tempfile = None
 
         # Create SQLite connection based on storage mode
-        if storage_mode == "memory":
+        if storage_mode == StorageMode.MEMORY:
             self.db = sqlite3.connect(":memory:")
-        elif storage_mode == "tempfile":
+        elif storage_mode == StorageMode.TEMPFILE:
             # Create temporary file that auto-deletes on close
             # pylint: disable=consider-using-with
             # Justification: tempfile must remain open for SQLite connection lifetime.