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

src/linters/collection_pipeline/linter.py

@@ -0,0 +1,437 @@
+"""
+Purpose: CollectionPipelineRule implementation for detecting loop filtering anti-patterns
+
+Scope: Main rule class implementing BaseLintRule interface for collection-pipeline detection
+
+Overview: Implements the BaseLintRule interface to detect for loops with embedded
+    filtering logic that could be refactored to collection pipelines. Detects patterns
+    like 'for x in iter: if not cond: continue; action(x)' which can be refactored to
+    use generator expressions or filter(). Based on Martin Fowler's refactoring pattern.
+    Integrates with thai-lint CLI and supports text, JSON, and SARIF output formats.
+    Supports comprehensive 5-level ignore system including project-level patterns,
+    linter-specific ignore patterns, file-level directives, line-level directives,
+    and block-level directives via IgnoreDirectiveParser.
+
+Dependencies: BaseLintRule, BaseLintContext, Violation, PipelinePatternDetector,
+    CollectionPipelineConfig, IgnoreDirectiveParser
+
+Exports: CollectionPipelineRule class
+
+Interfaces: CollectionPipelineRule.check(context) -> list[Violation], rule metadata properties
+
+Implementation: Uses PipelinePatternDetector for AST analysis, composition pattern with
+    config loading and comprehensive ignore checking via IgnoreDirectiveParser
+"""
+
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.types import Severity, Violation
+from src.linter_config.ignore import get_ignore_parser
+
+from .config import CollectionPipelineConfig
+from .detector import PatternMatch, PipelinePatternDetector
+
+
+class CollectionPipelineRule(BaseLintRule):  # thailint: ignore[srp,dry]
+    """Detects for loops with embedded filtering that could use collection pipelines."""
+
+    def __init__(self) -> None:
+        """Initialize the rule with ignore parser."""
+        self._ignore_parser = get_ignore_parser()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "collection-pipeline.embedded-filter"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Embedded Loop Filtering"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "For loops with embedded if/continue filtering patterns should be "
+            "refactored to use collection pipelines (generator expressions, filter())"
+        )
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for collection pipeline anti-patterns.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        if not self._should_analyze(context):
+            return []
+
+        config = self._load_config(context)
+        if not config.enabled:
+            return []
+
+        if self._is_file_ignored(context, config):
+            return []
+
+        if self._has_file_level_ignore(context):
+            return []
+
+        return self._analyze_python(context, config)
+
+    def _should_analyze(self, context: BaseLintContext) -> bool:
+        """Check if context should be analyzed.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if should analyze
+        """
+        return context.language == "python" and context.file_content is not None
+
+    def _get_config_dict(self, context: BaseLintContext) -> dict | None:
+        """Get configuration dictionary from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Config dict or None
+        """
+        if hasattr(context, "config") and context.config is not None:
+            return context.config
+        if hasattr(context, "metadata") and context.metadata is not None:
+            return context.metadata
+        return None
+
+    def _load_config(self, context: BaseLintContext) -> CollectionPipelineConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            CollectionPipelineConfig instance
+        """
+        config_dict = self._get_config_dict(context)
+        if config_dict is None or not isinstance(config_dict, dict):
+            return CollectionPipelineConfig()
+
+        # Check for collection_pipeline or collection-pipeline specific config
+        linter_config = config_dict.get(
+            "collection_pipeline", config_dict.get("collection-pipeline", config_dict)
+        )
+        return CollectionPipelineConfig.from_dict(linter_config)
+
+    def _is_file_ignored(self, context: BaseLintContext, config: CollectionPipelineConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be ignored
+        """
+        if not config.ignore:
+            return False
+
+        if not context.file_path:
+            return False
+
+        file_path = Path(context.file_path)
+        for pattern in config.ignore:
+            if self._matches_pattern(file_path, pattern):
+                return True
+        return False
+
+    def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Check if file path matches a glob pattern.
+
+        Args:
+            file_path: Path to check
+            pattern: Glob pattern
+
+        Returns:
+            True if path matches pattern
+        """
+        if file_path.match(pattern):
+            return True
+        if pattern in str(file_path):
+            return True
+        return False
+
+    def _has_file_level_ignore(self, context: BaseLintContext) -> bool:
+        """Check if file has file-level ignore directive.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if file should be ignored at file level
+        """
+        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
+
+    def _is_file_ignore_directive(self, line: str) -> bool:
+        """Check if line is a file-level ignore directive.
+
+        Args:
+            line: Line to check
+
+        Returns:
+            True if line has file-level ignore for this rule
+        """
+        line_lower = line.lower()
+        if "thailint: ignore-file" not in line_lower:
+            return False
+
+        # Check for general ignore-file (no rule specified)
+        if "ignore-file[" not in line_lower:
+            return True
+
+        # Check for rule-specific ignore
+        return self._matches_rule_ignore(line_lower, "ignore-file")
+
+    def _matches_rule_ignore(self, line: str, directive: str) -> bool:
+        """Check if line matches rule-specific ignore.
+
+        Args:
+            line: Line to check (lowercase)
+            directive: Directive name (ignore-file or ignore)
+
+        Returns:
+            True if ignore applies to this rule
+        """
+        import re
+
+        pattern = rf"{directive}\[([^\]]+)\]"
+        match = re.search(pattern, line)
+        if not match:
+            return False
+
+        rules = [r.strip().lower() for r in match.group(1).split(",")]
+        return any(self._rule_matches(r) for r in rules)
+
+    def _rule_matches(self, rule_pattern: str) -> bool:
+        """Check if rule pattern matches this rule.
+
+        Args:
+            rule_pattern: Rule pattern to check
+
+        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
+
+    def _analyze_python(
+        self, context: BaseLintContext, config: CollectionPipelineConfig
+    ) -> list[Violation]:
+        """Analyze Python code for collection pipeline patterns.
+
+        Args:
+            context: Lint context with Python file information
+            config: Collection pipeline configuration
+
+        Returns:
+            List of violations found
+        """
+        detector = PipelinePatternDetector(context.file_content or "")
+        matches = detector.detect_patterns()
+
+        return self._filter_matches_to_violations(matches, config, context)
+
+    def _filter_matches_to_violations(
+        self,
+        matches: list[PatternMatch],
+        config: CollectionPipelineConfig,
+        context: BaseLintContext,
+    ) -> list[Violation]:
+        """Filter matches by threshold and ignore rules.
+
+        Args:
+            matches: Detected pattern matches
+            config: Configuration with thresholds
+            context: Lint context
+
+        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
+
+    def _process_match(
+        self,
+        match: PatternMatch,
+        config: CollectionPipelineConfig,
+        context: BaseLintContext,
+    ) -> Violation | None:
+        """Process a single match into a violation if applicable.
+
+        Args:
+            match: Pattern match to process
+            config: Configuration with thresholds
+            context: Lint context
+
+        Returns:
+            Violation if match should be reported, None otherwise
+        """
+        if len(match.conditions) < config.min_continues:
+            return None
+
+        violation = self._create_violation(match, context)
+        if self._should_ignore_violation(violation, match.line_number, context):
+            return None
+
+        return violation
+
+    def _should_ignore_violation(
+        self, violation: Violation, line_num: int, context: BaseLintContext
+    ) -> bool:
+        """Check if violation should be ignored.
+
+        Args:
+            violation: Violation to check
+            line_num: Line number of the violation
+            context: Lint context
+
+        Returns:
+            True if violation should be ignored
+        """
+        if not context.file_content:
+            return False
+
+        # Check using IgnoreDirectiveParser for comprehensive ignore checking
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content):
+            return True
+
+        # Also check inline ignore on loop line
+        return self._has_inline_ignore(line_num, context)
+
+    def _has_inline_ignore(self, line_num: int, context: BaseLintContext) -> bool:
+        """Check for inline ignore directive on loop line.
+
+        Args:
+            line_num: Line number to check
+            context: Lint context
+
+        Returns:
+            True if line has ignore directive
+        """
+        line = self._get_line_text(line_num, context)
+        if not line:
+            return False
+
+        return self._is_ignore_directive(line.lower())
+
+    def _get_line_text(self, line_num: int, context: BaseLintContext) -> str | None:
+        """Get text of a specific line.
+
+        Args:
+            line_num: Line number (1-indexed)
+            context: Lint context
+
+        Returns:
+            Line text or None if invalid
+        """
+        if not context.file_content:
+            return None
+
+        lines = context.file_content.splitlines()
+        if line_num <= 0 or line_num > len(lines):
+            return None
+
+        return lines[line_num - 1]
+
+    def _is_ignore_directive(self, line: str) -> bool:
+        """Check if line contains ignore directive for this rule.
+
+        Args:
+            line: Line text (lowercase)
+
+        Returns:
+            True if line has applicable ignore directive
+        """
+        if "thailint:" not in line or "ignore" not in line:
+            return False
+
+        # General ignore (no rule specified)
+        if "ignore[" not in line:
+            return True
+
+        # Rule-specific ignore
+        return self._matches_rule_ignore(line, "ignore")
+
+    def _create_violation(self, match: PatternMatch, context: BaseLintContext) -> Violation:
+        """Create a Violation from a PatternMatch.
+
+        Args:
+            match: Detected pattern match
+            context: Lint context
+
+        Returns:
+            Violation object for the detected pattern
+        """
+        message = self._build_message(match)
+        file_path = str(context.file_path) if context.file_path else "unknown"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=file_path,
+            line=match.line_number,
+            column=0,
+            message=message,
+            severity=Severity.ERROR,
+            suggestion=match.suggestion,
+        )
+
+    def _build_message(self, match: PatternMatch) -> str:
+        """Build violation message.
+
+        Args:
+            match: Detected pattern match
+
+        Returns:
+            Human-readable message describing the violation
+        """
+        num_conditions = len(match.conditions)
+        if num_conditions == 1:
+            return (
+                f"For loop over '{match.iterable}' has embedded filtering. "
+                f"Consider using a generator expression."
+            )
+        return (
+            f"For loop over '{match.iterable}' has {num_conditions} filter conditions. "
+            f"Consider combining into a collection pipeline."
+        )

src/linters/collection_pipeline/suggestion_builder.py

@@ -0,0 +1,63 @@
+"""
+Purpose: Build refactoring suggestions for collection pipeline patterns
+
+Scope: Generate code suggestions for converting embedded filtering to collection pipelines
+
+Overview: Provides helper functions for generating refactoring suggestions when embedded
+    filtering patterns are detected. Handles condition inversion (converting continue guard
+    conditions to filter conditions), target name extraction, and suggestion string generation.
+    Separates suggestion logic from pattern detection logic for better maintainability.
+
+Dependencies: ast module for Python AST processing
+
+Exports: build_suggestion, invert_condition, get_target_name
+
+Interfaces: Functions for suggestion generation and condition transformation
+
+Implementation: AST-based condition inversion and string formatting for suggestions
+"""
+
+import ast
+
+
+def get_target_name(target: ast.expr) -> str:
+    """Get the loop variable name from AST target.
+
+    Args:
+        target: AST expression for loop target
+
+    Returns:
+        String representation of the loop variable
+    """
+    if isinstance(target, ast.Name):
+        return target.id
+    return ast.unparse(target)
+
+
+def invert_condition(condition: ast.expr) -> str:
+    """Invert a condition (for if not x: continue -> if x).
+
+    Args:
+        condition: AST expression for the condition
+
+    Returns:
+        String representation of the inverted condition
+    """
+    if isinstance(condition, ast.UnaryOp) and isinstance(condition.op, ast.Not):
+        return ast.unparse(condition.operand)
+    return f"not ({ast.unparse(condition)})"
+
+
+def build_suggestion(loop_var: str, iterable: str, conditions: list[str]) -> str:
+    """Generate refactoring suggestion code snippet.
+
+    Args:
+        loop_var: Name of the loop variable
+        iterable: Source representation of the iterable
+        conditions: List of filter conditions (already inverted)
+
+    Returns:
+        Code suggestion for refactoring to generator expression
+    """
+    combined = " and ".join(conditions)
+    return f"for {loop_var} in ({loop_var} for {loop_var} in {iterable} if {combined}):"

src/linters/dry/block_filter.py

@@ -10,7 +10,8 @@ Overview: Provides an extensible architecture for filtering duplicate code block
 
 Dependencies: ast, re, typing
 
-Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter
+Exports: BaseBlockFilter, BlockFilterRegistry, KeywordArgumentFilter, ImportGroupFilter,
+    LoggerCallFilter, ExceptionReraiseFilter
 
 Interfaces: BaseBlockFilter.should_filter(code_block, file_content) -> bool
 
@@ -196,6 +197,99 @@ class ImportGroupFilter(BaseBlockFilter):
         return "import_group_filter"
 
 
+class LoggerCallFilter(BaseBlockFilter):
+    """Filters single-line logger calls that are idiomatic but appear similar.
+
+    Detects patterns like:
+        logger.debug(f"Command: {cmd}")
+        logger.info("Starting process...")
+        logging.warning("...")
+
+    These are contextually different despite structural similarity.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the logger call filter."""
+        # Pattern matches: logger.level(...) or logging.level(...)
+        self._logger_pattern = re.compile(
+            r"^\s*(self\.)?(logger|logging|log)\."
+            r"(debug|info|warning|error|critical|exception|log)\s*\("
+        )
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is primarily single-line logger calls.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+        non_empty = [s for line in lines if (s := line.strip())]
+
+        if not non_empty:
+            return False
+
+        # Filter if it's a single line that's a logger call
+        if len(non_empty) == 1:
+            return bool(self._logger_pattern.match(non_empty[0]))
+
+        return False
+
+    @property
+    def name(self) -> str:
+        """Filter name."""
+        return "logger_call_filter"
+
+
+class ExceptionReraiseFilter(BaseBlockFilter):
+    """Filters idiomatic exception re-raising patterns.
+
+    Detects patterns like:
+        except SomeError as e:
+            raise NewError(...) from e
+
+    These are Python best practices for exception chaining.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the exception reraise filter."""
+        pass  # Stateless filter
+
+    def should_filter(self, block: CodeBlock, file_content: str) -> bool:
+        """Check if block is an exception re-raise pattern.
+
+        Args:
+            block: Code block to evaluate
+            file_content: Full file content
+
+        Returns:
+            True if block should be filtered
+        """
+        lines = file_content.split("\n")[block.start_line - 1 : block.end_line]
+        stripped_lines = [s for line in lines if (s := line.strip())]
+
+        if len(stripped_lines) != 2:
+            return False
+
+        return self._is_except_raise_pattern(stripped_lines)
+
+    @staticmethod
+    def _is_except_raise_pattern(lines: list[str]) -> bool:
+        """Check if lines form an except/raise pattern."""
+        first, second = lines[0], lines[1]
+        is_except = first.startswith("except ") and first.endswith(":")
+        is_raise = second.startswith("raise ") and " from " in second
+        return is_except and is_raise
+
+    @property
+    def name(self) -> str:
+        """Filter name."""
+        return "exception_reraise_filter"
+
+
 class BlockFilterRegistry:
     """Registry for managing duplicate block filters."""
 
@@ -239,14 +333,8 @@ class BlockFilterRegistry:
         Returns:
             True if block should be filtered out
         """
-        for filter_instance in self._filters:
-            if filter_instance.name not in self._enabled_filters:
-                continue
-
-            if filter_instance.should_filter(block, file_content):
-                return True
-
-        return False
+        enabled_filters = (f for f in self._filters if f.name in self._enabled_filters)
+        return any(f.should_filter(block, file_content) for f in enabled_filters)
 
     def get_enabled_filters(self) -> list[str]:
         """Get list of enabled filter names.
@@ -268,5 +356,7 @@ def create_default_registry() -> BlockFilterRegistry:
     # Register built-in filters
     registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
     registry.register(ImportGroupFilter())
+    registry.register(LoggerCallFilter())
+    registry.register(ExceptionReraiseFilter())
 
     return registry