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

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,130 @@
+"""
+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
+
+
+@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 12 attributes are cohesively related (detection thresholds, language
+    overrides, caching, 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 = 3
+    min_duplicate_tokens: int = 30
+    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
+
+    # Cache settings
+    cache_enabled: bool = True  # ON by default for performance
+    cache_path: str = ".thailint-cache/dry.db"
+    cache_max_age_days: int = 30
+
+    # 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}")
+
+    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", 3),
+            min_duplicate_tokens=config.get("min_duplicate_tokens", 30),
+            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"),
+            cache_enabled=config.get("cache_enabled", True),
+            cache_path=config.get("cache_path", ".thailint-cache/dry.db"),
+            cache_max_age_days=config.get("cache_max_age_days", 30),
+            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,126 @@
+"""
+Purpose: Storage management for duplicate code blocks with cache and memory fallback
+
+Scope: Manages storage of code blocks in SQLite cache or in-memory dict
+
+Overview: Provides unified storage interface for code blocks supporting both SQLite-backed caching
+    and in-memory fallback when cache disabled. Handles block insertion, retrieval, and duplicate
+    hash queries. Encapsulates Decision 6 (in-memory fallback) implementation. 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 either SQLite cache or in-memory dict based on cache_enabled setting
+"""
+
+from pathlib import Path
+
+from .cache import CodeBlock, DRYCache
+
+
+class DuplicateStorage:
+    """Manages storage of code blocks in cache or memory."""
+
+    def __init__(self, cache: DRYCache | None) -> None:
+        """Initialize storage with optional cache.
+
+        Args:
+            cache: SQLite cache instance (None for in-memory mode)
+        """
+        self._cache = cache
+        self._memory_store: dict[int, list[CodeBlock]] = {}
+
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to storage and cache.
+
+        Args:
+            file_path: Path to source file
+            blocks: List of code blocks to store
+        """
+        # Always add to memory for duplicate detection
+        self._add_to_memory(blocks)
+
+        # Also persist to cache if available
+        if self._cache:
+            self._add_to_cache(file_path, blocks)
+
+    def add_blocks_to_memory(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to in-memory storage only (for cache hits).
+
+        Args:
+            file_path: Path to source file (used for cache persistence check)
+            blocks: List of code blocks to store
+        """
+        # Add to memory for duplicate detection this run
+        self._add_to_memory(blocks)
+
+        # Guard clauses - early returns for skip conditions
+        if not self._cache:
+            return
+
+        if not blocks:
+            return
+
+        # Update cache with new blocks if needed (for fresh analysis)
+        self._update_cache_if_fresh(file_path, blocks)
+
+    def _update_cache_if_fresh(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Update cache if file analysis is fresh (not from cache).
+
+        Args:
+            file_path: Path to source file
+            blocks: List of code blocks to store
+        """
+        if not self._cache:
+            return
+
+        try:
+            mtime = file_path.stat().st_mtime
+        except OSError:
+            # File doesn't exist, skip cache
+            return
+
+        # File was analyzed (not cached), so persist if not fresh
+        if not self._cache.is_fresh(file_path, mtime):
+            self._add_to_cache(file_path, blocks)
+
+    def get_duplicate_hashes(self) -> list[int]:
+        """Get all hash values with 2+ occurrences from memory.
+
+        Returns:
+            List of hash values that appear in multiple blocks
+        """
+        # Always query from in-memory store for this run's files
+        return [h for h, blocks in self._memory_store.items() if len(blocks) >= 2]
+
+    def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
+        """Get all blocks with given hash value from memory.
+
+        Args:
+            hash_value: Hash to search for
+
+        Returns:
+            List of code blocks with this hash
+        """
+        # Always query from in-memory store for this run's files
+        return self._memory_store.get(hash_value, [])
+
+    def _add_to_cache(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add blocks to SQLite cache."""
+        if not self._cache or not blocks:
+            return
+
+        mtime = file_path.stat().st_mtime
+        self._cache.save(file_path, mtime, blocks)
+
+    def _add_to_memory(self, blocks: list[CodeBlock]) -> None:
+        """Add blocks to in-memory store."""
+        for block in blocks:
+            if block.hash_value not in self._memory_store:
+                self._memory_store[block.hash_value] = []
+            self._memory_store[block.hash_value].append(block)

src/linters/dry/file_analyzer.py

@@ -0,0 +1,127 @@
+"""
+Purpose: File analysis orchestration for duplicate detection
+
+Scope: Coordinates language-specific analyzers and cache checking
+
+Overview: Orchestrates file analysis by delegating to language-specific analyzers (Python, TypeScript)
+    and checking cache freshness. Handles cache hits by loading from cache, and cache misses by
+    analyzing files. Separates file analysis orchestration from main linter rule logic to maintain
+    SRP compliance.
+
+Dependencies: PythonDuplicateAnalyzer, TypeScriptDuplicateAnalyzer, DRYCache, DRYConfig, CodeBlock
+
+Exports: FileAnalyzer class
+
+Interfaces: FileAnalyzer.analyze_or_load(file_path, content, language, config, cache)
+
+Implementation: Delegates to language-specific analyzers, checks cache freshness
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .block_filter import BlockFilterRegistry, create_default_registry
+from .cache import CodeBlock, DRYCache
+from .config import DRYConfig
+from .python_analyzer import PythonDuplicateAnalyzer
+from .typescript_analyzer import TypeScriptDuplicateAnalyzer
+
+
+@dataclass
+class FileAnalysisContext:
+    """Context for file analysis."""
+
+    file_path: Path
+    content: str
+    language: str
+    config: DRYConfig
+    cache: DRYCache | None
+
+
+class FileAnalyzer:
+    """Orchestrates file analysis with cache support."""
+
+    def __init__(self, config: DRYConfig | None = None) -> None:
+        """Initialize with language-specific analyzers.
+
+        Args:
+            config: DRY configuration (used to configure filters)
+        """
+        # Create filter registry based on config
+        filter_registry = self._create_filter_registry(config)
+
+        # Initialize analyzers with filter registry
+        self._python_analyzer = PythonDuplicateAnalyzer(filter_registry)
+        self._typescript_analyzer = TypeScriptDuplicateAnalyzer()
+
+    def _create_filter_registry(self, config: DRYConfig | None) -> BlockFilterRegistry:
+        """Create filter registry based on configuration.
+
+        Args:
+            config: DRY configuration
+
+        Returns:
+            Configured BlockFilterRegistry
+        """
+        registry = create_default_registry()
+
+        if not config:
+            return registry
+
+        # Configure filters based on config.filters dict
+        for filter_name, enabled in config.filters.items():
+            if enabled:
+                registry.enable_filter(filter_name)
+            else:
+                registry.disable_filter(filter_name)
+
+        return registry
+
+    def analyze_or_load(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        file_path: Path,
+        content: str,
+        language: str,
+        config: DRYConfig,
+        cache: DRYCache | None = None,
+    ) -> list[CodeBlock]:
+        """Analyze file or load from cache.
+
+        Args:
+            file_path: Path to file
+            content: File content
+            language: File language
+            config: DRY configuration
+            cache: Optional cache instance
+
+        Returns:
+            List of CodeBlock instances
+        """
+        # Check if file is fresh in cache
+        if cache:
+            mtime = file_path.stat().st_mtime
+            if cache.is_fresh(file_path, mtime):
+                return cache.load(file_path)
+
+        # Analyze file based on language
+        return self._analyze_file(file_path, content, language, config)
+
+    def _analyze_file(
+        self, file_path: Path, content: str, language: str, config: DRYConfig
+    ) -> list[CodeBlock]:
+        """Analyze file based on language.
+
+        Args:
+            file_path: Path to file
+            content: File content
+            language: File language
+            config: DRY configuration
+
+        Returns:
+            List of CodeBlock instances
+        """
+        if language == "python":
+            return self._python_analyzer.analyze(file_path, content, config)
+        if language in ("typescript", "javascript"):
+            return self._typescript_analyzer.analyze(file_path, content, config)
+        return []