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

src/linters/collection_pipeline/linter.py

@@ -0,0 +1,420 @@
+"""
+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
+
+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
+
+
+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 == 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)
+        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.
+
+        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 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.
+
+        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
+        """
+        return rule_matches(self.rule_id, rule_pattern)
+
+    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
+        """
+        return [
+            violation
+            for match in matches
+            if (violation := self._process_match(match, config, context))
+        ]
+
+    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, IgnoreDirective.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,130 @@
+"""
+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, build_any_suggestion,
+    build_all_suggestion, build_filter_map_suggestion, build_takewhile_suggestion
+
+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}):"
+
+
+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/cqs/__init__.py

@@ -0,0 +1,54 @@
+"""
+Purpose: CQS (Command-Query Separation) linter package exports
+
+Scope: Detect CQS violations in Python and TypeScript code
+
+Overview: Package providing CQS violation detection for Python and TypeScript code.
+    Identifies functions that mix INPUT operations (queries that return values captured
+    in variables) and OUTPUT operations (commands that perform side effects without
+    capturing return values). Functions should either query state and return a value,
+    or command a change and return nothing. Mixing these violates CQS principles and
+    makes code harder to reason about.
+
+Dependencies: ast module for Python parsing, tree-sitter for TypeScript parsing
+
+Exports: CQSConfig, CQSPattern, CQSRule, FunctionAnalyzer, InputOperation, OutputOperation,
+    PythonCQSAnalyzer, TypeScriptCQSAnalyzer, TypeScriptFunctionAnalyzer,
+    TypeScriptInputDetector, TypeScriptOutputDetector, build_cqs_violation
+
+Interfaces: CQSConfig.from_dict() for YAML configuration loading,
+    CQSRule.check() for BaseLintRule interface
+
+Implementation: AST-based pattern detection for Python, tree-sitter for TypeScript,
+    with configurable ignore rules
+"""
+
+from .config import CQSConfig
+from .function_analyzer import FunctionAnalyzer
+from .input_detector import InputDetector
+from .linter import CQSRule
+from .output_detector import OutputDetector
+from .python_analyzer import PythonCQSAnalyzer
+from .types import CQSPattern, InputOperation, OutputOperation
+from .typescript_cqs_analyzer import TypeScriptCQSAnalyzer
+from .typescript_function_analyzer import TypeScriptFunctionAnalyzer
+from .typescript_input_detector import TypeScriptInputDetector
+from .typescript_output_detector import TypeScriptOutputDetector
+from .violation_builder import build_cqs_violation
+
+__all__ = [
+    "CQSConfig",
+    "CQSPattern",
+    "CQSRule",
+    "FunctionAnalyzer",
+    "InputDetector",
+    "InputOperation",
+    "OutputDetector",
+    "OutputOperation",
+    "PythonCQSAnalyzer",
+    "TypeScriptCQSAnalyzer",
+    "TypeScriptFunctionAnalyzer",
+    "TypeScriptInputDetector",
+    "TypeScriptOutputDetector",
+    "build_cqs_violation",
+]

src/linters/cqs/config.py

@@ -0,0 +1,55 @@
+"""
+Purpose: Configuration dataclass for CQS (Command-Query Separation) linter
+
+Scope: Pattern toggles, ignore patterns, and YAML configuration loading
+
+Overview: Provides CQSConfig dataclass with configurable options for CQS violation
+    detection. Controls minimum operation thresholds, methods to ignore (constructors
+    by default), decorators to ignore (property-like by default), and fluent interface
+    detection. Configuration can be loaded from dictionary (YAML) with sensible defaults.
+
+Dependencies: dataclasses, typing
+
+Exports: CQSConfig
+
+Interfaces: CQSConfig.from_dict() for YAML configuration loading
+
+Implementation: Dataclass with factory defaults and conservative default settings
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CQSConfig:
+    """Configuration for CQS linter."""
+
+    enabled: bool = True
+    min_operations: int = 1
+    ignore_methods: list[str] = field(default_factory=lambda: ["__init__", "__new__"])
+    ignore_decorators: list[str] = field(default_factory=lambda: ["property", "cached_property"])
+    ignore_patterns: list[str] = field(default_factory=list)
+    detect_fluent_interface: bool = True
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "CQSConfig":
+        """Load configuration from dictionary (YAML).
+
+        Args:
+            config: Dictionary containing configuration values.
+            language: Reserved for future multi-language support.
+
+        Returns:
+            CQSConfig instance with values from dictionary or defaults.
+        """
+        # Language parameter reserved for future multi-language support
+        _ = language
+        return cls(
+            enabled=config.get("enabled", True),
+            min_operations=config.get("min_operations", 1),
+            ignore_methods=config.get("ignore_methods", ["__init__", "__new__"]),
+            ignore_decorators=config.get("ignore_decorators", ["property", "cached_property"]),
+            ignore_patterns=config.get("ignore_patterns", []),
+            detect_fluent_interface=config.get("detect_fluent_interface", True),
+        )