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

src/linters/dry/block_grouper.py

@@ -0,0 +1,59 @@
+"""
+Purpose: Block grouping utilities for duplicate detection
+
+Scope: Groups code blocks by file path
+
+Overview: Provides grouping utilities for organizing code blocks by file. Used by ViolationDeduplicator
+    to process blocks on a per-file basis for overlap detection. Separates grouping logic to maintain
+    SRP compliance.
+
+Dependencies: CodeBlock, Violation
+
+Exports: BlockGrouper class
+
+Interfaces: BlockGrouper.group_blocks_by_file(blocks), group_violations_by_file(violations)
+
+Implementation: Simple dictionary-based grouping by file path
+"""
+
+from pathlib import Path
+
+from src.core.types import Violation
+
+from .cache import CodeBlock
+
+
+class BlockGrouper:
+    """Groups blocks and violations by file path."""
+
+    def group_blocks_by_file(self, blocks: list[CodeBlock]) -> dict[Path, list[CodeBlock]]:
+        """Group blocks by file path.
+
+        Args:
+            blocks: List of code blocks
+
+        Returns:
+            Dictionary mapping file paths to lists of blocks
+        """
+        grouped: dict[Path, list[CodeBlock]] = {}
+        for block in blocks:
+            if block.file_path not in grouped:
+                grouped[block.file_path] = []
+            grouped[block.file_path].append(block)
+        return grouped
+
+    def group_violations_by_file(self, violations: list[Violation]) -> dict[str, list[Violation]]:
+        """Group violations by file path.
+
+        Args:
+            violations: List of violations
+
+        Returns:
+            Dictionary mapping file paths to lists of violations
+        """
+        grouped: dict[str, list[Violation]] = {}
+        for violation in violations:
+            if violation.file_path not in grouped:
+                grouped[violation.file_path] = []
+            grouped[violation.file_path].append(violation)
+        return grouped

src/linters/dry/cache.py

@@ -0,0 +1,172 @@
+"""
+Purpose: SQLite storage manager for DRY linter duplicate detection
+
+Scope: Code block 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.
+    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.
+
+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()
+
+Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
+    storage_mode determines :memory: vs tempfile location, ACID transactions for reliability
+"""
+
+import sqlite3
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from .cache_query import CacheQueryService
+
+
+@dataclass
+class CodeBlock:
+    """Represents a code block location with hash."""
+
+    file_path: Path
+    start_line: int
+    end_line: int
+    snippet: str
+    hash_value: int
+
+
+class DRYCache:
+    """SQLite-backed storage for duplicate detection."""
+
+    SCHEMA_VERSION = 1
+
+    def __init__(self, storage_mode: str = "memory") -> None:
+        """Initialize storage with SQLite database.
+
+        Args:
+            storage_mode: Storage mode - "memory" (default) or "tempfile"
+        """
+        self._storage_mode = storage_mode
+        self._tempfile = None
+
+        # Create SQLite connection based on storage mode
+        if storage_mode == "memory":
+            self.db = sqlite3.connect(":memory:")
+        elif storage_mode == "tempfile":
+            # Create temporary file that auto-deletes on close
+            # pylint: disable=consider-using-with
+            # Justification: tempfile must remain open for SQLite connection lifetime.
+            # It is explicitly closed in close() method when cache is finalized.
+            self._tempfile = tempfile.NamedTemporaryFile(suffix=".db", delete=True)
+            self.db = sqlite3.connect(self._tempfile.name)
+        else:
+            raise ValueError(f"Invalid storage_mode: {storage_mode}")
+
+        self._query_service = CacheQueryService()
+
+        # Create schema
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS files (
+                file_path TEXT PRIMARY KEY,
+                mtime REAL NOT NULL,
+                hash_count INTEGER,
+                last_scanned TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )"""
+        )
+
+        self.db.execute(
+            """CREATE TABLE IF NOT EXISTS code_blocks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                file_path TEXT NOT NULL,
+                hash_value INTEGER NOT NULL,
+                start_line INTEGER NOT NULL,
+                end_line INTEGER NOT NULL,
+                snippet TEXT NOT NULL,
+                FOREIGN KEY (file_path) REFERENCES files(file_path) ON DELETE CASCADE
+            )"""
+        )
+
+        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)")
+
+        self.db.commit()
+
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to storage.
+
+        Args:
+            file_path: Path to source file
+            blocks: List of CodeBlock instances to store
+        """
+        if not blocks:
+            return
+
+        # Insert file metadata
+        try:
+            mtime = file_path.stat().st_mtime
+        except OSError:
+            mtime = 0.0  # File doesn't exist, use placeholder
+
+        self.db.execute(
+            "INSERT OR REPLACE INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
+            (str(file_path), mtime, len(blocks)),
+        )
+
+        # Insert code blocks
+        for block in blocks:
+            self.db.execute(
+                """INSERT INTO code_blocks
+                   (file_path, hash_value, start_line, end_line, snippet)
+                   VALUES (?, ?, ?, ?, ?)""",
+                (
+                    str(file_path),
+                    block.hash_value,
+                    block.start_line,
+                    block.end_line,
+                    block.snippet,
+                ),
+            )
+
+        self.db.commit()
+
+    def find_duplicates_by_hash(self, hash_value: int) -> list[CodeBlock]:
+        """Find all code blocks with the given hash value.
+
+        Args:
+            hash_value: Hash value to search for
+
+        Returns:
+            List of ALL CodeBlock instances with this hash (from all files)
+        """
+        rows = self._query_service.find_blocks_by_hash(self.db, hash_value)
+
+        blocks = []
+        for file_path_str, start, end, snippet, hash_val in rows:
+            block = CodeBlock(
+                file_path=Path(file_path_str),
+                start_line=start,
+                end_line=end,
+                snippet=snippet,
+                hash_value=hash_val,
+            )
+            blocks.append(block)
+
+        return blocks
+
+    def get_duplicate_hashes(self) -> list[int]:
+        """Get all 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 close(self) -> None:
+        """Close database connection and cleanup tempfile if used."""
+        self.db.close()
+        if self._tempfile:
+            self._tempfile.close()

src/linters/dry/cache_query.py

@@ -0,0 +1,61 @@
+"""
+Purpose: Query service for DRY cache database
+
+Scope: Handles SQL queries for duplicate hash detection
+
+Overview: Provides query methods for finding duplicate code blocks in the SQLite cache. Extracts
+    query logic from DRYCache to maintain SRP compliance. Handles queries for duplicate hashes
+    and blocks by hash value.
+
+Dependencies: sqlite3.Connection
+
+Exports: CacheQueryService class
+
+Interfaces: CacheQueryService.get_duplicate_hashes(db), find_duplicates_by_hash(db, hash_value)
+
+Implementation: SQL queries for duplicate detection, returns hash values and block data
+"""
+
+import sqlite3
+
+
+class CacheQueryService:
+    """Handles cache database queries."""
+
+    def get_duplicate_hashes(self, db: sqlite3.Connection) -> list[int]:
+        """Get all hash values that appear 2+ times.
+
+        Args:
+            db: Database connection
+
+        Returns:
+            List of hash values with 2 or more occurrences
+        """
+        cursor = db.execute(
+            """SELECT hash_value
+               FROM code_blocks
+               GROUP BY hash_value
+               HAVING COUNT(*) >= 2"""
+        )
+
+        return [row[0] for row in cursor]
+
+    def find_blocks_by_hash(self, db: sqlite3.Connection, hash_value: int) -> list[tuple]:
+        """Find all blocks with given hash value.
+
+        Args:
+            db: Database connection
+            hash_value: Hash to search for
+
+        Returns:
+            List of tuples (file_path, start_line, end_line, snippet, hash_value)
+        """
+        cursor = db.execute(
+            """SELECT file_path, start_line, end_line, snippet, hash_value
+               FROM code_blocks
+               WHERE hash_value = ?
+               ORDER BY file_path, start_line""",
+            (hash_value,),
+        )
+
+        return cursor.fetchall()

src/linters/dry/config.py

@@ -0,0 +1,134 @@
+"""
+Purpose: Configuration schema for DRY linter with caching support
+
+Scope: DRYConfig dataclass with validation, defaults, and loading from dictionary
+
+Overview: Defines configuration structure for the DRY linter including duplicate detection thresholds,
+    caching settings, and ignore patterns. Provides validation of configuration values to ensure
+    sensible defaults and prevent misconfiguration. Supports loading from YAML configuration files
+    through from_dict classmethod. Cache enabled by default for performance on large codebases.
+
+Dependencies: Python dataclasses module
+
+Exports: DRYConfig dataclass
+
+Interfaces: DRYConfig.__init__, DRYConfig.from_dict(config: dict) -> DRYConfig
+
+Implementation: Dataclass with field defaults, __post_init__ validation, and dict-based construction
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default configuration constants
+DEFAULT_MIN_DUPLICATE_LINES = 3
+DEFAULT_MIN_DUPLICATE_TOKENS = 30
+
+
+@dataclass
+class DRYConfig:  # pylint: disable=too-many-instance-attributes
+    """Configuration for DRY linter.
+
+    Note: Pylint too-many-instance-attributes disabled. This is a configuration
+    dataclass serving as a data container for related DRY linter settings.
+    All attributes are cohesively related (detection thresholds, language
+    overrides, storage mode, filtering). Splitting would reduce cohesion and make
+    configuration loading more complex without meaningful benefit.
+    """
+
+    enabled: bool = False  # Must be explicitly enabled
+    min_duplicate_lines: int = DEFAULT_MIN_DUPLICATE_LINES
+    min_duplicate_tokens: int = DEFAULT_MIN_DUPLICATE_TOKENS
+    min_occurrences: int = 2  # Minimum occurrences to report (default: 2)
+
+    # Language-specific overrides
+    python_min_occurrences: int | None = None
+    typescript_min_occurrences: int | None = None
+    javascript_min_occurrences: int | None = None
+
+    # Storage settings
+    storage_mode: str = "memory"  # Options: "memory" (default) or "tempfile"
+
+    # Ignore patterns
+    ignore_patterns: list[str] = field(default_factory=lambda: ["tests/", "__init__.py"])
+
+    # Block filters (extensible false positive filtering)
+    filters: dict[str, bool] = field(
+        default_factory=lambda: {
+            "keyword_argument_filter": True,  # Filter keyword argument blocks
+            "import_group_filter": True,  # Filter import statement groups
+        }
+    )
+
+    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"):
+            raise ValueError(
+                f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
+            )
+
+    def get_min_occurrences_for_language(self, language: str) -> int:
+        """Get minimum occurrences threshold for a specific language.
+
+        Args:
+            language: Language identifier (e.g., "python", "typescript", "javascript")
+
+        Returns:
+            Minimum occurrences threshold for the language, or global default
+        """
+        language_lower = language.lower()
+
+        language_overrides = {
+            "python": self.python_min_occurrences,
+            "typescript": self.typescript_min_occurrences,
+            "javascript": self.javascript_min_occurrences,
+        }
+
+        override = language_overrides.get(language_lower)
+        return override if override is not None else self.min_occurrences
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any]) -> "DRYConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values
+
+        Returns:
+            DRYConfig instance with values from dictionary
+        """
+        # Extract language-specific min_occurrences
+        python_config = config.get("python", {})
+        typescript_config = config.get("typescript", {})
+        javascript_config = config.get("javascript", {})
+
+        # Load filter configuration (merge with defaults)
+        default_filters = {
+            "keyword_argument_filter": True,
+            "import_group_filter": True,
+        }
+        custom_filters = config.get("filters", {})
+        filters = {**default_filters, **custom_filters}
+
+        return cls(
+            enabled=config.get("enabled", False),
+            min_duplicate_lines=config.get("min_duplicate_lines", DEFAULT_MIN_DUPLICATE_LINES),
+            min_duplicate_tokens=config.get("min_duplicate_tokens", DEFAULT_MIN_DUPLICATE_TOKENS),
+            min_occurrences=config.get("min_occurrences", 2),
+            python_min_occurrences=python_config.get("min_occurrences"),
+            typescript_min_occurrences=typescript_config.get("min_occurrences"),
+            javascript_min_occurrences=javascript_config.get("min_occurrences"),
+            storage_mode=config.get("storage_mode", "memory"),
+            ignore_patterns=config.get("ignore", []),
+            filters=filters,
+        )

src/linters/dry/config_loader.py

@@ -0,0 +1,44 @@
+"""
+Purpose: Configuration loading from lint context metadata
+
+Scope: Extracts and validates DRY configuration from context
+
+Overview: Handles extraction of DRY configuration from BaseLintContext metadata dictionary.
+    Validates configuration structure and converts to DRYConfig instance. Separates config
+    loading logic from main linter rule to maintain SRP compliance.
+
+Dependencies: BaseLintContext, DRYConfig
+
+Exports: ConfigLoader class
+
+Interfaces: ConfigLoader.load_config(context) -> DRYConfig
+
+Implementation: Extracts from context metadata, validates dict structure, uses DRYConfig.from_dict()
+"""
+
+from src.core.base import BaseLintContext
+
+from .config import DRYConfig
+
+
+class ConfigLoader:
+    """Loads DRY configuration from lint context."""
+
+    def load_config(self, context: BaseLintContext) -> DRYConfig:
+        """Load configuration from context metadata.
+
+        Args:
+            context: Lint context containing metadata
+
+        Returns:
+            DRYConfig instance
+        """
+        metadata = getattr(context, "metadata", None)
+        if not isinstance(metadata, dict):
+            return DRYConfig()
+
+        config_dict = metadata.get("dry", {})
+        if not isinstance(config_dict, dict):
+            return DRYConfig()
+
+        return DRYConfig.from_dict(config_dict)

src/linters/dry/deduplicator.py

@@ -0,0 +1,120 @@
+"""
+Purpose: Deduplication utility for overlapping code block violations
+
+Scope: Handles filtering of overlapping duplicate code violations
+
+Overview: Provides utilities to remove overlapping violations from duplicate code detection results.
+    Delegates grouping to BlockGrouper and filtering to ViolationFilter. Handles both block-level
+    deduplication (one block per file) and violation-level deduplication (removing overlaps).
+
+Dependencies: CodeBlock, Violation, BlockGrouper, ViolationFilter
+
+Exports: ViolationDeduplicator class
+
+Interfaces: ViolationDeduplicator.deduplicate_blocks(blocks), deduplicate_violations(violations)
+
+Implementation: Delegates to BlockGrouper and ViolationFilter for SRP compliance
+"""
+
+from src.core.types import Violation
+
+from .block_grouper import BlockGrouper
+from .cache import CodeBlock
+from .violation_filter import ViolationFilter
+
+
+class ViolationDeduplicator:
+    """Removes overlapping duplicate code violations."""
+
+    def __init__(self) -> None:
+        """Initialize with helper components."""
+        self._grouper = BlockGrouper()
+        self._filter = ViolationFilter()
+
+    def deduplicate_blocks(self, blocks: list[CodeBlock]) -> list[CodeBlock]:
+        """Remove overlapping blocks from same file.
+
+        When rolling hash creates overlapping windows, keep non-overlapping blocks.
+        Blocks are overlapping if they share any line numbers in the same file.
+
+        Args:
+            blocks: List of code blocks (may have overlaps from rolling hash)
+
+        Returns:
+            Deduplicated list of blocks (non-overlapping blocks preserved)
+        """
+        if not blocks:
+            return []
+
+        grouped = self._grouper.group_blocks_by_file(blocks)
+        deduplicated = []
+
+        for file_blocks in grouped.values():
+            kept = self._remove_overlaps_from_file(file_blocks)
+            deduplicated.extend(kept)
+
+        return deduplicated
+
+    def _remove_overlaps_from_file(self, file_blocks: list[CodeBlock]) -> list[CodeBlock]:
+        """Remove overlapping blocks from single file.
+
+        Args:
+            file_blocks: Blocks from same file
+
+        Returns:
+            Non-overlapping blocks
+        """
+        sorted_blocks = sorted(file_blocks, key=lambda b: b.start_line)
+        kept_blocks: list[CodeBlock] = []
+
+        for block in sorted_blocks:
+            if not self._overlaps_any_kept(block, kept_blocks):
+                kept_blocks.append(block)
+
+        return kept_blocks
+
+    def _overlaps_any_kept(self, block: CodeBlock, kept_blocks: list[CodeBlock]) -> bool:
+        """Check if block overlaps with any kept blocks.
+
+        Args:
+            block: Block to check
+            kept_blocks: Previously kept blocks
+
+        Returns:
+            True if block overlaps with any kept block
+        """
+        return any(self._blocks_overlap(block, kept) for kept in kept_blocks)
+
+    def _blocks_overlap(self, block1: CodeBlock, block2: CodeBlock) -> bool:
+        """Check if two blocks overlap (share any lines).
+
+        Args:
+            block1: First code block
+            block2: Second code block
+
+        Returns:
+            True if blocks overlap
+        """
+        return block1.start_line <= block2.end_line and block2.start_line <= block1.end_line
+
+    def deduplicate_violations(self, violations: list[Violation]) -> list[Violation]:
+        """Remove overlapping violations from same file.
+
+        Args:
+            violations: List of violations (may overlap)
+
+        Returns:
+            Deduplicated list of violations
+        """
+        if not violations:
+            return []
+
+        grouped = self._grouper.group_violations_by_file(violations)
+        deduplicated = []
+
+        for file_violations in grouped.values():
+            sorted_violations = sorted(file_violations, key=lambda v: v.line or 0)
+            kept = self._filter.filter_overlapping(sorted_violations)
+            deduplicated.extend(kept)
+
+        return deduplicated

src/linters/dry/duplicate_storage.py

@@ -0,0 +1,63 @@
+"""
+Purpose: Storage management for duplicate code blocks in SQLite
+
+Scope: Manages storage of code blocks in SQLite for duplicate detection
+
+Overview: Provides storage interface for code blocks using SQLite (in-memory or tempfile mode).
+    Handles block insertion and duplicate hash queries. Delegates all storage operations to
+    DRYCache SQLite layer. Separates storage concerns from linting logic to maintain SRP compliance.
+
+Dependencies: DRYCache, CodeBlock, Path
+
+Exports: DuplicateStorage class
+
+Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
+    get_blocks_for_hash(hash_value)
+
+Implementation: Delegates to SQLite cache for all storage operations
+"""
+
+from pathlib import Path
+
+from .cache import CodeBlock, DRYCache
+
+
+class DuplicateStorage:
+    """Manages storage of code blocks in SQLite."""
+
+    def __init__(self, cache: DRYCache) -> None:
+        """Initialize storage with SQLite cache.
+
+        Args:
+            cache: SQLite cache instance (in-memory or tempfile mode)
+        """
+        self._cache = cache
+
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to SQLite storage.
+
+        Args:
+            file_path: Path to source file
+            blocks: List of code blocks to store
+        """
+        if blocks:
+            self._cache.add_blocks(file_path, blocks)
+
+    def get_duplicate_hashes(self) -> list[int]:
+        """Get all hash values with 2+ occurrences from SQLite.
+
+        Returns:
+            List of hash values that appear in multiple blocks
+        """
+        return self._cache.get_duplicate_hashes()
+
+    def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
+        """Get all blocks with given hash value from SQLite.
+
+        Args:
+            hash_value: Hash to search for
+
+        Returns:
+            List of code blocks with this hash
+        """
+        return self._cache.find_duplicates_by_hash(hash_value)