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

src/linters/dry/cache.py

@@ -1,31 +1,45 @@
 """
-Purpose: SQLite cache manager for DRY linter with mtime-based invalidation
+Purpose: SQLite storage manager for DRY linter duplicate detection
 
-Scope: Code block storage, cache operations, and duplicate detection queries
+Scope: Code block storage, constant storage, and duplicate detection queries
 
-Overview: Implements persistent caching layer for duplicate code detection using SQLite database.
-    Stores code blocks with hash values, file locations, and metadata. Provides mtime-based cache
-    invalidation to detect stale entries. Serves dual purpose as both cache (avoid re-hashing) and
-    hash table (query duplicates across project). Includes indexes for fast hash lookups enabling
-    cross-file duplicate detection with minimal overhead.
+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 and constant name lookups enabling efficient cross-file detection.
 
-Dependencies: Python sqlite3 module (stdlib), pathlib.Path, dataclasses
+Dependencies: Python sqlite3 module (stdlib), tempfile module (stdlib), pathlib.Path, dataclasses
 
 Exports: CodeBlock dataclass, DRYCache class
 
-Interfaces: DRYCache.__init__, is_fresh, load, save, find_duplicates_by_hash, get_blocks_for_file,
-    add_blocks, cleanup_stale, close
+Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
+    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,
-    ACID transactions for reliability, foreign key constraints for data integrity
+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:
@@ -39,20 +53,32 @@ class CodeBlock:
 
 
 class DRYCache:
-    """SQLite-backed cache for duplicate detection."""
+    """SQLite-backed storage for duplicate detection."""
 
     SCHEMA_VERSION = 1
 
-    def __init__(self, cache_path: Path) -> None:
-        """Initialize cache with SQLite database.
+    def __init__(self, storage_mode: str = "memory") -> None:
+        """Initialize storage with SQLite database.
 
         Args:
-            cache_path: Path to SQLite database file
+            storage_mode: Storage mode - "memory" (default) or "tempfile"
         """
-        # Ensure parent directory exists
-        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        self._storage_mode = storage_mode
+        self._tempfile = None
+
+        # Create SQLite connection based on storage mode
+        if storage_mode == StorageMode.MEMORY:
+            self.db = sqlite3.connect(":memory:")
+        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.
+            # 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.db = sqlite3.connect(str(cache_path))
         self._query_service = CacheQueryService()
 
         # Create schema
@@ -80,70 +106,39 @@ 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)")
 
-        self.db.commit()
-
-    def is_fresh(self, file_path: Path, current_mtime: float) -> bool:
-        """Check if cached data is fresh (mtime matches).
-
-        Args:
-            file_path: Path to file
-            current_mtime: Current modification time
-
-        Returns:
-            True if cache is fresh, False if stale or missing
-        """
-        cursor = self.db.execute("SELECT mtime FROM files WHERE file_path = ?", (str(file_path),))
-        row = cursor.fetchone()
-
-        if not row:
-            return False  # Not in cache
-
-        cached_mtime = row[0]
-        return cached_mtime == current_mtime
-
-    def load(self, file_path: Path) -> list[CodeBlock]:
-        """Load cached code blocks for file.
-
-        Args:
-            file_path: Path to file
-
-        Returns:
-            List of CodeBlock instances from cache
-        """
-        cursor = self.db.execute(
-            """SELECT hash_value, start_line, end_line, snippet
-               FROM code_blocks
-               WHERE file_path = ?""",
-            (str(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)")
 
-        blocks = []
-        for hash_val, start, end, snippet in cursor:
-            block = CodeBlock(
-                file_path=file_path,
-                start_line=start,
-                end_line=end,
-                snippet=snippet,
-                hash_value=hash_val,
-            )
-            blocks.append(block)
-
-        return blocks
+        self.db.commit()
 
-    def save(self, file_path: Path, mtime: float, blocks: list[CodeBlock]) -> None:
-        """Save code blocks to cache.
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to storage.
 
         Args:
-            file_path: Path to file
-            mtime: File modification time
-            blocks: List of CodeBlock instances to cache
+            file_path: Path to source file
+            blocks: List of CodeBlock instances to store
         """
-        # Delete old data for this file
-        self.db.execute("DELETE FROM files WHERE file_path = ?", (str(file_path),))
+        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 INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
+            "INSERT OR REPLACE INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
             (str(file_path), mtime, len(blocks)),
         )
 
@@ -164,23 +159,6 @@ class DRYCache:
 
         self.db.commit()
 
-    def cleanup_stale(self, max_age_days: int) -> None:
-        """Remove cache entries older than max_age_days.
-
-        Args:
-            max_age_days: Maximum age in days for cache entries
-        """
-        # Use parameterized query to prevent SQL injection
-        self.db.execute(
-            """DELETE FROM files
-               WHERE last_scanned < datetime('now', ? || ' days')""",
-            (f"-{max_age_days}",),
-        )
-
-        # Vacuum to reclaim space
-        self.db.execute("VACUUM")
-        self.db.commit()
-
     def find_duplicates_by_hash(self, hash_value: int) -> list[CodeBlock]:
         """Find all code blocks with the given hash value.
 
@@ -205,14 +183,84 @@ 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."""
+        """Close database connection and cleanup tempfile if used."""
         self.db.close()
+        if self._tempfile:
+            self._tempfile.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,11 +15,21 @@ 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
 class DRYConfig:  # pylint: disable=too-many-instance-attributes
@@ -27,14 +37,14 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
     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
+    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 = 3
-    min_duplicate_tokens: int = 30
+    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
@@ -42,10 +52,8 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
     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
+    # Storage settings
+    storage_mode: str = "memory"  # Options: "memory" (default) or "tempfile"
 
     # Ignore patterns
     ignore_patterns: list[str] = field(default_factory=lambda: ["tests/", "__init__.py"])
@@ -58,18 +66,34 @@ 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:
+        self._validate_positive_fields()
+        valid_modes = (StorageMode.MEMORY, StorageMode.TEMPFILE)
+        if self.storage_mode not in valid_modes:
             raise ValueError(
-                f"min_duplicate_lines must be positive, got {self.min_duplicate_lines}"
+                f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
             )
-        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 _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.
@@ -91,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.
@@ -116,15 +159,19 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
         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_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"),
-            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),
+            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"),
         )

src/linters/dry/constant.py

@@ -0,0 +1,92 @@
+"""
+Purpose: Dataclasses for duplicate constants detection in DRY linter
+
+Scope: Data structures for constant extraction and cross-file detection
+
+Overview: Provides dataclasses for representing constants extracted from source code and their
+    locations across multiple files. ConstantInfo stores extracted constant metadata (name, line,
+    value) from a single file. ConstantLocation represents where a constant appears across the
+    project. ConstantGroup represents a group of related constants (exact or fuzzy matches) for
+    violation reporting. These structures support the duplicate constants detection feature that
+    identifies when the same constant name appears in multiple files.
+
+Dependencies: Python dataclasses module, pathlib for Path types
+
+Exports: ConstantInfo, ConstantLocation, ConstantGroup dataclasses
+
+Interfaces: Dataclass constructors with named fields
+
+Implementation: Immutable dataclasses with optional fields for extracted value context
+"""
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Shared pattern for ALL_CAPS constant names (public only, no leading underscore)
+# Used by both Python and TypeScript constant extractors
+# Requires at least 2 characters to exclude single-letter type params (P, T, K, V)
+CONSTANT_NAME_PATTERN = re.compile(r"^[A-Z][A-Z0-9_]+$")
+
+
+@dataclass
+class ConstantInfo:
+    """Information about a constant extracted from source code.
+
+    Represents a single constant definition found during file analysis.
+    Used during the collection phase before cross-file matching.
+    """
+
+    name: str  # Constant name (e.g., "API_TIMEOUT")
+    line_number: int  # Line where constant is defined
+    value: str | None = None  # Optional: the value (for violation message context)
+
+
+@dataclass
+class ConstantLocation:
+    """Location of a constant in the project.
+
+    Represents where a specific constant appears, including file path,
+    line number, and the value assigned. Used for cross-file reporting.
+    """
+
+    file_path: Path
+    line_number: int
+    name: str
+    value: str | None = None
+
+
+@dataclass
+class ConstantGroup:
+    """A group of related constants for violation reporting.
+
+    Groups constants that match (either exactly or via fuzzy matching)
+    across multiple files. Used by the violation builder to generate
+    comprehensive violation messages.
+    """
+
+    # The canonical name (first seen or most common)
+    canonical_name: str
+
+    # All locations where this constant (or fuzzy match) appears
+    locations: list[ConstantLocation] = field(default_factory=list)
+
+    # All names in this group (for fuzzy matches, may include variants)
+    all_names: set[str] = field(default_factory=set)
+
+    # Whether this is a fuzzy match (True) or exact match (False)
+    is_fuzzy_match: bool = False
+
+    def add_location(self, location: ConstantLocation) -> None:
+        """Add a location to this group.
+
+        Args:
+            location: The constant location to add
+        """
+        self.locations.append(location)
+        self.all_names.add(location.name)
+
+    @property
+    def file_count(self) -> int:
+        """Number of unique files containing this constant."""
+        return len({loc.file_path for loc in self.locations})