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

src/linters/cqs/violation_builder.py

@@ -0,0 +1,94 @@
+"""
+Purpose: Builds Violation objects from CQSPattern instances
+
+Scope: Violation message formatting and suggestion generation for CQS violations
+
+Overview: Provides build_cqs_violation function that converts a CQSPattern with a detected
+    CQS violation into a Violation object with properly formatted message. Message includes
+    function name (with class prefix for methods), lists INPUT operations with line numbers,
+    lists OUTPUT operations with line numbers, and provides actionable suggestion to split
+    the function into separate query and command functions.
+
+Dependencies: CQSPattern, InputOperation, OutputOperation, Violation, Severity
+
+Exports: build_cqs_violation
+
+Interfaces: build_cqs_violation(pattern: CQSPattern) -> Violation
+
+Implementation: String formatting with INPUT/OUTPUT line number aggregation
+"""
+
+from src.core.types import Severity, Violation
+
+from .types import CQSPattern
+
+
+def _format_inputs(pattern: CQSPattern) -> str:
+    """Format INPUT operations for violation message.
+
+    Args:
+        pattern: CQSPattern containing inputs
+
+    Returns:
+        Formatted string listing INPUTs with line numbers
+    """
+    if not pattern.inputs:
+        return ""
+
+    parts = [f"Line {inp.line}: {inp.target} = {inp.expression}" for inp in pattern.inputs]
+    return "; ".join(parts)
+
+
+def _format_outputs(pattern: CQSPattern) -> str:
+    """Format OUTPUT operations for violation message.
+
+    Args:
+        pattern: CQSPattern containing outputs
+
+    Returns:
+        Formatted string listing OUTPUTs with line numbers
+    """
+    if not pattern.outputs:
+        return ""
+
+    parts = [f"Line {out.line}: {out.expression}" for out in pattern.outputs]
+    return "; ".join(parts)
+
+
+def build_cqs_violation(pattern: CQSPattern) -> Violation:
+    """Build a Violation object from a CQSPattern.
+
+    Creates a violation message that includes:
+    - Function name (with class prefix for methods)
+    - List of INPUT operations with line numbers
+    - List of OUTPUT operations with line numbers
+    - Suggestion to split into query and command functions
+
+    Args:
+        pattern: CQSPattern representing a function that violates CQS
+
+    Returns:
+        Violation object with formatted message and suggestion
+    """
+    full_name = pattern.get_full_name()
+
+    # Build detailed message
+    inputs_str = _format_inputs(pattern)
+    outputs_str = _format_outputs(pattern)
+
+    message = (
+        f"Function '{full_name}' violates CQS: mixes queries and commands. "
+        f"INPUTs: {inputs_str}. OUTPUTs: {outputs_str}."
+    )
+
+    suggestion = "Split into separate query and command functions."
+
+    return Violation(
+        rule_id="cqs",
+        file_path=pattern.file_path,
+        line=pattern.line,
+        column=pattern.column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )

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

@@ -10,11 +10,15 @@ 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
 
 Implementation: Strategy pattern with filter registry for extensibility
+
+Suppressions:
+    - type:ignore[operator]: Tree-sitter Node comparison operations (optional dependency)
 """
 
 import ast
@@ -23,6 +27,9 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Protocol
 
+# Default filter threshold constants
+DEFAULT_KEYWORD_ARG_THRESHOLD = 0.8
+
 
 class CodeBlock(Protocol):
     """Protocol for code blocks (matches cache.CodeBlock)."""
@@ -50,9 +57,10 @@ class BaseBlockFilter(ABC):
         """
         pass
 
+    @property
     @abstractmethod
-    def get_name(self) -> str:
-        """Get filter name for configuration and logging."""
+    def name(self) -> str:
+        """Filter name for configuration and logging."""
         pass
 
 
@@ -67,7 +75,7 @@ class KeywordArgumentFilter(BaseBlockFilter):
     These are common in builder patterns and API calls.
     """
 
-    def __init__(self, threshold: float = 0.8):
+    def __init__(self, threshold: float = DEFAULT_KEYWORD_ARG_THRESHOLD):
         """Initialize filter.
 
         Args:
@@ -110,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:
@@ -149,8 +157,9 @@ class KeywordArgumentFilter(BaseBlockFilter):
             return False
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         return "keyword_argument_filter"
 
 
@@ -160,6 +169,10 @@ class ImportGroupFilter(BaseBlockFilter):
     Import organization often creates similar patterns that aren't meaningful duplication.
     """
 
+    def __init__(self) -> None:
+        """Initialize the import group filter."""
+        pass  # Stateless filter for import blocks
+
     def should_filter(self, block: CodeBlock, file_content: str) -> bool:
         """Check if block is only import statements.
 
@@ -181,11 +194,105 @@ class ImportGroupFilter(BaseBlockFilter):
 
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         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."""
 
@@ -201,7 +308,7 @@ class BlockFilterRegistry:
             filter_instance: Filter to register
         """
         self._filters.append(filter_instance)
-        self._enabled_filters.add(filter_instance.get_name())
+        self._enabled_filters.add(filter_instance.name)
 
     def enable_filter(self, filter_name: str) -> None:
         """Enable a specific filter by name.
@@ -229,14 +336,8 @@ class BlockFilterRegistry:
         Returns:
             True if block should be filtered out
         """
-        for filter_instance in self._filters:
-            if filter_instance.get_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.
@@ -256,7 +357,9 @@ def create_default_registry() -> BlockFilterRegistry:
     registry = BlockFilterRegistry()
 
     # Register built-in filters
-    registry.register(KeywordArgumentFilter(threshold=0.8))
+    registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
     registry.register(ImportGroupFilter())
+    registry.register(LoggerCallFilter())
+    registry.register(ExceptionReraiseFilter())
 
     return registry

src/linters/dry/block_grouper.py

@@ -26,6 +26,10 @@ from .cache import CodeBlock
 class BlockGrouper:
     """Groups blocks and violations by file path."""
 
+    def __init__(self) -> None:
+        """Initialize the block grouper."""
+        pass  # Stateless grouper for code blocks
+
     def group_blocks_by_file(self, blocks: list[CodeBlock]) -> dict[Path, list[CodeBlock]]:
         """Group blocks by file path.