thailint 0.5.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
@@ -53,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
 
 
@@ -113,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:
@@ -152,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"
 
 
@@ -163,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.
 
@@ -184,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."""
 
@@ -204,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.
@@ -232,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.
@@ -261,5 +359,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

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.
 

src/linters/dry/cache.py

@@ -1,32 +1,45 @@
 """
 Purpose: SQLite storage manager for DRY linter duplicate detection
 
-Scope: Code block storage and duplicate detection queries
+Scope: Code block storage, constant storage, and duplicate detection queries
 
-Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection.
-    Stores code blocks with hash values, file locations, and metadata during a single linter run.
+Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection
+    and duplicate constants detection. Stores code blocks with hash values and constants with
+    name/value pairs, enabling cross-file duplicate detection during a single linter run.
     Supports both :memory: mode (fast, RAM-only) and tempfile mode (disk-backed for large projects).
     No persistence between runs - storage is cleared when linter completes. Includes indexes for
-    fast hash lookups enabling cross-file duplicate detection with minimal overhead.
+    fast hash lookups and constant name lookups enabling efficient cross-file detection.
 
 Dependencies: Python sqlite3 module (stdlib), tempfile module (stdlib), pathlib.Path, dataclasses
 
 Exports: CodeBlock dataclass, DRYCache class
 
 Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
-    find_duplicates_by_hash(hash_value), get_duplicate_hashes(), close()
+    find_duplicates_by_hash(hash_value), duplicate_hashes, add_constants(file_path, constants),
+    all_constants, get_duplicate_constant_names(), close()
 
-Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
+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
+
 import sqlite3
 import tempfile
 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:
+    from .constant import ConstantInfo
+
 
 @dataclass
 class CodeBlock:
@@ -54,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.
@@ -93,6 +106,19 @@ class DRYCache:
         self.db.execute("CREATE INDEX IF NOT EXISTS idx_hash_value ON code_blocks(hash_value)")
         self.db.execute("CREATE INDEX IF NOT EXISTS idx_file_path ON code_blocks(file_path)")
 
+        # Constants table for duplicate constant detection
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS constants (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                file_path TEXT NOT NULL,
+                name TEXT NOT NULL,
+                line_number INTEGER NOT NULL,
+                value TEXT,
+                FOREIGN KEY (file_path) REFERENCES files(file_path) ON DELETE CASCADE
+            )"""
+        )
+        self.db.execute("CREATE INDEX IF NOT EXISTS idx_constant_name ON constants(name)")
+
         self.db.commit()
 
     def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
@@ -157,14 +183,82 @@ class DRYCache:
 
         return blocks
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values that appear 2+ times.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values that appear 2+ times.
 
         Returns:
             List of hash values with 2 or more occurrences
         """
         return self._query_service.get_duplicate_hashes(self.db)
 
+    def add_constants(
+        self,
+        file_path: Path,
+        constants: list[ConstantInfo],
+    ) -> None:
+        """Add constants to storage.
+
+        Args:
+            file_path: Path to source file
+            constants: List of ConstantInfo instances to store
+        """
+        if not constants:
+            return
+
+        for const in constants:
+            self.db.execute(
+                """INSERT INTO constants
+                   (file_path, name, line_number, value)
+                   VALUES (?, ?, ?, ?)""",
+                (
+                    str(file_path),
+                    const.name,
+                    const.line_number,
+                    const.value,
+                ),
+            )
+
+        self.db.commit()
+
+    @property
+    def all_constants(self) -> list[tuple[str, str, int, str | None]]:
+        """All constants from storage.
+
+        Returns:
+            List of tuples: (file_path, name, line_number, value)
+        """
+        cursor = self.db.execute("SELECT file_path, name, line_number, value FROM constants")
+        return cursor.fetchall()
+
+    def get_duplicate_constant_names(self) -> list[str]:
+        """Get constant names that appear in 2+ files.
+
+        Returns:
+            List of constant names appearing in multiple files
+        """
+        cursor = self.db.execute(
+            """SELECT name FROM constants
+               GROUP BY name
+               HAVING COUNT(DISTINCT file_path) >= 2"""
+        )
+        return [row[0] for row in cursor.fetchall()]
+
+    def get_constants_by_name(self, name: str) -> list[tuple[str, int, str | None]]:
+        """Get all locations of a constant by name.
+
+        Args:
+            name: The constant name to search for
+
+        Returns:
+            List of tuples: (file_path, line_number, value)
+        """
+        cursor = self.db.execute(
+            "SELECT file_path, line_number, value FROM constants WHERE name = ?",
+            (name,),
+        )
+        return cursor.fetchall()
+
     def close(self) -> None:
         """Close database connection and cleanup tempfile if used."""
         self.db.close()

src/linters/dry/cache_query.py

@@ -22,6 +22,10 @@ import sqlite3
 class CacheQueryService:
     """Handles cache database queries."""
 
+    def __init__(self) -> None:
+        """Initialize the cache query service."""
+        pass  # Stateless query service for database operations
+
     def get_duplicate_hashes(self, db: sqlite3.Connection) -> list[int]:
         """Get all hash values that appear 2+ times.
 

src/linters/dry/config.py

@@ -15,14 +15,20 @@ Exports: DRYConfig dataclass
 Interfaces: DRYConfig.__init__, DRYConfig.from_dict(config: dict) -> DRYConfig
 
 Implementation: Dataclass with field defaults, __post_init__ validation, and dict-based construction
+
+Suppressions:
+    - too-many-instance-attributes: Configuration dataclass with related settings
 """
 
 from dataclasses import dataclass, field
 from typing import Any
 
+from src.core.constants import StorageMode
+
 # Default configuration constants
 DEFAULT_MIN_DUPLICATE_LINES = 3
 DEFAULT_MIN_DUPLICATE_TOKENS = 30
+DEFAULT_DETECT_DUPLICATE_CONSTANTS = True
 
 
 @dataclass
@@ -60,23 +66,35 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
         }
     )
 
+    # Duplicate constants detection
+    detect_duplicate_constants: bool = DEFAULT_DETECT_DUPLICATE_CONSTANTS
+    min_constant_occurrences: int = 2  # Minimum files with same constant to report
+
+    # Language-specific overrides for constant detection
+    python_min_constant_occurrences: int | None = None
+    typescript_min_constant_occurrences: int | None = None
+
     def __post_init__(self) -> None:
         """Validate configuration values."""
-        if self.min_duplicate_lines <= 0:
-            raise ValueError(
-                f"min_duplicate_lines must be positive, got {self.min_duplicate_lines}"
-            )
-        if self.min_duplicate_tokens <= 0:
-            raise ValueError(
-                f"min_duplicate_tokens must be positive, got {self.min_duplicate_tokens}"
-            )
-        if self.min_occurrences <= 0:
-            raise ValueError(f"min_occurrences must be positive, got {self.min_occurrences}")
-        if self.storage_mode not in ("memory", "tempfile"):
+        self._validate_positive_fields()
+        valid_modes = (StorageMode.MEMORY, StorageMode.TEMPFILE)
+        if self.storage_mode not in valid_modes:
             raise ValueError(
                 f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
             )
 
+    def _validate_positive_fields(self) -> None:
+        """Validate that required fields are positive."""
+        positive_fields = [
+            ("min_duplicate_lines", self.min_duplicate_lines),
+            ("min_duplicate_tokens", self.min_duplicate_tokens),
+            ("min_occurrences", self.min_occurrences),
+            ("min_constant_occurrences", self.min_constant_occurrences),
+        ]
+        for name, value in positive_fields:
+            if value <= 0:
+                raise ValueError(f"{name} must be positive, got {value}")
+
     def get_min_occurrences_for_language(self, language: str) -> int:
         """Get minimum occurrences threshold for a specific language.
 
@@ -97,6 +115,25 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
         override = language_overrides.get(language_lower)
         return override if override is not None else self.min_occurrences
 
+    def get_min_constant_occurrences_for_language(self, language: str) -> int:
+        """Get minimum constant occurrences threshold for a specific language.
+
+        Args:
+            language: Language identifier (e.g., "python", "typescript")
+
+        Returns:
+            Minimum constant occurrences threshold for the language, or global default
+        """
+        language_lower = language.lower()
+
+        language_overrides = {
+            "python": self.python_min_constant_occurrences,
+            "typescript": self.typescript_min_constant_occurrences,
+        }
+
+        override = language_overrides.get(language_lower)
+        return override if override is not None else self.min_constant_occurrences
+
     @classmethod
     def from_dict(cls, config: dict[str, Any]) -> "DRYConfig":
         """Load configuration from dictionary.
@@ -131,4 +168,10 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
             storage_mode=config.get("storage_mode", "memory"),
             ignore_patterns=config.get("ignore", []),
             filters=filters,
+            detect_duplicate_constants=config.get(
+                "detect_duplicate_constants", DEFAULT_DETECT_DUPLICATE_CONSTANTS
+            ),
+            min_constant_occurrences=config.get("min_constant_occurrences", 2),
+            python_min_constant_occurrences=python_config.get("min_constant_occurrences"),
+            typescript_min_constant_occurrences=typescript_config.get("min_constant_occurrences"),
         )